【详细】Spring Boot+Mybatis Plus （全CRUD和分页查询）

加油，新时代打工人！

MyBatis-Plus快速入门–环境搭建
MyBatis-Plus–三种方式整合之一 Mybatis+MP整合
MyBatis-Plus–三种方式整合之二 Spring+MP整合
MyBatis-Plus–三种方式整合之三 Spring Boot+MP整合

数据库脚本和更多MP整合方式，参考以上文章

以下文章环境基于MyBatis-Plus–三种方式整合之三 Spring Boot+MP整合以上进行了扩展

新的分页插件

package itboywh.mp;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.autoconfigure.ConfigurationCustomizer;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author wh
 * @date 2021年12月01日15:56
 */
@Configuration
@MapperScan("itboywh.mp.mapper")
public class MybatisPlusConfig {
    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题(该属性会在旧插件移除后一同移除)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor();
        paginationInnerInterceptor.setDbType(DbType.MYSQL);
        paginationInnerInterceptor.setOverflow(true);
        interceptor.addInnerInterceptor(paginationInnerInterceptor);
        return interceptor;
    }

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

}

Spring Boot+Mybatis Plus 详细CRUD和分页查询

package itboywh.mp;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import itboywh.mp.mapper.UserMapper;
import itboywh.mp.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author wh
 * @date 2021年11月29日19:11
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class UserAdd {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void add() {
        User user = new User();
        user.setAge(20);
        user.setName("小明");
        user.setMail("itboywh@github.com");
        user.setUserName("xiaoming");
        user.setPassword("123456");
        int insert = userMapper.insert(user);
        System.out.println("受影响行数" + insert);
        System.out.println("id>=" + user.getId());
    }

    @Test
    public void selecById() {
        User select = userMapper.selectById(6);
        System.out.println("更根据用户id查询" + select);
    }

    @Test
    public void update1() {
        User user = new User();
        user.setAge(25);
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id", 6);
        int updateById = userMapper.update(user, queryWrapper);
        System.out.println("更新条数  " + updateById);
    }

    @Test
    public void update2() {
        UpdateWrapper<User> UpdateWrapper = new UpdateWrapper<>();
        UpdateWrapper.eq("id", 6).set("age", 5);
        int updateById = userMapper.update(null, UpdateWrapper);
        System.out.println("更新条数  " + updateById);
    }

    @Test
    public void deletebyId() {
        int deleteById = userMapper.deleteById(5);
        System.out.println("受影响行数 " + deleteById);
    }

    @Test
    public void deletebyMap() {
        Map<String, Object> columnMap = new HashMap<String, Object>();
        columnMap.put("name", "小豪");
        columnMap.put("age", 20);
//将columnMap中的元素设置为删除的条件，多个之间为and关系

        int i = userMapper.deleteByMap(columnMap);
        System.out.println("受影响行数 " + i);
    }

    /**
     * 根据 entity 条件，删除记录
     * queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     *
     * @param
     */
    @Test
    public void delete() {
        User user = new User();
        user.setName("小华");
        user.setAge(20);
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        int delete = userMapper.delete(queryWrapper);
        System.out.println("受影响行数" + delete);
    }

    /**
     * 删除（根据ID 批量删除）
     * idList 主键ID列表(不能为 null 以及 empty)
     *
     * @param
     */
    @Test
    public void deleteBatchIds() {
        // 删除（根据ID 批量删除）
        int deleteBatchIds = userMapper.deleteBatchIds(Arrays.asList(15, 17));
        System.out.println("受影响行数 " + deleteBatchIds);
    }

    /**
     * 根据 ID 查询
     * <p>
     * id 主键ID
     */
    @Test
    public void seletebyId() {
        User selectById = userMapper.selectById(16);
        System.out.println("根据ID查询 " + selectById);
    }

    /**
     * 查询（根据ID 批量查询）
     * idList 主键ID列表(不能为 null 以及 empty)
     *
     * @param
     */
    @Test
    public void selectBatchIds() {
        List<User> users = userMapper.selectBatchIds(Arrays.asList(16, 18));
        for (User user : users) {
            System.out.println(user);
        }
    }

    /**
     * 愿我们十二月份如烟花一样灿烂
     *We
     * @param
     */
    @Test
    public void live() {
        System.out.println("愿我们的十二月份如烟花一样灿烂           ");
    }

    /**
     * 根据 Wrapper 条件，查询总记录数
     * queryWrapper 实体对象封装操作类（可以为 null）
     *
     * @param
     */
    @Test
    public void selectOne() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
        queryWrapper.eq("name", "小明");
        User selectOne = userMapper.selectOne(queryWrapper);
        System.out.println("根据添加查询" + selectOne);
    }

    /**
     * 根据 Wrapper 条件，查询总记录数
     * queryWrapper 实体对象封装操作类（可以为 null）
     *
     * @param
     */
    @Test
    public void selectCount() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.gt("age", 20); //年龄大于20
        Integer selectCount = userMapper.selectCount(queryWrapper);
        System.out.println("查询是总数量" + selectCount);
    }

    /**
     * 根据 entity 条件，查询全部记录
     * queryWrapper 实体对象封装操作类（可以为 null）
     *
     * @param
     */
    @Test
    public void selectList() {
        List<User> users = this.userMapper.selectList(null);
        for (User user : users) {
            System.out.println(user);
        }
    }

    @Test
    public void selectPage() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("age", 2); //like模糊查询
        /**
         *  分页构造函数
         *
         * @param current 当前页
         * @param size    每页显示条数
         */
        Page<User> page = new Page<>(1, 1);

        IPage<User> iPage = userMapper.selectPage(page, queryWrapper);
        System.out.println("数据总条数" + iPage.getTotal());
        System.out.println("总页数" + iPage.getPages());
        System.out.println("当前页数" + iPage.getCurrent());

        List<User> users = iPage.getRecords();
        for (User user : users) {
            System.out.println(user);
        }
    }
}