03 mybatis-plus通用CRUD-优快云博客

本文链接：https://blog.youkuaiyun.com/cl66666666/article/details/114374614

本文介绍了mybatis-plus的通用CRUD操作，包括插入数据时的主键生成策略，如自增策略、手动输入、UUID、ID_WORKER_STR和ID_WORKER。主键策略在不同情况下有不同的使用方式，例如自增主键无需设置，而UUID和ID_WORKER算法适用于非自增主键。此外，还提及了更新、删除和查询数据的基本操作，以及分页查询需配置分页插件。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

项目文件看前面文章，

mybatis-plus官方api文档

插入数据

    /*
    插入一条记录 
    insert
    @param entity 实体对象
     */
    @Test
    public void testInsert(){
        User user =new User();
        user.setUserName("程程");
        user.setName("chengcheng");
        user.setPassWord("123456");
        /* 插入时间格式数据
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy‐MM‐dd HH:mm:ss");
        LocalDateTime localDateTime = LocalDateTime.parse("1990‐01‐01 00:00:00", df);
        user.setBirthday(localDateTime);
         */
        user.setBirthday("1991-01-01");
        user.setAge(34);
        user.setEmail("152415@it.com");
        int result = userMapper.insert(user); //返回的result是受影响的行数，并不是自增后的id
        System.out.println("result = " + result);
        System.out.println(user.getId()); //自增后的id会回填到对象中

        /*
        result = 1
        1367412631087063041
         */

    }

主键生成策略

在实体类User中设置id的生成策略

自增策略
mysql数据库主键为自增
不用设置主键，setId输入的无效

    @TableId(value = "id",type = IdType.AUTO)  //指定主键字段名
    private Long id;

手动输入
mysql数据库主键为自增增或不是自增都可以
必须设置主键setId，否则运行报错

    @TableId(value = "id",type = IdType.INPUT)  //指定主键字段名
    private Long id;

UUID
生成全局唯一ID。
mysql数据库主键为字符串类型，不是自增类型。
不用设置主键setId

    @TableId(value = "id",type = IdType.UUID)  //指定主键字段名
    private String id;

ID_WORKER_STR
采用雪花片算法（雪花算法生成的ID是纯数字且具有时间顺序，适合分布式场景）生成全局唯一ID，字符串类型。
mysql数据库主键为字符串类型，不是自增类型。

    @TableId(value = "id",type = IdType.ID_WORKER_STR)  //指定主键字段名
    private String id;

ID_WORKER
采用雪花片算法生成全局唯一ID，数值类型。
mysql数据库主键为数值类型，不是自增类型。

    @TableId(value = "id",type = IdType.ID_WORKER)  //指定主键字段名
    private Long id;

更新数据

    /*
     根据id进行更新操作
     updateById
     @param User 实体对象
     只能将对象中不为NULL的属性更新到表中。
     */
    @Test
    public void testUpdate(){
        User user = new User();
        user.setId(4L);
        user.setAge(100);
        user.setPassWord("123456789");
        int i = userMapper.updateById(user);
        System.out.println(i);
    }

    /*
    根据条件进行更新操作
    UPDATE tb_user SET age = 100,PASSWORD = '1111' WHERE NAME = 'chengcheng'
    只能将对象中不为NULL的属性更新到表中。
     */
    @Test
    public void testUpdateQuery(){
        User user = new User();
        user.setAge(100);  //要更新的值
        user.setPassWord("1111"); //要更新的值
        //设置条件
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name","chengcheng");
        int i = userMapper.update(user, queryWrapper);
        System.out.println(i);

    }

    /*
    将字段的值置为空并更新到数据库
    UPDATE tb_user SET age=23,birthday=5 WHERE id = 5 
     */
    @Test
    public void testUpdateUpdate(){
        //更新的条件以及字段
        UpdateWrapper<User> wrapper = new UpdateWrapper<>();
        wrapper.eq("id", 5).set("age", 23).set("birthday",null);
        //执行更新操作
        int result = this.userMapper.update(null, wrapper);
        System.out.println("result = " + result);
        
    }

删除数据

    /*
    根据id删除
     */
    @Test
    public void testDeleteByID(){
        int i = userMapper.deleteById(1367412631087063041L);
        System.out.println(i);
    }

    /*
    根据条件删除
    DELETE FROM tb_user WHERE name = ? AND age = ?
    程程2(String), 111(Integer)
     */
    @Test
    public void testDeleteByMap() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name","chengcheng");
        wrapper.eq("age",111);
        int delete = userMapper.delete(wrapper);
        System.out.println(delete);

        /* 上面也可这样写
        User user = new User();
        user.setAge(111);
        user.setName("chengcheng");
        //将实体对象进行包装，包装为操作条件
        QueryWrapper<User> wrapper = new QueryWrapper<>(user);
        int delete = userMapper.delete(wrapper);
        System.out.println(delete);
         */
    }

    /*
    批量删除
     DELETE FROM tb_user WHERE id IN ( ? , ? )
     4(Long), 5(Long)
     */
    @Test
    public void testDeleteBatchIds(){
        int i = userMapper.deleteBatchIds(Arrays.asList(4L, 5L));
        System.out.println(i);
    }

查询数据

    /*
    //根据id查询数据
    SELECT id,user_name,password,name,age,email,birthday FROM tb_user WHERE id= 1
     */
    @Test
    public void testSelectById() {
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }

    /*
    批量查询
    SELECT id,user_name,password,name,age,email,birthday FROM tb_user WHERE id IN ( ? , ? , ? )
     */
    @Test
    public void testSelectBatchIds() {
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L));
        for (User user : users) {
            System.out.println(user);
        }
    }

    /*
     根据条件，查询一条记录
     返回1条数据或null
     */
    @Test
    public void testSelectOne() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.eq("name", "李四");

        /*
        根据条件查询一条数据，如果结果超过一条会报错
        wrapper.eq("password", "123456");
        org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 3
         */
        User user = userMapper.selectOne(wrapper);
        System.out.println(user);
    }

    /*
    根据条件，查询总记录数,
    返回数值
     */
    @Test
    public void testSelectCount() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 15); //年龄大于15岁    gt 大于；eq 等于; lt小于
        //根据条件查询数据条数
        Integer count = userMapper.selectCount(wrapper);
        System.out.println(count);
    }

    /*
    根据条件，查询全部记录
    返回列表数据
     */
    @Test
    public void testSelectList() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 15); //年龄大于15岁
        //根据条件查询数据
        List<User> users = userMapper.selectList(wrapper);
        for (User user : users) {
            System.out.println("user = " + user);
        }
    }

分页查询，需要配置分页插件
MybatisPlusConfig

package li.chen.com.config;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan("li.chen.com.mapper")  //设置mapper包扫描
public class MybatisPlusConfig {
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }

}

    /*
     分页查询
     @param page 分页查询条件（可以为 RowBounds.DEFAULT）
     @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    @Test
    public void testSelectPage(){
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 15); //年龄大于20岁
        //参数1：当前页码，小于1的按1算
        //参数2：每页记录数
        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);
        }
        /*
        SELECT id,user_name,password,name,age,email,birthday FROM tb_user WHERE age > 15 LIMIT 1,1
        数据总条数：3
        总页数：3
         */
    }