MyBatisPlus的CRUD

可乐丿不加冰

已于 2022-06-06 11:15:36 修改

阅读量161

点赞数

文章标签：数据库 java database

于 2022-06-06 10:42:26 首次发布

本文链接：https://blog.csdn.net/weixin_44740485/article/details/125103538

版权

一、insert

1、插入操作

/**
 * 插入用户表一条数据
 */
@Test
public void testInsert(){
    User user = new User();
    user.setAge(20);
    user.setEmail("781505696@qq.com");
    user.setName("孙悟空");

    int result = userMapper.insert(user);
    System.out.println(result);
    System.out.println(user);
}

注意：数据库插入id是MP默认用雪花算法生成的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zjB4EPiF-1654159638787)(index_files\01.png)]

2、主键策略

（1）ID_WORKER

MyBatis-Plus默认的主键策略是：ID_WORKER 全局唯一ID

（2）自增策略

要想主键自增需要配置如下主键策略
- 需要在创建数据表的时候设置主键自增
- 实体字段中配置 @TableId(type = IdType.AUTO)

要想影响所有实体的配置，可以设置全局主键配置

#全局设置主键生成策略
mybatis-plus.global-config.db-config.id-type=auto

其它主键策略：分析 IdType 源码

二、update

1、根据Id更新操作

/**
 * 根据id更新一条数据
 */
@Test
public void testUpdateBtId(){
    User user = new User();
    user.setId(1449689775719071745L);
    user.setName("zhubajie");
    user.setAge(10);
    user.setEmail("123123@qq.com");
    int result = userMapper.updateById(user);
    System.out.println(user);
}

注意：update时生成的sql语句是：UPDATE user SET name=?, age=?, email=? WHERE id=?

2、自动填充

项目中经常会遇到一些数据，每次都使用相同的方式填充，例如记录的创建时间，更新时间等。

我们可以使用MyBatis Plus的自动填充功能，完成这些字段的赋值工作：

（1）数据库表中添加自动填充字段

在User表中添加datetime类型的新的字段 create_time、update_time

（2）实体上添加注解

@Data
public class User {
	......
	@TableField(fill = FieldFill.INSERT)
	private Date createTime;
	
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
}

（3）实现元对象处理器接口

注意：不要忘记添加 @Component 注解

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.Date;

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", () -> new Date(), Date.class); // 起始版本 3.3.3(推荐)
        this.strictInsertFill(metaObject, "updateTime", () -> new Date(), Date.class);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", () -> new Date(), Date.class); // 起始版本 3.3.3(推荐)
    }
}

3、乐观锁

悲观锁
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

**主要适用场景：**当要更新一条记录的时候，希望这条记录没有被别人更新，也就是说实现线程安全的数据更新

乐观锁实现方式：

取出记录时，获取当前version
更新时，带上这个version
执行更新时， set version = newVersion where version = oldVersion
如果version不对，就更新失败

（1）数据库中添加version字段

ALTER TABLE `user` ADD COLUMN `version` INT

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WCL6nx57-1654159638788)(index_files/7bf260f8-d483-49fe-b448-b2fbea3dddaf.png)]

（2）实体类添加version字段

并添加 @Version 注解

@Version
@TableField(fill = FieldFill.INSERT)
private Integer version;

（3）元对象处理器接口添加version的insert默认值

this.strictInsertFill(metaObject, "version", () -> 1, Integer.class);

特别说明:

支持的数据类型只有 int,Integer,long,Long,Date,Timestamp,LocalDateTime

整数类型下 newVersion = oldVersion + 1

newVersion 会回写到 entity 中

仅支持 updateById(id) 与 update(entity, wrapper) 方法

在 update(entity, wrapper) 方法下, wrapper 不能复用!!!

（4）在 MybatisPlusConfig 中注册 Bean

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@MapperScan("com.javaclimb.mybatisplus.mapper")
public class MybatisPlusConfig {

