数据库框架MyBatisPlus的使用解析!详细解析MyBatisPlus中API的使用方式-阿里云开发者社区

开发者社区> 攻城狮Chova> 正文

数据库框架MyBatisPlus的使用解析!详细解析MyBatisPlus中API的使用方式

简介: 本篇文章具体对数据库框架MyBatisPlus中的API的使用方式进行详细的说明解析,包括注解的使用,CRUD接口的使用和条件构造器的使用。通过实例对MyBatisPlus中API方法进行具体的使用说明,可以帮助你学会在项目中集成使用MyBatisPlus框架。
+关注继续查看

注解

@TableName
  • 表名注解:
属性类型是否必须缺省值描述
valueString表名
schemaStringschema
keepGlobalPrefixbooleanfalse是否保持使用全局的tablePrefix的值(要求设置tablePrefix并且自定义设置了value的值)
resultMapStringxmlresultMapid
autoResultMapbooleanfalse是否自动构建resultMap并使用,如果设置了resultMap就不会进行resultMap的自动构建注入
  • autoResultMap:

    • autoResultMap会自动构建一个ResultMap并注入到MyBatis中,一般情况下不会用到
    • autoResultMap只是注入了常用的CRUDMyBatis中,注入之前是动态的:根据entity的字段以及注解的变化而变化. 但是注入之后是静态的,就相当于写在xml中了
    • 对于直接指定typeHandler,MyBatis只支持写在两个地方:

      • 定义在resultMap里,只作用于select查询的返回结果封装
      • 定义在insertupdatesql中的 #{property} 里的property后面

        • 比如: #{property.typehandler=xxx.xxx.xxx}
        • 只作用于设置值
    • 除了这两种直接指定typeHandler,MyBatis有一个全局扫描自定义的typeHandler包的配置,根据property的类型去找typeHandler
@TableId
  • 主键注解:
属性类型是否必须缺省值描述
valueString主键字段名
typeEnumIdType.NONE主键类型

IdType:

描述
AUTO数据库ID自增
NONE无状态,该类型为未设置主键类型:注解里等于跟随全局,全局里约等于INPUT
INPUTinsert前自行set主键值
ASSIGN_ID分配ID: 主键类型为Number(LongInteger)String
使用接口IdentifierGenerator的方法nextId: 默认实现类为DefaultIdentifierGenerator雪花算法SnowFlakeIdWorker
ASSIGN_UUID分配UUID: 主键类型为String
使用接口IdentifierGenerator的方法nextUUID: 默认dafault方法
@TableField
  • 非主键字段注解:
