Mybatis Plus ActiveRecord 模式

Mybatis Plus ActiveRecord 模式使用

DEMO源码地址 https://gitee.com/JackSong2019/demo-mybatis3.git

前言

ActiveRecord 模式简介

ActiveRecord 是一种设计模式，它是一种在软件开发中用于管理关系数据库的模式，他简化了数据库操作的流程，使得开发人员可以更专注于业务逻辑而非数据库细节。它提供了一种面向对象的方法来处理数据库，使得数据库操作变得更加直观、易于维护和扩展。

关于 ActiveRecord 模式的一些重要概念和特点

  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 父工程

  <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 依赖：

  <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 文件主要是数据库连接信息

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 文件夹

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 接口

@Data
@TableName("`user`")
public class User extends Model<User>{
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

public interface UserMapper  extends BaseMapper<User> {
    
}

7、 CRUD操作测试

 /**
     * 测试查询所有
     */
    @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 工具类

说明:
对selectList查询后的结果用Stream流进行了一些封装，使其可以返回一些指定结果，简洁了api的调用
需要项目中已注入对应实体的BaseMapper

测试代码示例

 @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类

说明:

使用静态调用的方式，执行CRUD方法，避免Spring环境下Service循环注入、简洁代码，提升效率
需要项目中已注入对应实体的BaseMapper
对于参数为Wrapper的，需要在Wrapper中传入Entity或者EntityClass供寻找对应的Mapper
不建议在循环中调用，如果是批量保存，建议将数据构造好后使用 Db.saveBatch(数据) 保存

代码示例

 @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);
    }