SQLite

一、SQLite是什么？

SQLite 是一个轻量级、嵌入式的关系型数据库管理系统。它不需要独立的数据库服务器，所有数据都存储在一个单一的文件中，因其体积小、资源占用少，非常适合嵌入式系统、移动应用、桌面应用和小型网站使用。

二、SQLite的主要特点：

1. 轻量级：整个数据库引擎包含在一个小的库中。
2. 自给自足：SQLite不需要服务器或守护进程。它直接读写文件。
3. 事务支持：SQLite支持ACID事务（原子性、一致性、隔离性和持久性）。
4. 跨平台：可以在Windows、macOS、Linux、Android、iOS等平台使用。
5. 无安装：SQLite是一个单一的库文件，不需要安装。

三、使用SQLite的步骤：

1. 安装SQLite：

SQLite通常不需要特别安装，很多操作系统已经预装。如果你需要手动安装，可以到SQLite官网下载适合你的版本。

2. 创建数据库：

SQLite的数据库是存储在文件中的，创建数据库等同于创建一个文件。

通过命令行创建：

sqlite3 my_database.db

这会创建一个名为 my_database.db 的文件作为SQLite数据库。

3. 基本的SQLite命令：

以下是在SQLite命令行中使用的几个常见操作。

• 创建表：

  CREATE TABLE users (
      id INTEGER PRIMARY KEY AUTOINCREMENT,
      name TEXT,
      email TEXT
  );
  

• 插入数据：

  INSERT INTO users (name, email) VALUES ('John Doe', 'john@example.com');
  

• 查询数据：

  SELECT * FROM users;
  

• 更新数据：

  UPDATE users SET email = 'john.doe@example.com' WHERE id = 1;
  

• 删除数据：

  DELETE FROM users WHERE id = 1;
  

四、SQLite使用场景：

• 移动设备应用程序（如iOS、Android应用）
• 小型网站
• 桌面应用
• 嵌入式设备

如果你需要使用轻量级数据库管理系统且不想部署服务器，SQLite是一个非常好的选择。

五、SpringBoot集成SQLite

在Spring Boot 项目中集成 MyBatis 和 SQLite 需要通过配置数据源、MyBatis 和 SQLite 驱动程序来实现。下面是具体的步骤：

1. 添加依赖

在 pom.xml 中添加所需的依赖项，包括 MyBatis Starter 和 SQLite JDBC 驱动程序。

<dependencies>
    
    <dependency>
        <groupId>org.mybatis.spring.bootgroupId>
        <artifactId>mybatis-spring-boot-starterartifactId>
        <version>2.3.1version> 
    dependency>

    
    <dependency>
        <groupId>org.xerialgroupId>
        <artifactId>sqlite-jdbcartifactId>
        <version>3.41.2.1version> 
    dependency>
dependencies>

2. 配置 application.properties

在 src/main/resources/application.properties 中配置 SQLite 数据源。你可以指定 SQLite 数据库文件的位置。

# 数据库连接URL
spring.datasource.url=jdbc:sqlite:./my_database.db
spring.datasource.driver-class-name=org.sqlite.JDBC

# 禁用数据源自动配置
spring.datasource.initialization-mode=never

# MyBatis 配置
mybatis.type-aliases-package=com.example.demo.model
mybatis.mapper-locations=classpath:mapper/*.xml

3. 创建数据库表

在使用 MyBatis 之前，首先需要确保 SQLite 数据库中已经有相应的表结构。你可以使用 SQLite CLI 或者代码初始化数据库。

例如，在命令行中可以运行以下命令来创建一个 users 表：

CREATE TABLE users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT,
    email TEXT
);

4. 创建实体类

接下来，在 src/main/java/com/example/demo/model 目录下创建一个实体类 User。

package com.example.demo.model;

public class User {
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

5. 创建 Mapper 接口

在 src/main/java/com/example/demo/mapper 目录下创建 UserMapper 接口。

package com.example.demo.mapper;

import com.example.demo.model.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM users")
    List<User> findAll();

    @Insert("INSERT INTO users(name, email) VALUES(#{name}, #{email})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    void insert(User user);

    @Select("SELECT * FROM users WHERE id = #{id}")
    User findById(Long id);

    @Update("UPDATE users SET name=#{name}, email=#{email} WHERE id = #{id}")
    void update(User user);

    @Delete("DELETE FROM users WHERE id = #{id}")
    void delete(Long id);
}

6. 创建 Mapper XML 文件（可选）

如果需要使用 XML 来配置 SQL 查询，可以创建一个 UserMapper.xml 文件，放在 src/main/resources/mapper 目录下。

DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.demo.mapper.UserMapper">

    <resultMap id="BaseResultMap" type="com.example.demo.model.User">
        <id column="id" property="id" />
        <result column="name" property="name" />
        <result column="email" property="email" />
    resultMap>

    <select id="findAll" resultMap="BaseResultMap">
        SELECT * FROM users
    select>

    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO users (name, email)
        VALUES (#{name}, #{email})
    insert>

    <select id="findById" resultMap="BaseResultMap">
        SELECT * FROM users WHERE id = #{id}
    select>

    <update id="update">
        UPDATE users
        SET name = #{name}, email = #{email}
        WHERE id = #{id}
    update>

    <delete id="delete">
        DELETE FROM users WHERE id = #{id}
    delete>

mapper>

7. 创建服务类

在 src/main/java/com/example/demo/service 目录下创建一个服务类 UserService，用于调用 UserMapper 中的方法。

package com.example.demo.service;

import com.example.demo.mapper.UserMapper;
import com.example.demo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public List<User> getAllUsers() {
        return userMapper.findAll();
    }

    public User getUserById(Long id) {
        return userMapper.findById(id);
    }

    public void addUser(User user) {
        userMapper.insert(user);
    }

    public void updateUser(User user) {
        userMapper.update(user);
    }

    public void deleteUser(Long id) {
        userMapper.delete(id);
    }
}

8. 创建控制器

在 src/main/java/com/example/demo/controller 目录下创建 UserController，用于提供RESTful API。

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping
    public void addUser(@RequestBody User user) {
        userService.addUser(user);
    }

    @PutMapping("/{id}")
    public void updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        userService.updateUser(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

9. 运行项目

现在，你已经完成了 Spring Boot 与 MyBatis 集成 SQLite 的基础配置。启动项目后，你可以通过以下 API 测试应用：

• GET /users：获取所有用户
• GET /users/{id}：根据ID获取用户
• POST /users：添加新用户
• PUT /users/{id}：更新用户信息
• DELETE /users/{id}：删除用户

总结

通过以上步骤，Spring Boot、MyBatis 和 SQLite 已经成功集成。MyBatis 结合 SQLite 是一个非常轻量级的数据库解决方案，适合用于小型应用和嵌入式设备的开发。