MybatisPlus使用详情

一、简介

1.1 概述

MyBatis-Plus（简称MP）是一个MyBatis的增强工具，在MyBatis的基础上只做增强不做改变，为简化开发、提高效率而生。
MyBatisPlus官网：https://baomidou.com/
1.2 特性

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
  
• 损耗小：启动即会自动注入基本CURD，性能基本无损耗，直接面向对象操作
  
• 强大的CRUD操作：内置通用Mapper、通用Service，仅仅通过少量配置即可实现单表大部分CRUD操作，更有强大的条件构造器，满足各类使用需求
  
• 支持Lambda形式调用：通过Lambda表达式，方便的编写各类查询条件，无需再担心字段写错
  
• 支持主键自动生成：支持多达4种主键策略（内含分布式唯一ID生成器-Sequence），可自由配置，完美解决主键问题
  
• 支持ActiveRecord模式：支持ActiveRecord形式调用，实体类只需继承Model类即可进行强大的CRUD操作
  
• 支持自定义全局通用操作：支持全局通用方法注入（Write once, use anywhere）
  
• 内置代码生成器：采用代码或者Maven插件可快速生成Mapper、Model、Service、Controller层代码，支持模板引擎，更有超多自定义配置等您来使用
  
• 内置分页插件：基于MyBatis物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通List查询
  
• 分页插件支持多种数据库：支持MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer等多种数据库
  
• 内置性能分析插件：可输出SQL语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
  
• 内置全局拦截插件：提供全表delete、update操作智能分析阻断，也可自定义拦截规则，预防误操作
  

1.3 支持的数据库

任何能使用MyBatis进行CRUD，并且支持标准SQL的数据库，具体支持情况如下，如果不在下列表查看分页部分教程PR您的支持。

• MySQL，Oracle，DB2，H2，HSQL，SQLite，PostgreSQL，SQLServer，Phoenix，Gauss，ClickHouse，Sybase，OceanBase，Firebird，Cubrid，Goldilocks，csiidb
  
• 达梦数据库，虚谷数据库，人大金仓数据库，南大通用(华库)数据库，南大通用数据库，神通数据库，瀚高数据库
  

1.4 核心架构

二、入门案例

创建测试表

1. DROP TABLE IF EXISTS user;
3. CREATE TABLE `user`
4. (
5.     `id`       bigint(20) NOT NULL COMMENT '主键ID',
6.     `name`     varchar(30) DEFAULT NULL COMMENT '姓名',
7.     `sex`      char(1)     DEFAULT NULL COMMENT '性别 0:男 1:女',
8.     `age`      int(11)     DEFAULT NULL COMMENT '年龄',
9.     `birthday` date        DEFAULT NULL COMMENT '生日',
10.     PRIMARY KEY (`id`)
11. );
13. INSERT INTO `user` VALUES (1, 'Jone', '1', 27, '2001-10-04');
14. INSERT INTO `user` VALUES (2, 'Jack', '0', 20, '1999-10-04');
15. INSERT INTO `user` VALUES (3, 'Tom', '1', 28, '1996-08-12');
16. INSERT INTO `user` VALUES (4, 'Sandy', '1', 21, '2001-10-04');
17. INSERT INTO `user` VALUES (5, 'Billie', '0', 24, '1992-09-07');
18. INSERT INTO `user` VALUES (6, 'Jackson', '0', 18, '1996-08-12');
19. INSERT INTO `user` VALUES (7, 'Hardy', '1', 25, '1992-09-07');
20. INSERT INTO `user` VALUES (8, 'Rose', '1', 21, '1992-09-07');
21. INSERT INTO `user` VALUES (9, 'June', '0', 28, '1992-09-07');
22. INSERT INTO `user` VALUES (10, 'Aidan', '0', 17, '2001-10-04');

复制代码

引入依赖

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.     <modelVersion>4.0.0</modelVersion>
7.     <groupId>com.test</groupId>
8.     01_MyBatisPlus</artifactId>
9.     <version>1.0-SNAPSHOT</version>
10.     <parent>
11.         <groupId>org.springframework.boot</groupId>
12.         spring-boot-starter-parent</artifactId>
13.         <version>2.6.3</version>
14.         <relativePath/>
15.     </parent>
17.     <dependencies>
18.         
19.         <dependency>
20.             <groupId>org.springframework.boot</groupId>
21.             spring-boot-starter</artifactId>
22.         </dependency>
23.         
24.         <dependency>
25.             <groupId>org.springframework.boot</groupId>
26.             spring-boot-starter-test</artifactId>
27.             <scope>test</scope>
28.         </dependency>
29.         
30.         <dependency>
31.             <groupId>com.baomidou</groupId>
32.             mybatis-plus-boot-starter</artifactId>
33.             <version>3.4.2</version>
34.         </dependency>
36.         
37.         <dependency>
38.             <groupId>junit</groupId>
39.             junit</artifactId>
40.             <version>4.13</version>
41.             <scope>test</scope>
42.         </dependency>
44.         
45.         <dependency>
46.             <groupId>mysql</groupId>
47.             mysql-connector-java</artifactId>
48.         </dependency>
50.         
51.         <dependency>
52.             <groupId>org.projectlombok</groupId>
53.             lombok</artifactId>
54.         </dependency>
55.     </dependencies>
56. </project>

复制代码

实体类

1. package com.test.entity;
3. import lombok.AllArgsConstructor;
4. import lombok.Data;
5. import lombok.NoArgsConstructor;
7. @Data
8. @AllArgsConstructor
9. @NoArgsConstructor
10. public class User {
11.     private Long id;
12.     private String name;
13.     private String sex;
14.     private Integer age;
15.     private String birthday;
16. }

复制代码

Mapper接口

1. package com.test.mapper;
3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
4. import com.test.entity.User;
5. import org.apache.ibatis.annotations.Mapper;
7. @Mapper
8. public interface UserMapper extends BaseMapper<User> {
9. }

复制代码

application.yml

1. spring:
2.   datasource:
3.     driver-class-name: com.mysql.jdbc.Driver
4.   url: jdbc:mysql://localhost:3306/mybatisplus?serverTimezone=GMT%2b8
5.   username: root
6.   password: admin
7. #配置日志
8. mybatis-plus:
9.   configuration:
10.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

复制代码

启动类

1. package com.test;
3. import org.mybatis.spring.annotation.MapperScan;
4. import org.springframework.boot.SpringApplication;
5. import org.springframework.boot.autoconfigure.SpringBootApplication;
7. @SpringBootApplication
8. @MapperScan("com.test.mapper")
9. public class MyBatisPlusApplication {
10.     public static void main(String[] args) {
11.         SpringApplication.run(MyBatisPlusApplication.class, args);
12.     }
13. }

复制代码

测试类

