MybatisPlus--入门笔记（日志配置+CRUD+主键生成策略+自动更新时间+乐观锁+逻辑删除）

mybatis_plus使用步骤

1、导入依赖

<!--mybatis-plus-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.0.5</version>
    </dependency>

2、定义Mapper接口

/**
 * User持久层接口
 */
public interface UserMapper extends BaseMapper<User> {
}

接口继承BaseMapper之后，只需要传入实体类的泛型，就可以直接使用这个接口为我们提供的各种方法。如下图

3、定义配置类

/**
 * 配置类
 */
@Configuration
@MapperScan("com.gzgs.mybatis_plus.mapper")//开启mapper扫描
public class MyConfig {

}

也可以直接在项目引导类上配置mapperscan，但是后面肯定需要生成各种插件，为了统一管理，直接新建一个配置类即可。另外配置MapperScan之后，在mapper接口上可以不再配置mapper接口。

测试

这样就可以直接使用了

@Autowired
private UserMapper userMapper;
@Test
public void testSelectList() {
    List<User> users = userMapper.selectList(null);
    users.forEach(System.out::println);
}

日志配置

myabtsi_plus的日志配置只需要在配置类中添加以下内容即可

#mtbatis日志配置
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

添加Insert操作

@Test
public void testInsert(){
    User user=new User();
    user.setName("老孙");
    user.setAge(18);
    user.setEmail("1106@qq.com");
    userMapper.insert(user);
}

可以看到上面插入的数据是中文乱码，解决这个现象只需要在配置数据库信息加上这个即可。

spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=UTF-8

主键生成策略

可以看到上面我们插入数据时并没有指定插入的id，但是myabtis_plus自动为我们生成了id，这个id几乎是全球唯一的，它采用的是雪花算法生成的id，mybatis_plus的主键生成策略有如下几种。

主键生成策略	表达式
默认策略，雪花算法	ID_WORKER
用于主键类型是String的时候	ID_WORKER_STR
需要用户自己输入	INPUT
自动增长	AUTO

以下是IdType的源码

public enum IdType {
    AUTO(0),//自动增长
    NONE(1),
    INPUT(2),//用户输入
    ID_WORKER(3), //默认生成策略，雪花算法
    UUID(4), 
    ID_WORKER_STR(5);  //也是雪花算法，当主键类型是String的时候使用

    private int key;

    private IdType(int key) {
        this.key = key;
    }

    public int getKey() {
        return this.key;
    }
}

使用方法

只需要在实体类的主键字段上添加注解即可，如下

/**
* User实体类
*/

@Data
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

更新update操作

1、根据id更新user

@Test
public void testUpdate(){
    User user = new User();
    user.setId(1l);
    user.setName("张三");
   userMapper.updateById(user);

}

2、自动填充策略

项目中经常会遇到一些数据，每次都使用相同的方式填充，例如记录的创建时间，更新时间等。
我们可以使用MyBatis Plus的自动填充功能，完成这些字段的赋值工作：

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

在User表中添加datetime类型的新的字段 create_time、update_time，这也是阿里巴巴开发手册的开发规范，它建议我们在创建表的时候给表添加上这个两个字段。

ALTER TABLE USER ADD COLUMN create_time DATE;
ALTER TABLE USER ADD COLUMN update_time DATE;

（2）实体上添加注解

@Data
public class User {
    @TableId(type = IdType.ID_WORKER)
    private Long id;
    private String name;
    private Integer age;
    private String email;
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
}

（3）定义配置类

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyMetaObjectHandler.class);
    @Override
    public void insertFill(MetaObject metaObject) {
        LOGGER.info("start insert fill ....");
        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        LOGGER.info("start update fill ....");
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }
}

（4）测试

乐观锁

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

乐观锁实现方式：

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

1、在表中添加version字段

ALTER TABLE `user` ADD COLUMN `version` INT

2、在实体类上添加注解

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

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

 @Override
    public void insertFill(MetaObject metaObject) {
        LOGGER.info("start insert fill ....");
        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("updateTime", new Date(), metaObject);
        this.setFieldValByName("version", 1, metaObject);
    }

特别说明:

• 支持的数据类型只有 int,Integer,long,Long,Date,Timestamp,LocalDateTime
• 整数类型下 newVersion = oldVersion + 1
• newVersion 会回写到 entity 中
• 仅支持 updateById(id) 与 update(entity, wrapper) 方法
• 在 update(entity, wrapper) 方法下, wrapper 不能复用!!!

4、在配置类中配置乐观锁插件

/**
 * 乐观锁插件
 */
@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
    return new OptimisticLockerInterceptor();
}

5、模拟乐观锁更新数据

//测试乐观锁查询

