# demo-mybatis3

**Repository Path**: JackSong2019/demo-mybatis3

## Basic Information

- **Project Name**: demo-mybatis3
- **Description**: mybatis3的相关使用demo
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 1
- **Created**: 2024-05-08
- **Last Updated**: 2024-11-22

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

##  Mybatis Plus ActiveRecord 模式 使用示例

### 前言
#### ActiveRecord 模式 简介
- ##### ActiveRecord 是一种设计模式，它是一种在软件开发中用于管理关系数据库的模式，他简化了数据库操作的流程，使得开发人员可以更专注于业务逻辑而非数据库细节。它提供了一种面向对象的方法来处理数据库，使得数据库操作变得更加直观、易于维护和扩展。
  - ##### 关于 ActiveRecord 模式的一些重要概念和特点
  ```text
    1、对象关系映射 (ORM)：
    ActiveRecord 是一种对象关系映射 (ORM) 模式的实现。它将数据库中的表格（或集合）映射到应用程序中的对象。
  每个数据库表格对应于一个 ActiveRecord 模型类，而表格中的每一行数据则对应于该模型类的一个实例对象。

    2、模型类（Model Class）：
    在 ActiveRecord 中，模型类是应用程序中操作数据库的主要组件。每个模型类代表一个数据库表格，
  并且可以用于查询、插入、更新和删除表格中的数据。模型类通常继承自框架提供的 ActiveRecord 基类，
  这个基类提供了许多用于数据库操作的方法和功能。

    3、数据表与字段映射：
    ActiveRecord 模式通过约定俗成的方式将数据表中的字段映射到模型类的属性。
  例如，一个数据库表格中的 users 表可能会映射到一个 User 模型类，表中的每个字段（如 id、name、email 等）
  则对应于模型类中的属性。

    4、CRUD 操作：
    ActiveRecord 模式使得执行 CRUD 操作变得简单和直观。通过模型类，我们可以轻松地执行
  创建（Create）、读取（Read）、更新（Update）和删除（Delete）这些基本的数据库操作，
  而无需编写复杂的 SQL 查询语句。

    5、关联和查询：
    ActiveRecord 支持定义和使用关联关系，比如一对一、一对多、多对多等关系。
  这使得在处理复杂的数据模型时更加便捷。同时，ActiveRecord 提供了强大的查询接口，
  允许开发人员使用链式调用的方式构建复杂的数据库查询，而无需直接编写 SQL。

    6、数据验证和回调：
    ActiveRecord 提供了内置的数据验证功能，可以确保数据的完整性和一致性。
  开发人员可以在模型类中定义验证规则，以确保数据符合预期的格式和约束。此外，
  ActiveRecord 还支持回调机制，允许在数据保存、更新等操作前后执行特定的代码。
  ```



### 一、前置条件 JDK版本  Springboot版本  MybatisPlus版本
* JDK 17
* SpringBoot 3.+ 以上
* MybatisPlus 3.+ 以上
* 说明: 实体类只需继承 Model 类即可进行强大的 CRUD 操作 ; 需要项目中已注入对应实体的BaseMapper

### 二、示例数据脚本  将脚本数据脚本导入到数据库中
```
-- user 表Schema 脚本
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`
(
    id BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);