1. package com.test;
3. import com.test.entity.User;
4. import com.test.mapper.UserMapper;
5. import org.junit.Assert;
6. import org.junit.Test;
7. import org.junit.runner.RunWith;
8. import org.springframework.boot.test.context.SpringBootTest;
9. import org.springframework.test.context.junit4.SpringRunner;
11. import java.util.List;
12. import javax.annotation.Resource;
14. @SpringBootTest(classes = MyBatisPlusApplication.class)
15. @RunWith(SpringRunner.class)
16. public class Demo01 {
18.     @Resource
19.     private UserMapper userMapper;
21.     @Test
22.     public void testSelect() {
23.         // 传递null代表查询全部
24.         List<User> userList = userMapper.selectList(null);
25.         for (User user : userList) {
26.             System.out.println(user);
27.         }
28.     }
29. }

复制代码

三、BaseMapper接口

在MyBatisPlus中，我们编写的Mapper接口都继承与MyBatisPlus提供的BaseMapper接口，BaseMapper接口包含了MyBatisPlus帮我们提供操作数据库的一系列方法；
官网案例：https://baomidou.com/pages/49cc81/#mapper-crud-接口
使用示例：

1. package com.test;
3. import com.test.entity.User;
4. import com.test.mapper.UserMapper;
5. import org.junit.Test;
6. import org.junit.runner.RunWith;
7. import org.springframework.boot.test.context.SpringBootTest;
8. import org.springframework.test.context.junit4.SpringRunner;
10. import java.util.Arrays;
11. import java.util.HashMap;
12. import java.util.List;
13. import javax.annotation.Resource;
15. @SpringBootTest(classes = MyBatisPlusApplication.class)
16. @RunWith(SpringRunner.class)
17. public class Demo01_BaseMapper {
19.     @Resource
20.     private UserMapper userMapper;
22.     /**
23.      * 新增
24.      * INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
25.      */
26.     @Test
27.     public void insert() {
28.         User user = new User(100L, "Ken", "0", 20);
29.         userMapper.insert(user);
30.     }
32.     /**
33.      * 修改
34.      * UPDATE user SET name=?, age=?, email=? WHERE id=?
35.      */
36.     @Test
37.     public void update() {
38.         User user = new User(100L, "Kevin", "0", 25);
39.         userMapper.updateById(user);
40.     }
42.     /**
43.      * 根据id查询
44.      * SELECT id,name,age,email FROM user WHERE id=?
45.      */
46.     @Test
47.     public void selectById() {
48.         User user = userMapper.selectById(100L);
49.         System.out.println(user);
50.     }
52.     /**
53.      * 根据一批id查询
54.      * SELECT id,name,age,email FROM user WHERE id IN ( ?, ?, ? )
55.      */
56.     @Test
57.     public void selectBatchIds() {
58.         List<User> userList = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
59.         for (User user : userList) {
60.             System.out.println(user);
61.         }
62.     }
64.     /**
65.      * 根据条件查询数据
66.      * SELECT id,name,age,email FROM user WHERE name = ? AND id = ?
67.      */
68.     @Test
69.     public void selectByMap() {
70.         // 封装条件
71.         HashMap<String, Object> param = new HashMap<>();
72.         param.put("id", 10L);
73.         param.put("name", "Kevin");
74.         // 根据条件查询,map中的多个条件是并列关系 id=10 and name='小灰灰'
75.         List<User> userList = userMapper.selectByMap(param);
76.         for (User user : userList) {
77.             System.out.println(user);
78.         }
79.     }
81.     /**
82.      * 根据id删除
83.      * DELETE FROM user WHERE id=?
84.      */
85.     @Test
86.     public void deleteById() {
87.         userMapper.deleteById(100L);
88.     }
90.     /**
91.      * 根据id删除一批
92.      * DELETE FROM user WHERE id IN ( ?, ?, ? )
93.      */
94.     @Test
95.     public void deleteBatchIds() {
96.         userMapper.deleteBatchIds(Arrays.asList(1, 2, 3));
97.     }
99.     /**
100.      * 根据条件删除数据
101.      * DELETE FROM user WHERE name = ? AND id = ?
102.      */
103.     @Test
104.     public void deleteByMap() {
105.         // 封装条件
106.         HashMap<String, Object> param = new HashMap<>();
107.         param.put("id", 100L);
108.         param.put("name", "Kevin");
109.         userMapper.deleteByMap(param);
110.     }
111. }

复制代码

四、Wrapper接口

通过BaseMapper提供的一些方法我们可以完成一些基本的CRUD，但无法完成复杂条件的查询；对于复杂条件的查询，MyBatisPlus提供了Wrapper接口来处理；
Wrapper是MyBatisPlus提供的一个条件构造器，主要用于构建一系列条件，当Wrapper构建完成后，可以使用Wrapper中的条件进行查询、修改、删除等操作；
Wrapper的继承体系如下：

Wrapper是条件构造抽象类，最顶端父类，其主要实现类有如下：

• AbstractWrapper：用于查询条件封装，生成sql的where条件
  
  
  
  • QueryWrapper：Query条件封装
    
  • UpdateWrapper：Update条件封装
    
  • AbstractLambdaWrapper：使用Lambda语法
    
    
    
    • LambdaQueryWrapper：基于Lambda语法使用的查询Wrapper
      
    • LambdaUpdateWrapper：基于Lambda语法使用的更新Wrapper
      
    
    
  
  

官方文档：https://baomidou.com/pages/10c804/

4.1 基本方法

AbstractWrapper是其他常用Wrapper的父类，用于生成sql的where条件
4.1.1 方法介绍

AbstractWrapper提供了很多公有的方法，其子类全部具备这些方法，方法列表如下：
方法名解释示例eq等于 =eq(“name”, “老王”)--->
name = ‘老王’ne不等于 ne(“name”, “老王”)--->
name  ‘老王’gt大于 >gt(“age”, 18)--->
age > 18ge大于等于 >=ge(“age”, 18)--->
age >= 18lt小于 </tdtdlt(“age”, 18)strong---></strong>
age < 18le小于等于 </strong>
age </strong>
age between 18 and 30notBetweennot between 值1 and 值2notBetween(“age”, 18, 30)--->
age not between 18 and 30likeLIKE ‘%值%’like(“name”, “王”)--->      
     name like ‘%王%’notLikeNOT LIKE ‘%值%’notLike(“name”, “王”)--->
name not like ‘%王%’likeLeftLIKE ‘%值’likeLeft(“name”, “王”)--->
name like ‘%王’likeRightLIKE ‘值%’likeRight(“name”, “王”)--->         
name like ‘王%’isNull字段 IS NULLisNull(“name”)--->                  
     name is nullisNotNull字段 IS NOT NULLisNotNull(“name”)--->            
   name is not nullin字段 IN (v0, v1, …)in(“age”, 1, 2, 3)--->               
      age in (1,2,3)notIn字段 NOT IN (v0, v1, …)notIn(“age”, 1, 2, 3)--->               
   age not in (1,2,3)inSql字段 IN ( sql语句 )inSql(“id”, “select id from table where id < 3”)--->  
   id in (select id from table where id < 3)notInSql字段 NOT IN ( sql语句 )notInSql(“id”, “select id from table where id < 3”)--->  
