mybatis-plus

依赖

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.21</version>
</dependency>

<!--mybatis-plus依赖-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.1</version>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

资源文件配置

# 增加数据库连接
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/spring?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.Username=root
spring.datasource.password=lvxingchen
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# mybatisplus日志配置 - 控制台打印日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

创建poji 实体类

/**
 *Integer 之所以用包装类型，因为使用基本类型，没传值时，默认值会有对应的
 * 如：int默认为0，boolean默认为false，但是使用包装类：Integer没有没赋值，默认都为null
 */
@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class Users {
    private long id; // id之所以要用long类型，插入数据时，id如果不手动插入，plus默认采用雪花算法生成id
    private String loginName;
    private String name;
    private String password;
    private Date birthday;
}

创建mapper-> UserMapper.java（提示：需要在启动类文件中加上@MapperScan(xxx.xxx.xxx.mapper) mapper文件夹扫描）

package com.example.mybatisplus.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.mybatisplus.pojo.Users;

public interface UserMapper extends BaseMapper<Users> {
    /**
     * 如果需要添加自己的查询，这里添加即可
     */
}

直接测试

@SpringBootTest
class MybatisPlusApplicationTests {

    @Resource
    private UserMapper userMapper;

    @Test
    void contextLoads() {
        System.out.println("--------------------");
        List<Users> userList = userMapper.selectList(null);
        userList.forEach(System.out::println);
    }
}

 完事

配置日志

（上线可以取消掉）

# mybatisplus日志配置 - 控制台打印sql语句的日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

插入数据

@Test
public void inserTest() {
    Users user = new Users();
    user.setBirthday(new Date());
    user.setLoginName("测试");
    user.setName("吕星辰");
    user.setPassword("123");
    userMapper.insert(user);
}

 没插入id，为什么自动加上了？

 主键的生成策略

常用方式：

uuid（无排序、太长）、自增id、雪花算法（分布式系统唯一id生成）、数据库自增。

下边时mybatisPlus生成主键id的策略：

@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class Users {

    @TableId(type = IdType.AUTO)
    private Long id;
}

mybatis-plus  id的生成策略如下：

@Getter
public enum IdType {
    /**
     * 数据库ID自增
     * <p>该类型请确保数据库设置了 ID自增 否则无效</p>
     */
    AUTO(0),
    /**
     * 该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)
     */
    NONE(1),
    /**
     * 用户输入ID
     * <p>该类型可以通过自己注册自动填充插件进行填充</p>
     */
    INPUT(2),

    /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
    /**
     * 分配ID (主键类型为number或string）,
     * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(雪花算法)
     *
     * @since 3.3.0
     */
    ASSIGN_ID(3),
    /**
     * 分配UUID (主键类型为 string)
     * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(UUID.replace("-",""))
     */
    ASSIGN_UUID(4),
    /**
     * @deprecated 3.3.0 please use {@link #ASSIGN_ID}
     */
    @Deprecated
    ID_WORKER(3),
    /**
     * @deprecated 3.3.0 please use {@link #ASSIGN_ID}
     */
    @Deprecated
    ID_WORKER_STR(3),
    /**
     * @deprecated 3.3.0 please use {@link #ASSIGN_UUID}
     */
    @Deprecated
    UUID(4);

    private final int key;

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

更新

@Test
public void update() {
    Users user = new Users();
    user.setId(3L);
    user.setName("呵呵");
    userMapper.updateById(user);
}

自动填充

创建时间、编辑时间都是自动完成的，不希望手动更新。

代码级别的插入：

第一步：

字段上添加注解

@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class Users {

    // 只是在：插入时添加时间 - 创建时间
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    // 添加和更新时都修改字段 - 编辑时间
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date editTime;
}

 字段填充的策略如下：

第二步：

编写处理器

配置插入时的填充策略，这里的配置很简单，就是虽然plus帮我们自动添加时间，但是，它不知道添加的时间时当前时间还是别的时间，需要我们定制。

package com.example.mybatisplus.config;

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

import java.util.Date;

@Slf4j
@Component
public class MybatisplusMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("insert ·············");
        // 插入时的填充策略
        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("editTime", new Date(), metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("update ·············");
        // 更新（编辑）时的填充策略
        this.setFieldValByName("editTime", new Date(), metaObject);
    }
}