@Test
public void testOptimisticLocker(){
    //根据id查询
    User user = userMapper.selectById(1l);
    //修改
    user.setName("李四");
    //执行
    userMapper.updateById(user);
}

6、模仿乐观锁更新数据失败

//测试乐观锁失败查询

@Test
public void testOptimisticLockerFaild(){
    //根据id查询
    User user = userMapper.selectById(1l);
    //修改
    user.setName("李四");
    //模拟并发修改
    user.setVersion(user.getVersion()-1);
    //执行
    userMapper.updateById(user);
}

查询操作

1、通过id查询

//根据id查询
@Test
public void testSelectById(){
    User user = userMapper.selectById(1l);
    System.out.println(user);
}

2、通过id批量查询

 //根据id批量查询
@Test
public void testSelectBatchId(){
    List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    users.forEach(System.out::println);
}

3、通过map集合查询

//根据map查询
@Test
public void testSelectByMap(){
    HashMap<String, Object> map = new HashMap<>();

    map.put("name","Jack");
    map.put("age",20);
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);
}

4、分页查询

MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能

1、在配置类中添加分页插件

/**
 * 分页插件
 */

@Bean
public PaginationInterceptor paginationInterceptor(){
    //此时可以删除主类中的 @MapperScan 扫描注解
    return new PaginationInterceptor();
}

2、直接使用

 //测试分页查询
@Test
public void testSelectByPage(){
    Page<User> page=new Page<>(1,5);

    userMapper.selectPage(page,null);
    page.getRecords().forEach(System.out::println);
    System.out.println("=======>"+page.getCurrent());
    System.out.println("=======>"+page.getPages());
    System.out.println("=======>"+page.getSize());
    System.out.println("=======>"+page.getTotal());
    System.out.println("=======>"+page.hasNext());
    System.out.println("=======>"+page.hasPrevious());
}

测试selectMapsPage分页：结果集是Map

 //测试分页查询,返回结果为map
@Test
public void testSelectByPageMap(){
    Page<User> page=new Page<>(1,5);
    IPage<Map<String, Object>> mapIPage = userMapper.selectMapsPage(page, null);

    mapIPage.getRecords().forEach(System.out::println);
    System.out.println("=======>"+page.getCurrent());
    System.out.println("=======>"+page.getPages());
    System.out.println("=======>"+page.getSize());
    System.out.println("=======>"+page.getTotal());
    System.out.println("=======>"+page.hasNext());
    System.out.println("=======>"+page.hasPrevious());
}

删除操作

1、通过id删除

 //通过id删除
@Test
public void testDeleteById() {
    userMapper.deleteById(1330877639665135617l);
}

2、通过id批量删除

 //通过id批量删除
@Test
public void testDeleteByBatchIds(){
    userMapper.deleteBatchIds(Arrays.asList(1330859355859353601l,5));
}

3、通过map删除

 @Test
//通过map删除
public void testDeleteByMap(){
    HashMap<String, Object> stringObjectHashMap = new HashMap<>();
    stringObjectHashMap.put("name","张三");
    stringObjectHashMap.put("age",18);

    userMapper.deleteByMap(stringObjectHashMap);
}

4、逻辑删除

• 物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除数据
• 逻辑删除：假删除，将对应数据中代表是否被删除字段状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录

1、在数据中添加deleted字段

ALTER TABLE `user` ADD COLUMN `deleted` BOOLEAN

2、在属性上添加deleted字段

@TableLogic
@TableField(fill = FieldFill.INSERT)
private Integer deleted;

3、在元数据配置中给新增的记录deleted字段默认添加值

 @Override
public void insertFill(MetaObject metaObject) {
    LOGGER.info("start insert fill ....");
    this.setFieldValByName("createTime", new Date(), metaObject);//创建时间
    this.setFieldValByName("updateTime", new Date(), metaObject);//更新时间
    this.setFieldValByName("version", 1, metaObject);//乐观锁
    this.setFieldValByName("deleted", 0, metaObject);//逻辑删除
}

4、application.properties文件

#配置逻辑删除
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

5、在 MybatisPlusConfig 中注册 Bean

/**
 * 逻辑删除
 */
@Bean
public ISqlInjector iSqlInjector(){
    return new LogicSqlInjector();
}

6、测试逻辑删除

//逻辑删除
@Test
public void testLoginDelete(){
    userMapper.deleteById(2l);
}

可以看到，虽然我们执行的是delete操作，但是在数据库中实际上执行的是更新操作，将deleted的值改为1

Wrapper条件构造器

Wrapper条件构造器是mybatis_plus为我们提供的一个方便我们对sql语句执行条件进行简易包装的插件。

