Mybatis Plus ActiveRecord模式的具体使用
作者：阿松哥哥2018
ActiveRecord 是一种设计模式,它是一种在软件开发中用于管理关系数据库的模式,本文主要介绍了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);
}到此这篇关于Mybatis Plus ActiveRecord模式的具体使用的文章就介绍到这了,更多相关Mybatis Plus ActiveRecord内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！