id not in (select id from table where id < 3)groupBy分组：GROUP BY 字段, …groupBy(“id”, “name”)--->
group by id,nameorderByAsc排序：ORDER BY 字段, … ASCorderByAsc(“id”, “name”)--->
order by id ASC,name ASCorderByDesc排序：ORDER BY 字段, … DESCorderByDesc(“id”, “name”)--->
order by id DESC,name DESCorderBy排序：ORDER BY 字段, …orderBy(true, true, “id”, “name”)--->
order by id ASC,name ASChavingHAVING ( sql语句 )例1：having(“sum(age) > 10”)--->  
  having sum(age) > 10
例2：having(“sum(age) > {0}”, 11)--->
having sum(age) > 11func主要解决条件拼接func(i -> if(true) {i.eq(“id”, 1)} else {i.ne(“id”, 1)})or拼接 OReq(“id”,1).or().eq(“name”,“老王”)--->   
id = 1 or name = ‘老王’andAND 嵌套and(i -> i.eq(“name”, “李白”).ne(“status”, “活着”))--->   
and (name = ‘李白’ and status  ‘活着’)nested用于多条件拼接时nested(i -> i.eq(“name”, “李白”).ne(“status”, “活着”))--->   
(name = ‘李白’ and status  ‘活着’)apply用于拼接SQL语句例1：apply(“id = 1”)--->   
id = 1   
例2：apply(“id = {0}”,1)--->  
id = 1   
  例3：apply(“name like {0} and age > {1}”,“%J%”,18) --->   
name like ‘%J%’ and age > 18last无视优化规则直接拼接到 sql 的最后last(“limit 1”) --->   
在SQL语句最后面拼接：limit 1exists拼接 EXISTS ( sql语句 )exists(“select id from table where age = 1”)--->   
exists (select id from table where age = 1)notExists拼接 NOT EXISTS ( sql语句 )notExists(“select id from table where age = 1”)--->   
not exists (select id from table where age = 1)创建Wrapper对象：

• Wrappers静态方法：
  
  
  
  • public static  QueryWrapper query()
    
  
  
• 通过QueryWrapper对象的构造方法：
  
  
  
  • public QueryWrapper()
    
  
  

代码示例：

1. @SpringBootTest(classes = MyBatisPlusApplication.class)
2. @RunWith(SpringRunner.class)
3. public class Demo02_Wrapper {
5.     @Resource
6.     private UserMapper userMapper;
8.     /**
9.      * QueryWrapper的创建
10.      * SELECT id,name,age,email FROM user
11.      */
12.     @Test
13.     public void test1() {
14.         // 创建QueryWrapper，默认情况下查询所有数据
15.         QueryWrapper<User> wrapper = Wrappers.query();
16.         QueryWrapper<User> wrapper2 = new QueryWrapper<>();
18.         List<User> users = userMapper.selectList(wrapper);
19.         users.forEach(System.out::println);
20.     }
21. }

复制代码

4.1.2 基本方法的使用

官网案例：https://baomidou.com/pages/10c804/#abstractwrapper
使用示例：

1. @Test
2. public void test2() {
3.     QueryWrapper<User> wrapper = Wrappers.query();
4.     // name ='Jack'
5.     // wrapper.eq("name","Jack");
7.     //参数1: 是否要进行name条件的拼接
8.     String name = "Jack";
9.     wrapper.eq(StringUtils.isNotBlank(name), "name", name);
11.     // name != 'Jack'
12.     // wrapper.ne("name","Jack");
14.     // age > 20
15.     // wrapper.gt("age",20);
17.     // age < 20
18.     // wrapper.lt("age",20);
20.     // age=20
21.     // wrapper.lt("age",20);
23.     // age between 20 and 24
24.     // wrapper.between("age",20,24);
26.     // age not between 20 and 24
27.     // wrapper.notBetween("age",20,24);
29.     // name like "%J%"   自动拼接左右的%
30.     // wrapper.like("name","J");
32.     // name not like "%J%"
33.     // wrapper.notLike("name","J");
35.     // name like "%J"
36.     // wrapper.likeLeft("name","J");
38.     // name like 'J%'
39.     // wrapper.likeRight("name","J");
41.     // name is null
42.     // wrapper.isNull("name");
44.     // name is not null
45.     // wrapper.isNotNull("name");
47.     // name in ('Jack','Tom','Jone')
48.     // wrapper.in("name","Jack","Tom","Jone");
50.     // name not in ('Jack','Tom','Jone')
51.     // wrapper.notIn("name","Jack","Tom","Jone");
53.     List<User> users = userMapper.selectList(wrapper);
54.     users.forEach(System.out::println);
55. }

复制代码

4.1.3 子查询

示例代码：

1. @Test
2. public void test3() {
3.     // 创建wrapper对象
4.     QueryWrapper<User> wrapper = Wrappers.query();
5.     // 相当于: name in (select name from user where age > 21)
6.     wrapper.inSql("name", "select name from user where age > 21");
7.     // 相当于: name not in (select name from user where age > 21)
8.     // wrapper.notInSql("name","select name from user where age > 21");
9.     List<User> users = userMapper.selectList(wrapper);
10.     users.forEach(System.out::println);
11. }

复制代码

4.1.4 分组与排序

1）分组：
通过Wrapper.query()构建的查询字段默认是表中的所有字段，因此在这种情况下分组是没有意义的，分组具体的用法我们后面再详细介绍；

1. @Test
2. public void test4() {
3.     // 创建wrapper对象
4.     QueryWrapper<User> wrapper = Wrappers.query();
5.     // 相当于 select * from user where group sex
6.     // 这是一个没有意义的分组,分组必须结合查询的字段来体现,后续学QueryWrapper的select方法再介绍
7.     wrapper.groupBy("sex");
8.     List<User> users = userMapper.selectList(wrapper);
9.     users.forEach(System.out::println);
10. }

复制代码

2）having操作

1. @Test
2. public void test5() {
3.     // 创建wrapper对象
4.     QueryWrapper<User> wrapper = Wrappers.query();
5.     // group by sex having sex = 0
6.     wrapper.groupBy("sex");
7.     wrapper.having("sex", "0");
8.     List<User> users = userMapper.selectList(wrapper);
9.     users.forEach(System.out::println);
10. }

复制代码

3）排序：

