numberlongphp技巧_还在用MyBatis写CRUD这款神器帮你5分钟写后台治理基本功能

文章目录 [+]

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>  <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.1.1</version> </dependency>  <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,A1log4j.appender.A1=org.apache.log4j.ConsoleAppenderlog4j.appender.A1.layout=org.apache.log4j.PatternLayoutlog4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n2.3.3、编写实体类

@Data@AllArgsConstructor@NoArgsConstructorpublic 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)@SpringBootTestpublic 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、架构

numberlongphp技巧_还在用MyBatis写CRUD这款神器帮你5分钟写后台治理基本功能

三、常用表明3.1、@TableName

MyBatis-Plus中默认表名是跟实体类名同等，当我们实体类的类名和表名不一致的时候，MyBatis-Plus就会报错，但是我们实际上又有这种需求的时候，我们就须要利用@TableName这个表明，来指定当前实体类映射哪张数据库表。

numberlongphp技巧_还在用MyBatis写CRUD这款神器帮你5分钟写后台治理基本功能

（图片来自网络侵删）

@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表明用于标记非主键字段，他的浸染是指定当前属性映射数据库表哪一列，默认是跟属性名同等。
常用于办理以下两个问题：

工具中的属性名和字段名不一致的问题（非驼峰）工具中的属性字段在表中不存在的问题

他还有另一种用法，便是指定某个字段不加入查询。

四、通用CRUD

我们之前学过，利用MyBatis-Plus的时候，Mapper接口里面的方法不须要我们再自己写了，只须要继续BaseMapper接口即可获取到各种各样的单表操作。

4.1、插入操作4.1.1、方法定义

MyBatis-Plus中对付insert的方法定义是：

/ 插入一条记录 @param entity 实体工具/int insert(T entity);4.1.2、测试

package cn.linstudy.testimport 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)@SpringBootTestpublic 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、updateById4.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、update4.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进行更新 @Testpublic 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部分字段更新，利用update4.3、删除操作4.3.1、deleteById4.3.1.1、方法定义

/ 根据 ID 删除 @param id 主键ID/int deleteById(Serializable id);4.3.1.2、测试

@Testpublic void testDeleteById() {//实行删除操作int result = this.userMapper.deleteById(6L);System.out.println("result = " + result);}4.3.2、deleteByMap4.3.2.1、方法定义

/ 根据 columnMap 条件，删除记录 @param columnMap 表字段 map 工具/int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);4.3.2.2、测试

@Testpublic 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、delete4.3.3.1、方法定义

/ 根据 entity 条件，删除记录 @param wrapper 实体工具封装操作类（可以为 null）/int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);4.3.3.2、测试

@Testpublic 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、deleteBatchIds4.3.4.1、方法定义

/ 删除（根据ID 批量删除） @param idList 主键ID列表(不能为 null 以及 empty)/int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable>idList);4.3.4.2、测试

@Testpublic 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、selectById4.4.1.1、方法定义

/ 根据 ID 查询 @param id 主键ID/T selectById(Serializable id);4.1.1.2、测试

@Testpublic void testSelectById() {//根据id查询数据User user = this.userMapper.selectById(2L);System.out.println("result = " + user);}4.4.2、selectBatchIds4.4.2.1、方法定义

/ 查询（根据ID 批量查询） @param idList 主键ID列表(不能为 null 以及 empty)/List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable>idList);4.2.2.2、测试

@Testpublic 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、selectOne4.4.3.1、方法定义

/ 根据 entity 条件，查询一条记录 @param queryWrapper 实体工具封装操作类（可以为 null）/T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);4.4.3.2、测试

@Testpublic void testSelectOne() {QueryWrapper<User> wrapper = new QueryWrapper<User>();wrapper.eq("name", "李四");//根据条件查询一条数据，如果结果超过一条会报错User user = this.userMapper.selectOne(wrapper); System.out.println(user);}4.4.4、selectCount4.4.4.1、方法定义

/ 根据 Wrapper 条件，查询总记录数 @param queryWrapper 实体工具封装操作类（可以为 null）/Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);4.4.4.2、测试

@Testpublic 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、selectList4.4.5.1、方法定义

/ 根据 entity 条件，查询全部记录 @param queryWrapper 实体工具封装操作类（可以为 null）/List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);4.4.5.2、测试

@Testpublic 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、selectPage4.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 {/ 分页插件/@Beanpublic PaginationInterceptor paginationInterceptor() { return new PaginationInterceptor();}}4.4.6.3、测试

@Testpublic 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()方法进行注入的：

@Overridepublic 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 methodwas found.");}mapperRegistryCache.add(className);}}}

以SelectById为例查看：

public class SelectById extends AbstractMethod {@Overridepublic 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 nullallEq({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 nullallEq((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 val5.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 val5.5.7.2、范例

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 值2between(R column, Object val1, Object val2)between(boolean condition, R column, Object val1, Object val2) // notBetween ： NOT BETWEEN 值1 AND 值2notBetween(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 NULLisNull(R column)isNull(boolean condition, R column) // isNotNull : 字段 IS NOT NULLisNotNull(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、notLike5.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、likeRight5.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、or5.7.1.1、方法

// eq("id",1).or().eq("name","老王")--->id = 1 or name = '老王'or ：拼接 ORor()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、and5.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、groupBy5.8.1.1、方法

// groupBy("id", "name")--->group by id,namegroupBy ：分组：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、having5.8.2.1、方法

// having("sum(age) > 10")--->having sum(age) > 10// having("sum(age) > {0}", 11)--->having sum(age) > 11having ： 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); }六、通用Service接口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

@Servicepublic 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接口，泛型二是实体类。

@Servicepublic 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排序@Testpublic 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());}七、ActiveRecord7.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@NoArgsConstructorpublic 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)@SpringBootTestpublic 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)@SpringBootTestpublic 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)@SpringBootTestpublic class TestAR { / 用于测试新增数据 / @Test public void test3(){ Employee employee = new Employee(); employee.setId(11L); employee.setPassword("123"); employee.insert(); }}7.2.5、更新数据

@RunWith(SpringRunner.class)@SpringBootTestpublic class TestAR { / 用于测试更新 / @Test public void test5(){ Employee employee = new Employee(); employee.setId(1L); employee.setPassword("123456789"); employee.updateById(); }}7.2.6、删除数据

@RunWith(SpringRunner.class)@SpringBootTestpublic 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; }

测试类：

@Testpublic void testUpdate(){Employee employee = new Employee();employee.setPassword("123456");int result = this.employeeMapper.update(employee, null);System.out.println("result = " + result);}

实行后会创造掌握台报错了，当实行全表更新时，会抛出非常，这样有效防止了一些误操作。

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的启动类中配置。

Beanpublic OptimisticLockerInterceptor optimisticLockerInterceptor() {return new OptimisticLockerInterceptor();}8.3.3、表明实体字段

为表添加version字段，并赋初始值为1

ALTER TABLE `employee`ADD COLUMN `version` int(10) NULL AFTER `email`;UPDATE `tb_user` SET `version`='1';

为实体类添加version字段，并且添加@Version表明

@Versionprivate Integer version;

测试

@Testpublic void testUpdate(){Employee employee = new Employee();user.setPassword("456789");user.setId(2L);user.setVersion(1); //设置version为1int 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 不能复用。