测试

自动填充优化

（1）需求：不是每一个表都有创建和编辑时间，如果只想给有创建或编辑时间的表自动填充，判断是否有setter即可，如下：

 （2）需求： 根据某个字段来，如，如果没有给 create_time 赋值，那么需要自动填充

乐观锁？

目的：

当要更新一条记录时，我们希望这条记录没有被别人更新过，是为了防止更新冲突的问题。

总是很乐观，认为不会出现问题，无论何时都不会去上锁，如果出现问题，就更新值测试。

适合场景：多读。

// 查询时会把当前版本号oldVerson查出来，当更新时，条件如果成立，那么新版本号一般等于 oldVersion + 1
update table set version = newVersion where version = oldVersion and id = a;

// 例:
update user set name = "lxc", version = 3 where id = 1 and varsion = 2;

mybatis plus 乐观锁插件

实现插件两步

第一步：

package com.lxc.plus.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 配置 MybatisPlus 的乐观锁插件
 */
@Configuration
public class MybatisPlusIntercetorConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusIntercetor() {
        MybatisPlusInterceptor intercetor = new MybatisPlusInterceptor();
        intercetor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return intercetor;
    }
}

 第二步：

在实体的字段上添加@Version注解

/**
 * 版本
 */
@Version
private Integer version;

 说明

wrapper不能复用，否则会更新失败。

悲观锁？

通过数据库锁机制实现的。

它认为总是出现问题，无论干什么都会上锁，再去操作。

适合场景：多写。

查询操作

（1）selectById()、selectBatchIds() 

根据用户id和一组id查询（一组id为一个集合）

@Test
public void getS() {
    // 根据id查询用户
    Users user = userMapper.selectById(1);
    System.out.println(user);
    // 根据集合id去查询用户
    List<Users> userList = userMapper.selectBatchIds(Arrays.asList(1L,2L, 3L,4L));
    userList.forEach(System.out::println);
}

（2）根据简单条件查询 - Map类型方式

@Test
public void mapSearch() {
    Map<String, Object> simpleCondition = new HashMap<>();
    simpleCondition.put("name", "吕星辰");
    List<Users> usersList = userMapper.selectByMap(simpleCondition);
    usersList.forEach(System.out::println);
}

分页查询

mybatisplus内置了分页插件

提示：下边分页插件需要安装最新版 mybatis-plus-generator（3.4.0）才会有！！！

    <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-generator</artifactId>
      <version>3.4.0</version>
    </dependency>

第一步：

配置分页插件

package com.example.mybatisplus.config;


import com.baomidou.mybatisplus.annotation.DbType;
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;

@Configuration
@MapperScan("com.example.mybatisplus.mapper")
public class MybatisplusPageConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor () {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        return interceptor;
    }
}

第二步：

使用

@Test
public void all() {
    /**
     * 分页
     * current: 当前第几页
     * size: 一页展示的条数
     */
    Page<Users> userPage = new Page<>(2, 5);
    // 分页查询
    Page<Users> page = userMapper.selectPage(userPage, null);
    // 当前查寻的条数
    System.out.println(page.getSize());
    // 总条数
    System.out.println(page.getTotal());
    // 当前第几页
    System.out.println(page.getCurrent());
    // 一共分几页
    System.out.println(page.getPages());
    System.out.println("====================================================");
    // 获取所有查询出来的数据 List 列表
    userPage.getRecords().forEach(System.out::println);
}

 删除操作

物理删除

@Test
public void deleteDate() {
    // 根据id删除一条 - 硬删除
    userMapper.deleteById(1415564093779075074L);
    // 根据id集合，删除多个
    userMapper.deleteBatchIds(Arrays.asList(2L, 3L));
    // 根据某个字段删除
    Map<String, Object> map = new HashMap<>() {
        {
            put("login_name", "测试2");
        }
    };
    userMapper.deleteByMap(map);
}

 

 逻辑删除