1. @Test
2. public void test6() {
3.     //  创建wrapper对象
4.     QueryWrapper<User> wrapper = Wrappers.query();
5.     /**
6.      * 参数1: 是否是Asc排序(升序), true : asc排序, false: desc排序
7.      * 参数2: 排序的字段
8.      */
9.     // wrapper.orderByAsc("age");                // order by age asc
10.     // wrapper.orderByDesc("age");                // order by age desc
11.     List<User> users = userMapper.selectList(wrapper);
12.     users.forEach(System.out::println);
13. }

复制代码

4.1.5 多条件的拼接

Wrapper对象在调用每一个方法时都会返回当前对象（Wrapper），这样可以很好的方便我们链式编程；另外MyBatisPlus在拼接多个条件时默认使用and拼接，如果需要使用or，那么需要显示的调用or()方法；
1）and拼接条件：

1. @Test
2. public void test7() {
3.     //创建wrapper对象
4.     QueryWrapper<User> wrapper = Wrappers.query();
5.     // 默认情况下,多条件是以and拼接
6.     // SQL语句: name LIKE "%a%" AND age > 20 AND sex = 0
7.     wrapper.like("name", "%a%")
8.             .lt("age", 20)
9.             .eq("sex", 0);
10.     List<User> users = userMapper.selectList(wrapper);
11.     users.forEach(System.out::println);
12. }

复制代码

2）or拼接条件：

1. @Test
2. public void test8() {
3.     //  创建wrapper对象
4.     QueryWrapper<User> wrapper = Wrappers.query();
5.     /*
6.     默认情况下,多条件是以and拼接
7.     SQL语句: name LIKE "%a%" OR age > 20 AND sex = 0
8.     */
9.     wrapper.like("name", "%a%")
10.             .or()
11.             .lt("age", 20)
12.             .eq("sex", 0);   // 该条件仍然以AND拼接
13.     List<User> users = userMapper.selectList(wrapper);
14.     users.forEach(System.out::println);
15. }

复制代码

4.1.6 其他方法

1）and方法：用于拼接一个其他的整体条件；示例如下：

1. @Test
2. public void test1() {
3.     QueryWrapper<User> wrapper = Wrappers.query();
5.     // 生成的SQL为: (age < ? AND (sex = ? OR name LIKE ?))
6.    
7. //    wrapper.lt("age", 20);
8. //    wrapper.and(new Consumer<QueryWrapper<User>>() {
9. //        @Override
10. //        public void accept(QueryWrapper<User> userQueryWrapper) {
11. //            userQueryWrapper.eq("sex", 0)
12. //                    .or()
13. //                    .like("name", "J");
14. //        }
15. //    });
16.   
17.     // 生成的SQL为:  (age < ? AND sex = ? OR name LIKE ?)
18.     wrapper.lt("age", 20)
19.             .eq("sex", 0)
20.             .or()
21.             .like("name", "J");
22.     List<User> users = userMapper.selectList(wrapper);
23.     users.forEach(System.out::println);
24. }

复制代码

2）func方法：用于多条件的拼接，直接使用之前的方法也可以做到这个功能；示例如下：

1. @Test
2. public void test2() {
3.     QueryWrapper<User> wrapper = Wrappers.query();
5.     // 生成的SQL语句条件: (age < ? AND name LIKE ? AND sex = ?)
6.     wrapper.lt("age", 20);
7.     wrapper.func(new Consumer<QueryWrapper<User>>() {
8.         @Override
9.         public void accept(QueryWrapper<User> userQueryWrapper) {
10.             userQueryWrapper.like("name", "a");
11.             userQueryWrapper.eq("sex", "0");
12.         }
13.     });
14.     // 等价于:
15. //    wrapper.lt("age", 20)
16. //            .like("name", "a")
17. //            .eq("sex", "0");
18.     List<User> users = userMapper.selectList(wrapper);
19.     users.forEach(System.out::println);
20. }

复制代码

3）nested方法：功能等价于and方法

1. @Test
2. public void test3() {
3.     QueryWrapper<User> wrapper = Wrappers.query();
4.     // 生成的SQL语句条件为: (id = ? AND (name LIKE ? OR age > ?))
5.     // nested()等价于and方法()
6.     wrapper.eq("id", 1);
7.     wrapper.nested(new Consumer<QueryWrapper<User>>() {
8.         @Override
9.         public void accept(QueryWrapper<User> userQueryWrapper) {
10.             // 默认情况下是用and来拼接多个条件
11.             userQueryWrapper.like("name", "a")
12.                     .or().gt("age", 20);
13.         }
14.     });
15.     List<User> users = userMapper.selectList(wrapper);
16.     users.forEach(System.out::println);
17. }

复制代码

4）apply方法：可以使用占位符进行参数传参；示例如下：

1. @Test
2. public void test4() {
3.     QueryWrapper<User> wrapper = Wrappers.query();
4.     // SQL: (name like ? and age > ?)
5.     // wrapper.apply("name like {0} and age > {1}", "%J%", 18);
7.     // SQL: (date_format(birthday, '%Y-%m-%d') = ?)
8.     wrapper.apply("date_format(birthday, '%Y-%m-%d') = {0}", "2001-10-04");
9.     List<User> users = userMapper.selectList(wrapper);
10.     users.forEach(System.out::println);
11. }

复制代码

5）last方法：无视优化规则直接拼接到 sql 的最后,只能调用一次,多次调用以最后一次为准 有sql注入的风险

Tips：apply方法可以防止SQL注入，但last方法不能；

1. @Test
2. public void test5() {
3.     QueryWrapper<User> wrapper = Wrappers.query();
5.     // 无视优化规则直接拼接到 sql 的最后,只能调用一次,多次调用以最后一次为准 有sql注入的风险
7.     // SQL: name = 'Jone'
8.     // String name = "Jone";
9.     // wrapper.last("where name = '" + name + "'");
11.     // SQL: SELECT id,name,sex,age FROM user where name ='' or 1=1; -- '
12.     String name = "' or 1=1; -- ";
13.     wrapper.last("where name ='" + name + "'");  // 出现SQL注入问题
15.     List<User> users = userMapper.selectList(wrapper);
16.     users.forEach(System.out::println);
17. }

复制代码

6）exists方法：用于exists语句

1. @Test
2. public void test6() {
3.     QueryWrapper<User> wrapper = Wrappers.query();
4.     // SQL: (EXISTS (select 1))
5.     wrapper.exists("select 1");
6.     List<User> users = userMapper.selectList(wrapper);
7.     users.forEach(System.out::println);
8. }

复制代码

7）notExists方法：

1. @Test
2. public void test7() {
3.     QueryWrapper<User> wrapper = Wrappers.query();
4.     // SQL: (NOT EXISTS (select 1))
5.     wrapper.notExists("select 1");
6.     List<User> users = userMapper.selectList(wrapper);
7.     users.forEach(System.out::println);
8. }

复制代码

4.2 QueryWrapper

