MyBatis-plus 使用说明

一、注解的作用

@TableName("数据库名字")
1.字符串类型，不是必填，用来指定数据表名称
@TableId(主键)
1.当实体类没有@TableId默认id为主键
2.当实体类有@TableId,字段为主键
3.CRUD操作时主键不允许被修改,其余字段均被拼接，(warpper>@TableId>默认id)
@TableField("非主键名称") 
1.字段注解，该注解用于标识非主键的字段。将数据库列与 JavaBean 中的属性进行映射

@TableLogic 
注解用于实现数据库数据逻辑删除。注意，该注解只对自动注入的 sql 起效，如：private int a=0
@EnumValue
@Version 实现乐观锁，该注解用于字段上面。（需要配置）
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")

二、条件构造器

查删增：

QueryWrapper queryWrapper = new QueryWrapper();

改：

UpdateWrapper updateWrapper = new UpdateWrapper();

在 IService 中提供了一个 query 方法，该方法返回 QueryChainWrapper 对象。我们可以使用该对象实现链式查询，避免每次都创建 QueryWrapper 对象。query 方法定义如下：

List<Zzg> list = zzgService.query()
                .eq("name","aa")
                .eq("age",2)
                .list();
或
zzgService.query().eq("name","aa").eq("age",2).list()

1.allEq条件：

注释：对应的 SQL 语句，是否忽略 value 等于 null 的条件
// 示例1：
Map<String,Object> params = new HashMap<>();
params.put("age", null);
params.put("sex", "男");
allEq(params )
// 对应的 SQL 语句
sex = '男' and age is null
 
// 示例2：
Map<String,Object> params = new HashMap<>();
params.put("age", null);
params.put("sex", "男");
allEq(params , false)
// 对应的 SQL 语句，忽略了 value 等于 null 的条件
sex = '男'

2.eq（等于），ne（不等于）

3.gt（大于>），ge（大于等于>=），lt（小于<），le（小于等于<=）

4.between和notBetween（在什么之间用and连接）

wrapper.between("age", 18, 30);

5.like(模糊查询) notlike(模糊查询) likeLeft(左模糊查询 “%like”) likeRight(右模糊查询 “like%”)

6.isNull isNotNull

7.in notIn（或者）

8.inSql notInSql （子查询）

wrapper.inSql("user_id", "select user_id from user where user_id<10");

9.orderByAsc orderByDesc （排序）

10.exists notExists（拼接EXISTS sql语句）

existsSql：exists SQL 语句
condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件

注释：sql存在existsSql返回true否则false
exists(String existsSql)
exists(boolean condition, String existsSql)

11.last （追加一个sql语句）

last 行数将无视 SQL 的优化规则，直接指定的 SQL 拼接到 SQL 的最后
last 函数只能调用一次，如果多次调用，以最后一次调用为准（有sql注入的风险,请谨慎使用）

注释：函数只能调用一次，如果多次调用，以最后一次调用为准（有sql注入的风险,请谨慎使用）
last(String lastSql)
last(boolean condition, String lastSql)
//案例
QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.last("limit 1,10");
//sql
SELECT user_id,name,sex,age,face,salary,borthday 
FROM user limit 1,10

12.apply （拼接sql）

applySql：要拼接的 SQL 语句，该 SQL 语句中可能会有 {0}、{1}、...、{n} 等字符串，用来替换参数。
params：参数列表，用于替换 applySql SQL 语句中的 {0}、{1}、...、{n} 等
condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件。

apply(String applySql, Object... params)
apply(boolean condition, String applySql, Object... params)

//案例
// 拼接：id = 100
apply("id = 100");
 
// 拼接：date_format(dateColumn,'%Y-%m-%d') = '2018-08-08'")
apply("date_format(dateColumn,'%Y-%m-%d') = '2018-08-08'")
 
// 拼接：date_format(dateColumn,'%Y-%m-%d') = '2018-08-08'")
apply("date_format(dateColumn,'%Y-%m-%d') = {0}", "2018-08-08")

