Mybatis-Plus快速上手

1. 依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.3</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.16</version>
</dependency>

1. 添加访问数据库的mapper和service

1. 1. mapper

//需要继承BaseMapper
public interface UsersMapper extends BaseMapper<Users> {
}

1. 1. service

// 接口需要继承IService
public interface UsersService extends IService<Users> {

}
// 实现类需要继承 ServiceImpl
@Service
public class UsersServiceImpl extends ServiceImpl<UsersMapper, Users> implements UsersService {
}

1. 1. 启动类添加mapper扫描

@MapperScan(basePackages = {"com.heima.mpdemo.mapper"})
@SpringBootApplication
public class MpDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(MpDemoApplication.class, args);
    }
}

1. 常用注解

1. 1. @TableName 标注在实体类上 表示一个表名
   2. @TableId 标注在id上

1. 1. 1. @TableId(value = "id", type = IdType.ASSIGN_ID)
      2. 数据库 ID 自增 -- AUTO
      3. 无状态 -- NONE
      4. insert 前自行 set 主键值 -- INPUT
      5. 通过雪花算分类ID -- ASSIGN_ID
      6. 分配 UUID -- ASSIGN_UUID

1. 1. @TableField 标注在属性上 标识数据库中一个字段
   2. Mapper层的CURD
   3. Service层的CURD
   4. 代码生成器

1. 1. 1. 下载mybatis-plus插件

      2. 

1. 1. 分页插件

1. 1. 1. 编写一个配置类 写上@Configuration注解
      2. 将分页插件加载到Spring容器中

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

1. 1. 1. 使用分页插件

/**
 * 分页查询
 * */
@Test
public void testSelectPage(){
    // 构造分页条件
    IPage<Users> iPage = new Page<>(1, 2);
    // 构造查询条件
    LambdaQueryWrapper<Users> queryWrapper = new LambdaQueryWrapper<Users>();
    queryWrapper.gt(Users::getUserId, 0).gt(Users::getAge, 10);
    // 分页查询
    IPage<Users> iPage1 = usersMapper.selectPage(iPage, queryWrapper);
    //当前页的数据列表
    List<Users> records = iPage1.getRecords();
    //总记录的条数
    long total = iPage1.getTotal();
    //总页数
    long pages = iPage1.getPages();
    log.info(JSON.toJSONString(records) + ", total：{}, pages:{}", total, pages);
}

1. 1. 多数据源 -- 可以使用两个数据库中的数据

1. 1. 1. 添加依赖

<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
  <version>3.4.0</version>
</dependency>

1. 1. 1. 在配置文件中添加配置

spring:
  datasource:
    dynamic:
      primary: mpdemo #设置默认的数据源或者数据源组,默认值即为mpdemo
      strict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
      datasource:
        sky:
          url: jdbc:mysql://localhost:3306/sky_take_out?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=false
          username: root
          password: root
          driver-class-name: com.mysql.cj.jdbc.Driver
        mpdemo:
          url: jdbc:mysql://localhost:3306/mpdemo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8&useSSL=false
          username: root
          password: root
          driver-class-name: com.mysql.jdbc.Driver
mybatis-plus:
  mapper-locations: classpath:/mapper/**/*.xml
  global-config:
    db-config:
      id-type: auto

1. 1. 1. 使用@DS注解切换数据源
      2. @DS 可以注解在方法上或类上，同时存在就近原则 方法上注解 优先于 类上注解

1. 1. 自动填充

1. 1. 1. 设置需要自动填充的字段 属性上添加注解

public class User {

    // 注意！这里需要标记为填充字段
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    
    @TableField(fill = FieldFill.UPDATE)
    private Date updateTime;
}

1. 1. 1. 自定义实现类 MyMetaObjectHandler

 @Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill ....");
        this.strictInsertFill(metaObject, "createTime", Date.class,new Date());
        this.strictInsertFill(metaObject, "createUser", Long.class, UserThreadLocal.get().getUserId());

        this.strictInsertFill(metaObject, "updateTime", Date.class,new Date());
        this.strictInsertFill(metaObject, "updateUser", Long.class, UserThreadLocal.get().getUserId());
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill ....");
        this.strictInsertFill(metaObject, "updateTime", Date.class,new Date());
        this.strictInsertFill(metaObject, "updateUser", Long.class, UserThreadLocal.get().getUserId());
    }
}

1. 1. 逻辑删除

1. 1. 1. 首先在配置文件中添加一个全局的配置

mybatis-plus:
  global-config:
    db-config:
      # 要逻辑删除的字段名
      logic-delete-field: deleted
      # 删除以后字段为1
      logic-delete-value: 1
      # 没有删除字段为0
      logic-not-delete-value: 0

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

@TableLogic
private Integer deleted;

1. 1. 1. 效果

1. 1. 1. 1. 删除的时候会先查询一次 然后删除操作变更新操作
         2. 删除和更新的时候会追加where条件 防止删除和更新 已删除的数据

1. 1. 乐观锁加锁

1. 1. 1. 原理：两个用户同时修改数据库中的数据，先进行查询，第一个查询到version是0，第二个查询到也是0，此时第一个在修改的时候同时where判断version，同时把version给修改掉，第二个再去修改的时候where判断的时候条件就不符合了，所以返回为0
      2. 把乐观锁的插件注册到Spring容器中

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
    return interceptor;
}

1. 1. 1. 在实体类的字段上加上@Version注解

@Version
private Integer version;

1. Mapper的CRUD

// 插入一条记录
int insert(T entity);

// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录
int deleteByMap(@Param

// 根据 whereWrapper 条件，更新记录
int update(@Param(Constants.ENTITY) T updateEntity, @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

1. Service的CRUD

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);

// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

// 根据 queryWrapper 设置的条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updat

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

// 无条件分页查询
IPage<T> page(IPage<T> page);
// 条件分页查询
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
// 无条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page);
// 条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);

// 查询总记录数
int count();S
// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);