Spring Boot MyBatis Plus 增删改查
文章目录
一、环境准备
1.1 配置日志
application.yml
# 主要便于输出生成的SQL语句,不是必需项。
logging:
level:
root: warn
com.mp.dao: trace
pattern:
console: '%p%m%n'
1.2 工程结构
基于 Spring Boot MyBatis Plus 快速入门基础上,实现CRUD测试功能。

二、插入数据
insertTest.java
package com.mp;
import ...
@RunWith(SpringRunner.class)
@SpringBootTest
public class InsertTest {
@Autowired
private UserMapper userMapper;
@Test
public void insert() {
User user = new User();
user.setName("刘明强");
user.setAge(31);
user.setManagerId(1088248166370832385L);
user.setCreateTime(LocalDateTime.now());
int rows = userMapper.insert(user);
System.out.println("影响记录数:"+rows);
// 获取插入后的id(后来手动编写,未测试)
Long id = user.getId();
System.out.println("新纪录的ID:"+id);
}
}
运行结果:
三、删除数据
3.1 根据id删除
int deleteById(Serializable id)
根据 ID 删除,id 主键ID。
public void deleteByIds() {
int rows = userMapper.deleteById(1094592041087729666L);
System.out.println("删除条数:"+rows);
}
3.2 普通删除
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap)
根据 columnMap 条件,删除记录。columnMap 表字段 map 对象。
@Test
public void deleteByMap() {
Map<String,Object> columnMap = new HashMap<>();
columnMap.put("name", "王天风");
columnMap.put("age", 26);
int rows = userMapper.deleteByMap(columnMap);
System.out.println("删除条数:"+rows);
}
3.3 批量删除
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList)
删除(根据ID 批量删除),idList 主键ID列表(不能为 null 以及 empty)。
@Test
public void deleteBatchIds() {
List<Long> listIds = Arrays.asList(
1087982257332887553L,
1088248166370832385L,
1094590409767661570L);
int rows = userMapper.deleteBatchIds(listIds);
System.out.println("删除条数:"+rows);
}
3.3 以条件构造器作为参数的删除
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper)
根据 entity 条件,删除记录。wrapper 实体对象封装操作类(可以为 null)。
public void deleteByWrapper() {
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getAge,27);
int rows = userMapper.delete(lambdaQueryWrapper);
System.out.println("删除条数:"+rows);
}
四、修改数据
4.1 根据id更新
int updateById(@Param(Constants.ENTITY) T entity)
根据 ID 修改,entity 实体对象。
public void updateByIds() {
User user = new User();
user.setId(1088248166370832385L);
user.setAge(26);
user.setEmail("wtf2@baomidou.com");
int rows = userMapper.updateById(user);
System.out.println("影响记录数:" + rows);
}
4.2 以条件构造器作为参数的更新
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper)
根据 whereEntity 条件,更新记录。
@Test
public void updateByWrapper() {
User user = new User();
user.setAge(29);
user.setEmail("lyw2019@baomidou.com");
UpdateWrapper<User> updateWrapper = new UpdateWrapper<User>();
updateWrapper.eq("name", "李艺伟").eq("age", 28);
int rows = userMapper.update(user, updateWrapper);
System.out.println("影响记录数:" + rows);
}
4.3 set语句更新
/**
* 适用于更新少量字段
*/
@Test
public void updateBySet() {
UpdateWrapper<User> updateWrapper = new UpdateWrapper<User>();
updateWrapper.eq("name", "李艺伟").set("age", 30);
int rows = userMapper.update(null, updateWrapper);
System.out.println("影响记录数:" + rows);
}
4.4 lambda更新
/**
* lambda更新
*/
@Test
public void updateByLambda() {
LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<User>();
lambdaUpdateWrapper.eq(User::getName, "李艺伟").set(User::getAge, 29);
int rows = userMapper.update(null, lambdaUpdateWrapper);
System.out.println("影响记录数:" + rows);
}
五、查询数据
5.1 普通查询
1. T selectById(Serializable id)
根据 ID 查询,id为主键ID。
@Test
public void selectById() {
User user = userMapper.selectById(1094590409767661570L);
System.out.println(user);
}
2. List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList)
查询(根据ID 批量查询),idList 主键ID列表(不能为 null 以及 empty)。
public void selectBatchIds() {
List<Long> idsList = Arrays.asList(
1088248166370832385L,
1094592041087729666L,
1094590409767661570L);
List<User> userList = userMapper.selectBatchIds(idsList);
userList.forEach(System.out::println);
}
3. List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap)
查询(根据 columnMap 条件),columnMap 表字段 map 对象。
public void selectByMap() {
// map的key为表中的列字段名
// map.put("name","王天风")
// map.put("age",25)
// where name="王天风" and age=30
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("name", "王天风");
columnMap.put("age", 25);
List<User> userList = userMapper.selectByMap(columnMap);
userList.forEach(System.out::println);
}
5.2 以条件构造器作为参数的查询
1. T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper)
根据 entity 条件,查询一条记录。queryWrapper 实体对象封装操作类(可以为 null)。
/**
* 查询结果仅返回一条或零条记录,多条结果则报错。
*/
@Test
public void selectOne() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "刘红雨");
User user = userMapper.selectOne(queryWrapper);
System.out.println(user);
}
2. Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper)
根据 Wrapper 条件,查询总记录数。queryWrapper 实体对象封装操作类(可以为 null)。
/**
* 获取记录数
*/
@Test
public void selectCount() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "雨");
Integer count = userMapper.selectCount(queryWrapper);
System.out.println("共有"+count+"条记录姓名包含‘雨’");
}
3. List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper)
根据 entity 条件,查询全部记录。queryWrapper 实体对象封装操作类(可以为 null)。
/**
* 1.名字中包含雨并且年龄小于40
* name like '%雨%' and age<40
*/
@Test
public void selectByWrapper() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "雨").lt("age", 40);
List<User> userlist = userMapper.selectList(queryWrapper);
userlist.forEach(System.out::println);
}
/**
* 2.名字中包含雨并且年龄大于等于20且小于等于40并且email不为空
* name like '%雨%' and age between 20 and 40 and email is not null
*/
queryWrapper.like("name", "雨").between("age",20,40).isNotNull("email");
List<User> userList = userMapper.selectList(queryWrapper);
/**
* 3.名字为王姓或者年龄大于等于25,按照年龄降序排列,年龄相同按照id升序排列
* name like '王%' or age>=25 order by age desc, id asc
*/
queryWrapper.likeRight("name", "王").or().ge("age",25)
.orderByDesc("age").orderByAsc("id");
List<User> userList = userMapper.selectList(queryWrapper);
/**
* 4.创建日期为2019年2月14日并且直属上级名字为王姓(apply方式防止sql注入)
* date_format(create_time,'%Y-%m-%d') and manager_id in
* (select id from user where name like '王%')
*/
queryWrapper.apply("date_format(create_time, '%Y-%m-%d')={0}", "2019-02-14")
.inSql("manager_id", "select id from user where name like '王%'");
List<User> userList = userMapper.selectList(queryWrapper);
/**
* 5.名字为王姓并且(年龄小于40或者邮箱不为空)
* name like '王%' and (age<40 or email is not null)
*/
queryWrapper.likeRight("name","王")
.and(s->s.lt("age",40).or().isNotNull("email"));
List<User> userList = userMapper.selectList(queryWrapper);
/**
* 6.名字为王姓或者(年龄小于40并且年龄大于20并且邮箱不为空)
* name like '王%' or (age<40 and age>20 and email is not null)
*/
queryWrapper.likeRight("name", "王")
.or(s->s.lt("age",40).gt("age",20).or().isNotNull("email"));
List<User> userList = userMapper.selectList(queryWrapper);
/**
* 7.(年龄小于40或邮箱不为空)并且名字为王姓
* (age<40 or email is not null) and name like '王%'
*/
queryWrapper.nested(s->s.lt("age",40).or().isNotNull("email"))
.likeRight("name","王%");
List<User> userList = userMapper.selectList(queryWrapper);
/**
* 8.年龄为30、31、34、35
* age in (30,31,34,35)
*/
queryWrapper.in("age", Arrays.asList(30,31,34,35));
List<User> userList = userMapper.selectList(queryWrapper);
/**
* 9.只返回满足条件的一种一条语句即可
* limit 1
*/
queryWrapper.in("age", Arrays.asList(30,31,34,35))
.last("limit 1");
List<User> userList = userMapper.selectList(queryWrapper);
4. List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper)
根据 Wrapper 条件,查询全部记录。queryWrapper 实体对象封装操作类(可以为 null)。
/**
* 返回map集合,可用于json等。
*/
@Test
public void selectMaps() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("id", "name");
List<Map<String,Object>> userList = userMapper.selectMaps(queryWrapper);
userList.forEach(System.out::println);
}
# 运行结果
{name=大boss, id=1087982257332887553}
{name=王天风, id=1088248166370832385}
{name=李艺伟, id=1088250446457389058}
{name=张雨琪, id=1094590409767661570}
{name=刘红雨, id=1094592041087729666}
/**
* 按直属上级分组,查询每组的最大年龄、平均年龄、最小年龄,且只取年龄综合小于500的组
* select max(age) max_age, avg(age) avg_age, min(age) min_age
* from user
* group by manager_id
* having sum(age) < 500
*/
@Test
public void selectMaps32() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("max(age) max_age","avg(age) avg_age", "min(age) min_age")
.groupBy("manager_id")
.having("sum(age)<{0}",500);
List<Map<String,Object>> userList = userMapper.selectMaps(queryWrapper);
userList.forEach(System.out::println);
}
# 运行结果
{max_age=40, avg_age=40.0000, min_age=40}
{max_age=25, avg_age=25.0000, min_age=25}
{max_age=32, avg_age=30.3333, min_age=28}
5. List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper)
根据 Wrapper 条件,查询全部记录。只返回第一个字段的值。
5.3 Select不列出全部字段
/**
* 1、结果只返回指定的字段列
*/
@Test
public void selectByWrapper10() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("id", "name").like("name","雨");
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
/**
* 2、结果只返回排除的字段列
*/
@Test
public void selectByWrapper22() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select(User.class, info->
!info.getColumn().equals("create_time") &&
!info.getColumn().equals("manager_id")).like("name","雨");
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
5.4 condition作用
/**
* condition用法
* name 不为空: 执行匹配查询,否则忽略
* email不为空: 执行匹配查询,否则忽略
*/
@Test
public void selectByWrapperCondition() {
// 只搜索邮箱中包含‘x’字符的记录
String name = "", email = "w";
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like(StringUtils.isNotBlank(name), "name", name)
.like(StringUtils.isNotBlank(email), "email", email);
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
5.5 实体作为条件构造器构造方法的参数
/**
* 默认等值匹配,适用前台直接传递过来的对象
*/
@Test
public void selectByWrapperEntity() {
User user = new User();
user.setName("刘红雨");
user.setAge(32);
QueryWrapper<User> queryWrapper = new QueryWrapper<>(user);
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
5.6 Lambda条件构造器
/**
* Lambda条件构造器,适用于以对象类为中心。
*/
@Test
public void selectLambda() {
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(User::getName, "雨").lt(User::getAge, 40);
List<User> userList = userMapper.selectList(lambdaQueryWrapper);
userList.forEach(System.out::println);
}
六、常用注解
@TableName
实体类与数据库表名不一致时,可通过该注解显式指定。
# 数据库名称
mp_user
# 通过注解指定关联
@TableName("mp_user")
public class User {
}
@TableId
实体类与表主键字段名不一致时,可通过该注解显式指定。
# 手动更改user主键'id'=>'fk'
fk 为主键
# 通过注解指定关联
public class User {
@TableId("fk")
private Long id;
}
@TableField
实体类与表内字段不一致时,可通过该注解显式指定。
# 数据库表字段name表示姓名
name
# 通过注解指定关联
public class User {
@TableField("name")
private String realName;
}
指定实体类某些字段不保存至数据库
# 实体类
public class User {
// 指定数据库不存在该字段
@TableField(exist=false)
private String remark;
}
# 正常调用
public void insert() {
User user = new User();
user.setRemark("该段信息不会保存至数据库");
}
指定实体作为条件构造器构造方法参数时某些字段的匹配模式
# 实体类
public class User {
@TableField(condition = SqlCondition.LIKE)
private String name;
# 获取姓名中包含“雨”的所有记录
public void selectByWrapperEntity() {
User user = new User();
user.setName("雨");
QueryWrapper<User> queryWrapper = new QueryWrapper<>(user);
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论