MybatisPlus

Spring相关注解

@TableName是mybatis-plus中的注解，主要是实现实体类型和数据库中的表实现映射,在对象中添加@TableName，指定数据库表名.

@TableId :将数据库的主键与之映射,在调用mplus中继承的baseMapper封装的方法时,如果不指定该主键,则传入id无效查询,结果为null(例如baseMapper的getOne(参数为id))

//AUTO自增,根据当前表中id最大值自增+1
@TableId(type = IdType.Auto)
private Long id;
//NONE,MP set主键,雪花算法实现:数据类型为long,数据库表的长度要改
@TableId(type = IdType.NONE)
private Long id;
//开发者手动赋值 INPUT,如果没有对id进行赋值,那么存进数据库中为0(long)
@TableId(type = IdType.INPUT)
private Long id;
//ASSIGN_ID 使用mp自动赋值 采取雪花算法
//ASSIGN_UUID  要求主键类型必须是String类型,会自动生成UUID进行赋值

@TableField注解可以指定字段的一些属性，常常解决的问题有2个：
1、对象中的属性名和字段名不一致的问题（非驼峰）
2、对象中的属性字段在表中不存在的问

@TableField(value="email")//解决字段名不一致
private String mail;
@TableField(exist=false)//该字段在数据库表中不存在
private String address;
@TableField(select=false)//大字段不加入查询
private String password;

SpringBoot相关配置

#MyBatis 配置文件位置.
mybatis-plus.config-location = classpath:mybatis-config.xml
#MyBatis Mapper 所对应的 XML 文件位置.
mybatis-plus.mapper-locations = classpath*:mybatis/*.xml
#别名包扫描路径，注册后在 Mapper 对应的 XML 文件中可以直接使用类名
mybatis-plus.type-aliases-package = cn.itcast.mp.pojo
#关闭自动驼峰映射，该参数不能和mybatis-plus.config-location同时存在
mybatis-plus.configuration.map-underscore-to-camel-case=false
#全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存，默认为 true。
mybatis-plus.configuration.cache-enabled=false
#全局默认主键类型，设置后，即可省略实体对象中的@TableId(type = IdType.AUTO)配置。
mybatis-plus.global-config.db-config.id-type=auto
#表名前缀，全局配置后可省略@TableName()配置。
mybatis-plus.global-config.db-config.table-prefix=tb_

BaseMapper通用CRUD

1.插入

int result = this.baseMapper.insert(user); //返回的result是受影响的行数，并不是自增后的id

2.更新

//updateById 根据id更新，更新不为null的字段
this.baseMapper.updateById(user);

// update(QueryWrapper)更新的条件
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("id", 6);
//执行更新操作
int result = this.baseMapper.update(user, wrapper);

//update(UpdateWrapper)更新的条件以及字段
UpdateWrapper<User> wrapper = new UpdateWrapper<>();
wrapper.eq("id", 6).set("age", 23);
//执行更新操作
int result = this.baseMapper.update(null, wrapper);

3.删除

//deleteById 执行删除操作
int result = this.baseMapper.deleteById(6L);

//deleteByMap 将columnMap中的元素设置为删除的条件多个之间为and关系
int result = this.userMapper.deleteByMap(columnMap);

//deleteBatchIds 将实体对象进行包装，包装为操作条件
QueryWrapper<User> wrapper = new QueryWrapper<>(user);
int result = this.userMapper.delete(wrapper);
//根据id集合批量删除
int result = this.userMapper.deleteBatchIds(Arrays.asList(1L,10L,20L));

4.查询

//selectBatchIds 根据id查询数据
User user = this.userMapper.selectById(2L);
List<User> users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 10L));

//selectOne
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.eq("name", "李四");
//根据条件查询一条数据，如果结果超过一条会报错
User user = this.userMapper.selectOne(wrapper);

//selectCount 根据条件查询数据条数
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.gt("age", 23); //年龄大于23岁
Integer count = this.userMapper.selectCount(wrapper);

//selectList 根据 entity 条件，查询全部记录
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.gt("age", 23); //年龄大于23岁
//根据条件查询数据
List<User> users = this.baseMapper.selectList(wrapper);

// selectPage 根据 entity 条件，查询全部记录（并翻页）,需安装插件
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.gt("age", 20); //年龄大于20岁
Page<User> page = new Page<>(1,1);
//根据条件查询数据
IPage<User> iPage = this.baseMapper.selectPage(page, wrapper);

IService通用CRUD

1.Save

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

2.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);

3.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);

4.Update

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

5.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);

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

// 无条件分页查询
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);

9.Chain

// 链式查询 普通
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);

条件构造器

allEq

//个别参数说明: params : key 为数据库字段名, value 为字段值 a : 为 true 则在 map 的 value 为null 时调用 isNull 方法,为 false 时则忽略 value 为 null 的
allEq(Map<R, V> params)
allEq(Map<R, V> params, boolean a)
allEq(boolean condition, Map<R, V> params, boolean a)

基本比较操作

//eq(等于=),ne(不等于<>),gt(打于>),ge(大于等于>=),lt(小于<),le(小于等于<=),between(BETWEEN 值1 AND 值2),notBetween(同上),in(字段 IN (value.get(0), value.get(1), ...)),notIn(同上)
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("password", "123456")
.ge("age", 20)
.in("name", "李四", "王五", "赵六");

模糊查询

like -> LIKE ‘%值%‘
notLike -> NOT LIKE ‘%值%‘
likeLeft -> LIKE ‘%值‘
likeRight -> LIKE ‘值%‘
wrapper.like("name", "曹");

排序

orderBy -> 排序：ORDER BY 字段, ...
orderByAsc -> 排序：ORDER BY 字段, ... ASC
orderByDesc -> 排序：ORDER BY 字段, ... DESC
wrapper.orderByDesc("age");

逻辑查询

or -> OR
主动调用 or 表示紧接着下一个方法不是用 and 连接!(不调用 or 则默认为使用 and 连接)

and -> AND 嵌套
例: and(i -> i.eq("name", "李白").ne("status", "活着")) ---> and (name = ‘李白‘ and status <> ‘活着‘)

groupBy

groupBy("id", "name")
    //—>group by id,name

having

having("sum(age) > 10")
    //—>having sum(age) > 10

select(进行指定字段查询)

wrapper.eq("name", "李四").or().eq("age", 24)
.select("id", "name", "age");

inSql

inSql("id", "select id from table where id < 3")
    //—>id in (select id from table where id < 3)
    //notInSql同上

exists

exists("select id from table where age = 1")
    //—>exists (select id from table where age = 1)
    //notExists

mybatis-plus学习