属性类型是否必须缺省值描述
valueString字段名
elString映射为原生 #{ } 逻辑,相当于xml里的 #{ } 部分
existbooleantrue是否为数据库表字段
conditionString字段where实体查询比较条件
如果有值设置则按设置的值为准,如果没有值则为默认全局的 %s = #{%s}
updateString字段update set部分注入
比如 : update = "%s + 1", 表示更新时会set version = version + 1. 该属性的优先级高于el
insertStrategyEnumDEFAULTNOT_NULL:
insert into table_a(< if test="columnProperty != null" >column< /if >) values (< if test="columnProperty != null">#{columnProperty}< /if >)
updateStrategyEnumDEFAULTIGNORED:
update table_a set column = #{columnProperty}
whereStrategyEnumDEFAULTNOT_EMPTY:
where < if test="columnProperty != null and columnProperty != ' ' ">column = #{columnProperty}< /if >
fillEnumFiledFill.DEFAULT字段自动填充策略
selectbooleantrue是否进行select查询
keepGlobalFormatbooleanfalse是否保持全局的format进行处理
jdbcTypeJdbcTypeJdbcType.UNDEFINEDJDBC类型,该默认值不代表会按照该值生效
typeHandlerClass<? extends TypeHandler>UnknownTypeHandler.class类型处理器,该默认值不代表会按照该值生效
numericScaleString指定小数点后保留的位数
  • numbericScale只生效于updatesql
  • jdbcTypetypeHandler如果不配合 @TableName#autoResultMap = true一起使用,也只生效于updatesql
  • typeHandler中,如果字段类型和set进去的类型为equals关系,则只需要让自定义的typeHandlerMyBatis加载到即可,不需要使用注解
  • FieldStrategy:
描述
IGNORED忽略判断
NOT_NULLNULL判断
NOT_EMPTY非空判断:只针对于字符串类型
其它类型字段依然为非NULL判断
DEFAULT追随全局配置
  • FieldFill:
描述
DEFAULT默认不处理
INSERT插入时填充字段
UPDATE更新时填充字段
INSERT_UPDATE插入和更新时填充字段
@Version
  • 乐观锁注解,标记@Version在字段上
@EnumValue
  • 通枚举类注解,注解在枚举字段上
@TableLogic
  • 表字段逻辑处理(逻辑删除)注解
属性类型是否必须默认值描述
valueString逻辑未删除值
delvalString逻辑删除值
@SqpParser
  • 租户注解,支持method和mapper接口
属性类型是否必须默认值描述
filterbooleanfalsetrue: 表示过滤SQL解析,即不会进入SqlParser解析链
false: 进解析链并追加例如tenant_id等条件
@KeySequence
  • 序列主键策略
属性类型是否必须默认值描述
valueString序列名
clazzClassLong.classID的类型
可以指定String.class, 这样返回的Sequence值是字符串1

CRUD接口

Service CRUD

  • 通用Service CRUD封装IService接口,进一步封装CRUD
  • 采用前缀命名方式区分Mapper层来避免混淆:

    • get: 查询单行
    • remove: 删除
    • list: 查询集合
    • page: 分页
  • 泛型T为任意实体对象
  • 如果存在自定义通用Service方法,需要创建自定义的IBaseService继承Mybatis-Plus提供的基类
  • 对象Wrapper为条件构造器
save
/**
 * 插入一条记录(选择字段,策略插入)
 * 
 * @param entity 实体对象 T 
 * @return 是否插入成功
 */
boolean save(T entity);
saveBatch
/**
 * 批量插入记录
 * 
 * @param entityList 实体对象集合 Collection<T> 
 * @return 是否插入成功
 */
boolean saveBatch(Collection<T> entityList);

/**
 * 批量插入记录
 * 
 * @param entityList 实体对象集合 Collection<T>
 * @param batchSize 插入批次数量 int
 * @return 是否插入成功
 */
boolean saveBatch(Collection<T> entityList, int batchSize);
saveOrUpdate
/**
 * 如果TableId存在就更新记录,否则就插入一条记录
 * 
 * @param entity 实体对象 T 
 * @return 是否插入成功
 */
boolean saveOrUpdate(T entity);

/**
 * 根据updateWrapper尝试更新,否则执行saveOrUpdate(T)方法
 * 
 * @param entity 实体对象 T
 * @param updateWrapper 实体对象封装操作类 UpdateWrapper
 * @return 是否插入成功
 */
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
saveOrUpdateBatch
/**
 * 批量修改插入
 * 
 * @param entryList 实体对象集合 Collection<T>
 * @return 是否插入成功
 */
boolean saveOrUpdate(Collection<T> entryList);

/**
 * 批量修改插入
 * 
 * @param entryList 实体对象集合 Collection<T>
 * @param batchSize 插入批次数量 int
 * @return 是否插入成功
 */
boolean saveOrUpdate(Collection<T> entryList, int batchSize);
remove
/**
 * 根据entity条件,删除记录
 * 
 * @param queryWrapper 实体包装类 QueryWrapper
 * @return 是否删除成功
 */
boolean remove(Wrapper<T> queryWrapper);
removeById
/**
 * 根据ID删除记录
 * 
 * @param id 主键ID Serializable
 * @return 是否删除成功
 */
boolean removeById(Serializable id);
removeByMap
/**
 * 根据columnMap条件删除记录
 * 
 * @param columnMap 表字段map对象 Map<String, Object>
 * @return 是否删除成功
 */
boolean removeById(Serializable id);
removeByIds
/**
 * 根据ID批量删除记录
 * 
 * @param idList 主键ID列表 Collection<? extends Serializeable>
 * @return 是否删除成功
 */
boolean removeByIds(Collection<? extends Serializeable> idList);
update
/**
 * 根据updateWrapper条件更新记录,需要设置sqlset
 * 
 * @param updateWrapper 实体对象封装操作类 UpdateWrapper
 * @return 是否更新成功
 */
boolean update(Wrapper<T> updateWrapper);

/**
 * 根据whereEntity条件更新记录
 * 
 * @param entity 实体对象 T
 * @param updateWrapper 实体对象封装操作类 UpdateWrapper
 * @return 是否更新成功
 */
boolean update(T entity, Wrapper<T> updateWrapper);
updateById
/**
 * 根据ID选择修改
 * 
 * @param entity 实体对象 T
 * @return 是否更新成功
 */
boolean updateById(T entity);
updateBatchById
/**
 * 根据ID批量更新
 * 
 * @param entityList 实体对象集合 Collection<T>
 * @return 是否更新成功
 */
boolean updateBatchById(Collection<T> entityList);

/**
 * 根据ID批量更新
 * 
 * @param entityList 实体对象集合 Collection<T>
 * @param batchSize 更新批次数量
 * @return 是否更新成功
 */
boolean updateBatchById(Collection<T> entityList, int batchSize);
getById
/**
 * 根据ID查询
 * 
 * @param id 主键ID Serializable
 * @return 实体对象 T
 */
T getById(Serializable id);
getOne
/**
 * 根据Wrapper查询一条记录
 * 结果集如果是多个会抛出异常,随机取一条加上限制条件 wrapper.last("LIMIT 1")
 * 
 * @param queryWrapper 实体对象封装操作类 QueryWrapper
 * @return 实体对象 T
 */
T getOne(Wrapper<T> queryWrapper);

/**
 * 根据Wrapper查询一条记录
 * 
 * @param queryWrapper 实体对象封装操作类 QueryWrapper
 * @param throwEx 有多个result是否抛出异常
 * @return 实体对象 T
 */
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
getMap
/**
 * 根据Wrapper查询一条记录
 * 
 * @param queryWrapper 实体对象封装操作类 QueryWrapper
 * @return 实体对象Map Map<String, Object>
 */
Map<String, Object> getMap(Wrapper<T> queryWrapper);
getObj
/**
 * 根据Wrapper查询一条记录
 * 
 * @param queryWrapper 实体对象封装操作类 QueryWrapper
 * @param mapper 转换函数
 * @return 实体对象Map Map<String, Object>
 */
<V> V getMap(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
list
/**
 * 查询所有
 * 
 * @return 实体对象集合 List<T>
 */
List<T> list();

/**
 * 查询所有列表
 * 
 * @param queryWrapper 实体对象封装操作类 QueryWrapper
 * @return 实体对象集合 List<T>
 */
List<T> list(Wrapper<T> queryWrapper);
listByIds
/**
 * 根据Ids批量查询
 * 
 * @param idList 主键ID列表
 * @return 实体对象集合 List<T>
 */
Collection<T> listByIds(Collection<? extends Serializable> idList);
listByMap
/**
 * 根据columnMap条件查询
 * 
 * @param columnMap 表字段map对象
 * @return 实体对象集合 List<T>
 */
Collection<T> listByMap(Map<String, Object> columnMap);
listMaps
/**
 * 查询所有列表
 * 
 * @return 实体对象Map集合 List<Map<String, Object>>
 */
List<Map<String, Object>> listMaps();

/**
 * 查询列表
 * 
 * @param queryWrapper 实体对象封装操作类 QueryWrapper
 * @return 实体对象Map集合 List<Map<String, Object>>
 */
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
listObjs
/**
 * 查询全部记录
 * 
 * @return 实体对象集合 List<Object>
 */
List<Object> listObjs();

/**
 * 查询全部记录
 * 
 * @param mapper 转换函数
 * @return 实体对象集合 <V> List<V>
 */
<V> List<V> listObjs(Function<? super Object, V> mapper);

/**
 * 根据Wrapper条件,查询全部记录
 * 
 * @param queryWrapper 实体对象封装操作类
 * @return 实体对象集合 List<Object>
 */
List<Object> listObjs(Wrapper<T> queryWrapper);

/**
 * 根据Wrapper条件,查询全部记录
 * 
 * @param queryWrapper 实体对象封装操作类
 * @param mapper 转换函数
 * @return 实体对象集合 <V> List<V>
 */
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
page
/**
 * 分页查询所有记录
 * 
 * @param page 分页查询条件 IPage<T>
 * @return 分页对象集合 IPage<T>
 */
IPage<T> page(IPage<T> page);

/**
 * 根据Wrapper条件,分页查询
 * 
 * @param page 分页查询条件 IPage<T> 
 * @param queryWrapper 实体对象封装操作类
 * @return 分页对象集合 IPage<T>
 */
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
pageMaps
/**
 * 分页查询所有记录
 * 
 * @param page 分页查询条件 IPage<T>
 * @return 分页对象Map集合 IPage<Map<String, Object>>
 */
IPage<Map<String, Object>> pageMaps(IPage<T> page);

/**
 * 根据Wrapper条件,分页查询
 * 
 * @param page 分页查询条件 IPage<T>
 * @param queryWrapper 实体对象封装操作类
 * @return 分页对象Map集合 IPage<Map<String, Object>>
 */
IPage<Map<String, Object>> page(IPage<T> page, Wrapper<T> queryWrapper);
count
/**
 * 查询总记录数
 * 
 * @return 总记录的数目 int
 */
int count();

/**
 * 根据Wrapper条件,查询总记录数目
 * 
 * @param queryWrapper 实体对象封装操作类
 * @return 记录数目 int
 */
int count(Wrapper<T> queryWrapper);

Chain 链式

query
/**
 * 普通链式查询 
 * 
 * @return 链式查询条件构造器 QueryChainWrapper<T>
 */
QueryChainWrapper<T> query();

/**
 * Lambda式链式查询,不支持Kotlin
 * 
 * @return Lambda式链式查询条件构造器
 */
LambdaQueryChainWrapper<T> lambdaQuery();


/*
 * 示例
 */
 query().eq("column", value).one();
 lambdaQuery().eq(Entity :: getId, value).list();
update
/**
 * 普通链式更改
 * 
 * @return 链式更改条件构造器  UpdateChainWrapper<T>
 */
 UpdateChainWrapper<T> update();

/**
 * Lambda式链式更改,不支持Kotlin
 * 
 * @return Lambda式链式更改条件构造器 LambdaUpdateChainWrapper<T>
 */
 LambdaUpdateChainWrapper<T> lambdaUpdate();

/*
 * 示例
 */
 update().eq("column", value).remove();
 lambdaUpdate().eq(Entity :: getId, value).update(entity)

Mapper CRUD

  • 通用CRUD封装BaseMapper接口,在MyBatis-Plus启动时自动解析实体表关系映射转换为MyBatis内部对象注入容器
  • 泛型T为任意实体对象
  • 参数Serializable为任意类型主键 ,MyBatis-Plus不推荐使用复合主键约定. 每一张表都有自己的唯一ID主键
  • 对象Wrapper为条件构造器
insert
/**
 * 插入一条记录
 * 
 * @param entity 实体对象 T
 * @return 是否插入成功 int
 */ 
int insert(T entity);
delete
/**
 * 根据entity条件,删除记录
 * 
 * @param wrapper 实体对象封装操作类,可以为null Wrapper<T>
 * @return 是否删除成功 int
 */ 
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
deleteBatchIds
/**
 * 根据IDs批量删除记录
 * 
 * @param idList 主键ID列表,不能为null以及不能为空 Collection<? extends Serializable>
 * @return 是否批量删除成功 int
 */ 
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
deleteById
/**
 * 根据ID删除记录
 * 
 * @param id 主键ID Serializable 
 * @return 是否删除成功 int
 */ 
int deleteById(Serializable id);
deleteByMap
/**
 * 根据columMap条件删除记录
 * 
 * @param cloumnMap 表字段Map对象 Map<String, Object> 
 * @return 是否删除成功 int
 */ 
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> cloumnMap);
update
/**
 * 根据whereEntity条件更新记录
 * 
 * @param entity 实体对象,set条件值,可以为null T
 * @param updateWrapper 实体对象封装操作类,可以为null,里面的entity用于生成where语句 Wrapper<T>
 * @return 是否更新成功 int
 */ 
int update(@Param(Constant.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
updateById
/**
 * 根据ID更新记录
 * 
 * @param entity 实体对象,set条件值,可以为null T
 * @return 是否更新成功 int
 */
int updateById(@Param(Constants.ENTITY) T entity);
selectById
/**
 * 根据ID查询
 *
 * @param id 主键ID Serializable 
 * @return 实体对象 T
 */
T selectById(Serializable id);
selectOne
/**
 * 根据entity条件,查询一条记录
 *
 * @param queryWrapper 实体对象封装操作类,可以为null Wrapper<T> 
 * @return 实体对象 T
 */
T selectOne(@Param(Constants.Wrapper) Wrapper<T> queryWrapper);
selectBatchIds
/**
 * 根据IDs批量查询记录
 *
 * @param idList 主键ID列表,不能为null以及不能为空 Collection<? extends Serializable> 
 * @return 实体对象集合 List<T>
 */
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
selectList
/**
 * 根据entity条件,查询全部记录
 *
 * @param queryWrapper 实体对象封装操作类,可以为null Wrapper<T>
 * @return 实体对象集合 List<T>
 */
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
selectByMap
/**
 * 根据cloumnMap条件,查询全部记录
 *
 * @param columnMap 表字段map对象 Map<String, Object>
 * @return 实体对象集合 List<T> 
 */
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
selectMaps
/**
 * 根据Wrapper条件,查询全部记录
 *
 * @param queryWrapper 实体对象封装操作类,可以为null Wrapper<T>
 * @return 实体对象Map集合 List<Map<String, Object>> 
 */
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
selectObjs
/**
 * 根据Wrapper条件,查询全部记录,只返回第一个字段的值
 *
 * @param queryWrapper 实体对象封装操作类,可以为null Wrapper<T>
 * @return 实体对象集合 List<Object> 
 */
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
selectPage
/**
 * 根据Wrapper条件,查询全部记录并分页
 *
 * @param page 分页查询条件 IPage<T>
 * @param queryWrapper 实体对象封装操作类,可以为null Wrapper<T>
 * @return 分页对象集合 Ipage<T>
 */
Ipage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
selectMapsPage
/**
 * 根据Wrapper条件,查询全部记录并分页
 *
 * @param page 分页查询条件 IPage<T>
 * @param queryWrapper 实体对象封装操作类,可以为null Wrapper<T>
 * @return 分页对象Map集合 Ipage<Map<String, Object>>
 */
Ipage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
selectCount
/**
 * 根据Wrapper条件,查询记录数目
 * 
 * @param queryWrapper 实体对象封装操作类,可以为null Wrapper<T>
 * @return 记录数目 Integer
 */
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

Mapper 选装件

  • 选装件位于com.baomidou.mybatisplus.extension.injector.methods.addtional包下,需要配合SQL注入器使用
alwaysUpdateSomeColumnById
/**
 * 根据ID更新列表字段
 *  
 * @param entity 实体对象,set条件值,可以为null T
 * @return 是否更新成功 int
 */
 int alwaysUpdateSomeColumnById(T entity);
insertBatchSomeColumn
/**
 * 批量数据插入列表
 *  
 * @param entryList 实体对象集合 List<T>
 * @return 是否批量插入成功 int
 */
 int insertBatchSomeColumn(List<T> entryList);
deleteByIdWithFill
/**
 * 根据Id删除数据
 *  
 * @param entity 实体对象,set条件值,可以为null T
 * @return 是否删除成功 int
 */
 int deleteByIdWithFill(T entity);

条件构造器

  • 出现的第一个入参boolean condition表示该条件是否加入最后生成的SQL
  • 代码块内的多个方法均为从上往下补全个别boolean类型的入参,默认为true
  • 泛型Param均为Wrapper子类的实例,均具有AbstractWrapper的所有方法
  • 方法入参中出现的R为泛型,在普通Wrapper中是String,LambdaWrapper中是函数. 比如 - Entity::getId, 其中Entity为实体类 ,getId为字段idgetMethod
  • 方法入参中出现的R column表示数据库字段,当R具体类型为String时则为数据库字段名而不是实体类字段名, 如果字段名是数据库关键字的需要用转义符包裹
  • 普通Wrapper中入参为MapList的均以json形式表现
  • 使用中如果入参的Map或者List为空,则不会加入最后生成的SQL
  • 注意:

    • 不要在RPC调用中使用Wrapper进行传输:

      • Wrapper很重
      • 传输Wrapper可以类比为controller中使用map接收值
      • 正确的RPC调用时是写一个DTO进行传输,被调用方再根据DTO执行相应的操作

AbstractWrapper

  • QueryWrapper(LambdaQueryWrapper)UpdateWrapper(LambdaUpdateWrapper) 的父类

    • 用于生成SQLwhere条件
    • entity属性也用于生成SQLwhere条件
allEq
allEq(Map<R, V> params);

allEq(Map<R, V> params, boolean null2IsNull);

allEq(boolean condition, Map<R, V> params, boolean null2IsNull);
  • 全部eq或者个别isNull :

    • params:

      • key为数据库字段名
      • value为字段值
    • null2IsNull:

      • 如果为true则在mapvaluenull时调用isNull方法
      • 如果为false则忽略valuenull
  1. allEq({id:1,name:"wang",age:null}) --> id = 1 and name = 'wang' and age is null
  2. allEq({id:1,name:'"wang",age:null}, false) --> id = 1 and name = 'wang'
allEq(BiPredicate<R, V> filter, Map<R, V> params);
allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull);
allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNUll);
  • filter:

    • 过滤函数,是否允许字段传入比对条件
  • params:

    • key为数据库字段名
    • value为字段值
  • null2IsNull:

    • 如果为true则在mapvaluenull时调用isNull方法
    • 如果为false则忽略valuenull
  1. allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"wang",age:null}) --> name = 'wang' and age is null
  2. allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"wang",age:null}, false) --> name = 'wang'