QueryWrapper是AbstractWrapper的子类，主要用于查询指定字段，方法列表如下：
方法名解释示例select(String… sqlSelect)设置查询字段例1：select(“id”, “name”, “age”)
例2：select(i -> i.getProperty().startsWith(“test”))示例代码：

1. package com.test;
3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
4. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
5. import com.test.entity.User;
6. import com.test.mapper.UserMapper;
7. import org.junit.Test;
8. import org.junit.runner.RunWith;
9. import org.springframework.boot.test.context.SpringBootTest;
10. import org.springframework.test.context.junit4.SpringRunner;
11. import javax.annotation.Resource;
12. import java.util.List;
14. @SpringBootTest(classes = MyBatisPlusApplication.class)
15. @RunWith(SpringRunner.class)
16. public class Demo04_QueryWrapper {
18.     @Resource
19.     private UserMapper userMapper;
21.     // 选择查询的字段
22.     @Test
23.     public void test1() throws Exception {
24.         QueryWrapper<User> wrapper = Wrappers.query();
25.         // 确定要查询的字段
26.         wrapper.select("id", "name", "sex");
27.         // in
28.         wrapper.in("id", "1", "2");
29.         // SQL: SELECT id,name,sex FROM user WHERE (id IN (?,?))
30.         List<User> userList = userMapper.selectList(wrapper);
31.         userList.forEach(System.out::println);
32.     }
34.     @Test
35.     public void test2() throws Exception {
36.         User user = new User();
37.         user.setId(1L);
38.         // user当做查询的条件
39.         QueryWrapper<User> wrapper = Wrappers.query(user);
40.         // 指定查询的列
41.         wrapper.select("id", "name", "sex");
43.         // SQL: SELECT id,name,sex FROM user WHERE id=?
44.         List<User> userList = userMapper.selectList(wrapper);
45.         userList.forEach(System.out::println);
46.     }
47. }

复制代码

4.3 UpdateWrapper

UpdateWrapper也是AbstractWrapper的子类，因此UpdateWrapper也具备之前的那些查询方法，不同的是，UpdateMapper在那些方法基础之上还提供了很多有关于更新操作的方法；
方法如下：
方法名解释示例set(String column, Object val)设置查询字段例1：set("name", "老李头")
例2：set("name", "")
—>数据库字段值变为空字符串
例3：set("name", null)
—>数据库字段值变为nullsetSql(String sql)设置set子句的部分SQL例1：setSql("name = '老李头'")  
例2：setSql("name = '老李头',age=20 where id=1")示例代码：

1. package com.test;
3. import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
4. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
5. import com.test.entity.User;
6. import com.test.mapper.UserMapper;
7. import org.junit.Test;
8. import org.junit.runner.RunWith;
9. import org.springframework.boot.test.context.SpringBootTest;
10. import org.springframework.test.context.junit4.SpringRunner;
12. import javax.annotation.Resource;
13. import java.util.List;
15. @SpringBootTest(classes = MyBatisPlusApplication.class)
16. @RunWith(SpringRunner.class)
17. public class Demo05_UpdateWrapper {
19.     @Resource
20.     private UserMapper userMapper;
22.     @Test
23.     public void test1() throws Exception {
24.         UpdateWrapper<User> wrapper = Wrappers.update();
25.         // UpdateWrapper也是AbstractWrapper的子类,因此也具备一些基本的查询方法
26.         wrapper.like("name", "J");
27.         List<User> userList = userMapper.selectList(wrapper);
28.         for (User user : userList) {
29.             System.out.println(user);
30.         }
31.     }
33.     /**
34.      * 第一种方法: 使用wrapper来修改,并且指定查询条件
35.      *
36.      * @throws Exception
37.      */
38.     @Test
39.     public void test2() throws Exception {
40.         UpdateWrapper<User> wrapper = Wrappers.update();
41.         wrapper.set("name", "Jackson");
42.         wrapper.set("age", "16");
43.         wrapper.set("sex", "1");
44.         wrapper.eq("id", 2L);
46.         // SQL: UPDATE user SET name=?, sex=?, age=? WHERE (id = ?)
47.         userMapper.update(null, wrapper);
48.     }
50.     /**
51.      * 第二种方法: 使用wrapper来封装条件,使用entity来封装修改的数据
52.      *
53.      * @throws Exception
54.      */
55.     @Test
56.     public void test3() throws Exception {
57.         UpdateWrapper<User> wrapper = Wrappers.update();
58.         wrapper.eq("id", 2L);
59.         User user = new User(null, "Jack", "0", 28);
60.         // SQL: UPDATE user SET name=?, sex=?, age=? WHERE (id = ?)
61.         userMapper.update(user, wrapper);
62.     }
64.     /**
65.      * 第三种方法: Wrappers.update(user)传递查询的条件,使用wrapper来修改
66.      *
67.      * @throws Exception
68.      */
69.     @Test
70.     public void test4() throws Exception {
71.         User user = new User();
72.         user.setId(1L);
74.         // user当做查询条件
75.         UpdateWrapper<User> wrapper = Wrappers.update(user);
76.         wrapper.set("name", "xiaohui");
77.         wrapper.set("sex", "0");
78.         wrapper.set("age", "22");
80.         // SQL : UPDATE user SET name=?,sex=?,age=? WHERE id=?
81.         userMapper.update(null, wrapper);
82.     }
84.     /**
85.      * setSql方法
86.      *
87.      * @throws Exception
88.      */
89.     @Test
90.     public void test5() throws Exception {
91.         UpdateWrapper<User> wrapper = Wrappers.update();
92.         wrapper.setSql("name='abc',sex='0',age=18 where id=1");
94.         // SQL: UPDATE user SET name='abc',sex='0',age=18 where id=1
95.         userMapper.update(null, wrapper);
96.     }
97. }

复制代码

4.4 LambdaQueryWrapper

LambdaQueryWrapper是QueryWrapper的子类，具备QueryWrapper的所有方法，QueryWrapper的方法上提供了一系列有关于方法引的操作；
使用示例：

