Mybatis Plus ActiveRecord 模式 使用
DEMO源码地址 https://gitee.com/JackSong2019/demo-mybatis3.git
前言
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);
}