Java-主流框架—（16）Mybatis-Plus
1.了解Mybatis-Plus
1.1Mybatis-Plus介绍
MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
官网：mybatis.plus 或 Redirect
愿景
我们的愿景是成为 MyBatis 最好的搭档，就像 魂斗罗 中的 1P、2P，基友搭配，效率翻倍。
1.2代码以及文档
文档地址：mybatis.plus
源码地址：https://github.com/baomidou/mybatis-plus
1.3特性
-
无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
-
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
-
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
-
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
-
支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer2005、SQLServer 等多种数据库
-
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
-
支持 XML 热加载：Mapper 对应的 XML 支持热加载，对于简单的 CRUD 操作，甚至可以无 XML 启动
-
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
-
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
-
支持关键词自动转义：支持数据库关键词（order、key......）自动转义，还可自定义关键词
-
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
-
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
-
内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
-
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作
-
内置 Sql 注入剥离器：支持 Sql 注入剥离，有效预防 Sql 注入攻击
1.4构架
1.5做着
Mybatis-Plus是由baomidou（苞米豆）组织开发并且开源的，目前该组织大概有30人左右。
码云地址：baomidou: 苞米豆，为提高生产率而生！
2.快速开始
对于Mybatis整合MP有常常有三种用法，分别是Mybatis+MP、Spring+Mybatis+MP、Spring Boot+Mybatis+MP。
2.1创建数据库以及表
-- 创建测试表
CREATE TABLE `tb_user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`user_name` varchar(20) NOT NULL COMMENT '用户名',
`password` varchar(20) NOT NULL COMMENT '密码',
`name` varchar(30) DEFAULT NULL COMMENT '姓名',
`age` int(11) DEFAULT NULL COMMENT '年龄',
`email` varchar(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
-- 插入测试数据
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('1', 'zhangsan', '123456', '张三', '18', '[email protected]');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('2', 'lisi', '123456', '李四', '20', '[email protected]');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('3', 'wangwu', '123456', '王五', '28', '[email protected]');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('4', 'zhaoliu', '123456', '赵六', '21', '[email protected]');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('5', 'sunqi', '123456', '孙七', '24', '[email protected]');2.2创建工程
导入依赖：
4.0.0
cn.itcast.mp
itcast-mybatis-plus
1.0-SNAPSHOT
itcast-mybatis-plus-simple
pom
com.baomidou
mybatis-plus
3.1.1
mysql
mysql-connector-java
5.1.47
com.alibaba
druid
1.0.11
org.projectlombok
lombok
true
1.18.4
junit
junit
4.12
org.slf4j
slf4j-log4j12
1.6.4
org.apache.maven.plugins
maven-compiler-plugin
1.8
1.8
2.3Mybatis + MP
2.3.1 创建Module
itcast-mybatis-plus
cn.itcast.mp
1.0-SNAPSHOT
4.0.0
jar
itcast-mybatis-plus-simple
log4j.properties：
log4j.rootLogger=DEBUG,A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n2.3.2 Mybatis实现查询User
1.编写mybatis-config.xml文件
2.User实体对象
package mytest.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
private Long id;
private String user_Name;
private String password;
private String name;
private Integer age;
private String email;
}3.UserMapper
package mytest.mapper;
import mytest.pojo.User;
import java.util.List;
public interface UserMapper {
List findAll();
}
4.UserMapper.xml
5.TestMybatis
package mytest;
import mytest.mapper.UserMapper;
import mytest.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import java.io.InputStream;
public class TestMybatis {
@Test
public void testFindAll() throws Exception{
String config="mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(config);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//测试查询
for (User user : userMapper.findAll()) {
System.out.println(user);
}
}
}
2.3.3 Mybatis + MP实现查询User
1.将UserMapper继承BaseMapper，将拥有BaseMapper的所有方法
package mytest.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import mytest.pojo.User;
import java.util.List;
public interface UserMapper extends BaseMapper {
List findAll();
}
2.第二步，使用MP中的MybatisSqlSessionFactoryBuilder进程构建：
package mytest;
import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
import mytest.mapper.UserMapper;
import mytest.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.Test;
import java.io.InputStream;
import java.util.List;
public class TestMybatis {
@Test
public void testFindAll() throws Exception{
String config="mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(config);
SqlSessionFactory sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//测试查询
// List userList = userMapper.findAll();
//调用BaseMapper中的方法
List userList = userMapper.selectList(null);
for (User user : userList) {
System.out.println(user);
}
}
}
简单说明：
-
由于使用了MybatisSqlSessionFactoryBuilder进行了构建，继承的BaseMapper中的方法就载入到了SqlSession中，所以就可以直接使用相关的方法；
-
2.4Spring + Mybatis +MP
引入了Spring框架，数据源、构建等工作就交给了Spring管理。
2.4.1 创建子Module
itcast-mybatis-plus
cn.itcast.mp
1.0-SNAPSHOT
4.0.0
itcast-mybatis-plus-spring
5.1.6.RELEASE
org.springframework
spring-webmvc
${spring.version}
org.springframework
spring-jdbc
${spring.version}
org.springframework
spring-test
${spring.version}
2.4.2实现查询User
第一步，编写jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
jdbc.username=root
jdbc.password=123456789第二步，编写applicationContext.xml
第三步，编写User对象以及UserMapper接口：
package mytest.pojo;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
private Long id;
private String userName;
private String password;
private String name;
private Integer age;
private String email;
}package mytest.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import mytest.pojo.User;
import java.util.List;
public interface UserMapper extends BaseMapper {
}
第四步，编写测试用例：（在test目录下添加resources目录，加入jdbc.properties和applicationApplication.xml）
package mytest;
import mytest.mapper.UserMapper;
import mytest.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class TestSpringMP {
@Autowired
private UserMapper userMapper;
@Test
public void testSelectList(){
List users = this.userMapper.selectList(null);
for (User user : users) {
System.out.println(user);
}
}
} 
2.5 SpringBoot + Mybatis + MP
使用SpringBoot将进一步的简化MP的整合，需要注意的是，由于使用SpringBoot需要继承parent，所以需要重新创建工程，并不是创建子Module。
2.5.1导入依赖包
4.0.0
org.springframework.boot
spring-boot-starter-parent
2.1.4.RELEASE
cn.itcast.mp
itcast-mp-springboot
1.0-SNAPSHOT
org.springframework.boot
spring-boot-starter
org.springframework.boot
spring-boot-starter-logging
org.springframework.boot
spring-boot-starter-test
test
org.projectlombok
lombok
true
com.baomidou
mybatis-plus-boot-starter
3.1.1
mysql
mysql-connector-java
5.1.47
org.slf4j
slf4j-log4j12
org.springframework.boot
spring-boot-maven-plugin
log4j.properties：
log4j.rootLogger=DEBUG,A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n2.5.2编写application.properties
spring.application.name = itcast-mp-springboot
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/mp?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
spring.datasource.username=root
spring.datasource.password=root2.5.3编写pojo
package cn.itcast.mp.pojo;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
private Long id;
private String userName;
private String password;
private String name;
private Integer age;
private String email;
}2.5.4编写mapper
package cn.itcast.mp.mapper;
import cn.itcast.mp.pojo.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
public interface UserMapper extends BaseMapper {
} 2.5.5编写启动类
package cn.itcast.mp;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
@MapperScan("cn.itcast.mp.mapper") //设置mapper接口的扫描包
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}2.5.6编写测试用例
package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testSelect() {
List userList = userMapper.selectList(null);
for (User user : userList) {
System.out.println(user);
}
}
} 3.通用CRUD
3.1插入操作
3.1.1方法定义
/**
* 插入一条记录
*
* @param entity 实体对象
*/
int insert(T entity);3.1.2测试用例
package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testInsert(){
User user = new User();
user.setAge(20);
user.setEmail("[email protected]");
user.setName("曹操");
user.setUserName("caocao");
user.setPassword("123456");
int result = this.userMapper.insert(user); //返回的result是受影响的行数，并不是自增后的id
System.out.println("result = " + result);
System.out.println(user.getId()); //自增后的id会回填到对象中
}
}
可以看到，数据已经写入到了数据库，但是，id的值不正确，我们期望的是数据库自增长，实际是MP生成了id的值写入到了数据库。
如何设置id的生成策略呢？
MP支持的id策略：
package com.baomidou.mybatisplus.annotation;
import lombok.Getter;
/**
* 生成ID类型枚举类
*
* @author hubin
* @since 2015-11-10
*/
@Getter
public enum IdType {
/**
* 数据库ID自增
*/
AUTO(0),
/**
* 该类型为未设置主键类型
*/
NONE(1),
/**
* 用户输入ID
* 该类型可以通过自己注册自动填充插件进行填充
*/
INPUT(2),
/* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
/**
* 全局唯一ID (idWorker)
*/
ID_WORKER(3),
/**
* 全局唯一ID (UUID)
*/
UUID(4),
/**
* 字符串全局唯一ID (idWorker 的字符串表示)
*/
ID_WORKER_STR(5);
private final int key;
IdType(int key) {
this.key = key;
}
}修改User对象：
package cn.itcast.mp.pojo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
@TableId(type = IdType.AUTO) //指定id类型为自增长
private Long id;
private String userName;
private String password;
private String name;
private Integer age;
private String email;
}3.1.4@TableField
3.2更新操作
在MP中，更新操作有2种，一种是根据id更新，另一种是根据条件更新。
3.2.1根据id更新
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testUpdateById() {
User user = new User();
user.setId(6L); //主键
user.setAge(21); //更新的字段
//根据id更新，更新不为null的字段
this.userMapper.updateById(user);
}
}
3.2.2根据条件更新
/**
* 根据 whereEntity 条件，更新记录
*
* @param entity 实体对象 (set 条件值,可以为 null)
* @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper updateWrapper); package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import net.minidev.json.writer.UpdaterMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testUpdate() {
User user = new User();
user.setAge(22); //更新的字段
//更新的条件
QueryWrapper wrapper = new QueryWrapper<>();
wrapper.eq("id", 5);
//执行更新操作
int result = this.userMapper.update(user, wrapper);
System.out.println("result = " + result);
}
} 
或者，通过UpdateWrapper进行更新：
@Test
public void testUpdate() {
//更新的条件以及字段
UpdateWrapper wrapper = new UpdateWrapper<>();
wrapper.eq("id", 5).set("age", 23);
//执行更新操作
int result = this.userMapper.update(null, wrapper);
System.out.println("result = " + result);
} 
3.3删除操作
3.3.1deleteById
/**
* 根据 ID 删除
*
* @param id 主键ID
*/
int deleteById(Serializable id);package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testDeleteById() {
//执行删除操作
int result = this.userMapper.deleteById(6L);
System.out.println("result = " + result);
}
}
3.3.2deleteByMap
/**
* 根据 columnMap 条件，删除记录
*
* @param columnMap 表字段 map 对象
*/
int deleteByMap(@Param(Constants.COLUMN_MAP) Map columnMap); package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.HashMap;
import java.util.Map;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testDeleteByMap() {
Map columnMap = new HashMap<>();
columnMap.put("age",20);
columnMap.put("name","张三");
//将columnMap中的元素设置为删除的条件，多个之间为and关系
int result = this.userMapper.deleteByMap(columnMap);
System.out.println("result = " + result);
}
} 
3.3.3delete
/**
* 根据 entity 条件，删除记录
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
int delete(@Param(Constants.WRAPPER) Wrapper wrapper); package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.HashMap;
import java.util.Map;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testDeleteByMap() {
User user = new User();
user.setAge(20);
user.setName("张三");
//将实体对象进行包装，包装为操作条件
QueryWrapper wrapper = new QueryWrapper<>(user);
int result = this.userMapper.delete(wrapper);
System.out.println("result = " + result);
}
} 3.3.4deleteBatchids
/**
* 删除（根据ID 批量删除）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
int deleteBatchIds(@Param(Constants.COLLECTION) Collection idList);package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.Arrays;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testDeleteByMap() {
//根据id集合批量删除
int result = this.userMapper.deleteBatchIds(Arrays.asList(1L,10L,20L));
System.out.println("result = " + result);
}
}3.4查询操作
MP提供了多种查询操作，包括根据id查询、批量查询、查询单条数据、查询列表、分页查询等操作。
3.4.1selectById
/**
* 根据 ID 查询
*
* @param id 主键ID
*/
T selectById(Serializable id);package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testSelectById() {
//根据id查询数据
User user = this.userMapper.selectById(2L);
System.out.println("result = " + user);
}
}
3.4.2 selectBatchids
/**
* 查询（根据ID 批量查询）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
List selectBatchIds(@Param(Constants.COLLECTION) Collection idList); package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.Arrays;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testSelectBatchIds() {
//根据id集合批量查询
List users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 10L));
for (User user : users) {
System.out.println(user);
}
}
} 
3.4.3 selectOne
/**
* 根据 entity 条件，查询一条记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
T selectOne(@Param(Constants.WRAPPER) Wrapper queryWrapper); package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testSelectOne() {
QueryWrapper wrapper = new QueryWrapper();
wrapper.eq("name", "李四");
//根据条件查询一条数据，如果结果超过一条会报错
User user = this.userMapper.selectOne(wrapper);
System.out.println(user);
}
} 
3.4.4 selectCount
/**
* 根据 Wrapper 条件，查询总记录数
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
Integer selectCount(@Param(Constants.WRAPPER) Wrapper queryWrapper); package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testSelectCount() {
QueryWrapper wrapper = new QueryWrapper();
wrapper.gt("age", 23); //年龄大于23岁
//根据条件查询数据条数
Integer count = this.userMapper.selectCount(wrapper);
System.out.println("count = " + count);
}
} 3.4.5 selectList
/**
* 根据 entity 条件，查询全部记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
List selectList(@Param(Constants.WRAPPER) Wrapper queryWrapper); package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testSelectList() {
QueryWrapper wrapper = new QueryWrapper();
wrapper.gt("age", 23); //年龄大于23岁
//根据条件查询数据
List users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println("user = " + user);
}
}
} //根据大于小于条件查找符合条件的列表
@Test
public void testSelectList1() {
QueryWrapper wrapper = new QueryWrapper();
wrapper.gt("age", 23); //年龄大于23岁
//根据条件查询数据
List users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println("user = " + user);
}
}
//根据大于小于条件查找符合条件的列表
@Test
public void testSelectList2() {
QueryWrapper wrapper = new QueryWrapper();
wrapper.lambda().lt(User::getAge, 23);//年龄大于23岁
//根据条件查询数据
List users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println("user = " + user);
}
}
//根据大于小于条件查找符合条件的列表
@Test
public void testSelectList3() {
LambdaQueryWrapper lqw = new LambdaQueryWrapper();
lqw.lt(User::getAge, 23);//年龄大于23岁
//根据条件查询数据
List users = this.userMapper.selectList(lqw);
for (User user : users) {
System.out.println("user = " + user);
}
}
//根据大于小于条件查找符合条件的列表
@Test
public void testSelectList4() {
LambdaQueryWrapper lqw = new LambdaQueryWrapper();
lqw.lt(User::getAge, 23);//年龄大于23岁
lqw.gt(User::getAge, 19);//年龄小于19岁
// lqw.lt(User::getAge, 23).gt(User::getAge, 19);//年龄小于19岁
//根据条件查询数据
List users = this.userMapper.selectList(lqw);
for (User user : users) {
System.out.println("user = " + user);
}
}
//根据大于小于条件查找符合条件的列表
@Test
public void testSelectList5() {
LambdaQueryWrapper lqw = new LambdaQueryWrapper();
lqw.lt(User::getAge, 19).or().gt(User::getAge, 23);//年龄小于19岁或者大于23
//根据条件查询数据
List users = this.userMapper.selectList(lqw);
for (User user : users) {
System.out.println("user = " + user);
}
}
3.4.6 selectPage
/**
* 根据 entity 条件，查询全部记录（并翻页）
*
* @param page 分页查询条件（可以为 RowBounds.DEFAULT）
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
IPage selectPage(IPage page, @Param(Constants.WRAPPER) Wrapper queryWrapper); 拦截器：
package mytest.Config;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@MapperScan("mytest.mapper") //设置mapper接口的扫描包
public class MybatisPlusConfig {
/**
* 分页插件
*/
@Bean
public MybatisPlusInterceptor paginationInterceptor() {
//定义mp拦截器
MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
//添加具体的拦截器
mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
return mybatisPlusInterceptor;
}
}配置分页插件：
package cn.itcast.mp;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@MapperScan("cn.itcast.mp.mapper") //设置mapper接口的扫描包
public class MybatisPlusConfig {
/**
* 分页插件
*/
@Bean
public PaginationInterceptor paginationInterceptor() {
return new PaginationInterceptor();
}
}测试用例：
package cn.itcast.mp;
import cn.itcast.mp.mapper.UserMapper;
import cn.itcast.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
//分页查询
@Test
public void testSelectByPage(){
//第几页 每页几条
Page page = new Page<>(1,2);
//根据条件查询数据
IPage iPage = this.userMapper.selectPage(page, null);
System.out.println("当前页码值：" + iPage.getCurrent());
System.out.println("每页显示数：" + iPage.getSize());
System.out.println("总页数：" + iPage.getPages());
System.out.println("总条数：" + iPage.getTotal());
List users = iPage.getRecords();
for (User user : users) {
System.out.println("user = " + user);
}
}
@Test
public void testSelectPage() {
QueryWrapper wrapper = new QueryWrapper();
wrapper.gt("age", 20); //年龄大于20岁
Page page = new Page<>(1,1);
//根据条件查询数据
IPage iPage = this.userMapper.selectPage(page, wrapper);
System.out.println("数据总条数：" + iPage.getTotal());
System.out.println("总页数：" + iPage.getPages());
List users = iPage.getRecords();
for (User user : users) {
System.out.println("user = " + user);
}
}
} 
3.5条件查询null判定
//虚拟页面传过来null值，进行查询数据
@Test
public void selectByAgeUpAndDown(){
UserQuery userQuery = new UserQuery();
userQuery.setAge(20);
userQuery.setAge2(25);
//
//null判定
//方法一
// LambdaQueryWrapper lqw = new LambdaQueryWrapper<>();
// if( null != userQuery.getAge()){
// lqw.gt(User::getAge,userQuery.getAge());//大于小的
// }
// if ( null != userQuery.getAge2()){
// lqw.lt(User::getAge,userQuery.getAge2());//小于大的
// }
// List userList = userMapper.selectList(lqw);
// System.out.println(userList);
//方法二
LambdaQueryWrapper lqw = new LambdaQueryWrapper<>();
//先判断第一个条件是否为true 如果真 则链接条件，否则不链接
lqw.lt(null!= userQuery.getAge2(),User::getAge,userQuery.getAge2());
lqw.gt(null!= userQuery.getAge(),User::getAge,userQuery.getAge());
List userList = userMapper.selectList(lqw);
System.out.println(userList);
} 3.6查询投影
//查询投影
@Test
public void testAnyoneField(){
//用QueryWrapper查询只有id，username，email的投影
// QueryWrapper qw = new QueryWrapper<>();
// qw.select("id","user_name","email");
// List users = this.userMapper.selectList(qw);
// System.out.println(users);
//用LambdaQueryWrapper查询只有id，username，email的投影
// LambdaQueryWrapper lqw = new LambdaQueryWrapper();
// lqw.select(User::getId,User::getUserName,User::getEmail);
// List users = this.userMapper.selectList(lqw);
// System.out.println(users);
} 3.7统计计数
//查询投影
@Test
public void testAnyoneField(){
//查询计数
// QueryWrapper qw = new QueryWrapper<>();
// qw.select("count(*) as count");
// List> users = this.userMapper.selectMaps(qw);
// System.out.println(users);
//查询分组
QueryWrapper qw = new QueryWrapper<>();
qw.select("count(*) as count,email");
qw.groupBy("email");
List> users = this.userMapper.selectMaps(qw);
System.out.println(users);
} 3.6 SQL注入原理
前面我们已经知道，MP在启动后会将BaseMapper中的一系列的方法注册到meppedStatements中，那么究竟是如何注入的呢？流程又是怎么样的？下面我们将一起来分析下。
在MP中，ISqlInjector负责SQL的注入工作，它是一个接口，AbstractSqlInjector是它的实现类，实现关系如下：
在AbstractSqlInjector中，主要是由inspectInject()方法进行注入的，如下：
@Override
public void inspectInject(MapperBuilderAssistant builderAssistant, Class mapperClass) {
Class modelClass = extractModelClass(mapperClass);
if (modelClass != null) {
String className = mapperClass.toString();
Set mapperRegistryCache = GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
if (!mapperRegistryCache.contains(className)) {
List methodList = this.getMethodList();
if (CollectionUtils.isNotEmpty(methodList)) {
TableInfo tableInfo = TableInfoHelper.initTableInfo(builderAssistant, modelClass);
// 循环注入自定义方法
methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));
} else {
logger.debug(mapperClass.toString() + ", No effective injection method was found.");
}
mapperRegistryCache.add(className);
}
}
} 在实现方法中，methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));是关键，循环遍历方法，进行注入。
最终调用抽象方法injectMappedStatement进行真正的注入：
/**
* 注入自定义 MappedStatement
*
* @param mapperClass mapper 接口
* @param modelClass mapper 泛型
* @param tableInfo 数据库表反射信息
* @return MappedStatement
*/
public abstract MappedStatement injectMappedStatement(Class mapperClass, Class modelClass, TableInfo tableInfo);
以SelectById为例查看：
public class SelectById extends AbstractMethod {
@Override
public MappedStatement injectMappedStatement(Class mapperClass, Class modelClass, TableInfo tableInfo) {
SqlMethod sqlMethod = SqlMethod.LOGIC_SELECT_BY_ID;
SqlSource sqlSource = new RawSqlSource(configuration, String.format(sqlMethod.getSql(),
sqlSelectColumns(tableInfo, false),
tableInfo.getTableName(), tableInfo.getKeyColumn(), tableInfo.getKeyProperty(),
tableInfo.getLogicDeleteSql(true, false)), Object.class);
return this.addSelectMappedStatement(mapperClass, sqlMethod.getMethod(), sqlSource, modelClass, tableInfo);
}
}可以看到，生成了SqlSource对象，再将SQL通过addSelectMappedStatement方法添加到meppedStatements中。
3.7条件查询
//条件查询
@Test
public void testIf(){
//两个if条件测试
// LambdaQueryWrapper lqw = new LambdaQueryWrapper<>();
// lqw.eq(User::getUserName,"lisi").eq(User::getPassword,"123456");
// User user = userMapper.selectOne(lqw);
// System.out.println(user);
//范围查询
LambdaQueryWrapper lqw = new LambdaQueryWrapper<>();
//lt le 不带等号 gt ge 带灯号
// lqw.between(User::getAge,10,20);//10~20之间
lqw.ge(User::getAge,10).le(User::getAge,20);//10~20之间带等号
// lqw.gt(User::getAge,10).lt(User::getAge,20);//10~20之间
List userList = userMapper.selectList(lqw);
System.out.println(userList);
//模糊匹配
// LambdaQueryWrapper lqw = new LambdaQueryWrapper<>();
// //模糊查询 like
lqw.like(User::getUserName,"a");//是否含有a %a%
// lqw.likeRight(User::getUserName,"l");//左边匹配 l%
lqw.likeLeft(User::getUserName,"l");//左边匹配 %l
// List userList = userMapper.selectList(lqw);
// System.out.println(userList);
} 3.8字段映射与表名映射
1.数据库字段名与类属性名不同
2.数据库中字段缺少类中的属性
3.密码属性查出效果删除
4.表名与类名不匹配
4.DML编程控制
4.1id生成策略控制(insert)
主键生成的策略有哪几种方式？
不同的表应用不同的id生成策略
-
日志：自增（1,2,3,4，……）
-
购物订单：特殊规则（FQ23948AK3843）
-
外卖单：关联地区日期等信息（10 04 20200314 34 91）
-
关系表：可省略id
-
……
4.1.1id生成策略控制(@TableId注解)
4.1.2全局策略配置
省去每次都写表前缀和id的自增类型
mybatis-plus:
global-config:
db-config:
id-type: assign_id
table-prefix: tbl_
id生成策略全局配置
表名前缀全局配置
4.2多记录操作(批量Delete/select)
MyBatisPlus是否支持批量操作？
4.2.1按照主键删除多条记录
//删除指定多条数据
List list = new ArrayList<>();
list.add(1402551342481838081L);
list.add(1402553134049501186L);
list.add(1402553619611430913L);
userDao.deleteBatchIds(list); 4.2.2根据主键查询多条记录
//查询指定多条数据
List list = new ArrayList<>();
list.add(1L);
list.add(3L);
list.add(4L);
userDao.selectBatchIds(list); 4.3逻辑删除
在实际环境中，如果想删除一条数据，是否会真的从数据库中删除该条数据？
-
删除操作业务问题：业务数据从数据库中丢弃
-
逻辑删除：为数据设置是否可用状态字段，删除时设置状态字段为不可用状态，数据保留在数据库中
4.3.1逻辑删除案例
①：数据库表中添加逻辑删除标记字段
②：实体类中添加对应字段，并设定当前字段为逻辑删除标记字段
package mytest.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
@Data
public class User {
private Long id;
//逻辑删除字段，标记当前记录是否被删除
@TableLogic(value = "0",delval = "1")
private Integer deleted;
}③：配置逻辑删除字面值
mybatis-plus:
global-config:
db-config:
table-prefix: tbl_
# 逻辑删除字段名
logic-delete-field: deleted
# 逻辑删除字面值：未删除为0
logic-not-delete-value: 0
# 逻辑删除字面值：删除为1
logic-delete-value: 1
逻辑删除本质：逻辑删除的本质其实是修改操作。如果加了逻辑删除字段，查询数据时也会自动带上逻辑删除字段。
4.4乐观锁
乐观锁主张的思想是什么？
-
业务并发现象带来的问题：秒杀
4.4.1乐观锁案列
①：数据库表中添加锁标记字段
②：实体类中添加对应字段，并设定当前字段为逻辑删除标记字段
package mytest.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.Version;
import lombok.Data;
@Data
public class User {
private Long id;
@Version
private Integer version;
}③：配置乐观锁拦截器实现锁机制对应的动态SQL语句拼装
package mytest.config;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MpConfig {
@Bean
public MybatisPlusInterceptor mpInterceptor() {
//1.定义Mp拦截器
MybatisPlusInterceptor mpInterceptor = new MybatisPlusInterceptor();
//2.添加乐观锁拦截器
mpInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
return mpInterceptor;
}
}
④：使用乐观锁机制在修改前必须先获取到对应数据的verion方可正常进行
@Test
public void testUpdate() {
/*User user = new User();
user.setId(3L);
user.setName("Jock666");
user.setVersion(1);
userDao.updateById(user);*/
//1.先通过要修改的数据id将当前数据查询出来
//User user = userDao.selectById(3L);
//2.将要修改的属性逐一设置进去
//user.setName("Jock888");
//userDao.updateById(user);
//1.先通过要修改的数据id将当前数据查询出来
User user = userDao.selectById(3L); //version=3
User user2 = userDao.selectById(3L); //version=3
user2.setName("Jock aaa");
userDao.updateById(user2); //version=>4
user.setName("Jock bbb");
userDao.updateById(user); //verion=3?条件还成立吗？
}
---------------------------------------------------------------------------------------------------------------------------------
内容有部分存在书籍、课堂、网络记录，如有雷同纯属巧合