eq
eq(R column, Object val);
eq(boolean condition, R column, Object val);
  • 等于 = :
eq("name", "wang") --> name = 'wang'
ne
ne(R column, Object val);
ne(boolean condition, R column, Object val);
  • 不等于 <> :
ne("name", "wang") --> name <> 'wang'
gt
gt(R column, Object val);
gt(boolean condition, R column, Object val);
  • 大于 > :
gt("age", 18) --> age > 18
ge
ge(R column, Object val)
ge(boolean condition, R column, Object val)
  • 大于等于 >= :
ge("age", 18) --> age >= 18
lt
lt(R column, Object val);
lt(boolean condition, R column, Object val);
  • 小于 < :
lt("age", 18) --> age < 18
le
le(R column, Object val);
le(boolean condition, R column, Object val);
  • 小于等于 <= :
le("age", 18) --> age <= 18
between
between(R column, Object val1, Object val2);
between(boolean condition, R column, Object val1, Object val2);
  • between 值1 and 值2 :
between("age", 18, 30) --> age between 18 and 30
notBetween
notBetween(R column, Object val1, Object val2);
notBetween(boolean condition, R column, Object val1, Object val2);
  • not between 值1 and 值2
notBetween("age", 18, 30) --> age not between 18 and 30
like
like(R column, Object val);
like(boolean condition, R column, Object val);
  • like '%值%' :
