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=trueusername: rootpassword: 123456driver-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操作測試

 /*** 測試查詢所有*/@Testpublic void testSelectAll() {System.out.println(("----- selectAll method test ------"));User user = new User();List<User> userList = user.selectAll();userList.forEach(System.out::println);}/*** 測試新增*/@Testpublic 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());}/*** 測試單條查詢*/@Testpublic 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());}/*** 測試修改*/@Testpublic 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());}/*** 測試刪除*/@Testpublic 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(數據) 保存

代碼示例

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