    /**
     * 乐观锁插件
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }
}

（5）测试

/**
 * 测试乐观锁增加
 */
@Test
public void testOptimisticLocker(){
    User user = new User();
    user.setAge(11);
    user.setEmail("1112212222@qq.com");
    user.setName("tangsheng");

    int result = userMapper.insert(user);
    System.out.println(result);
    System.out.println(user);
}

/**
 * 测试乐观锁更新
 */
@Test
public void testUpdateOptimisticLocker(){
    //注意：必须先查询才能再更新
    User user = userMapper.selectById(1449689775719071753L);
    user.setName("zhubajie1");
    user.setAge(12);
    user.setEmail("123123@qq.com");
    int result = userMapper.updateById(user);
    System.out.println(user);
}

4、逻辑删除

物理删除：从数据库中直接移除
逻辑删除：再数据库中没有被移除，而是通过一个变量来让他失效！ deleted = 0 => deleted = 1
管理员可以查看被删除的记录！防止数据的丢失，类似于回收站！
1、在数据表中增加一个 deleted 字段
在这里插入图片描述
2、实体类中增加属性

 //1是已删除，0是未删除
    @TableField(select = false,fill = FieldFill.INSERT) //查询的时候不想查询该字段  @TableField(select = false)
    private Integer deleted;

3、配置文件中进行配置

#mybatis日志
mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: deleted # 全局逻辑删除的实体字段名，也可实体类字段上加上@TableLogic注解
      logic-delete-value: 1 # 逻辑已删除值
      logic-not-delete-value: 0 # 逻辑未删除值

4、在自动填充策略中在insert用户时添加填充deleted字段为1

 // 插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", () -> new Date(), Date.class); // 起始版本 3.3.3(推荐)
        this.strictInsertFill(metaObject, "version", () -> 1, Integer.class);
        this.strictInsertFill(metaObject, "deleted", () -> 0, Integer.class);
    }

5、测试
新增数据

@Test
    void addUser() {
        User user = new User();
        user.setName("齐天大圣");
        user.setAge(3600);
        user.setEmail("789456@qq.com");
        int result = userMapper.insert(user);
        System.out.println(user);
    }

逻辑删除

 @Test
    public void logicDeleteUserById(){
        userMapper.delete(Wrappers.lambdaQuery(User.class).eq(User::getAge,3600));
    }

5、代码生成器

a、依赖

 <!--swagger-ui-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- velocity 模板引擎, Mybatis Plus 代码生成器需要 -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.0</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.0</version>
        </dependency>
        <!--mybatis-plus依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <!--mysql驱动-->
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

b、代码

package com.lcj;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;

/**
 * 代码生成器
 */
public class CodeGenerator {

    @Test
    public void genCode() {

        String moduleName = "edu";

        //创建代码生成器对象
        AutoGenerator autoGenerator = new AutoGenerator();

        /*
         1、全局配置
        */
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath + "/src/main/java");
        gc.setAuthor("lcj");
        gc.setOpen(false); // 生成后是否打开资源管理器
        gc.setFileOverride(false); // 重新成时文件是否覆盖
        gc.setServiceName("%sService");    // 去掉Service接口的首字母I
        gc.setIdType(IdType.ASSIGN_ID); // 主键策略
        gc.setDateType(DateType.ONLY_DATE);// 定义生成的实体类中日期类型
        gc.setSwagger2(true);// 开启 Swagger2 模式
        autoGenerator.setGlobalConfig(gc);