1. package com.test;
3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
4. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
5. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
6. import com.test.entity.User;
7. import com.test.mapper.UserMapper;
8. import org.junit.Test;
9. import org.junit.runner.RunWith;
10. import org.springframework.boot.test.context.SpringBootTest;
11. import org.springframework.test.context.junit4.SpringRunner;
13. import java.util.List;
14. import javax.annotation.Resource;
16. @SpringBootTest(classes = MyBatisPlusApplication.class)
17. @RunWith(SpringRunner.class)
18. public class Demo06_LambdaQueryWrapper {
20.     @Resource
21.     private UserMapper userMapper;
23.     /**
24.      * 使用QueryWrapper
25.      * @throws Exception
26.      */
27.     @Test
28.     public void test1() throws Exception {
29.         QueryWrapper<User> wrapper = Wrappers.query();
30.         wrapper.eq("id", "1");
31.         List<User> userList = userMapper.selectList(wrapper);
32.         for (User user : userList) {
33.             System.out.println(user);
34.         }
35.     }
37.     /**
38.      * 使用LambdaQueryWrapper
39.      * @throws Exception
40.      */
41.     @Test
42.     public void test2() throws Exception {
43.         LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery();
44.         // id=1
45.         // wrapper.eq(User::getId,1);
47.         // select id,name,age from user where id in (1,2,3) and name like "%a%"
48.         wrapper.in(User::getId, "1", "2", "3")
49.                 .like(User::getName, "a")
50.                 .select(User::getId, User::getName, User::getAge);
51.         List<User> userList = userMapper.selectList(wrapper);
52.         for (User user : userList) {
53.             System.out.println(user);
54.         }
55.     }
56. }

复制代码

4.5 LambdaUpdateMapper

LambdaUpdateMapper同样是UpdateMapper的子类，具备UpdateMapper的所有方法，UpdateMapper的方法上提供了一系列有关于方法引的操作；
示例代码：

1. package com.test;
3. import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
4. import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
5. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
6. import com.test.entity.User;
7. import com.test.mapper.UserMapper;
8. import org.junit.Test;
9. import org.junit.runner.RunWith;
10. import org.springframework.boot.test.context.SpringBootTest;
11. import org.springframework.test.context.junit4.SpringRunner;
12. import javax.annotation.Resource;
14. @SpringBootTest(classes = MyBatisPlusApplication.class)
15. @RunWith(SpringRunner.class)
16. public class Demo07_LambdaUpdateWrapper {
18.     @Resource
19.     private UserMapper userMapper;
21.     /**
22.      * 使用UpdateWrapper
23.      *
24.      * @throws Exception
25.      */
26.     @Test
27.     public void test1() throws Exception {
28.         UpdateWrapper<User> wrapper = Wrappers.update();
29.         wrapper.eq("id", "1");
30.         wrapper.set("name", "xiaohui");
31.         wrapper.set("age", 20);
32.         userMapper.update(null, wrapper);
33.     }
35.     /**
36.      * 使用LambdaUpdateWrapper
37.      *
38.      * @throws Exception
39.      */
40.     @Test
41.     public void test2() throws Exception {
42.         LambdaUpdateWrapper<User> wrapper = Wrappers.lambdaUpdate();
43.         wrapper.eq(User::getId, "1");
44.         wrapper.set(User::getName, "xiaolan");
45.         wrapper.set(User::getAge, 18);
46.         userMapper.update(null, wrapper);
47.     }
48. }

复制代码

五、Mapper分页查询

5.1 配置

在MyBatis中提供有Page对象来帮助我们实现分页查询，在Page对象中有如下成员：
成员变量说明List getRecords()当前页数据public long getTotal()总记录数public long getSize()页大小public long getCurrent()当前页default long getPages()总页数public boolean hasNext()是否有上一页public boolean hasPrevious()是否有上一页MyBatisPlus的分页逻辑底层是通过分页插件来完成的，因此我们首先要配置MyBatisPlus的分页插件；
配置分页插件：

1. package com.test.config;
3. import com.baomidou.mybatisplus.annotation.DbType;
4. import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
5. import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
6. import org.mybatis.spring.annotation.MapperScan;
7. import org.springframework.context.annotation.Bean;
8. import org.springframework.context.annotation.Configuration;
10. @Configuration
11. @MapperScan("com.test.mapper")          // mapper接口的所在位置
12. public class MyBatisPlusConfig {
13.     @Bean
14.     public MybatisPlusInterceptor mybatisPlusInterceptor() {
15.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
16.         interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
17.         return interceptor;
18.     }
19. }

复制代码

5.2 分页查询

在BaseMapper中主要提供有如下方法来完成分页查询：

• E selectPage(E page, @Param(Constants.WRAPPER) Wrapper queryWrapper)：
  
  
  
  • 参数1：分页配置类
    
  • 参数2：分页查询条件
    
  • 解释：根据分页配置和分页查询条件来完成分页查询，当前页数据为指定类型
    
  
  
• E selectMapsPage(E page, @Param(Constants.WRAPPER) Wrapper queryWrapper)
  
  
  
  • 参数1：分页配置类
    
  • 参数2：分页查询条件
    
  • 解释：根据分页配置和分页查询条件来完成分页查询，当前页数据为Map类型
    
  
  

1）无条件分页查询：

1. package com.test;
3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
4. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
5. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
6. import com.test.entity.User;
7. import com.test.mapper.UserMapper;
8. import org.junit.Test;
9. import org.junit.runner.RunWith;
10. import org.springframework.boot.test.context.SpringBootTest;
11. import org.springframework.test.context.junit4.SpringRunner;
13. import java.util.List;
14. import javax.annotation.Resource;
16. @SpringBootTest(classes = MyBatisPlusApplication.class)
17. @RunWith(SpringRunner.class)
18. public class Demo06_BaseMapper {
20.     @Resource
21.     private UserMapper userMapper;
23.     /**
24.      * 无条件分页查询
25.      * @throws Exception
26.      */
27.     @Test
28.     public void test1() throws Exception {
29.         // 封装分页信息
30.         Page<User> page = new Page<>(1, 3);
31.         /*
32.         执行分页查询,并将结果封装到page中
33.         参数1: 分页配置
34.         参数2: 查询条件
35.         */
36.         userMapper.selectPage(page, null);
38.         // 当前页数据
39.         List<User> pageData = page.getRecords();
40.         for (User user : pageData) {
41.             System.out.println(user);
42.         }
43.         System.out.println("------------");
44.         System.out.println("当前页：" + page.getCurrent());
45.         System.out.println("每页显示的条数：" + page.getSize());
46.         System.out.println("总记录数：" + page.getTotal());
47.         System.out.println("总页数：" + page.getPages());
48.         System.out.println("是否有上一页：" + page.hasPrevious());
49.         System.out.println("是否有下一页：" + page.hasNext());
50.     }
51. }

复制代码

查询结果：

1. # 首先查询总记录数
2. ==>  Preparing: SELECT COUNT(*) FROM user
3. ==> Parameters:
4. <==    Columns: COUNT(*)
5. <==        Row: 10
6. <==      Total: 1
8. # 再查询分页
9. ==>  Preparing: SELECT id,name,sex,age FROM user LIMIT ?
10. ==> Parameters: 3(Long)
11. <==    Columns: id, name, sex, age
12. <==        Row: 1, Jone, 1, 27
13. <==        Row: 2, Jack, 0, 20
14. <==        Row: 3, Tom, 1, 28
15. <==      Total: 3
16. Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@226eba67]
17. User(id=1, name=Jone, sex=1, age=27)
18. User(id=2, name=Jack, sex=0, age=20)
19. User(id=3, name=Tom, sex=1, age=28)
20. ------------
21. 当前页：1
22. 每页显示的条数：3
23. 总记录数：10
24. 总页数：4
25. 是否有上一页：false
26. 是否有下一页：true
27. 2022-11-15 15:28:16 INFO 8724 --- com.zaxxer.hikari.HikariDataSource: HikariPool-1 - Shutdown initiated...
28. 2022-11-15 15:28:16 INFO 8724 --- com.zaxxer.hikari.HikariDataSource: HikariPool-1 - Shutdown completed.
30. Process finished with exit code 0

