# Mybatis-plus<二>通用CRUD,分页

Mybatis-plus<二>通用CRUD,分页

与博客Mybatis-plus<一>为同一个Springboot项目。

Demo GitHub下载地址：https://github.com/RJvon/Mybatis_plus_demo（包含数据库建表sql，数据库数据与源代码）

Mybatis-plus官网： https://mp.baomidou.com/
未经作者同意请勿转载

Service CRUD 接口说明

说明:

• 通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
• 泛型 T 为任意实体对象
• 对象 Wrapper 为 条件构造器

CRUD接口：

Insert

// @param entity 实体对象
// 插入一条记录
int insert(T entity);

@Test
public void insertTest1() {
    Employees employees = new Employees();
    employees.setId(109);
    employees.setBirth(LocalDateTime.of(2019, Month.SEPTEMBER, 10, 14, 46, 56));
    employees.setName("冯北航");
    employees.setSex(false);
    employees.setSchool("北京航空航天大学");
    employees.setTel("12345678910");
    int insert = employeesMapper.insert(employees);
    System.out.println(employees);
    System.out.println(insert);
}

Delete

// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
        employees.setTel("12345676910");
        employees.setName("caocao");
        QueryWrapper<Employees> wrapper = new QueryWrapper<>(Employees);
		employeesMapper.delete(wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
		int result = this.employeesMapper.deleteBatchIds(Arrays.asList(105,106));
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录,多个条件之间是and关系
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
		比如 map.put("name")="陈中山"
        map.put("tel")="12345676910"
        删除"name"="陈中山";"tel"="12345676910"的对象

    @Test
    public void testDeleteById(){
        // 根据id删除数据
        int result = this.employeesMapper.deleteById(101);
    }

    @Test
    public void testDeleteByMap(){
        Map<String,Object> map = new HashMap<>();
        map.put("name", "钱北大");
        map.put("sex", true);
        // 根据map删除数据，多条件之间是and关系
        int result = this.employeesMapper.deleteByMap(map);
    }

    @Test
    public void testDelete(){
        //用法一：
        QueryWrapper<Employees> wrapper = new QueryWrapper<Employees>();
        wrapper.eq("name", "李交通")
                .eq("sex", false);

/*        //用法二：
        Employees employees = new Employees();
        employees.setName("孙复旦");
        employees.setSex(true);
        QueryWrapper<Employees> wrapper = new QueryWrapper<>(employees);*/
        // 根据包装条件做删除
        int result = this.employeesMapper.delete(wrapper);
    }

    @Test
    public void  testDeleteBatchIds(){
        // 根据id批量删除数据
        int result = this.employeesMapper.deleteBatchIds(Arrays.asList(105,106));
        System.out.println("result => " + result);
    }

    @Test
    public void testSelectBatchIds(){
        // 根据id批量查询数据
        List<Employees> employees = this.employeesMapper.selectBatchIds(Arrays.asList(2L, 3L, 4L, 100L));
        for (Employees e : employees) {
            System.out.println(employees);
        }
    }

Update

// 根据 whereWrapper 条件，更新记录
int update(@Param(Constants.ENTITY) T updateEntity, @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

@Test
public void updateTest(){
    Employees employees = new Employees();
    employees.setId(101);
    employees.setTel("00000000000");
    int i = employeesMapper.updateById(employees);
    System.out.println(i);
}

Select

// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

@Test
public void getSelect1() {
    System.out.println(employeesMapper.selectById(101));
}
@Test
public void getSelect2() {
    List<Employees> employees = employeesMapper.selectBatchIds(Arrays.asList(101, 102, 103));
    for (Employees employee : employees) {
        System.out.println(employee);
    }
}

    @Test
    public void testSelectPage(){
        Page<Employees> employeesPage = new Page<>(3, 2);
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.eq("sex",true);
        Page page = employeesMapper.selectPage(employeesPage, wrapper);
        System.out.println("数据总条数： " + page.getTotal());
        System.out.println("数据总页数： " + page.getPages());
        System.out.println("当前页数： " + page.getCurrent());
        List records = page.getRecords();
        records.forEach(System.out::println);
    }

分页——Springboot中添加

@Configuration
@MapperScan("scan.your.mapper.package")
public class MybatisPlusConfig {

    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题(该属性会在旧插件移除后一同移除)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        return interceptor;
    }

    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return configuration -> configuration.setUseDeprecatedExecutor(false);
    }
}

​