       /*
        2、数据源配置
        */
        DataSourceConfig dataSource = new DataSourceConfig();
        dataSource.setDriverName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        autoGenerator.setDataSource(dataSource);
        /*
        3、包配置
         */
        PackageConfig pc = new PackageConfig();
        pc.setParent("com.lcj.service");
        pc.setModuleName(moduleName); //模块名
        pc.setController("controller");
        pc.setEntity("entity");
        pc.setService("service");
        pc.setMapper("mapper");
        autoGenerator.setPackageInfo(pc);
        /*
        4、策略配置
         */
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("user"); // 设置要映射的表名,多个表用都好隔开
        strategy.setNaming(NamingStrategy.underline_to_camel);// 数据库表映射到实体的命名策略
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);// 数据库表字段映射到实体的命名策略
        strategy.setEntityLombokModel(true); // lombok 模型 @Accessors(chain = true) setter链式操作
        strategy.setLogicDeleteFieldName("deleted");// 逻辑删除字段名
        // 自动填充配置
        TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
        TableFill gmtModified = new TableFill("gmt_modified", FieldFill.INSERT_UPDATE);
        ArrayList<TableFill> tableFills = new ArrayList<>();
        tableFills.add(gmtCreate);
        tableFills.add(gmtModified);
        strategy.setTableFillList(tableFills);
        // 乐观锁
        strategy.setVersionFieldName("version");
        // restful api风格控制器
        strategy.setRestControllerStyle(true);
        // url 中驼峰转连字符
        strategy.setControllerMappingHyphenStyle(true);

        autoGenerator.setStrategy(strategy);
        //执行
        autoGenerator.execute();

    }

}

三、select

1、根据id查询记录

@Test
public void testSelectById() {
    User user = userMapper.selectById(1L);
    System.out.println(user);
}

2、通过多个id批量查询

完成了动态sql的foreach的功能

@Test
public void testSelectBatchIds(){
    List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    users.forEach(System.out::println);
}

3、简单的条件查询

通过map封装查询条件

@Test
public void testSelectByMap(){
    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "bailongma");
    map.put("age", 33);
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);
}

**注意：**map中的key对应的是数据库中的列名。例如数据库user_id，实体类是userId，这时map的key需要填写user_id

4、分页

（1）在 MybatisPlusConfig 中注册 Bean

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@MapperScan("com.javaclimb.mybatisplus.mapper")
public class MybatisPlusConfig {

    /**
     * 分页插件
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();        
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

(2) 测试

/**
 * 分页查询
 */
@Test
public void testSelectPage(){
    Page<User> page = new Page<>(2,3);
    userMapper.selectPage(page, Wrappers.<User>lambdaQuery().ge(User::getAge,10));
    List<User> records = page.getRecords();
    records.forEach(System.out::println);
    page.hasNext();
    page.hasPrevious();
}

四、delete

1、根据id删除记录

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

2、批量删除

/**
 * 根据主键id批量删除
 */
@Test
public void testDeleteBatchByIds() {
    int result = userMapper.deleteBatchIds(Arrays.asList(1449689775719071745L, 1449689775719071746L));
    System.out.println(result);
}

3、简单的条件查询删除

/**
 * 条件删除
 */
@Test
public void testDeleteByMap() {
    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "shasheng");
    int result = userMapper.deleteByMap(map);
    System.out.println(result);
}

五、复杂查询

如果想进行复杂条件查询，那么需要使用条件构造器 Wapper，常用它的子类QueryWrapper来实现。UpdateWrapper ： Update 条件封装，用于Entity对象更新操作。

1、ge、gt、le、lt、isNull、isNotNull

@Test
public void test1(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.ge("age",11)
            .isNull("name");
    int result = userMapper.delete(queryWrapper);
    System.out.println(result);
}

2、eq、ne

@Test
public void test2(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("name","zhubajie");
    User user = userMapper.selectOne(queryWrapper);
    System.out.println(user);
}

3、between、notBetween

@Test
public void test3(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.between("age",20,30);
    List<User> users = userMapper.selectList(queryWrapper);
    System.out.println(users);
}

4、allEq

@Test
public void test4(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    Map<String,Object> map = new HashMap<>();
    map.put("id",1L);
    map.put("name","Jack");
    map.put("age",30);
    queryWrapper.allEq(map);
    List<User> users = userMapper.selectList(queryWrapper);
    System.out.println(users);
}