复制代码

九、ActiveRecord使用

9.1 ActiveRecord简介

ActiveRecord也属于ORM（对象关系映射）层，由Rails最早提出，遵循标准的ORM模型：表映射到记录，记录映射到对象，字段映射到对象属性。配合遵循的命名和配置惯例，能够很大程度的快速实现模型的操作，而且简洁易懂。
ActiveRecord的主要思想是：
1）每一个数据库表对应创建一个类，类的每一个对象实例对应于数据库中表的一行记录，通常表的每个字段在类中都有相应的Field；
2）ActiveRecord同时负责把自己持久化，在ActiveRecord中封装了对数据库的访问，即CURD；
3）ActiveRecord是一种领域模型(Domain Model)，封装了部分业务逻辑。
简而言之，AR建立了Java对象与数据库表逻辑上的直接映射，方便了程序的编写。而在MyBatisPlus中使用AR非常简单，只需让JavaBean继承Model类即可。
9.2 Model类使用

在MyBatisPlus中，只要将我们的JavaBean继承与Model类即可获取AR功能，即JavaBean自身实现自身的CURD；
让JavaBean继承Model：

1. /**
2. * 带条件分页查询
3. *
4. * @throws Exception
5. */
6. @Test
7. public void test2() throws Exception {
8.     QueryWrapper<User> wrapper = Wrappers.query();
9.     wrapper.like("name", "a");
11.     // 封装分页信息
12.     Page<User> page = new Page<>(1, 3);
13.     /*
14.     执行分页查询,并将结果封装到page中
15.     参数1: 分页配置
16.     参数2: 查询条件
17.     */
18.     userMapper.selectPage(page, wrapper);
20.     // 当前页数据
21.     List<User> pageData = page.getRecords();
22.     for (User user : pageData) {
23.         System.out.println(user);
24.     }
25.     System.out.println("------------");
26.     System.out.println("当前页：" + page.getCurrent());
27.     System.out.println("每页显示的条数：" + page.getSize());
28.     System.out.println("总记录数：" + page.getTotal());
29.     System.out.println("总页数：" + page.getPages());
30.     System.out.println("是否有上一页：" + page.hasPrevious());
31.     System.out.println("是否有下一页：" + page.hasNext());
32. }

复制代码

测试代码：

1.   ==>  Preparing: SELECT COUNT(*) FROM user WHERE (name LIKE ?)
2.   ==> Parameters: %a%(String)
3.   <==    Columns: COUNT(*)
4.   <==        Row: 5
5.   <==      Total: 1
6.   ==>  Preparing: SELECT id,name,sex,age FROM user WHERE (name LIKE ?) LIMIT ?
7.   ==> Parameters: %a%(String), 3(Long)
8.   <==    Columns: id, name, sex, age
9.   <==        Row: 2, Jack, 0, 20
10.   <==        Row: 4, Sandy, 1, 21
11.   <==        Row: 6, Jackson, 0, 18
12.   <==      Total: 3
13.   Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@58a2b4c]
14.   User(id=2, name=Jack, sex=0, age=20)
15.   User(id=4, name=Sandy, sex=1, age=21)
16.   User(id=6, name=Jackson, sex=0, age=18)
17. ------------
18. 当前页：1
19. 每页显示的条数：3
20. 总记录数：5
21. 总页数：2
22. 是否有上一页：false
23. 是否有下一页：true

复制代码

十、多数据源配置

1）引入多数据源依赖：

1. /**
2. * 查询结果以Map返回
3. *
4. * @throws Exception
5. */
6. @Test
7. public void test3() throws Exception {
8.     // 封装分页信息
9.     Page page = new Page<>(1, 3);
10.     userMapper.selectMapsPage(page, null);
11.     // 每一条记录都是一个HashMap
12.     List<HashMap<String, Object>> pageData = page.getRecords();
13.     for (HashMap userMap : pageData) {
14.         System.out.println(userMap);
15.     }
16.     System.out.println("------------");
17.     System.out.println("当前页：" + page.getCurrent());
18.     System.out.println("每页显示的条数：" + page.getSize());
19.     System.out.println("总记录数：" + page.getTotal());
20.     System.out.println("总页数：" + page.getPages());
21.     System.out.println("是否有上一页：" + page.hasPrevious());
22.     System.out.println("是否有下一页：" + page.hasNext());
23. }

复制代码

2）准备两个数据库

1.   ==>  Preparing: SELECT COUNT(*) FROM user
2.   ==> Parameters:
3.   <==    Columns: COUNT(*)
4.   <==        Row: 10
5.   <==      Total: 1
6.   ==>  Preparing: SELECT id,name,sex,age FROM user LIMIT ?
7.   ==> Parameters: 3(Long)
8.   <==    Columns: id, name, sex, age
9.   <==        Row: 1, Jone, 1, 27
10.   <==        Row: 2, Jack, 0, 20
11.   <==        Row: 3, Tom, 1, 28
12.   <==      Total: 3
13.   Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7123be6c]
14.   {sex=1, name=Jone, id=1, age=27}
15.   {sex=0, name=Jack, id=2, age=20}
16.   {sex=1, name=Tom, id=3, age=28}
17. ------------
18. 当前页：1
19. 每页显示的条数：3
20. 总记录数：10
21. 总页数：4
22. 是否有上一页：false
23. 是否有下一页：true
24. 2022-11-15 15:50:37 INFO 20980 --- com.zaxxer.hikari.HikariDataSource: HikariPool-1 - Shutdown initiated...
25. 2022-11-15 15:50:37 INFO 20980 --- com.zaxxer.hikari.HikariDataSource: HikariPool-1 - Shutdown completed.
27. Process finished with exit code 0

复制代码

3）多数据源配置：

1. package com.test.service;
3. import com.baomidou.mybatisplus.extension.service.IService;
4. import com.test.entity.User;
6. public interface IUserService extends IService<User> {
7. }

复制代码

4）启动类：

1. package com.test;
3. import org.mybatis.spring.annotation.MapperScan;
4. import org.springframework.boot.SpringApplication;
5. import org.springframework.boot.autoconfigure.SpringBootApplication;
7. @SpringBootApplication
8. @MapperScan("com.test.mapper")
9. public class MyBatisPlusApplication {
10.     public static void main(String[] args) {
11.         SpringApplication.run(MyBatisPlusApplication.class, args);
12.     }
13. }

