五、条件构造器

条件构造器可以简单理解为条件拼接对象，用于生成 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、le

le表示小于等于。le("age", 18)等价于age <= 18。

le(R column, Object val)
le(boolean condition, R column, Object val)
复制代码

5.5.9、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.9.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.9.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.10、isNull、isNotNull

我们可以使用isNull/isNotNull来表示为空/不为空。

isNull("name")等价于name is null。

isNotNull("name")等价于name is not null。

5.5.10.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.10.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.11、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.11.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.11.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.12、inSql、notInSql

与上一个不同的是，他的格式是：字段 IN ( sql语句 ) / 字段 NOT IN ( sql语句 )，接的是SQL语句片段。

5.5.12.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.12.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);
    }
复制代码

六、通用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

@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());
}
复制代码

七、ActiveRecord

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);
}
复制代码

执行后会发现控制台报错了，当执行全表更新时，会抛出异常，这样有效防止了一些误操作。

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、注解实体字段

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

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

为实体类添加version字段，并且添加@Version注解

@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 不能复用。

还在用MyBatis写CRUD?这款神器帮你5分钟写后台管理基本功能（下）