--  Data 脚本
DELETE FROM `user`;
INSERT INTO `user` (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');
```

### 三、初始化工程
- 1、 创建一个空的 Spring Boot 工程
```
  提示 :
    a、可以使用 Spring Initializer (opens new window)快速初始化一个 Spring Boot 工程
    b、也可以创建一个maven空工程，然后按需要引入依赖
  ```

#添加依赖
- 2、 引入 Spring Boot Starter 父工程
  ```pom.xml
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <!-- 因为使用的mybatis plus 3.+ 所以需要指定springboot3.+以上的版本 -->
        <version>3.1.5</version>
        <relativePath/>
    </parent>
    ```
- 3、 引入 spring-boot-starter、spring-boot-starter-test、mybatis-plus-boot-starter、mysql 依赖：
```pom.xml
  <dependencies>
          <!-- SpringBoot -->
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter</artifactId>
          </dependency>
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-test</artifactId>
              <scope>test</scope>
          </dependency>
  
          <!-- lombok -->
          <dependency>
              <groupId>org.projectlombok</groupId>
              <artifactId>lombok</artifactId>
              <scope>provided</scope>
          </dependency>
  
          <!-- mybatis plus3 -->
          <dependency>
              <groupId>com.baomidou</groupId>
              <!--3.5.4开始,支持SpringBoot3使用此版本-->
              <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
              <version>3.5.4</version>
          </dependency>
  
          <!-- mysql -->
          <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>8.0.33</version>
              <scope>runtime</scope>
          </dependency>
      </dependencies>
```
- 4、 配置application.yml 文件 主要是数据库连接信息
```yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test_db?serverTimezone=UTC&useSSL=false&allowPublicKeyRetrieval=true
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
``` 
- 5、 添加启动类，在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 Mapper 文件夹
```java
package org.example;


import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("org.example.mapper")
public class DemoMybatis3Application {
    public static void main(String[] args) {
        SpringApplication.run(DemoMybatis3Application.class, args);
    }
}
```
- 6、编写 User 实体类 及 UserMapper 接口
```java
@Data
@TableName("`user`")
public class User extends Model<User>{
    private Long id;
    private String name;
    private Integer age;
    private String email;
}
```
```java
public interface UserMapper  extends BaseMapper<User> {
    
}
```
- 7、 CRUD操作测试
```java
 /**
     * 测试查询所有
     */
    @Test
    public void testSelectAll() {
        System.out.println(("----- selectAll method test ------"));
        User user = new User();
        List<User> userList = user.selectAll();
        userList.forEach(System.out::println);
    }

    /**
     * 测试新增
     */
    @Test
    public void add() {
        System.out.println(("----- add method test ------"));
        User user = new User();
        user.setName("赵六");
        user.setAge(30);
        user.setEmail("zhaoliu@163.com");
        user.insert();
        System.out.println(user.toString());
    }

    /**
     * 测试单条查询
     */
    @Test
    public void getOne() {
        System.out.println(("----- getOne method test ------"));
        User user = new User();
//        user.setId(9L);
//        user = user.selectById();
        user = user.selectById(9L);
        System.out.println(user.toString());
    }

    /**
     * 测试修改
     */
    @Test
    public void update() {
        System.out.println(("----- update method test ------"));
        User user = new User();
        user.setId(9L);
        user.setName("赵六六");
        user.setAge(33);
        user.setEmail("zhaoliu@163.com");
        user.updateById();
        System.out.println(user.toString());
    }

    /**
     * 测试删除
     */
    @Test
    public void del() {
        System.out.println(("----- del method test ------"));
        User user = new User();
//        user.setId(9L);
//        user.deleteById();
        boolean b = user.deleteById(9L);
        System.out.println(b);
    }
```
- 8、 SimpleQuery 工具类
```text
说明:
对selectList查询后的结果用Stream流进行了一些封装，使其可以返回一些指定结果，简洁了api的调用
需要项目中已注入对应实体的BaseMapper
```
  测试代码示例
  ```java
   @Test
public void listOperate() {
  System.out.println(("----- SimpleQuery listOperate method test ------"));
  List<String> userNames = new java.util.ArrayList<>();
  List<String> emails = new java.util.ArrayList<>();
  // 该查询 追加了 获取id集，打印，获取name集，获取email集的操作
  List<Long> ids = SimpleQuery.list(lambdaQuery(),
          User::getId, System.out::println, user -> userNames.add(user.getName()),
          user -> emails.add(user.getEmail()));
  // 打印ids
  ids.forEach(System.out::println);
  // 打印userNames
  userNames.forEach(System.out::println);
  // 打印emails
  emails.forEach(System.out::println);
}

/**
 * 测试查询 keyMap 返回为Map<属性,实体>
 */
@Test
public void keyMap() {
  System.out.println(("----- SimpleQuery keyMap method test ------"));
  // 查询表内记录，封装返回为Map<属性,实体>
//        Map<Long,User> userMap = SimpleQuery.keyMap(Wrappers.lambdaQuery(),
//                User::getId);
  // 查询表内记录，封装返回为Map<属性,实体>，考虑了并行流的情况
  Map<Long,User> userMap = SimpleQuery.keyMap(lambdaQuery(),
          User::getId,true);
  userMap.forEach((k,v)->{
    System.out.println(k+"-->"+v);
  });
}


/**
 * 测试查询 map  返回为Map<属性,属性>
 */
@Test
public void map() {
  System.out.println(("----- SimpleQuery map method test ------"));
  //  查询表内记录，封装返回为Map<属性,属性>
//        Map<Long,String> userMap = SimpleQuery.map(Wrappers.lambdaQuery(),
//                User::getId,User::getName);
  // 查询表内记录，封装返回为Map<属性,属性>，考虑了并行流的情况
  Map<Long,String> userMap = SimpleQuery.map(lambdaQuery(),
          User::getId,User::getEmail,true);
  userMap.forEach((k,v)->{
    System.out.println(k+"-->"+v);
  });
}

/**
 * 测试查询 group  返回为Map<属性,List<实体>>
 */
@Test
public void group() {
  System.out.println(("----- SimpleQuery group method test ------"));
  //  查询表内记录，封装返回为Map<属性,List<实体>>
//        Map<Integer,List<User>> userMap = SimpleQuery.group(Wrappers.lambdaQuery(),
//                User::getAge);
  // 查询表内记录，封装返回为Map<属性,List<实体>>，考虑了并行流的情况
  Map<Integer,List<User>> userMap = SimpleQuery.group(lambdaQuery(),
          User::getAge,true);
  userMap.forEach((k,v)->{
    System.out.println(k+"-->"+v);
  });
}

/**
 * 测试查询 group  返回为Map<属性,分组后对集合进行的下游收集器>
 */
@Test
public void groupM() {
  System.out.println(("----- SimpleQuery groupM method test ------"));
  //  查询表内记录，封装返回为Map<属性,List<实体>>
//        Map<Integer, Set<User>> group = SimpleQuery.group(Wrappers.lambdaQuery(),
//                User::getAge, Collectors.toSet());

//        Map<Integer, Map<Long, String>> group = SimpleQuery.group(Wrappers.lambdaQuery(),
//                User::getAge, Collectors.toMap(User::getId, User::getName, (a, b) -> a));

//        // 查询表内记录，封装返回为Map<属性,List<实体>>，考虑了并行流的情况
//        Map<Integer, Set<User>> group = SimpleQuery.group(Wrappers.lambdaQuery(),
//                User::getAge, Collectors.toSet(),true);
  Map<Integer, Map<Long, String>> group = SimpleQuery.group(lambdaQuery(),
          User::getAge, Collectors.toMap(User::getId, User::getName, (a, b) -> a));
  group.forEach((k,v)->{
    System.out.println(k+"-->"+v);
  });
}

/**
 * 测试查询 list 返回为List<属性>
 */
@Test
public void list() {
  System.out.println(("----- SimpleQuery list method test ------"));
  // 查询表内记录，封装返回为List<属性>
//        List<String> names = SimpleQuery.list(Wrappers.lambdaQuery(), User::getName);
  // 查询表内记录，封装返回为List<属性>，考虑了并行流的情况
  List<String> names = SimpleQuery.list(lambdaQuery(), User::getName,true);
  // 打印 names
  names.forEach(System.out::println);
}

@Test
void testList() {
  // 我要这张表里的ids
  List<Long> entityIds = SimpleQuery.list(lambdaQuery(), User::getId);
  assertThat(entityIds).containsExactly(1L, 2L);

  // 可叠加后续操作
  List<String> names = SimpleQuery.list(lambdaQuery(), User::getName,
          e -> Optional.ofNullable(e.getName())
                  .map(String::toUpperCase)
                  .ifPresent(e::setName));
  assertThat(names).containsExactly("RUBEN", null);
}

  ```
- 9、Db类
```text
说明:

使用静态调用的方式，执行CRUD方法，避免Spring环境下Service循环注入、简洁代码，提升效率
需要项目中已注入对应实体的BaseMapper
对于参数为Wrapper的，需要在Wrapper中传入Entity或者EntityClass供寻找对应的Mapper
不建议在循环中调用，如果是批量保存，建议将数据构造好后使用 Db.saveBatch(数据) 保存
```
代码示例
```java
 @Test
    void dbTest() {
        // 根据id查询
        List<User> list = Db.listByIds(Arrays.asList(1L, 2L), User.class);
        list.stream().forEach(System.out::println);

        // 根据条件构造器查询
        List<User> list1 = Db.list(Wrappers.lambdaQuery(User.class));
        list1.stream().forEach(System.out::println);
        // 批量根据id更新
//        boolean isSuccess = Db.updateBatchById(list);
    }
```