like("name", "wang") --> name like '%wang%'
notLike
notLike(R column, Object val);
notLike(boolean condition, R column, Object val);
  • not like '%值%' :
notLike("name", "wang") --> name not like '%wang%'
likeLeft
likeLeft(R column, Obeject val);
likeLeft(boolean condition, R column, Object val);
  • like '%值' :
likeLeft("name", "wang") --> name like '%wang'
likeRight
likeRight(R column, Object val);
likeRight(boolean condition, R column, Object val);
  • like '值%' :
likeRight("name", "wang") --> name like 'wang%'
isNull
isNull(R column);
isNull(boolean condition, R column);
  • 字段 is null :
isNull("name") --> name is null
isNotNull
isNotNull(R column);
isNotNull(boolean condition, R column);
  • 字段 is not null :
isNotNull("name") --> name is not null
in
in(R column, Collection<?> value);
in(booelan condition, R column, Collection<?> value);
  • 字段 in (value.get(0), value.get(1) ...) :
in("age", {1, 2, 3}) --> age in (1, 2, 3)
in(R column, Object... values);
in(booelan condition, R column, Object... values);
  • 字段 in (v0, v1 ...) :
in("age", 1, 2, 3) --> age in (1, 2, 3)
notIn
notIn(R column, Collection<?> value);
notIn(booelan condition, R column, Collection<?> value);
  • 字段 not in (value.get(0), value.get(1) ...) :
