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测试功能。

image.png

二、插入数据

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

运行结果:
image.png

三、删除数据

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

评论

暂无评论