**
mybaits-plus常用使用方法
**
常用三层分别继承方法
1.1mapper层（接口定义层）可以用BaseMapper
例如：
1.2.里面常用的封装方法有
1.3常用方法介绍
【添加数据：（增）】
int insert(T entity); // 插入一条记录
注：
T 表示任意实体类型
entity 表示实体对象
【删除数据：（删）】
int deleteById(Serializable id); // 根据主键 ID 删除
int deleteByMap(@Param(Constants.COLUMN_MAP) MapString, Object> columnMap); // 根据 map 定义字段的条件删除
int delete(@Param(Constants.WRAPPER) WrapperT> wrapper); // 根据实体类定义的 条件删除对象
int deleteBatchIds(@Param(Constants.COLLECTION) Collection? extends Serializable> idList); // 进行批量删除
注：
id 表示 主键 ID
columnMap 表示表字段的 map 对象
wrapper 表示实体对象封装操作类，可以为 null。
idList 表示 主键 ID 集合（列表、数组），不能为 null 或 empty
【修改数据：（改）】
int updateById(@Param(Constants.ENTITY) T entity); // 根据 ID 修改实体对象。
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) WrapperT> updateWrapper); // 根据 updateWrapper 条件修改实体对象
注：
update 中的 entity 为 set 条件，可以为 null。
updateWrapper 表示实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
【查询数据：（查）】
T selectById(Serializable id); // 根据 主键 ID 查询数据
ListT> selectBatchIds(@Param(Constants.COLLECTION) Collection? extends Serializable> idList); // 进行批量查询
ListT> selectByMap(@Param(Constants.COLUMN_MAP) MapString, Object> columnMap); // 根据表字段条件查询
T selectOne(@Param(Constants.WRAPPER) WrapperT> queryWrapper); // 根据实体类封装对象 查询一条记录
Integer selectCount(@Param(Constants.WRAPPER) WrapperT> queryWrapper); // 查询记录的总条数
ListT> selectList(@Param(Constants.WRAPPER) WrapperT> queryWrapper); // 查询所有记录（返回 entity 集合）
ListMapString, Object>> selectMaps(@Param(Constants.WRAPPER) WrapperT> queryWrapper); // 查询所有记录（返回 map 集合）
ListObject> selectObjs(@Param(Constants.WRAPPER) WrapperT> queryWrapper); // 查询所有记录（但只保存第一个字段的值）
E extends IPageT>> E selectPage(E page, @Param(Constants.WRAPPER) WrapperT> queryWrapper); // 查询所有记录（返回 entity 集合），分页
E extends IPageMapString, Object>>> E selectMapsPage(E page, @Param(Constants.WRAPPER) WrapperT> queryWrapper); // 查询所有记录（返回 map 集合），分页
注：
queryWrapper 表示实体对象封装操作类（可以为 null）
page 表示分页查询条件
2.1service层（接口方法）可以用IService
介绍：
使用 代码生成器 生成的 service 接口中，其继承了 IService 接口。
IService 内部进一步封装了 BaseMapper 接口的方法（当然也提供了更详细的方法）。
使用时，可以通过 生成的 mapper 类进行 CRUD 操作，也可以通过 生成的 service 的实现类进行 CRUD 操作。（当然，自定义代码执行也可）
此处简单介绍一下 IService 中封装的常用方法。
2.2方法介绍
【添加数据：（增）】
default boolean save(T entity); // 调用 BaseMapper 的 insert 方法，用于添加一条数据。
boolean saveBatch(CollectionT> entityList, int batchSize); // 批量插入数据
注：
entityList 表示实体对象集合
batchSize 表示一次批量插入的数据量，默认为 1000
【添加或修改数据：（增或改）】
boolean saveOrUpdate(T entity); // id 若存在，则修改， id 不存在则新增数据
default boolean saveOrUpdate(T entity, WrapperT> updateWrapper); // 先根据条件尝试更新，然后再执行 saveOrUpdate 操作
boolean saveOrUpdateBatch(CollectionT> entityList, int batchSize); // 批量插入并修改数据
【删除数据：（删）】
default boolean removeById(Serializable id); // 调用 BaseMapper 的 deleteById 方法，根据 id 删除数据。
default boolean removeByMap(MapString, Object> columnMap); // 调用 BaseMapper 的 deleteByMap 方法，根据 map 定义字段的条件删除
default boolean remove(WrapperT> queryWrapper); // 调用 BaseMapper 的 delete 方法，根据实体类定义的 条件删除对象。
default boolean removeByIds(Collection? extends Serializable> idList); // 用 BaseMapper 的 deleteBatchIds 方法, 进行批量删除。
【修改数据：（改）】
default boolean updateById(T entity); // 调用 BaseMapper 的 updateById 方法，根据 ID 选择修改。
default boolean update(T entity, WrapperT> updateWrapper); // 调用 BaseMapper 的 update 方法，根据 updateWrapper 条件修改实体对象。
boolean updateBatchById(CollectionT> entityList, int batchSize); // 批量更新数据
【查找数据：（查）】
default T getById(Serializable id); // 调用 BaseMapper 的 selectById 方法，根据 主键 ID 返回数据。
default ListT> listByIds(Collection? extends Serializable> idList); // 调用 BaseMapper 的 selectBatchIds 方法，批量查询数据。
default ListT> listByMap(MapString, Object> columnMap); // 调用 BaseMapper 的 selectByMap 方法，根据表字段条件查询
default T getOne(WrapperT> queryWrapper); // 返回一条记录（实体类保存）。
MapString, Object> getMap(WrapperT> queryWrapper); // 返回一条记录（map 保存）。
default int count(WrapperT> queryWrapper); // 根据条件返回 记录数。
default ListT> list(); // 返回所有数据。
default ListT> list(WrapperT> queryWrapper); // 调用 BaseMapper 的 selectList 方法，查询所有记录（返回 entity 集合）。
default ListMapString, Object>> listMaps(WrapperT> queryWrapper); // 调用 BaseMapper 的 selectMaps 方法，查询所有记录（返回 map 集合）。
default ListObject> listObjs(); // 返回全部记录，但只返回第一个字段的值。
default E extends IPageT>> E page(E page, WrapperT> queryWrapper); // 调用 BaseMapper 的 selectPage 方法，分页查询
default E extends IPageMapString, Object>>> E pageMaps(E page, WrapperT> queryWrapper); // 调用 BaseMapper 的 selectMapsPage 方法，分页查询
注：
get 用于返回一条记录。
list 用于返回多条记录。
count 用于返回记录总数。
page 用于分页查询。
【链式调用：】
default QueryChainWrapperT> query(); // 普通链式查询
default LambdaQueryChainWrapperT> lambdaQuery(); // 支持 Lambda 表达式的修改
default UpdateChainWrapperT> update(); // 普通链式修改
default LambdaUpdateChainWrapperT> lambdaUpdate(); // 支持 Lambda 表达式的修改
注：
query 表示查询
update 表示修改
Lambda 表示内部支持 Lambda 写法。
形如：
query().eq("column", value).one();
lambdaQuery().eq(Entity::getId, value).list();
update().eq("column", value).remove();
lambdaUpdate().eq(Entity::getId, value).update(entity);
3.1条件构造器
上面介绍的 接口方法的参数中，会出现各种 wrapper，比如 queryWrapper、updateWrapper 等。wrapper 的作用就是用于定义各种各样的查询条件（where）。
Wrapper 条件构造抽象类
-- AbstractWrapper 查询条件封装，用于生成 sql 中的 where 语句。
-- QueryWrapper Entity 对象封装操作类，用于查询。
-- UpdateWrapper Update 条件封装操作类，用于更新。
-- AbstractLambdaWrapper 使用 Lambda 表达式封装 wrapper
-- LambdaQueryWrapper 使用 Lambda 语法封装条件，用于查询。
-- LambdaUpdateWrapper 使用 Lambda 语法封装条件，用于更新。
3.2常用条件
参考源码以及官方文档总结的，还是一句话，混个眼熟，多用用就熟练
【通用条件：】
【比较大小： ( =, , >, >=, , = )】
eq(R column, Object val); // 等价于 =，例: eq("name", "老王") ---> name = '老王'
ne(R column, Object val); // 等价于 ，例: ne("name", "老王") ---> name '老王'
gt(R column, Object val); // 等价于 >，例: gt("name", "老王") ---> name > '老王'
ge(R column, Object val); // 等价于 >=，例: ge("name", "老王") ---> name >= '老王'
lt(R column, Object val); // 等价于 ，例: lt("name", "老王") ---> name '老王'
le(R column, Object val); // 等价于 =，例: le("name", "老王") ---> name = '老王'
【范围：（between、not between、in、not in）】
between(R column, Object val1, Object val2); // 等价于 between a and b, 例： between("age", 18, 30) ---> age between 18 and 30
notBetween(R column, Object val1, Object val2); // 等价于 not between a and b, 例： notBetween("age", 18, 30) ---> age not between 18 and 30
in(R column, Object... values); // 等价于 字段 IN (v0, v1, ...),例: in("age",{1,2,3}) ---> age in (1,2,3)
notIn(R column, Object... values); // 等价于 字段 NOT IN (v0, v1, ...), 例: notIn("age",{1,2,3}) ---> age not in (1,2,3)
inSql(R column, Object... values); // 等价于 字段 IN (sql 语句), 例: inSql("id", "select id from table where id ) ---> id in (select id from table where id 3)
notInSql(R column, Object... values); // 等价于 字段 NOT IN (sql 语句)
【模糊匹配：（like）】
like(R column, Object val); // 等价于 LIKE '%值%'，例: like("name", "王") ---> name like '%王%'
notLike(R column, Object val); // 等价于 NOT LIKE '%值%'，例: notLike("name", "王") ---> name not like '%王%'
likeLeft(R column, Object val); // 等价于 LIKE '%值'，例: likeLeft("name", "王") ---> name like '%王'
likeRight(R column, Object val); // 等价于 LIKE '值%'，例: likeRight("name", "王") ---> name like '王%'
【空值比较：（isNull、isNotNull）】
isNull(R column); // 等价于 IS NULL，例: isNull("name") ---> name is null
isNotNull(R column); // 等价于 IS NOT NULL，例: isNotNull("name") ---> name is not null
【分组、排序：（group、having、order）】
groupBy(R... columns); // 等价于 GROUP BY 字段, ...， 例: groupBy("id", "name") ---> group by id,name
orderByAsc(R... columns); // 等价于 ORDER BY 字段, ... ASC， 例: orderByAsc("id", "name") ---> order by id ASC,name ASC
orderByDesc(R... columns); // 等价于 ORDER BY 字段, ... DESC， 例: orderByDesc("id", "name") ---> order by id DESC,name DESC
having(String sqlHaving, Object... params); // 等价于 HAVING ( sql语句 )， 例: having("sum(age) > {0}", 11) ---> having sum(age) > 11
【拼接、嵌套 sql：（or、and、nested、apply）】
or(); // 等价于 a or b， 例：eq("id",1).or().eq("name","老王") ---> id = 1 or na服务器托管网me = '老王'
or(ConsumerParam> consumer); // 等价于 or(a or/and b)，or 嵌套。例: or(i -> i.eq("name", "李白").ne("status", "活着")) ---> or (name = '李白' and status '活着')
and(ConsumerParam> consumer); // 等价于 and(a or/and b)，and 嵌套。例: and(i -> i.eq("name", "李白").ne("status", "活着")) ---> and (name = '李白' and status '活着')
nested(ConsumerParam> consumer); // 等价于 (a or/and b)，普通嵌套。例: nested(i -> i.eq("name", "李白").ne("status", "活着")) ---> (name = '李白' and status '活着')
apply(String applySql, Object... params); // 拼接sql（若不使用 params 参数，可能存在 sql 注入），例: apply("date_format(dateColumn,'%Y-%m-%d') = {0}", "2008-08-08") ---> date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")
last(String lastSql); // 无视优化规则直接拼接到 sql 的最后，可能存若在 sql 注入。
exists(String existsSql); // 拼接 exists 语句。例: exists("select id from table where age = 1") ---> exists (select id from table where age = 1)
【QueryWrapper 条件：】
select(String... sqlSelect); // 用于定义需要返回的字段。例： select("id", "name", "age") ---> select id, name, age
select(PredicateTableFieldInfo> predicate); // Lambda 表达式，过滤需要的字段。
lambda(); // 返回一个 LambdaQueryWrapper
【UpdateWrapper 条件：】
set(String column, Object val); // 用于设置 set 字段值。例: set("name", null) ---> set name = null
etSql(String sql); // 用于设置 set 字段值。例: setSql("name = '老李头'") ---> set name = '老李头'
lambda(); // 返回一个 LambdaUpdateWrapper```
（3）简单使用，测试一下 QueryWrapper
@Test
public void testQueryWrapper() {
// Step1：创建一个 QueryWrapper 对象
QueryWrapperUser> queryWrapper = new QueryWrapper>();
// Step2： 构造查询条件
queryWrapper
.select("id", "name", "age")
.eq("age", 20)
.like("name", "j");
// Step3：执行查询
userService
.list(queryWrapper)
.forEach(System.out::println);
}
常见使用方法查询：
/**
* 最简单的根据id查询
* p>
* ==> Preparing: SELECT id,version,age,gender,name,position,account,password,status,type,create_time,update_time FROM sys_user WHERE id=?
* ==> Parameters: 20(Integer)
*/
@Test
public void selectById() {
SysUser sysUser = sysUserMapper.selectById(20);
System.out.println("sysUser=" + sysUser);`在这里插入代码片`
}
/**
* 根据多个id批量查询
* p>
* ==> Preparing: SELECT id,version,age,gender,name,position,account,password,status,type,create_time,update_time FROM sys_user WHERE id IN ( ? , ? , ? , ? )
* ==> Parameters: 17(Integer), 18(Integer), 19(Integer), 20(Integer)
*/
@Test
public void selectBatchIds() {
ListInteger> asList = Arrays.asList(17, 18, 19, 20);
ListSysUser> sysUsers = sysUserMapper.selectBatchIds(asList);
System.out.println("list=" + sysUsers);
}
/**
* 条件构造器
*
* 1、名字中包含 东平 并且年龄小于等于30
* name like '%东平%' and age Preparing: SELECT id,version,age,gender,name,position,account,password,status,type,create_time,update_time FROM sys_user
* WHERE (name LIKE ? AND age Parameters: %东平%(String), 30(Integer)
*
* 备注:
* 等于的英语单词是:equals
* 小于的英文:less than
* le表示小于等于
* 同样的道理
* 大于的英文为 greater than
* gt 表示大于 >
* ge 表示大于等于 >=
*/
@Test
public void testQueryWrapper1() {
QueryWrapper queryWrapper = new QueryWrapperSysUser>();
queryWrapper.like("name", "东平");
queryWrapper.le("age", 30);
ListSysUser> sysUsers = sysUserMapper.selectList(queryWrapper);
System.out.println("list=" + sysUsers);
}
/**
* map条件查询
* 注意:map条件中的key是用数据库中的字段对应,而不是与java中的实体对应
* ==> Preparing: SELECT id,version,age,gender,name,position,account,password,status,type,create_time,update_time FROM sys_user WHERE name = ? AND age = ?
* ==> Parameters: 李东平(String), 18(String)
*/
@Test
public void selectByMap() {
MapString, Object> columnMap = new HashMap>();
columnMap.put("name", "李东平");
columnMap.put("age", "18");
// columnMap 拼接的条件为 WHERE name = ? AND age = ?
ListSysUser> sysUsers = sysUserMapper.selectByMap(columnMap);
System.out.println("list=" + sysUsers);
}
/**
* java实体作为条件
* ==> Preparing: SELECT id,version,age,gender,name,parent_id,position,account,password,status,type,create_time,update_time FROM sys_user WHERE age=? AND name=?
* ==> Param服务器托管网eters: 18(Integer), 张无忌(String)
*/
@Test
public void test2() {
SysUser sysUser = new SysUser().setName("张无忌").setAge(18);
QueryWrapper queryWrapper = new QueryWrapper(sysUser);
//queryWrapper.setEntity(sysUser);
List sysUsers = sysUserMapper.selectList(queryWrapper);
System.out.println("list=" + sysUsers);
}
常用使用方法连接：
https://www.cnblogs.com/l-y-h/p/12859477.html
服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net
相关推荐: 开发工具篇第二十一讲：详解业务日志监控工具Grafana
详解业务日志监控工服务器托管网具Grafana 本文是开发工具篇第21讲：对业务日志监控工具Grafana实战进行详解。grafana监控用于对业务日志的监控，统计业务日志某个字段的个数或者比例进行钉钉或者电话报警。 文章目录 详解业务日志监控工具Grafan…