notIn("age", {1, 2, 3}) --> age not in (1, 2, 3)
notIn(R column, Object... values);
notIn(boolean condition, R column, Object... values);
  • 字段 not in (v0, v1 ...) :
notIn("age", 1, 2, 3) --> age not in (1, 2, 3)
inSql
inSql(R column, String inValue);
inSql(boolean condition, R column, String inValue);
  • 字段 in (sql) :
inSql("age", "1, 2, 3, 4, 5, 6") --> age in (1, 2, 3, 4, 5, 6)
inSql("id", "select id from table where id < 3") --> id in (select id from table where id < 3)
notInSql
notInSql(R column, String inValue);
notInSql(boolean condition, R column, String inValue);
  • 字段 not in (sql) :
  1. notInSql("age", "1, 2, 3, 4, 5, 6") --> age not in (1, 2, 3, 4, 5, 6)
  2. notInSql("id", "select id from table where id < 3") --> age not in (select id from table where id < 3)
groupBy
groupBy(R... columns);
groupBy(boolean condition, R... columns);
  • group by 字段 ... :
groupBy("id", "name") --> group by id,name
orderByAsc
orderByAsc(R... columns);
orderByAsc(boolean condition, R... columns);
  • order by 字段 ... asc :
orderByAsc("id", "name") --> order by id,name asc
oederByDesc
orderByDesc(R... columns);
orderByDesc(boolean condition, R... columns);
  • order by 字段 ... desc :