• Wrapper ： 条件构造抽象类，最顶端父类
  • AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
    • QueryWrapper ： Entity 对象封装操作类，不是用lambda语法
    • UpdateWrapper ： Update 条件封装，用于Entity对象更新操作
  • AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
    • LambdaQueryWrapper ：看名称也能明白就是用于Lambda语法使用的查询Wrapper
    • LambdaUpdateWrapper ： Lambda 更新封装Wrapper

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

 //测试添加构造器
@Test
public void testWrapper1(){
    QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
    userQueryWrapper.isNull("name").ge("age",10).isNotNull("email");
    userMapper.delete(userQueryWrapper);
}

ge：大于 ，gt：大于等于
le：小于，lt：小于等于

真实的sql语句===》 UPDATE user SET deleted=1 WHERE deleted=0 AND name IS NULL AND age >= ? AND email IS NOT NULL

2、eq、ne

//测试添加构造器
    @Test
    public void testWrapper2(){
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.eq("name","Jack");
        List<User> users = userMapper.selectList(userQueryWrapper);
        System.out.println(users);
    }

真实的sql语句===》 SELECT id,name,age,email,create_time,update_time,version,deleted FROM user WHERE deleted=0 AND name = ?

3、between、notBetween

包含边界大小

//测试添加构造器
@Test
public void testWrapper1(){
    QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
    userQueryWrapper.between("age",10,20);
    userMapper.selectList(userQueryWrapper);
}

真实的sql语句===》 SELECT id,name,age,email,create_time,update_time,version,deleted FROM user WHERE deleted=0 AND age BETWEEN ? AND ?

4、allEq

 //测试添加构造器
@Test
public void testWrapper1(){
    QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
    Map<String,Object> map=new HashMap<>();
    map.put("name","Jack");
    map.put("age",20);
    map.put("email","test2@baomidou.com");
    QueryWrapper<User> userQueryWrapper1 = userQueryWrapper.allEq(map);
    userMapper.selectList(userQueryWrapper);
}

真实的sql语句===》 SELECT id,name,age,email,create_time,update_time,version,deleted FROM user WHERE deleted=0 AND name = ? AND age = ? AND email = ?

5、like、notLike、likeLeft、likeRight

//测试添加构造器
@Test
public void testWrapper3(){
    QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
    userQueryWrapper.likeLeft("name","老");
    List<User> users = userMapper.selectList(userQueryWrapper);
    System.out.println(users);
}

真实的sql语句===》 SELECT id,name,age,email,create_time,update_time,version,deleted FROM user WHERE deleted=0 AND name LIKE %老(String)

like-------%key%
nolike--------！%key%
likeLeft--------%key
likeRight--------key%

代码生成器

import com.baomidou.mybatisplus.annotation.DbType;
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.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import org.junit.jupiter.api.Test;

public class GetCode {
    @Test
    public void main1() {
        // 1、创建代码生成器
        AutoGenerator mpg = new AutoGenerator();
        // 2、全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        System.out.println(projectPath);
        gc.setOutputDir(projectPath + "/src/main/java");
        gc.setAuthor("sdl");
        gc.setOpen(false); //生成后是否打开资源管理器
        gc.setFileOverride(false); //重新生成时文件是否覆盖
        /*
         * mp生成service层代码，默认接口名称第一个字母有 I
         * UcenterService
         * */
        gc.setServiceName("%sService"); //去掉Service接口的首字母I
        gc.setIdType(IdType.ID_WORKER); //主键策略
        gc.setDateType(DateType.ONLY_DATE);//定义生成的实体类中日期类型
        gc.setSwagger2(true);//开启Swagger2模式
        mpg.setGlobalConfig(gc);
        // 3、数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/guli?serverTimezone=GMT%2B8");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);
        // 4、包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("serviceedu"); //模块名
        pc.setParent("com.atguigu");
        pc.setController("controller");
        pc.setEntity("entity");
        pc.setService("service");
        pc.setMapper("mapper");
        mpg.setPackageInfo(pc);
        // 5、策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("edu_teacher");
        strategy.setNaming(NamingStrategy.underline_to_camel);//数据库表映射到实体的命名策略
        strategy.setTablePrefix(pc.getModuleName() + "_"); //生成实体时去掉表前缀
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);//数据库表字段映射到实体的命名策略
        strategy.setEntityLombokModel(true); // lombok 模型 @Accessors(chain = true) setter链式操作
        strategy.setRestControllerStyle(true); //restful api风格控制器
        strategy.setControllerMappingHyphenStyle(true); //url中驼峰转连字符
        mpg.setStrategy(strategy);
        // 6、执行
        mpg.execute();
    }
}

码云笔记下载地址：https://gitee.com/sun-dalin/learning-notes.git