mybatisplus简单笔记(更新中)

官方文档MyBatis-Plus

PART1 初步配置

1.简单User表demo

User

id	name	sex
1	小良	W
2	小红	M

2.数据库SQL

DROP TABLE IF EXISTS user;
CREATE TABLE user
(
	id BIGINT(20) NOT NULL COMMENT '主键ID',
	name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
	sex VARCHAR(10) NULL DEFAULT NULL COMMENT '性别',
	PRIMARY KEY (id)
);


DELETE FROM user;
INSERT INTO user (id, name, sex) VALUES
(1, '小良', 'M'),
(2, '小红', 'W');

3.导入依赖

<dependency>
   <groupId>com.baomidou</groupId>
   <artifactId>mybatis-plus-boot-starter</artifactId>
   <version>3.4.3.1</version>
</dependency>

*一般引入plus后不再引入MyBatis依赖，避免版本差异冲突

4.yml文件配置

mybatis-plus:
  # 扫描实体类的路径
  type-aliases-package: com.example.mybatisplusdemo.entity
  # mapper xml文件地址
  mapper-locations: classpath:/mappers/*.xml
  configuration:
    # 配置将执行的sql打印出来，开发或测试的时候可用
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    # 查询出来的字段进行驼峰转换
    map-underscore-to-camel-case: true
    global-config:
      #主键类型  AUTO:"数据库ID自增", INPUT:"用户输入ID",ID_WORKER:"全局唯一ID (数字类型唯一ID)", UUID:"全局唯一ID UUID";
      id-type: AUTO
      #字段策略 IGNORED:"忽略判断",NOT_NULL:"非 NULL 判断"),NOT_EMPTY:"非空判断"
      field-strategy: NOT_EMPTY

      # 逻辑删除配置
      db-config:
        # 删除前
        logic-not-delete-value:
        # 删除后
        logic-delete-value:

*xml文件地址扫描也可以在启动类中加上注解

@MapperScan("com.test.mapper")

5.实体类User.java

@Data
public class User{
    private Long id;
    private String name;
    private String sex;
}

6.Mapper类UserMapper.java

public interface UserMapper extends BaseMapper<User> {

}

PART2 相关注解

常用的注解及属性（详细见官方文档）

1.表名注解@TableName(value = "表名，非必需", resultMap = "xml中resultMap的id，非必需")

2.主键注解@TableId(value="主键字段名，非必需", type="注解类型，非必需，默认IdType.NONE")

*IdType常用的值：AUTO 数据库id自增，NONE 无状态，INPUT插入前自行设置主键值，ASSIGN_ID 默认使用雪花算法分配Number类型id，ASSIGN_UUID 分配UUID为String类型id

3.非主键字段注解@TableField(value="数据库字段名，非必需",el="el表达式，相当于xml中#{...}非必需", exist="是否为表字段，默认true", typeHandler="类型处理器，默认UnknownTypeHandler.class", numericScale="指定小数保留位数")

4.乐观锁@Vervison

5.枚举字段@EnumValue

6.表字段逻辑删除@TableLogic

PART3 代码生成器

详细见官方文档代码生成器 | MyBatis-Plus(可先跳过)

PART4 结合Wrapper条件构造器的CURD

IService CURD接口

public interface IUserService extends IService<User> {

}

增Save

// 插入一条记录
boolean save(User user);
// 批量插入
boolean saveBatch(List<User> user);
// 制定数量的批量插入
boolean saveBatch(List<User> user, 3);

新增或更新SaveOrUpdate

// 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);

删除Remove

// 根据 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);

更新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);

查询Get

// 根据 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

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

分页查询Page

// 无条件分页查询 IPage<T>翻页对象
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);

记录统计查询Count

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

链式查询/更新（少用）

// 链式查询 普通
QueryChainWrapper<T> query();
// 链式查询 lambda 式。注意：不支持 Kotlin
LambdaQueryChainWrapper<T> lambdaQuery(); 

// 示例：
query().eq("column", value).one();
lambdaQuery().eq(Entity::getId, value).list();


// 链式更改 普通
UpdateChainWrapper<T> update();
// 链式更改 lambda 式。注意：不支持 Kotlin 
LambdaUpdateChainWrapper<T> lambdaUpdate();

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

BaseMapper CURD接口

public interface UserMapper extends BaseMapper<User> {

}

增Insert

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

删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);

改Update

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

查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);

条件构造器速查

AbstractWrapper是QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的父类，用于生成 sql 的 where 条件

对应的表demo

User

id	name	sex
1	小良	W
2	小红	M

1.allEq 通过一个Map构造多个相等的查询条件

allEq(Map<k,v> map)
allEq(Map<k,v> map, boolean n)
allEq(BiPredicate<r, v> filter, Map<k, v> map)
Map<k,v> k为数据库字段名，v为需要等于的值，n默认为true，构造条件is null，当n为false时，无视null值,filter为过来满足条件的字段

官方文档的例子：
allEq({id:1,name:"小良",sex:null}) => id = 1 and name = '小良' and sex is null
allEq({id:1,name:"小良",sex:null}, false) => id = 1 and name = '小良'
allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"小良",sex:null})--->name = '老王' //先过滤出满足含有a的字段，成为最终的查询条件

实际运用：
--构造条件为QueryWrapper
QueryWrapper<User> userQueryWrapper = Wrappers.query();
Map<String , Object> map = new HashMap<>();
map.put("id" , 1);
map.put("name" , "小良");
map.put("sex" , "M");
userQueryWrapper.allEq(map);
List<User> results = this.IUserService.list(userQueryWrapper);

--构造条件为LambdaQueryWrapper
LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>();
Map<SFunction<User, ?>, Object> params = new HashMap<>();
params.put(User::getName,"小良");
query.allEq(params);
List<User> results = this.IUserService.list(query);

2.eq/nq/gt... 构造单个相等/模糊查询等查询条件

【eq】 等于
eq("name","小良") -> name = '小良'

实际运用：
//查询名字等于小良的记录
//eq("name", "小良") -> name = '小良'
LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>();
query.eq(Use::getName,"小良"):
List<User> results = this.IUserService.list(query);

【ne】 不等于
//查询名字不等于小良的记录
//ne("name", "小良") -> name <> '小良'
LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>();
query.nq(User::getName,"小良"):
List<User> results = this.IUserService.list(query);

【gt】大于
//查询id大于1的记录
//gt("id", 1) -> id > 1
LambdaQueryWrapper<User> query = new LambdaQueryWrapper<>();
query.gt(User::getId,1):
List<User> results = this.IUserService.list(query);

同理
【ge】 大于等于
ge("id", 4) -> id >= 4

【lt】小于
lt("id",4) -> id < 4

【le】 小于等于
le("id",4) -> id <= 4

【between】 范围内
between("id", 1, 3) -> id between 1 and 3

【notBetween】 范围外
notBetween("id", 1, 3) -> id not between 1 and 3

【like】 模糊查询 包含某条件
like("name", "小") -> name like '%小%'

【notLike】 模糊查询 不包含某条件
notLike("name", "小") -> name not like '%小%'

【likeLeft】 模糊查询 以条件结尾
likeLeft("name", "小") -> name like '%小'

【likeRight】 模糊查询 以条件开头
likeRight("name", "小") -> name like '小%'

【isNull】 为空
isNull("name") -> name is null

【isNotNull】 不为空
isNotNull("name") -> name is not null


【in】 在指定值中
in("id",{1,2,3}) -> id in (1,2,3)

【notIn】 不在指定的值中
notIn("id",{1,2,3}) -> id not in (1,2,3)


【inSql】 在子查询的结果中
inSql("id", "1,2,3") -> id in (1,2,3)
inSql("id", "select id from otherUser where id < 3") -> id in (select id from otherUser where id < 3)

【notInSql】 不在子查询的结果中
notInSql("id", "1,2,3") -> id not in (1,2,3)
例: notInSql("id", "select id from otherUser where id < 3") -> id not in (select id from otherUser where id < 3)

【groupBy】结合聚合函数,根据一个或多个列对结果集进行分组
groupBy("id", "name") -> group by id,name

【orderBy/orderByAsc】升序排序
orderBy("id", "name") -> order by id ASC,name ASC
orderByAsc("id", "name") -> order by id ASC,name ASC

【orderByDesc】降序排序
orderByDesc("id", "name") -> order by id DESC,name DESC

【having】为分组提供条件
having("sum(id) > 10") -> having sum(id) > 10
having("sum(id) > {0}", 11)--->having sum(age) > 11

【func】结合if else来选择不同的条件
func(i -> if(true) {i.eq("id", 1)} else {i.ne("id", 1)})

【or连接】下一条语句为or连接（都不写则默认是两条语句间为and连接）
eq("id",1).or().eq("name","小良") -> id = 1 or name = '小良'
对比eq("id",1).eq("name","小良") -> id =1 and name = '小良'

【or嵌套】
or(i -> i.eq("name", "小良").ne("id", 1)) -> or (name = '小良' and id <> 1)

【and连接】两条语句间为and连接
eq("id",1).eq("name","小良") -> id =1 and name = '小良'

【and嵌套】
and(i -> i.eq("name", "小良").ne("id", 1)) -> and (name = '李白' and status <> '活着')