orderByDesc("id", "name") --> order by id,name desc
orderBy
orderBy(boolean condition, boolean isAsc, R... columns);
  • order by 字段 ... :
orderBy(true, true, "id", "name") --> order by id,name asc
having
having(String sqlHaving, Object... params);
having(boolean condition, String sqlHaving, Object... params);
  • having (sql) :
  1. having("sum(age) > 10") --> having sum(age) > 10
  2. having("sum(age) > {0}", 10) --> having sum(age) > 10
or
or();
or(boolean condition);
  • 拼接 or :
  • 注意事项:

    • 主动调用or表示紧接着下一个方法不是用and连接
    • 不调用or则默认使用and连接
eq("id", 1).or().eq("name", "wang") --> id = 1 or name = 'wang'
or(Consumer<Param> consumer);
or(boolean condition, Consumer<Param> consumer);
  • 嵌套 or :
or(i -> i.eq("name", "li").ne("status", "live")) --> or(name = 'li' and status <> 'live')
and
and(Consumer<Param> consumer);
and(boolean condition, Consumer<Param> consumer);
  • 嵌套 and
and(i -> i.eq('name', 'li').ne('status', 'live')) --> and(name = 'li' and status <> 'live')
nested
nested(Consumer<Param> consumer);
nested(boolean condition, Consumer<Param> consumer);
  • 正常嵌套 不带 and 或者 or :