13.nested（嵌套sql）

consumer：构造内嵌SQL条件
condition：用于指定当前这个条件是否有效；如果为 true，则应用当前条件；如果为 false，则忽略当前条件。

nested(Consumer<Param> consumer)
nested(boolean condition, Consumer<Param> consumer)

//查询所有姓黄，性别为男，年龄大于 30，薪水大于 9000 的用户信息，如下：
QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.likeRight("name", "黄");
wrapper.nested(new Consumer<QueryWrapper<UserBean>>() {
    @Override
    public void accept(QueryWrapper<UserBean> userBeanQueryWrapper) {
        userBeanQueryWrapper.eq("sex", "男")
                .gt("age", 30).gt("salary", 9000);
    }
});
//sql语句
SELECT user_id,name,sex,age,face,salary,borthday 
FROM user 
WHERE (name LIKE ? AND (sex = ? AND age > ? AND salary > ?))

14.groupBy（分组）

groupBy(R... columns)
groupBy(boolean condition, R... columns)

15.or和and（语句拼接）

or()
or(boolean condition)
//or嵌套
or(Consumer<Param> consumer)
or(boolean condition, Consumer<Param> consumer)
//and嵌套
and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)
//实例
QueryWrapper<UserBean> wrapper = new QueryWrapper<>();
wrapper.and(new Consumer<QueryWrapper<UserBean>>() {
    @Override
    public void accept(QueryWrapper<UserBean> userBeanQueryWrapper) {
        userBeanQueryWrapper.eq("sex", "男")
            .between("salary", 5000, 6000);
    }
});
 
wrapper.and(new Consumer<QueryWrapper<UserBean>>() {
    @Override
    public void accept(QueryWrapper<UserBean> userBeanQueryWrapper) {
        userBeanQueryWrapper.gt("age", 30)
            .likeRight("name", "黄");
    }
});

三、Service CRUD 接口

1.Save（添加）

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
注释：int batchSize 将数据分成多个批次，每个批次数量为batchSize
boolean saveBatch(Collection<T> entityList, int batchSize);

2.SaveOrUpdate（修改）

// TableId 注解存在更新记录，否插入一条记录
注释：@TableId 作为修改的条件，无匹配项这插入一条数据
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
注释：先根据wrapper条件进行匹配当不满足条件时执行saveOrUpdate(T)方法
（考虑是否有@TableId否是根据id）
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
注释：无匹配则插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

3.Update（修改）

// 根据 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 updateBatchById(Collection<T> entityList, int batchSize);

4.Romove（删除）

注解：跟据字段名和字段值进行删除
// 根据 entity 条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

5. Get（查询）

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
注释：throwEx：有多个 result 是否抛出异常
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);

6.List（查询）

// 查询所有
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);

7.Page分页查询

配置分页插件：

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

@Configuration
public class MyBatisPlusConfig {
    /**
     * 分页插件配置
     *
     * @return
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 向MyBatis-Plus的过滤器链中添加分页拦截器，需要设置数据库类型（主要用于分页方言）
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

注释：3为页数，5为每页的最大数据
Page<UserBean> page = new Page(3, 5);
// 无条件分页查询
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);

8.Count（查询条数）

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

四、Mapper CRUD接口

1.Insert（添加）

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

2.Delete（删除）

// 根据 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(Constants.COLUMN_MAP) Map<String, Object> columnMap);

3. Update（更新）

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

4.Select（查询）

// 根据 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.Jdbc驱动：高版本兼容低版本，com.mysql.cj.jdbc.Driver（高） com.mysql.jdbc.Driver（低）

2.当warpper为null时查询全部

3.配置日志：默认的控制台输出

mybatis-plus:
  mapper-locations: classpath:mapper/*.xml  #配置映射文件
  type-aliases-package: com.example.test.entity #配置实体类
#配置日志  打印sql语句
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

大神：MyBatis Plus 简介 - MyBatis Plus 教程

官网：MyBatis-Plus (baomidou.com)

MyBatis-plus 使用说明

悦读