MyBatis-Plus Service CRUD 接口测试

　　使用 users 表测试 MyBatis-Plus Service CRUD 接口方法，Git地址

MySQL数据库

users 表结构展示

 sql

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for users
-- ----------------------------
DROP TABLE IF EXISTS `users`;
CREATE TABLE `users`  (
  `id` int(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '姓名',
  `age` int(0) NULL DEFAULT NULL COMMENT '年龄',
  `birthday` date NULL DEFAULT NULL COMMENT '出生日期',
  `job_number` char(7) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '工号',
  `address` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '所在地',
  `remark` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

实体类(Lombok)

实体类

@Setter
@Getter
@Accessors(chain = true)
@TableName("users")
@ToString
public class Users {

    /**
     * 主键
     */
    @TableId
    private Integer id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 年龄
     */
    private Integer age;

    /**
     * 出生日期
     */
    private LocalDate birthday;

    /**
     * 工号
     */
    private String jobNumber;

    /**
     * 所在地
     */
    private String address;

    /**
     * 备注
     */
    private String remark;

}

 lombok依赖

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

Mapper

@Mapper
public interface UserMapper extends BaseMapper<Users> {


}

Service

public interface UserService extends IService<Users> {

}

ServiceImpl

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, Users> implements UserService {

}

Service CRUD 接口

 自动创建 user 工具类

public class GenerateUsersUtil {

    /**
     * 创建用户
     *
     * @param size   创建列表大小
     * @param remark 设置备注信息
     * @return java.util.List<me.mrniurh.mybatisplustest.entity.Users>
     */
    public static List<Users> generateUserList(Integer size, String remark) {

        List<Users> userList = new ArrayList<>();
        if (ObjectUtils.isEmpty(size) || size <= 0) {
            return userList;
        }
        // 添加随机用户信息
        for (int i = 0; i < size; i++) {

            Random random = new Random();

            userList.add(new Users().setAge(25)
                    .setName("Test" + random.nextInt(1000))
                    .setBirthday(LocalDate.of(1996, random.nextInt(11) + 1, random.nextInt(27) + 1))
                    .setAddress("Test")
                    .setJobNumber("MP" + String.format("%05d", random.nextInt(99999)))
                    .setRemark(remark));
        }
        return userList;

    }
}

至此准备工作结束，下面是一些测试方法

Save

方法

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

测试

@SpringBootTest
public class saveTests {

    @Resource
    UserService userService;

    @Test
    void insertOneUserTest() {

        // 单条记录新增
        Users user = new Users()
                .setAge(25)
                .setName("Frank")
                .setBirthday(LocalDate.of(1996, 5, 4))
                .setAddress("福建")
                .setJobNumber("MP00006")
                .setRemark("Test");
        userService.save(user);

    }

    @Test
    public void batchInsetTest() {

        // 批量新增
        // 100 个随机用户
        List<Users> userList = GenerateUsersUtil.generateUserList(100, "batchInsertTest");
        userService.saveBatch(userList);

    }

    @Test
    public void batchInsertWithSizeTest() {

        // 批量新增
        // 1000 个随机用户
        List<Users> userList = GenerateUsersUtil.generateUserList(1000, "batchInsertWithSizeTest");
        userService.saveBatch(userList, 200);

    }

}

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

测试

@SpringBootTest
public class SaveOrUpdateTests {

    @Resource
    UserService userService;


    @Test
    public void saveOrUpdateTest() {

        // 更新数据
        Users user = userService.getById(1);
        user.setRemark("saveOrUpdateTest");
        userService.saveOrUpdate(user);

        // 新增数据
        Users user2 = new Users()
                .setAge(25)
                .setName("Jim")
                .setBirthday(LocalDate.of(1997, 5, 4))
                .setAddress("Test")
                .setJobNumber("MP00006")
                .setRemark("saveOrUpdateTestNew");

        /**
         * 对于有 id 的数据会首先查询是否该 id 在数据库中存在，存在则更新，不存在该 id 或 id 为空则直接新增
         */
        userService.saveOrUpdate(user2);

    }

    @Test
    public void saveOrUpdateByWrapperTest() {

        UpdateWrapper<Users> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("address", "北京")
                .set("remark", "saveOrUpdateByWrapperTest");


        Users user = userService.getById(1);
        user.setAge(35);
        user.setRemark("测试");
        /**
         * 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
         * 如果根据 wrapper 不能更新成功，就会直接按照 user 更新,若根据 wrapper 能够更新成功，则更新结束
         *
         * 源码：default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper) {
         *         return this.update(entity, updateWrapper) || this.saveOrUpdate(entity);
         *     }
         */
        userService.saveOrUpdate(user, updateWrapper);
    }

    @Test
    public void saveOrUpdateBatchTest() {

        List<Users> allUsers = new ArrayList<>();

        // 更新用户列表
        List<Users> updateUsers = userService.lambdaQuery().between(Users::getId, 100, 300).list();
        updateUsers.forEach(user -> user.setRemark("saveOrUpdateBatchTest"));

        // 新增用户列表
        List<Users> insertUsers = GenerateUsersUtil.generateUserList(200, "saveOrUpdateBatchTest");

        allUsers.addAll(updateUsers);
        allUsers.addAll(insertUsers);

        userService.saveOrUpdateBatch(allUsers);
    }

    @Test
    public void saveOrUpdateBatchWithSizeTest() {

        List<Users> allUsers = new ArrayList<>();

        // 新增用户列表
        List<Users> insertUsers = GenerateUsersUtil.generateUserList(400, "saveOrUpdateBatchTest");

        // 更新用户列表
        List<Users> updateUsers = userService.lambdaQuery().between(Users::getId, 500, 800).list();
        updateUsers.forEach(user -> user.setRemark("saveOrUpdateBatchTest"));


        allUsers.addAll(updateUsers);
        allUsers.addAll(insertUsers);

        userService.saveOrUpdateBatch(allUsers, 220);
    }

}

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

测试 

@SpringBootTest
public class RemoveTest {

    @Resource
    UserService userService;


    @Test
    public void removeTest() {

        // 根据 wrapper 删除
        QueryWrapper<Users> wrapper = new QueryWrapper<>();
        wrapper.lambda().between(Users::getId, 3230, 3260);

        userService.remove(wrapper);
    }

    @Test
    public void removeByIdTest() {
        // 根据 id 删除
        userService.removeById(3220);
    }

    @Test
    public void removeByMapTest() {

        Map<String, Object> map = new HashMap<>();
        map.put("id", 3215);
        map.put("address", "Test");

        userService.removeByMap(map);

        /**
         * ==>  Preparing: DELETE FROM users WHERE address = ? AND id = ?
         * ==> Parameters: Test(String), 3215(Integer)
         * <==    Updates: 1
         */
    }

    @Test
    public void removeByIdsTest() {

        // 根据 id 批量删除
        List<Integer> ids = new ArrayList() {{
            add(3212);
            add(3213);
        }};

        userService.removeByIds(ids);

        /**
         * ==>  Preparing: DELETE FROM users WHERE id IN ( ? , ? )
         * ==> Parameters: 3212(Integer), 3213(Integer)
         * <==    Updates: 2
         */
    }

}

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

测试 

@SpringBootTest
public class UpdateTests {

    @Resource
    UserService userService;

    @Test
    public void updateTest() {

        UpdateWrapper<Users> updateWrapper = new UpdateWrapper<>();
        updateWrapper.between("birthday", "1996-10-01", "1996-12-31")
                .set("remark", "updateTest");
        userService.update(updateWrapper);
    }

    @Test
    public void updateByEntityAndWrapper() {

        // 根据 whereWrapper 条件，更新记录
        Users user = userService.getById(3225);

        UpdateWrapper<Users> updateWrapper = new UpdateWrapper<>();
        updateWrapper.between("birthday", "1996-01-01", "1996-03-31")
                .set("remark", "updateByEntityAndWrapper");
        userService.update(user, updateWrapper);

    }

    @Test
    public void updateByIdTest() {
        // // 根据 ID 选择修改
        Users user = userService.getById(4107);
        user.setRemark("updateByIdTest");
        userService.updateById(user);
    }

    @Test
    public void updateBatchByIdTest() {

        // 根据ID 批量更新
        List<Users> users = userService.lambdaQuery().between(Users::getBirthday, "1996-01-01", "1996-06-30").list();
        users.forEach(user -> user.setRemark("updateBatchByIdTest"));

        userService.updateBatchById(users);
    }

    @Test
    public void updateBatchByIdWithSizeTest() {
        // 根据ID 批量更新
        List<Users> users = userService.lambdaQuery().between(Users::getBirthday, "1996-07-01", "1996-12-31").or(i -> i.eq(Users::getBirthday, "2016-06-30")).list();
        users.forEach(user -> user.setRemark("updateBatchByIdWithSizeTest"));

        userService.updateBatchById(users, 100);
    }
}

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

测试

@SpringBootTest
public class GetTests {

    @Resource
    UserService userService;

    @Test
    public void getByIdTest() {

        // 根据 ID 查询
        Users user = userService.getById(4107);
        System.err.println(user);
    }

    @Test
    public void getOneTest() {
        // 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
        Users user = userService.getOne(Wrappers.<Users>lambdaQuery().eq(Users::getId, 4107));
        System.err.println(user);
    }

    @Test
    public void getOneWithThrowFlagTest() {
        // 根据 Wrapper，查询一条记录,false 不报错，选择第一条，true报错
        Users user = userService.getOne(Wrappers.<Users>lambdaQuery().ge(Users::getId, 4107), false);
        System.err.println(user);
    }

    @Test
    public void getMapTest() {

        // 根据 Wrapper，查询一条记录,多条记录会显示第一条
        Map<String, Object> map = userService.getMap(Wrappers.<Users>lambdaQuery().ge(Users::getId, 4130));
        System.err.println(map.get("birthday"));
    }

    @Test
    public void getObjTest() {
        // 根据 Wrapper，查询一条记录,多条记录会显示第一条
        Integer id = userService.getObj(Wrappers.<Users>lambdaQuery().eq(Users::getId, 4130), o -> Integer.parseInt(o.toString()));
        System.err.println(id);
    }


}

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

测试

@SpringBootTest
public class ListTests {

    @Resource
    UserService userService;

    @Test
    public void listTest() {
        // 查询所有
        List<Users> list = userService.list();
        System.err.println(list);
    }

    @Test
    public void listByWrapperTest() {
        // 根据 wrapper 查询列表
        List<Users> list = userService.list(Wrappers.<Users>lambdaQuery().between(Users::getId, 4100, 4200));
        System.err.println(list);
    }

    @Test
    public void listByIdsTest() {
        // 查询（根据ID 批量查询）
        List<Integer> ids = new ArrayList() {{
            add(4107);
            add(4108);
        }};
        List<Users> list = userService.listByIds(ids);
        System.err.println(list);
    }

    @Test
    public void listByMapTest() {
        // 查询（根据 columnMap 条件）
        Map<String, Object> map = new HashMap() {{
            put("address", "Test");
            put("remark", "updateBatchByIdTest");
        }};

        List<Users> list = userService.listByMap(map);
        System.err.println(list);
    }

    @Test
    public void listMapsTest() {
        // 查询所有列表
        List<Map<String, Object>> maps = userService.listMaps();
        System.err.println(maps);
    }

    @Test
    public void listMapsByWrapperTest() {
        // 通过 wrapper 查询列表
        List<Map<String, Object>> maps = userService.listMaps(Wrappers.<Users>lambdaQuery().between(Users::getId, 4100, 4200));
        System.out.println(maps);
    }

    @Test
    public void listObjsTest() {
        // 查询全部记录 id
        List<Object> objs = userService.listObjs();
        System.err.println(objs);
    }

    @Test
    public void listObjsByMapperTest() {
        // 查询全部记录 id,加类型转换
        List<Integer> ids = userService.listObjs(o -> Integer.parseInt(o.toString()));
        System.err.println(ids);
    }

    @Test
    public void listObjsByWrapperTest() {
        // 根据 Wrapper 条件，查询全部记录
        List<Object> list = userService.listObjs(Wrappers.<Users>lambdaQuery()
                .between(Users::getId, 4100, 4200).last("limit 10"));
        System.err.println(list);
    }

    @Test
    public void listObjsByWrapperAndMapper() {
        // 根据 Wrapper 条件，查询全部记录
        List<Integer> list = userService.listObjs(Wrappers.<Users>lambdaQuery()
                        .between(Users::getId, 4100, 4200),
                o -> Integer.parseInt(o.toString()));
        System.err.println(list);
    }

}

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

测试 

@SpringBootTest
public class PageTests {

    @Resource
    UserService userService;

    @Test
    public void pageTest() {
        // 查询总记录数
        Page list = userService.page(new Page<>());
        System.err.println("records:" + list.getRecords());
        System.err.println("current:" + list.getCurrent());
    }

    @Test
    public void pageByWrapperTest() {
        // 条件分页查询
        Page list = userService.page(new Page<>(), Wrappers.<Users>lambdaQuery().between(Users::getId, 4100, 4200));
        System.err.println("records:" + list.getRecords());
        System.err.println("current:" + list.getCurrent());
    }

    @Test
    public void pageMapsTest() {
        // 无条件分页查询
        Page<Map<String, Object>> list = userService.pageMaps(new Page<>());
        System.err.println("records:" + list.getRecords());
        System.err.println("current:" + list.getCurrent());
    }

    @Test
    public void pageMapsByWrapperTest() {
        // 条件分页查询
        Page list = userService.pageMaps(new Page<>(), Wrappers.<Users>lambdaQuery().between(Users::getId, 4100, 4200));
        System.err.println("records:" + list.getRecords());
        System.err.println("current:" + list.getCurrent());
    }
}

Count

方法 

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

测试 

@SpringBootTest
public class CountTests {

    @Resource
    UserService userService;

    @Test
    public void countTest() {
        // 查询总记录数
        Integer count = userService.count();
        System.err.println("count:" + count);
    }

    @Test
    public void countByWrapperTest() {
        // 根据 Wrapper 条件，查询总记录数
        Integer count = userService.count(Wrappers.<Users>lambdaQuery()
                .between(Users::getId, 4100, 4200));
        System.err.println("count:" + count);
    }

}

saveOrUpdate(T entity, Wrapper<T> updateWrapper) 和 update(T updateEntity, Wrapper<T> whereWrapper)

saveOrUpdate(T entity, Wrapper<T> updateWrapper)

　　根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法（只会执行一个方法，两者之间是或的关系，根据 wrapper 更新的方法先执行）

update(T updateEntity, Wrapper<T> whereWrapper)

　　根据 whereWrapper 条件，更新记录，更新内容为 updateEntity 中的属性，若 whereWrapper 中有 set,则在 whereWrapper 设置的属性值会覆盖掉 updateEntity 中的属性值。