nested(i -> i.eq("name", "li").ne("status", "live")) --> (name = 'li' and status <> 'live')
apply
apply(String applySql, Object... params);
apply(boolean condition, String applySql, Object... params);
  • 拼接 sql :

    • 该方法可用于数据库函数
    • 动态入参的params对应前面applySql内部的 {index} 部分
    • 这样是不会有sql注入风险的,反之会有
  1. apply("id = 1") --> id = 1
  2. apply("date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'") --> date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'
  3. apply("date_format(dateColumn, '%Y-%m-%d') = {0}", "2008-08-08") --> date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'
last
last(String lastSql);
last(boolean condition, String lastSql);
  • 无视优化规则直接拼接到sql的最后
  • 只能调用一次,多次调用以最后一次为准
  • 有sql注入的风险,不推荐使用
last("limit 1") --> limit 1
exists
exists(String existsSql);
exists(boolean condition, String existsSql);
  • 拼接 exists(sql) :
exists("select id from table where age = 1") --> exists(select id from table where age = 1)
notExists
notExists(String notExistsSql);
notExists(boolean condition, String notExistsSql);
  • 拼接 not exists(sql) :
notExists("select id from table where age = 1") --> not exists (select id from table where age = 1)

QueryWrapper

  • 继承自AbstractWrapper, 自身的内部属性entity也是用于生成where条件
  • 其中的LambdaQueryWrapper, 可以通过new QueryWrapper().lambda() 方法获取
