还在用MyBatis写CRUD?这款神器帮你5分钟写后台管理基本功能
Posted .Der_Rabe
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了还在用MyBatis写CRUD?这款神器帮你5分钟写后台管理基本功能相关的知识，希望对你有一定的参考价值。
、MyBatis回顾文章转载：乐字节
1.1、回顾MyBatis
1.1.1、建库建表
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(255) DEFAULT NULL,
`password` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
复制代码1.1.2、引入依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
复制代码1.1.3、application.properties
spring.datasource.druid.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.druid.url=jdbc:mysql:///db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
spring.datasource.druid.username=root
spring.datasource.druid.password=123456
复制代码1.1.4、编写Mapper接口
public interface UserMapper {
List<Employee> selectAll();
}
复制代码1.1.5、编写Mapper.xml
<select id="selectAll" resultMap="BaseResultMap">
select id,username,password
from user
</select>
复制代码1.1.6、MyBatis存在的缺点
我们可以发现传统的MyBatis存在很致命的问题，每个实体表对应一个实体类，对应一个Mapper.java接口，对应一个Mapper.xml配置文件每个Mapper.java接口都有重复的crud方法，每一个Mapper.xml都有重复的crud的sql配置。如果想解决这个问题，唯一的办法就是使用MyBatis-Plus。
二、了解Mybatis-Plus MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 
2.1、代码以及文档
文档地址：mybatis.plus/guide/ 源码地址：github.com/baomidou/my…
2.2、特性
- 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑。
- 损耗小：启动即会自动注入基本 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 注入攻击。
2.3、快速开始
2.3.1、导入依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--简化代码的工具包-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!--mybatis-plus的springboot支持-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.1.1</version>
</dependency>
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</dependency>
复制代码2.3.2、log4j.properties
og4j.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%n
复制代码2.3.3、编写实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private Integer id;
private String username;
private String password;
private String type;
}
复制代码2.3.4、编写mapper
// 直接继承Myabtis-Plus的BaseMapper即可，泛型表示实体类
public interface UserMapper extends BaseMapper<User> {
}
复制代码2.3.5、编写启动类
@SpringBootApplication
// 设置mapper接口扫描包
@MapperScan("cn.linstudy.mapper")
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
复制代码2.3.6、测试
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testSelect() {
List<User> userList = userMapper.selectList(null);
for (User user : userList) {
System.out.println(user);
}
}
}
复制代码2.4、架构
3.1、@TableName
MyBatis-Plus中默认表名是跟实体类名一致，当我们实体类的类名和表名不一致的时候，MyBatis-Plus就会报错，但是我们实际上又有这种需求的时候，我们就需要使用@TableName这个注解，来指定当前实体类映射哪张数据库表。
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("user")
public class User {
private Integer id;
private String username;
private String password;
private String type;
}
复制代码3.2、@TableId
我们在使用insert方法的时候会发现一个很奇怪的现象。他生成的ID格外长，这是因为他使用的算法是使用雪花算法生成的ID，我们想要的是自增的ID，所以我们需要设置主键增长的策略。
我们可以使用@TableId这个注解。他的作用是主键注解，标记当前属性映射表的主键，其中type是属性指定的主键类型，他有这几个值：
- IdType.AUTO：数据库ID自增。
- IdType.NONE：无状态,该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)。
- IdType.INPUT：insert前自行set主键值。
- IdType.ASSIGN_ID：分配ID(主键类型为Number(Long和Integer)或String)(since 3.3.0),使用接口IdentifierGenerator的方法nextId(默认实现类为DefaultIdentifierGenerator雪花算法)。
- 分配UUID,主键类型为String(since 3.3.0),使用接口IdentifierGenerator的方法nextUUID(默认default方法)
3.3、@TableField
我们有些时候，数据库的字段名和实体类的名字可能会不一样，或者是说实体类中有的字段而数据库中却没有，我们需要用@TableField这个注解。 @TableField注解用于标记非主键字段，他的作用是指定当前属性映射数据库表哪一列， 默认是跟属性名一致。常用于解决以下两个问题：
- 对象中的属性名和字段名不一致的问题（非驼峰）
- 对象中的属性字段在表中不存在的问题
他还有另一种用法，就是指定某个字段不加入查询。
我们之前学过，使用MyBatis-Plus的时候，Mapper接口里面的方法不需要我们再自己写了，只需要继承BaseMapper接口即可获取到各种各样的单表操作。
4.1、插入操作
4.1.1、方法定义
MyBatis-Plus中对于insert的方法定义是：
/**
* 插入一条记录
*
* @param entity 实体对象
*/
int insert(T entity);
复制代码4.1.2、测试
package cn.linstudy.test
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("test@itcast.cn");
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会回填到对象中
}
}
复制代码4.2、更新操作
4.2.1、updateById
4.2.1.1、方法定义
/**
* 根据 ID 修改
*
* @param entity 实体对象
*/
int updateById(@Param(Constants.ENTITY) T entity);
复制代码4.2.1.2、测试
// 需求： 将id=1用户名字修改为xiaolin
@Test
public void testUpdateById(){
Employee employee = new Employee();
employee.setId(1L);
employee.setName("xiaolin");
employeeMapper.updateById(employee);
}
// 注意： 拼接sql时，所有非null 字段都进行set 拼接
// UPDATE employee SET name=?, age=?, admin=? WHERE id=?
// 改进的方法是先查，再替换，最后更新
// 需求： 将id=1用户名字修改为xiaolin
@Test
public void testUpdateById2(){
Employee employee = employeeMapper.selectById(1L);
employee.setName("xiaolin");
employeeMapper.updateById(employee);
}
复制代码4.2.2、update
4.2.2.1、方法定义
/**
* 根据 whereEntity 条件，更新记录
*
* @param entity 实体对象 (set 条件值,可以为 null)
* @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T>
updateWrapper);
复制代码4.2.2.2、测试
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
// 方法一：使用QueryWrapper
@Test
public void testUpdate() {
User user = new User();
user.setAge(22); //更新的字段
//更新的条件
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("id", 6);
//执行更新操作
int result = this.userMapper.update(user, wrapper);
System.out.println("result = " + result);
}
//方法二： 通过UpdateWrapper进行更新
@Test
public void testUpdate(){
//更新的条件以及字段
UpdateWrapper<User> wrapper=new UpdateWrapper<>();
wrapper.eq("id",6).set("age",23);
//执行更新操作
int result=this.userMapper.update(null,wrapper);
System.out.println("result = "+result);
}
}
复制代码4.2.2.3、使用建议
-
知道id，并且所有更新使用
updateById -
部分字段更新，使用
update
4.3、删除操作
4.3.1、deleteById
4.3.1.1、方法定义
/**
* 根据 ID 删除
*
* @param id 主键ID
*/
int deleteById(Serializable id);
复制代码4.3.1.2、测试
@Test
public void testDeleteById() {
//执行删除操作
int result = this.userMapper.deleteById(6L);
System.out.println("result = " + result);
}
复制代码4.3.2、deleteByMap
4.3.2.1、方法定义
/**
* 根据 columnMap 条件，删除记录
*
* @param columnMap 表字段 map 对象
*/
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
复制代码4.3.2.2、测试
@Test
public void testDeleteByMap() {
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("age",20);
columnMap.put("name","张三");
//将columnMap中的元素设置为删除的条件，多个之间为and关系
int result = this.userMapper.deleteByMap(columnMap);
System.out.println("result = " + result);
}
复制代码4.3.3、delete
4.3.3.1、方法定义
/**
* 根据 entity 条件，删除记录
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
复制代码4.3.3.2、测试
@Test
public void testDeleteByMap() {
User user = new User();
user.setAge(20);
user.setName("张三");
//将实体对象进行包装，包装为操作条件
QueryWrapper<User> wrapper = new QueryWrapper<>(user);
int result = this.userMapper.delete(wrapper);
System.out.println("result = " + result);
}
复制代码4.3.4、deleteBatchIds
4.3.4.1、方法定义
/**
* 删除（根据ID 批量删除）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable>
idList);
复制代码4.3.4.2、测试
@Test
public void testDeleteByMap() {
//根据id集合批量删除
int result = this.userMapper.deleteBatchIds(Arrays.asList(1L,10L,20L));
System.out.println("result = " + result);
}
复制代码4.4、查询操作
MyBatis-Plus提供了多种查询操作，包括根据id查询、批量查询、查询单条数据、查询列表、分页查询等操作。
4.4.1、selectById
4.4.1.1、方法定义
/**
* 根据 ID 查询
*
* @param id 主键ID
*/
T selectById(Serializable id);
复制代码4.1.1.2、测试
@Test
public void testSelectById() {
//根据id查询数据
User user = this.userMapper.selectById(2L);
System.out.println("result = " + user);
}
复制代码4.4.2、selectBatchIds
4.4.2.1、方法定义
/**
* 查询（根据ID 批量查询）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable>
idList);
复制代码4.2.2.2、测试
@Test
public void testSelectBatchIds() {
//根据id集合批量查询
List<User> users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 10L));
for (User user : users) {
System.out.println(user);
}
}
复制代码4.4.3、selectOne
4.4.3.1、方法定义
/**
* 根据 entity 条件，查询一条记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
复制代码4.4.3.2、测试
@Test
public void testSelectOne() {
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.eq("name", "李四");
//根据条件查询一条数据，如果结果超过一条会报错
User user = this.userMapper.selectOne(wrapper);
System.out.println(user);
}
复制代码4.4.4、selectCount
4.4.4.1、方法定义
/**
* 根据 Wrapper 条件，查询总记录数
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
复制代码4.4.4.2、测试
@Test
public void testSelectCount() {
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.gt("age", 23); //年龄大于23岁
Integer count = this.userMapper.selectCount(wrapper);
System.out.println("count = " + count);
}
复制代码4.4.5、selectList
4.4.5.1、方法定义
/**
* 根据 entity 条件，查询全部记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
复制代码4.4.5.2、测试
@Test
public void testSelectList() {
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.gt("age", 23); //年龄大于23岁
//根据条件查询数据
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println("user = " + user);
}
}
复制代码4.4.6、selectPage
4.4.6.1 方法定义
/**
* 根据 entity 条件，查询全部记录（并翻页）
*
* @param page 分页查询条件（可以为 RowBounds.DEFAULT）
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
复制代码4.4.6.2、配置分页插件
@Configuration
@MapperScan("cn.itcast.mp.mapper") //设置mapper接口的扫描包
public class MybatisPlusConfig {
/**
* 分页插件
*/
@Bean
public PaginationInterceptor paginationInterceptor() {
return new PaginationInterceptor();
}
}
复制代码4.4.6.3、测试
@Test
public void testSelectPage() {
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.gt("age", 20); //年龄大于20岁
Page<User> page = new Page<>(1,1);
//根据条件查询数据
IPage<User> iPage = this.userMapper.selectPage(page, wrapper);
System.out.println("数据总条数：" + iPage.getTotal());
System.out.println("总页数：" + iPage.getPages());
List<User> users = iPage.getRecords();
for (User user : users) {
System.out.println("user = " + user);
}
}
复制代码4.4.7、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<String> mapperRegistryCache =
GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
if (!mapperRegistryCache.contains(className)) {
List<AbstractMethod> 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);
}
}
}
复制代码
以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中。
条件构造器可以简单理解为条件拼接对象，用于生成 sql 的 where 条件。
5.1、继承体系
在MyBatis-Plus中，Wrapper接口的实现类关系如下：
-
AbstractWrapper： 用于查询条件封装，生成 sql 的 where 条件。
-
QueryWrapper： Entity 对象封装操作类，不是用lambda语法。
-
UpdateWrapper： Update 条件封装，用于Entity对象更新操作。
-
AbstractLambdaWrapper： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
-
LambdaQueryWrapper：看名称也能明白就是用于Lambda语法使用的查询Wrapper。
-
LambdaUpdateWrapper： Lambda 更新封装Wrapper。
5.2、更新操作
5.2.1、普通更新
@Test
public void testUpdate(){
Employee employee = new Employee();
employee.setId(1L);
employee.setName("xiaolin");
employeeMapper.updateById(employee);
}
复制代码这种更新会导致数据的丢失，因为我只想更新部分的字段。
5.2.2、UpdateWrapper更新
5.2.2.1、set
如果说我们需要更新部分的字段可以选择UpdateWrapper进行更新。他的方法主要是有两个：
- set(String column, Object val)
- set(boolean condition, String column, Object val)
// 需求：将id=1的员工name改为xiaolin
@Test
public void testUpdate2(){
UpdateWrapper<Employee> wrapper = new UpdateWrapper<>();
wrapper.eq("id", 1L);
// 相当于sql语句中的set name = xiaolin
wrapper.set("name", "xiaolin");
employeeMapper.update(null, wrapper);
}
复制代码5.2.2.2、
MyBatis-Plus还提供了另一种方式来修改，那就是可以利用setSql直接写入sql语句。
// 需求：将id=1的用户name改为xiaolin
@Test
public void testUpdate3(){
UpdateWrapper<Employee> wrapper = new UpdateWrapper<>();
wrapper.eq("id", 1L);
wrapper.setSql("name=\'xiaolin\'");
employeeMapper.update(null, wrapper);
}
复制代码5.2.3、LambdaUpdateWrapper更新
我们还可以利用JDK8的新语法配合LambdaUpdateWrapper来进行操作。
// 需求：将id=1的用户name改为xiaolin
@Test
public void testUpdate4(){
LambdaUpdateWrapper<Employee> wrapper = new LambdaUpdateWrapper<>();
wrapper.eq(Employee::getId, 1L);
wrapper.set(Employee::getName, "xiaolin");
employeeMapper.update(null, wrapper);
}
复制代码5.2.4、开发建议
推荐使用LambdaUpdateWrapper更新。
5.3、查询操作
5.3.1、普通查询
// 需求：查询name=xiaolin， age=18的用户
@Test
public void testQuery1(){
Map<String, Object> map = new HashMap<>();
map.put("name", "xiaolin");
map.put("age", 18);
System.out.println(employeeMapper.selectByMap(map));
}
复制代码5.3.2、QueryWrapper查询
// 需求：查询name=xiaolin， age=18的用户
@Test
public void testQuery2(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.eq("name", "xiaolin").eq("age", 18);
System.out.println(employeeMapper.selectList(wrapper));
}
复制代码5.3.3、LambdaQueryWrapper查询
//需求：查询name=xiaolin， age=18的用户
@Test
public void testQuery3(){
LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(Employee::getName, "xiaolin").eq(Employee::getAge, 18);
System.out.println(employeeMapper.selectList(wrapper));
}
复制代码5.3.4、开发建议
推荐使用LambdaUpdateWrapper更新
5.4、高级查询
5.4.1、列投影
所谓的烈投影就是指定查询后返回的列。我们利用的是select方法进行实现的。他有三个重载方法：
- select(String... sqlSelect) ：参数是指定查询后返回的列。
- select(Predicate<TableFieldInfo> predicate)：参数是Predicate 函数，满足指定判定逻辑列才返回。
- select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)：参数1是通过实体属性映射表中列，参数2是Predicate 函数， 满足指定判定逻辑列才返回。
// 需求：查询所有员工， 返回员工name， age列
@Test
public void testQuery4(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.select("name", "age");
employeeMapper.selectList(wrapper);
}
// 需求：查询所有员工， 返回员工以a字母开头的列
@Test
public void testQuery4(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.select(Employee.class, tableFieldInfo->tableFieldInfo.getProperty().startsWith("a"));
employeeMapper.selectList(wrapper);
}
复制代码5.4.2、排序
5.4.2.1、orderByAsc/orderByDesc
排序分为两种，等价SQL: select ..from table ORDER BY 字段, ... ASC;
- orderByAsc： 正序排序。
- orderByDesc：倒序排序。
// 需求：查询所有员工信息按age正序排， 如果age一样， 按id正序排
@Test
public void testQuery5(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.orderByAsc("age", "id");
employeeMapper.selectList(wrapper);
}
复制代码5.4.2.2、orderBy
如果官方写好的排序不适用于我们的话，我们可以使用定制排序-order by。等价SQL：select ..from table ORDER BY 字段;
orderBy(boolean condition, boolean isAsc, R... columns)：参数1：控制是否进行排序，参数2：控制是不是正序。
// 需求：查询所有员工信息按age正序排， 如果age一样， 按id正序排
@Test
public void testQuery5(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
// orderBy(true, true, "id", "name")等价于order by id ASC,name ASC
//apper.orderByAsc("age", "id");
//等价于：
wrapper.orderBy(true, true, "age", "id");
employeeMapper.selectList(wrapper);
}
// 需求：查询所有员工信息按age正序排， 如果age一样， 按id倒序排
@Test
public void testQuery7(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.orderByAsc("age");
wrapper.orderByDesc("id");
employeeMapper.selectList(wrapper);
}
复制代码5.5、条件查询
5.5.1、allEq（全等匹配）
5.5.1.1、方法
allEq(Map<R, V> params) // params : key为数据库字段名,value为字段值
allEq(Map<R, V> params, boolean null2IsNull) // 为true则在map的value为null时调用 isNull 方法,为false时则忽略value为null的
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)
复制代码 null2IsNull这个参数的意思是为true则在map的value为null时调用 isNull 方法,为false时则忽略value为null的。例如：
- allEq({id:1,name:"老王",age:null})--->id = 1 and name = \'老王\' and age is null
- allEq({id:1,name:"老王",age:null}, false) ---> id = 1 and name = \'老王\'
5.5.1.2、范例
// 需求：查询name=xiaolin， age=18的员工信息
@Test
public void testQuery8(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
Map<String, Object> map = new HashMap<>();
map.put("name", "xiaolin");
map.put("age", 18);
wrapper.allEq(map);
employeeMapper.selectList(wrapper);
}
@Test
public void testQuery8(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
Map<String, Object> map = new HashMap<>();
map.put("name", "xiaolin");
map.put("age", 18);
map.put("dept_id", null);
wrapper.allEq(map, true);
employeeMapper.selectList(wrapper);
}
复制代码5.5.2、allEq（全等匹配带条件过滤的）
5.5.2.1、方法
allEq(BiPredicate<R, V> filter, Map<R, V> params)
allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
复制代码 filter : 过滤函数,是否允许字段传入比对条件中 params 与 null2IsNull同上，例如：
- allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"老王",age:null})--->name = \'老王\' and age is null
- allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"老王",age:null}, false)--->name = \'老王\'
5.5.2.2、范例
// 需求：查询满足条件员工信息， 注意传入的map条件中， 包含a的列才参与条件查询
@Test
public void testQuery9(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
Map<String, Object> map = new HashMap<>();
map.put("name", "xiaolin");
map.put("age", 18);
wrapper.allEq((k, v)-> k.contains("m"), map);
employeeMapper.selectList(wrapper);
}
复制代码5.5.3、eq
我们可以使用eq来判断单个参数判断是否相等。eq("name", "老王")等价于name = \'老王\'。
5.5.3.1、方法
eq(R column, Object val)
eq(boolean condition, R column, Object val) // 相较于上一个方法，多了一个条件，当前面的条件成立时，才拼接后面语句，常用于判断当某个值不为空的时候进行拼接。
复制代码5.5.3.2、范例
// 需求：查询name=xiaolin员工信息
@Test
public void testQuery10(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.eq("name", "xiaolin");
employeeMapper.selectList(wrapper);
}
复制代码5.5.4、ne
我们可以使用ne来判断某个参数是否不相等。 ne("name", "老王")等价于name != \'老王\'。
// 需求：查询name !=xiaolin员工信息
@Test
public void testQuery11(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.ne("name", "xiaolin");
employeeMapper.selectList(wrapper);
}
复制代码5.5.5、gt
gt表示大于。gt("age", 18)等价于age > 18
5.5.5.1、方法
gt(R column, Object val)
gt(boolean condition, R column, Object val)
复制代码5.5.5.2、范例
// 需求：查询age > 12 员工信息
@Test
public void testQuery12(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.gt("age", "12");
employeeMapper.selectList(wrapper);
}
复制代码5.5.6、ge
ge表示大于等于。ge("age", 18)等价于age > =18
5.5.6.1、方法
ge(R column, Object val)
ge(boolean condition, R column, Object val)
复制代码5.5.6.2、范例
// 需求：查询age >= 12 员工信息
@Test
public void testQuery12(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.ge("age", "12");
employeeMapper.selectList(wrapper);
}
复制代码5.5.7、lt
lt表示小于1。lt("age", 18)等价于age < 18
5.5.7.1、方法
lt(R column, Object val)
lt(boolean condition, R column, Object val
复制代码5.5.7.2、范例
// 需求：查询age < 12 员工信息
@Test
public void testQuery12(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.lt("age", "12");
employeeMapper.selectList(wrapper);
}
复制代码5.5.8、lt
lt表示小于1。lt("age", 18)等价于age < 18
5.5.8、方法
lt(R column, Object val)
lt(boolean condition, R column, Object val
复制代码5.5.7.2、范例
// 需求：查询age < 12 员工信息
@Test
public void testQuery12(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.lt("age", "12");
employeeMapper.selectList(wrapper);
}
复制代码5.5.9、le
le表示小于等于。le("age", 18)等价于age <= 18。
le(R column, Object val)
le(boolean condition, R column, Object val)
复制代码5.5.10、between、notBetween
我们使用between/notBetween来表示介于/不介于两者之间。
between("age", 18, 30)等价于age between 18 and 30。
notBetween("age", 18, 30)等价于age not between 18 and 30
5.5.10.1、方法
// between ： BETWEEN 值1 AND 值2
between(R column, Object val1, Object val2)
between(boolean condition, R column, Object val1, Object val2)
// notBetween ： NOT BETWEEN 值1 AND 值2
notBetween(R column, Object val1, Object val2)
notBetween(boolean condition, R column, Object val1, Object val2)
复制代码5.5.10.2、范例
// 需求：查询年龄介于18~30岁的员工信息
@Test
public void testQuery13(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.between("age", 18, 30);
employeeMapper.selectList(wrapper);
}
// 需求：查询年龄小于18或者大于30岁的员工信息【用between实现】
@Test
public void testQuery13(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.notBetween("age", 18, 30);
employeeMapper.selectList(wrapper);
}
复制代码5.5.11、isNull、isNotNull
我们可以使用isNull/isNotNull来表示为空/不为空。
isNull("name")等价于name is null。
isNotNull("name")等价于name is not null。
5.5.11.1、方法
// isNull : 字段 IS NULL
isNull(R column)
isNull(boolean condition, R column)
// isNotNull : 字段 IS NOT NULL
isNotNull(R column)
isNotNull(boolean condition, R column)
复制代码5.5.11.2、范例
// 需求： 查询dept_id 为null 员工信息
@Test
public void testQuery16(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.isNull("dept_id");
employeeMapper.selectList(wrapper);
}
// 需求： 查询dept_id 为不为null 员工信息
@Test
public void testQuery16(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.isNotNull("dept_id");
employeeMapper.selectList(wrapper);
}
复制代码5.5.12、in、notIn
我们可以使用in/notIn来表示值在/不在这里面。
in("age",{1,2,3})--->age in (1,2,3)
notIn("age",{1,2,3})--->age not in (1,2,3)
5.5.12.1、方法
// in : 字段 IN (value1, value2, ...)
in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)
// notIn : 字段 NOT IN (value1, value2, ...)
notIn(R column, Object... values)
notIn(boolean condition, R column, Object... values)
复制代码5.5.12.2、范例
// 需求： 查询id为1， 2 的员工信息
@Test
public void testQuery18(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.in("id", 1L, 2L);
employeeMapper.selectList(wrapper);
}
// 需求： 查询id不为1，2 的员工信息
@Test
public void testQuery19(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.notIn("id", 1L, 2L);
employeeMapper.selectList(wrapper);
}
复制代码5.5.13、inSql、notInSql
与上一个不同的是，他的格式是：字段 IN ( sql语句 ) / 字段 NOT IN ( sql语句 )，接的是SQL语句片段。
5.5.13.1、方法
inSql("age", "1,2,3,4,5,6")等价于age in (1,2,3,4,5,6)
notInSql("id", "select id from table where id < 3")--->id not in (select id from table where id < 3)
// inSql ： 字段 IN ( sql语句 )
inSql(R column, String inValue)
inSql(boolean condition, R column, String inValue)
// notInSql ： 字段 NOT IN ( sql语句 )
notInSql(R column, String inValue)
notInSql(boolean condition, R column, String inValue)
复制代码5.5.13.2、范例
// 需求： 查询id为1， 2 的员工信息
@Test
public void testQuery20(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.inSql("id", "1,2");
employeeMapper.selectList(wrapper);
}
// 需求： 查询id不为1，2 的员工信息
@Test
public void testQuery21(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.notInSql("id", "1,2");
employeeMapper.selectList(wrapper);
}
复制代码5.6、模糊查询
5.6.1、like、notLike
5.6.1.1、方法
// like: LIKE \'%值%\':like("name", "王")等价于name like \'%王%\'
like: LIKE \'%值%\'
like(R column, Object val)
like(boolean condition, R column, Object val)
// notLike("name", "王")--->name not like \'%王%\'
notLike : NOT LIKE \'%值%\'
notLike(R column, Object val)
notLike(boolean condition, R column, Object val)
复制代码5.6.1.2、范例
// 需求： 查询name中含有lin字样的员工
@Test
public void testQuery14(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.like("name", "lin");
employeeMapper.selectList(wrapper);
}
// 需求： 查询name中不含有lin字样的员工
@Test
public void testQuery14(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.notLike("name", "lin");
employeeMapper.selectList(wrapper);
}
复制代码5.6.2、likeLeft、likeRight
5.6.2.1、方法
// likeLeft("name", "王")--->name like \'%王\'
likeLeft ： LIKE \'%值\'
likeLeft(R column, Object val)
likeLeft(boolean condition, R column, Object val)
// likeRight("name", "王")--->name like \'王%\'
likeRight ： LIKE \'值%\'
likeRight(R column, Object val)
likeRight(boolean condition, R column, Object val)
复制代码5.6.2.2、范例
// 需求： 查询name以lin结尾的员工信息
@Test
public void testQuery15(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.likeLeft("name", "lin");
employeeMapper.selectList(wrapper);
}
// 需求： 查询姓王的员工信息
@Test
public void testQuery16(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.likeRight("name", "王");
employeeMapper.selectList(wrapper);
}
复制代码5.7、逻辑运算符
5.7.1、or
5.7.1.1、方法
// eq("id",1).or().eq("name","老王")--->id = 1 or name = \'老王\'
or ： 拼接 OR
or()
or(boolean condition)
// or还可以嵌套使用
// or(i -> i.eq("name", "李白").ne("status", "活着"))--->or (name = \'李白\' and status <> \'活着\')
or(Consumer<Param> consumer)
or(boolean condition, Consumer<Param> consumer)
复制代码主动调用or表示紧接着下一个方法不是用and连接!(不调用or则默认为使用and连接)
5.7.1.2、范例
// 需求： 查询age = 18 或者 name=xiaolin 或者 id =1 的用户
@Test
public void testQuery24(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.eq("age", 18)
.or()
.eq("name", "xiaolin")
.or()
.eq("id", 1L);
employeeMapper.selectList(wrapper);
}
// 需求：查询name含有lin字样的，或者 年龄在18到30之间的用户
@Test
public void testQuery25(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.like("name", "lin")
.or(wr -> wr.le("age", 30).ge("age", 18));
employeeMapper.selectList(wrapper);
}
复制代码5.7.2、and
5.7.2.1、方法
// 嵌套and：
and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)
复制代码5.7.2.2、范例
// 需求：查询年龄介于18~30岁的员工信息
@Test
public void testQuery26(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.le("age", 30).ge("age", 18);
employeeMapper.selectList(wrapper);
}
// 需求：查询name含有lin字样的并且 年龄在小于18或者大于30的用户
@Test
public void testQuery27(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.like("name", "lin")
.and(wr -> wr.le("age", 30)
.or()
.ge("age", 18));
employeeMapper.selectList(wrapper);
}
复制代码5.8、分组查询
5.8.1、groupBy
5.8.1.1、方法
// groupBy("id", "name")--->group by id,name
groupBy ： 分组：GROUP BY 字段, ...
groupBy(R... columns)
groupBy(boolean condition, R... columns)
复制代码5.8.1.2、范例
// 需求： 以部门id进行分组查询，查每个部门员工个数
@Test
public void testQuery22(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.groupBy("dept_id");
wrapper.select("dept_id", "count(id) count");
employeeMapper.selectMaps(wrapper);
}
复制代码5.8.2、having
5.8.2.1、方法
// having("sum(age) > 10")--->having sum(age) > 10
// having("sum(age) > {0}", 11)--->having sum(age) > 11
having ： HAVING ( sql语句 )
having(String sqlHaving, Object... params)
having(boolean condition, String sqlHaving, Object... params)
复制代码5.8.2.2、范例
// 需求： 以部门id进行分组查询，查每个部门员工个数， 将大于3人的部门过滤出来
@Test
public void testQuery23(){
QueryWrapper<Employee> wrapper = new QueryWrapper<>();
wrapper.groupBy("dept_id")
.select("dept_id", "count(id) count")
//.having("count > {0}", 3)
.having("count >3");
employeeMapper.selectMaps(wrapper);
}
复制代码6.1、传统方式
在以前的业务层中，我们需要写接口和实现类，其中有不少的接口都是重复的CRUD，没有任何技术含量。
6.1.1、Service接口
public interface EmployeeService {
void save(Employee employee);
void update(Employee employee);
void delete(Long id);
Employee get(Long id);
List<Employee> list();
}
复制代码6.1.2、ServiceImpl
@Service
public class EmployeeServiceImpl implements EmployeeService {
@Autowired
private EmployeeMapper mapper;
@Override
public void save(Employee employee) {
mapper.insert(employee);
}
@Override
public void update(Employee employee) {
mapper.updateById(employee); //必须全量更新
}
@Override
public void delete(Long id) {
mapper.deleteById(id);
}
@Override
public Employee get(Long id) {
return mapper.selectById(id);
}
@Override
public List<Employee> list() {
return mapper.selectList(null);
}
}
复制代码6.2、MyBatis-Plus的通用Service接口
既然需要重复写那么多没有技术含量的代码，那么肯定MyBatis-Plus会帮我们做好，我们只需要简单两部即可使用MyBatis-Plus给我们写好的CRUD方法，他会自动调用mapper接口方法。
- 自定义服务接口继承IService接口，其中泛型是实体类对象
public interface IEmployeeService extends IService<Employee> {
}
复制代码- 服务接口实现类集成IService接口实现类ServiceImpl同时实现自定义接口，泛型一是实体类的mapper接口，泛型二是实体类。
@Service
public class EmployeeServiceImpl extends ServiceImpl<EmployeeMapper, Employee> implements IEmployeeService {
}
复制代码6.2.1、常用方法
- getBaseMapper()：获取引用的XxxxMapper对象。
- getOne(wrapper)：指定条件查询单个， 结果数据超过1个报错。
- list(wrapper)：指定条件查询多个。
6.2.2、分页
分页所用的方法是：page(page, wrapper)，他也可以配合高级查询一起。
6.2.2.1、配置分页插件
我们需要在配置类中配置分页插件。
//分页
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor(DbType.MYSQL);
paginationInnerInterceptor.setOverflow(true); //合理化
interceptor.addInnerInterceptor(paginationInnerInterceptor);
return interceptor;
}
复制代码6.2.2.2、编写分页代码
MyBatis-Plus的分页对象是IPage，分页信息封装对象，里面有各种分页相关信息等价于之前的PageInfo。
//需求：查询第2页员工信息， 每页显示3条， 按id排序
@Test
public void testPage(){
EmployeeQuery qo = new EmployeeQuery();
qo.setPageSize(3);
qo.setCurrentPage(2);
IPage<Employee> page = employeeService.query(qo);
System.out.println("当前页：" + page.getCurrent());
System.out.println("总页数：" + page.getPages());
System.out.println("每页显示条数：" + page.getSize());
System.out.println("总记录数：" + page.getTotal());
System.out.println("当前页显示记录：" + page.getRecords());
}
复制代码7.1、什么是ActiveRecord
ActiveRecord也属于ORM（对象关系映射）层，由Rails最早提出，遵循标准的ORM模型：表映射到记录，记录映射到对象，字段映射到对象属性。配合遵循的命名和配置惯例，能够很大程度的快速实现模型的操作，而且简洁易懂。
ActiveRecord的主要思想是：
- 每一个数据库表对应创建一个类，类的每一个对象实例对应于数据库中表的一行记录；通常表的每个字段 在类中都有相应的Field。
- ActiveRecord同时负责把自己持久化，在ActiveRecord中封装了对数据库的访问，即CURD。
- ActiveRecord是一种领域模型(Domain Model)，封装了部分业务逻辑；
ActiveRecord（简称AR）一直广受动态语言（ php 、 Ruby 等）的喜爱，而 Java 作为准静态语言，对于ActiveRecord 往往只能感叹其优雅，所以我们也在 AR 道路上进行了一定的探索，喜欢大家能够喜欢。
7.2、开启AR之旅
在MP中，开启AR非常简单，只需要将实体对象继承Model即可。
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee extends Model<Employee> {
@TableId(type = IdType.AUTO)
private Long id;
private String username;
private String name;
private String password;
private String email;
private Integer age;
private Boolean admin;
private Long deptId;
private Boolean status;
}
复制代码7.2.1、查询所有
@RunWith(SpringRunner.class)
@SpringBootTest
public class Test1 {
@Autowired
EmployeeMapper employeeMapper;
/**
* 用于测试查询所有
*/
@Test
public void test(){
Employee employee = new Employee();
List<Employee> employees = employee.selectAll();
for (Employee employee1 : employees) {
System.out.println(employee1);
}
}
}
复制代码7.2.2、根据id查询
@RunWith(SpringRunner.class)
@SpringBootTest
public class Test2 {
/**
* 用于测试根据id查询
*/
@Test
public void test2(){
Employee employee = new Employee();
employee.setId(1L);
System.out.println(employee.selectById());
}
}
复制代码7.2.3、根据条件查询
/**
* 用于测试根据条件查询
*/
@Test
public void test4(){
Employee employee = new Employee();
QueryWrapper<Employee> userQueryWrapper = new QueryWrapper<>();
userQueryWrapper.le("password","123");
List<Employee> employees = employee.selectList(userQueryWrapper);
for (Employee employee1 : employees) {
System.out.println(employee1);
}
}
复制代码7.2.4、新增数据
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestAR {
/**
* 用于测试新增数据
*/
@Test
public void test3(){
Employee employee = new Employee();
employee.setId(11L);
employee.setPassword("123");
employee.insert();
}
}
复制代码7.2.5、更新数据
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestAR {
/**
* 用于测试更新
*/
@Test
public void test5(){
Employee employee = new Employee();
employee.setId(1L);
employee.setPassword("123456789");
employee.updateById();
}
}
复制代码7.2.6、删除数据
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestAR {
/**
* 用于测试删除
*/
@Test
public void test6(){
Employee employee = new Employee();
employee.setId(1L);
employee.deleteById();
}
}
复制代码8.1、插件机制简介
MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：
- Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
- ParameterHandler (getParameterObject, setParameters)
- ResultSetHandler (handleResultSets, handleOutputParameters)
- StatementHandler (prepare, parameterize, batch, update, query)
我们看到了可以拦截Executor接口的部分方法，比如update，query，commit，rollback等方法，还有其他接口的一些方法等。总体概括为：
- 拦截执行器的方法。
- 拦截参数的处理。
- 拦截结果集的处理。
- 拦截Sql语法构建的处理。
8.2、执行分析插件
在MP中提供了对SQL执行的分析的插件，可用作阻断全表更新、删除的操作，注意：该插件仅适用于开发环境，不适用于生产环境。我们首先要在启动类上配置：
@Bean
public SqlExplainInterceptor sqlExplainInterceptor(){
SqlExplainInterceptor sqlExplainInterceptor = new SqlExplainInterceptor();
List<ISqlParser> sqlParserList = new ArrayList<>();
// 攻击 SQL 阻断解析器、加入解析链
sqlParserList.add(new BlockAttackSqlParser());
sqlExplainInterceptor.setSqlParserList(sqlParserList);
return sqlExplainInterceptor;
}
复制代码测试类：
@Test
public void testUpdate(){
Employee employee = new Employee();
employee.setPassword("123456");
int result = this.employeeMapper.update(employee, null);
System.out.println("result = " + result);
}
复制代码执行后会发现控制台报错了，当执行全表更新时，会抛出异常，这样有效防止了一些误操作。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JpBJRX8S-1620720482907)(MyBatisPlus.assets/image-20210509210703826.png)]
8.3、乐观锁插件
8.3.1、适用场景
当要更新一条记录的时候，希望这条记录没有被别人更新。
乐观锁的实现方式：
- 取出记录时，获取当前version。
- 更新时，带上这个version。
- 执行更新时， set version = newVersion where version = oldVersion。
- 如果version不对，就更新失败。
8.3.2、插件配置
我们需要在spring.xml中进行配置。
<bean class="com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor"/>
复制代码然后在singboot的启动类中配置。
Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
return new OptimisticLockerInterceptor();
}
复制代码8.3.3、注解实体字段
ALTER TABLE `employee`
ADD COLUMN `version` int(10) NULL AFTER `email`;
UPDATE `tb_user` SET `version`=\'1\';
复制代码@Version
private Integer version;
复制代码@Test
public void testUpdate(){
Employee employee = new Employee();
user.setPassword("456789");
user.setId(2L);
user.setVersion(1); //设置version为1
int result = this.userMapper.updateById(user);
System.out.println("result = " + result);
}
复制代码8.3.4、说明
- 支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime。
- 整数类型下 newVersion = oldVersion + 1。
- newVersion 会回写到 entity 中仅支持 updateById(id) 与 update(entity, wrapper) 方法。
- 在 update(entity, wrapper) 方法下, wrapper 不能复用。
文章转载：乐字节
在学编程,学Python，Java的小伙伴们，一个人摸黑学会很难,up也是过来人, 欢迎加入扣裙：链接 备注75 这里给大家准备了配套视频、书籍等学习资源，还有接单技巧
以上是关于还在用MyBatis写CRUD?这款神器帮你5分钟写后台管理基本功能的主要内容，如果未能解决你的问题，请参考以下文章
取代 Mybatis Generator，这款代码生成神器配置更简单，开发效率更高