5、like、notLike、likeLeft、likeRight

@Test
public void test5() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.like("name","a")
                .notLike("name","b");
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
    System.out.println(maps);
}

6、in、notIn、inSql、notinSql、exists、notExists

in、notIn:

in(“age”,1,2,3)------->age in (1,2,3)

in(“age”,{1,2,3})------->age in (1,2,3)

notIn(“age”,1,2,3)------->age not in (1,2,3)

inSql、notinSql:往往用来实现子查询

inSql(“id”,“select id from user where id<4”)----> id in (select id from user where id<4)

@Test
public void test6() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.inSql("id","select id from user where id<3");
    List<Object> objects = userMapper.selectObjs(queryWrapper);
    System.out.println(objects);
}

7、or、and

@Test
public void test7() {
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    User user = new User();
    user.setAge(50);
    user.setName("Rose");

    userUpdateWrapper.like("name","a")
            .or()
            .between("age",20,25);
    int result = userMapper.update(user,userUpdateWrapper);
    System.out.println(result);
}

UPDATE user SET name=?, age=?, update_time=? WHERE (name LIKE ? OR age BETWEEN ? AND ?)

8、嵌套or、嵌套and

这里使用了lambda表达式，or中的表达式最后翻译成sql时会被加上圆括号。

@Test
public void test8() {
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    User user = new User();
    user.setAge(60);
    user.setName("Tom");
    userUpdateWrapper.like("name","b")
            .or(i -> i.eq("name","Jack").ne("age",20));
    //UPDATE user SET name=?, age=?, update_time=? WHERE (name LIKE ? OR (name = ? AND age <> ?))
    int result = userMapper.update(user,userUpdateWrapper);
    System.out.println(result);
}

9、orderBy、orderByDesc、orderByAsc

@Test
public void test9() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.orderBy(true,false,"id");
    List<User> users = userMapper.selectList(queryWrapper);
    System.out.println(users);
}

10、last

直接拼接道sql的最后

注意：只能调用一次，多次调用以最后一次为准，有sql注入的风险，谨慎使用

@Test
public void test10() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.last("limit 1");
    List<User> users = userMapper.selectList(queryWrapper);
    System.out.println(users);
}

11、指定要查询的列

@Test
public void test11() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.select("id","name","age");
    List<User> users = userMapper.selectList(queryWrapper);
    System.out.println(users);
}

12、set、setSql

@Test
public void test12() {
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    User user = new User();
    user.setAge(50);

    userUpdateWrapper.like("name","a")
            .or()
            .between("age",20,25)
            .set("name","Mike")
            .setSql(" email='123@qq.com'");
    // UPDATE user SET age=?, update_time=?, name=?, email='123@qq.com' WHERE (name LIKE ? OR age BETWEEN ? AND ?)
    int result = userMapper.update(user,userUpdateWrapper);
    System.out.println(result);
}

n(users);
}


## **12、set、setSql**

```java
@Test
public void test12() {
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    User user = new User();
    user.setAge(50);

    userUpdateWrapper.like("name","a")
            .or()
            .between("age",20,25)
            .set("name","Mike")
            .setSql(" email='123@qq.com'");
    // UPDATE user SET age=?, update_time=?, name=?, email='123@qq.com' WHERE (name LIKE ? OR age BETWEEN ? AND ?)
    int result = userMapper.update(user,userUpdateWrapper);
    System.out.println(result);
}

可乐丿不加冰

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MyBatisPlus的CRUD

注意：数据库插入id是MP默认用雪花算法生成的[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zjB4EPiF-1654159638787)(index_files\01.png)]（1）ID_WORKERMyBatis-Plus默认的主键策略是：ID_WORKER 全局唯一ID（2）自增策略要想主键自增需要配置如下主键策略要想影响所有实体的配置，可以设置全局主键配置其它主键策略：分析 IdType 源码注意：update时生成的sql语句是：UPDATE user SE
复制链接

扫一扫