select
select(String... sqlSelect);
select(Predicate<TableFieldInfo> predicate);
select(Class<T> entityClass, Predicate<TableFieldInfo> predicate);
  • select方法分为两类:

    • 第二类方法:

      • 过滤查询字段,主键除外
      • 入参不包括class的调用前需要wrapper内的entity属性有值
    • 这两类方法重复调用以最后一次为准
  1. select("id", "name", "age")
  2. select(i -> i.getProperty().startsWith("test"))

UpdateWrapper

  • 继承自AbstractWrapper, 自身的内部属性entity也是用于生成where条件
  • 其中的LambdaUpdateWrapper, 可以通过new updateWrapper().lambda() 方法调用
set
set(String column, Object val);
set(boolean condition, String column, Object val);
  • SQL set 字段 :
set("name", ''li")
set("name", "") --> 数据库字段值变为空字符串
set("name", null) --> 数据库字段值变为 null
setSql
setSql(String sql);
set("name = 'li'")

lambda

  • 获取LambdaWrapper:

    • QueryWrapper中是获取LambdaQueryWrapper
    • UpdateWrapper中是获取LambdaUpdateWrapper

使用Wrapper自定义SQL

Service.java
mysqlMapper.getAll(Wrappers.<MysqlData>.lambdaQuery().eq(MysqlData :: getGroup, 1));
注解方式-Mapper.java
@Select("select * from mysql_data ${ew.customSqlSegment}")
List<MysqlData> getAll(@Param(Constants.WRAPPER) Wrapper wrapper);
XML形式-Mapper.xml
<select id="getAll" resultType="MysqlData">
    SELECT * FROM mysql_data ${ew.customSqlSegment}
</select>

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
使用IntelliJ IDEA开发SpringMVC网站(二)框架配置
原文:使用IntelliJ IDEA开发SpringMVC网站(二)框架配置 摘要 讲解如何配置SpringMVC框架xml,以及如何在Tomcat中运行 目录[-] 文章已针对IDEA 15做了一定的更新,部分更新较为重要,请重新阅读文章并下载最新源码。
989 0
Database · 理论基础 · 数据库事务隔离发展历史
事务隔离是数据库系统设计中根本的组成部分,本文主要从标准层面来讨论隔离级别的发展历史,首先明确隔离级别划分的目标;之后概述其否定之否定的发展历程;进而引出 Adya给出的比较合理的隔离级别定义,最终总结隔离标准一路走来的思路。
1258 0
使用iOS原生sqlite3框架对sqlite数据库进行操作(一)
使用iOS原生sqlite3框架对sqlite数据库进行操作
36 0
MyBatis Generator(MBG)数据库特定信息
使用说明本节收集不同数据库的使用信息。DB2MySQLOraclePostgreSQL请告知我们您正在使用的数据库发现的任何怪癖 - 我们很乐意将信息添加到此部分以备将来参考。原文:Database Specific Information 相关阅读: MyBatis Generator (MB...
630 0
SSM框架——使用 MyBatis Generator 生成代码,包括:Model、Dao、Mapping
基于 SSM 框架开发,Mybatis 属于半自动 ORM,如果每个数据表相关的 Model、Dao、Mapping 都要自己动手去写,是不是很麻烦呢?工作量最大的就是书写Mapping的映射文件,而且手动书写很容易出错。
1156 0
FFMPEG音频开发: Linux下采集摄像头(使用V4L2框架)数据录制成MP4视频保存到本地
FFMPEG音频开发: Linux下采集摄像头(使用V4L2框架)数据录制成MP4视频保存到本地
22 0
使用iOS原生sqlite3框架对sqlite数据库进行操作(三)
使用iOS原生sqlite3框架对sqlite数据库进行操作
29 0
+关注
攻城狮Chova
一位有自我修养的攻城狮。 2006年《时代》周刊年度人物, 2008年感动中国组委会特别奖获得者。 专注分享技术干货,面试经验和攻城狮故事~ 欢迎点赞关注支持,是我持续进步的动力!
77
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载