复制代码

5）实体类：

1. package com.test;
3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
4. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
5. import com.baomidou.mybatisplus.extension.conditions.query.QueryChainWrapper;
6. import com.baomidou.mybatisplus.extension.conditions.update.UpdateChainWrapper;
7. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
8. import com.test.entity.User;
9. import com.test.service.IUserService;
10. import org.junit.Test;
11. import org.junit.runner.RunWith;
12. import org.springframework.boot.test.context.SpringBootTest;
13. import org.springframework.test.context.junit4.SpringRunner;
15. import java.util.HashMap;
16. import java.util.List;
17. import javax.annotation.Resource;
19. @SpringBootTest(classes = MyBatisPlusApplication.class)
20. @RunWith(SpringRunner.class)
21. public class Demo07_Service {
23.     @Resource
24.     private IUserService userService;
26.     /**
27.      * 新增
28.      *
29.      * @throws Exception
30.      */
31.     @Test
32.     public void test1() throws Exception {
33.         User user = new User(null, "xiaohui", "0", 20);
34.         userService.save(user);
35.     }
37.     /**
38.      * 如果id存在则修改,不存在则新增
39.      *
40.      * @throws Exception
41.      */
42.     @Test
43.     public void test2() throws Exception {
44.         User user = new User(1L, "xiaohui", "0", 20);
45.         userService.saveOrUpdate(user);
46.     }
48.     /**
49.      * 根据id删除
50.      *
51.      * @throws Exception
52.      */
53.     @Test
54.     public void test3() throws Exception {
55.         userService.removeById(1L);
56.     }
58.     /**
59.      * 根据id修改
60.      *
61.      * @throws Exception
62.      */
63.     @Test
64.     public void test4() throws Exception {
65.         User user = new User(1L, "xiaolan", "1", 18);
66.         userService.updateById(user);
67.     }
69.     /**
70.      * 根据id查询
71.      *
72.      * @throws Exception
73.      */
74.     @Test
75.     public void test5() throws Exception {
76.         User user = userService.getById(1L);
77.         System.out.println(user);
78.     }
80.     /**
81.      * 查询列表
82.      *
83.      * @throws Exception
84.      */
85.     @Test
86.     public void test6() throws Exception {
87.         QueryWrapper<User> wrapper = Wrappers.query();
88.         wrapper.in("id", "1", "2");
89.         // 查询所有
90.         // List<User> userList = userService.list();
91.         // 通过wrapper查询
92.         List<User> userList = userService.list(wrapper);
93.         for (User user : userList) {
94.             System.out.println(user);
95.         }
96.     }
98.     /**
99.      * 查询总记录数
100.      *
101.      * @throws Exception
102.      */
103.     @Test
104.     public void test7() throws Exception {
105.         QueryWrapper<User> wrapper = Wrappers.query();
106.         wrapper.like("name", "a");
107.         // 查询总记录数
108.         //int count = userService.count();
109.         // 根据条件查询总记录数
110.         int count = userService.count(wrapper);
111.         System.out.println(count);
112.     }
114.     /**
115.      * 分页查询(当前页类型为指定类型)
116.      *
117.      * @throws Exception
118.      */
119.     @Test
120.     public void test8() throws Exception {
121.         Page<User> page = new Page<>(1, 3);
122.         userService.page(page);
123.         // 当前页数据
124.         List<User> pageData = page.getRecords();
125.         for (User user : pageData) {
126.             System.out.println(user);
127.         }
128.         System.out.println("------------");
129.         System.out.println("当前页：" + page.getCurrent());
130.         System.out.println("每页显示的条数：" + page.getSize());
131.         System.out.println("总记录数：" + page.getTotal());
132.         System.out.println("总页数：" + page.getPages());
133.         System.out.println("是否有上一页：" + page.hasPrevious());
134.         System.out.println("是否有下一页：" + page.hasNext());
135.     }
136.    
137.     /**
138.      * 分页查询(当前页结果为HashMap类型)
139.      *
140.      * @throws Exception
141.      */
142.     @Test
143.     public void test9() throws Exception {
144.         Page page = new Page<>(1, 3);
145.         userService.pageMaps(page);
146.         // 当前页数据
147.         List<HashMap<String, Object>> pageData = page.getRecords();
148.         for (HashMap userMap : pageData) {
149.             System.out.println(userMap);
150.         }
151.         System.out.println("------------");
152.         System.out.println("当前页：" + page.getCurrent());
153.         System.out.println("每页显示的条数：" + page.getSize());
154.         System.out.println("总记录数：" + page.getTotal());
155.         System.out.println("总页数：" + page.getPages());
156.         System.out.println("是否有上一页：" + page.hasPrevious());
157.         System.out.println("是否有下一页：" + page.hasNext());
158.     }
159.    
160.     /**
161.      * 链式查询
162.      *
163.      * @throws Exception
164.      */
165.     @Test
166.     public void test10() throws Exception {
167.         QueryChainWrapper<User> chainWrapper = userService.query();
168.         // SQL: SELECT id,name,age FROM user WHERE (id IN (?,?,?) AND name LIKE ?)
169.         List<User> userList = chainWrapper.select("id", "name", "age")
170.                 .in("id", "1", "2", "3")
171.                 .like("name", "a")
172.                 .list();
173.         for (User user : userList) {
174.             System.out.println(user);
175.         }
176.     }
177.    
178.     /**
179.      * 链式修改
180.      *
181.      * @throws Exception
182.      */
183.     @Test
184.     public void test11() throws Exception {
185.         UpdateChainWrapper<User> chainWrapper = userService.update();
186.         // SQL: UPDATE user SET age=? WHERE (id IN (?,?) OR sex = ?)
187.         chainWrapper.in("id","1","2")
188.                 .or()
189.                 .eq("sex","0")
190.                 .set("age",20)
191.                 .update();
192.     }
193. }

复制代码

6）编写两个Mapper：

1. @Data
2. @AllArgsConstructor
3. @NoArgsConstructor
4. @TableName("t_user")
5. public class User {
6.     private Long id;
7.     private String name;
8.     private String sex;
9.     private Integer age;
10. }

复制代码

1. mybatis-plus:
2.   global-config:         # MyBatisPlus全局配置
3.     db-config:          # 配置数据库
4.       table-prefix: t_  #配置表名前缀为t_

复制代码

7）测试类：

1. @Data
2. @AllArgsConstructor
3. @NoArgsConstructor
4. @TableName("t_user")
5. public class User {
6.     // 将当前属性所对应的字段作为主键
7.     @TableId
8.     private Long id;
9.     private String name;
10.     private String sex;
11.     private Integer age;
12. }

复制代码

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！