实际执行的时编辑操作。

官方对插入数据时有中肯的推荐

第一步：

实体类字段上加上@TableLogic注解

@TableLogic
private int deleted;

第二步：

在资源配置文件中配置

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

第三步：

测试

@Test
public void deleteDate() {
    //根据id删除一条
    userMapper.deleteById(1L);
}

 提示：查询时默认过滤掉已删除数据,且使用 wrapper.entity 生成的where条件会忽略该字段

@TableFiled

（1）查询时忽略掉某个字段

 

性能分析插件

（1）maven安装

<dependency>
  <groupId>p6spy</groupId>
  <artifactId>p6spy</artifactId>
  <version>3.9.1</version>
</dependency>

（2）application.yml配置

（3）添加spy.properties资源配置文件

#3.2.1以上使用
modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
#3.2.1以下使用或者不配置
#modulelist=com.p6spy.engine.logging.P6LogFactory,com.p6spy.engine.outage.P6OutageFactory
# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
#日志输出到控制台
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
# 使用日志系统记录 sql
#appender=com.p6spy.engine.spy.appender.Slf4JLogger
# 设置 p6spy driver 代理
deregisterdrivers=true
# 取消JDBC URL前缀
useprefix=true
# 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,commit,resultset
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动可多个
#driverlist=org.h2.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 2 秒
outagedetectioninterval=2

注意

 测试效果

如果想把打印结果保存到文件中，如下：

 会输出到项目文件的根目录

 

 

动态表名

有这么三张表，表中字段一样，都有增删改查基本接口，此时可以使用动态表名来处理。

动态表名配置

（1）配置类

@Configuration
public class MybatisPlusIntercetorConfig {

    // 存储表名：
    // 规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，
    // 如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题
    public static ThreadLocal<String> myThreadLocal = new ThreadLocal<>();

    /**
     * 动态表名配置
     * 外界通过 MybatisPlusIntercetorConfig.myThreadLocal.set(”表名“)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        DynamicTableNameInnerInterceptor dynamicTableNameInnerInterceptor = new DynamicTableNameInnerInterceptor();
        HashMap<String, TableNameHandler> map = new HashMap<>(2) {{
            put("user", (sql, tableName) -> {
                // 这里判断下，如果没有传表名，那么使用默认的，如果传了使用传的表名
                if(null != myThreadLocal.get()) {
                    return myThreadLocal.get();
                }else {
                    return tableName;
                }
            });
        }};
        dynamicTableNameInnerInterceptor.setTableNameHandlerMap(map);
        interceptor.addInnerInterceptor(dynamicTableNameInnerInterceptor);
        return interceptor;
    }
}

（2）测试

@Test
void getList() {
    // 设置表名：
    MybatisPlusIntercetorConfig.myThreadLocal.set("user_20210808");
    List<User> userList = userMapper.selectList(new QueryWrapper<>());
    System.out.println(userList);
}

 

复杂查询  - Wrapper

1、根据条件查询多个：

eq()等于、ne() 不等于、gt() 大于、

@Test
public void getCondition () {
    QueryWrapper<Users> wrapper = new QueryWrapper<>();
    wrapper.gt("id", 10)
            .eq("name", "吕星辰2")
            .eq("login_name", "测试2 ");
    // 根据条件查询多个
    userMapper.selectList(wrapper);
}

2、 根据条件单个查询： 

3、区间查询

@Test
public void getCondition () {
    QueryWrapper<Users> wrapper = new QueryWrapper<>();
    wrapper.between("id", 2, 4);
    // 根据条件查询一个
    userMapper.selectList(wrapper);
}

 4、模糊查询

%?%

@Test
public void getLike () {
    QueryWrapper<Users> queryWrapper = new QueryWrapper<>();
    queryWrapper.notLike("name", "l").like("login_name", "星辰");
    userMapper.selectList(queryWrapper);
}

左 - %?、右 - ?%  模糊

@Test
public void getLike () {
    QueryWrapper<Users> queryWrapper = new QueryWrapper<>();
    queryWrapper.likeLeft("name", "星辰");
    userMapper.selectList(queryWrapper);
}