MyBatis-Plus中使用BaseMapper实现基本CRUD
MyBatis-Plus中的基本CRUD在内置的BaseMapper中都已得到了实现，我们可以直接使用，接口如 下：
package com.baomidou.mybatisplus.core.mapper;
public interface BaseMapper<T> extends Mapper<T> {
/**
* 插入一条记录
int insert(T entity);
/**
* 根据 ID 删除
* @param id 主键ID */
int deleteById(Serializable id);
/**
* 根据实体(ID)删除
* @param entity 实体对象
* @since 3.4.4 */
int deleteById(T entity);
/**
* 根据 columnMap 条件，删除记录
* @param columnMap 表字段 map 对象 */
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
/**
* 根据 entity 条件，删除记录
* @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where
语句）
*/
int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 删除（根据ID 批量删除）
* @param idList 主键ID列表(不能为 null 以及 empty) */
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
/**
* 根据 ID 修改
* @param entity 实体对象 */
int updateById(@Param(Constants.ENTITY) T entity);
/**
* 根据 whereEntity 条件，更新记录
* @param entity 实体对象 (set 条件值 ,可以为 null)
* @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成
where 语句）
*/
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
/**
* 根据 ID 查询
* @param id 主键ID */
T selectById(Serializable id);
/**
* 查询（根据ID 批量查询）
* @param idList 主键ID列表(不能为 null 以及 empty) */
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
/**
* 查询（根据 columnMap 条件）
* @param columnMap 表字段 map 对象 */
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
/**
* 根据 entity 条件，查询一条记录
*
查询一条记录，例如 qw.last(\"limit 1\") 限制取一条记录 , 注意：多条数据会报异常
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
default T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper) { List<T> ts = this.selectList(queryWrapper);
if (CollectionUtils.isNotEmpty(ts)) {
if (ts.size() != 1) {
throw ExceptionUtils.mpe(\"One record is expected, but the query result is multiple records\");
}
return ts.get(0);
}
return null;
}
/**
* 根据 Wrapper 条件，查询总记录数
* @param queryWrapper 实体对象封装操作类（可以为 null） */
Long selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 entity 条件，查询全部记录
* @param queryWrapper 实体对象封装操作类（可以为 null） */
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录
* @param queryWrapper 实体对象封装操作类（可以为 null） */
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录
*
注意： 只返回第一个字段的值</p>
* @param queryWrapper 实体对象封装操作类（可以为 null） */
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 entity 条件，查询全部记录（并翻页）
* @param page 分页查询条件（可以为 RowBounds.DEFAULT）
* @param queryWrapper 实体对象封装操作类（可以为 null） */
<P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
/**
* 根据 Wrapper 条件，查询全部记录（并翻页）
* @param page 分页查询条件
* @param queryWrapper 实体对象封装操作类 */
<P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
}
插入
@Testpublic void testInsert(){ User user = new User(null, \"张三\", 23, \"zhangsan@qcby.com\"); //INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? ) int result = userMapper.insert(user); System.out.println(\"受影响行数：\"+result); //1948652625792266241 System.out.println(\"id自动获取：\"+user.getId());}
删除
通过id删除记录
@Testpublic void testDeleteById(){ //通过id删除用户信息 //DELETE FROM user WHERE id=? int result = userMapper.deleteById(1948651568068509697l); System.out.println(\"受影响行数：\"+result);}
@Testpublic void testDeleteByIdWithEntity() { // deleteById(T entity)：本质还是根据主键ID删除（从实体中取ID） // DELETE FROM user WHERE id = ? User user = new User(); user.setId(8L); // 必须设置主键ID，否则无法删除 // 其他字段不会影响删除（只认主键） user.setName(\"不重要的名字\"); int result = userMapper.deleteById(user); System.out.println(\"根据实体中的ID删除，受影响行数：\" + result);}
通过id批量删除记录
@Test
public void testDeleteBatchIds(){
//通过多个id批量删除
//DELETE FROM user WHERE id IN ( ? , ? , ? )
List<Long> idList = Arrays.asList(1L, 2L, 3L);
int result = userMapper.deleteBatchIds(idList);
System.out.println(\"受影响行数：\"+result);
}
通过map条件删除记录
@Test
public void testDeleteByMap(){
//根据map集合中所设置的条件删除记录
//DELETE FROM user WHERE name = ? AND age = ?
Map<String, Object> map = new HashMap();
map.put(\"age\", 23);
map.put(\"name\", \"张三\");
int result = userMapper.deleteByMap(map);
System.out.println(\"受影响行数：\"+result);
}
通过条件删除
@Testpublic void testDeleteByWrapper() { // 根据条件删除用户信息 // DELETE FROM user WHERE name = ? AND age = ? QueryWrapper queryWrapper = new QueryWrapper(); queryWrapper.eq(\"name\", \"测试用户\") // 条件1：姓名为\"测试用户\" .eq(\"age\", 20); // 条件2：年龄为20 int result = userMapper.delete(queryWrapper); System.out.println(\"受影响行数：\" + result);}@Testpublic void testDeleteByWrapper2() { // 根据条件删除用户信息（另一种条件示例） // DELETE FROM user WHERE email IS NULL QueryWrapper queryWrapper = new QueryWrapper(); queryWrapper.isNull(\"email\"); // 条件：邮箱为空 int result = userMapper.delete(queryWrapper); System.out.println(\"受影响行数：\" + result);}
修改
通过id修改
@Testpublic void testUpdateById(){ User user = new User(4L, \"admin\", 22, null);//UPDATE user SET name=?, age=? WHERE id=? int result = userMapper.updateById(user); System.out.println(\"受影响行数：\"+result);}
通过条件修改
@Testpublic void testUpdate(){ // 假设有一个 UpdateWrapper 对象，设置查询条件为 age > 25，更新满足条件的用户的邮箱 UpdateWrapper updateWrapper = new UpdateWrapper(); updateWrapper.gt(\"age\", 25); User updateUser = new User(); updateUser.setEmail(\"new.email@example.com\"); int rows = userMapper.update(updateUser, updateWrapper); // 调用 update 方法 if (rows > 0) { System.out.println(\"Users updated successfully.\"); } else { System.out.println(\"No users updated.\"); }}
查询
通过id查找
@Testpublic void testSelectById(){//根据id查询用户信息//SELECT id,name,age,email FROM user WHERE id=? User user = userMapper.selectById(4L); System.out.println(user);}
通过条件查询
@Testpublic void testSelectOne(){//根据条件查询用户信息//SELECT id,name,age,email FROM user WHERE name = ? AND age = ? QueryWrapper queryWrapper = new QueryWrapper(); queryWrapper.eq(\"name\", \"admin2\").eq(\"age\", 22); User user = userMapper.selectOne(queryWrapper); System.out.println(user); /* // 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，查询一条满足条件的用户 QueryWrapper queryWrapper = new QueryWrapper(); queryWrapper.gt(\"age\", 25); User user = userMapper.selectOne(queryWrapper); // 调用 selectOne 方法 System.out.println(\"User: \" + user); */}
通过id查询多个
@Testpublic void testSelectBatchIds(){//根据多个id查询多个用户信息//SELECT id,name,age,email FROM user WHERE id IN ( ? , ? ) List idList = Arrays.asList(4L, 5L); List list = userMapper.selectBatchIds(idList); list.forEach(System.out::println);}
通过map条件查询用户信息
@Testpublic void testSelectByMap(){//通过map条件查询用户信息//SELECT id,name,age,email FROM user WHERE name = ? AND age = ? Map map = new HashMap(); map.put(\"age\", 22); map.put(\"name\", \"admin\"); List list = userMapper.selectByMap(map); list.forEach(System.out::println);}
结果list输出
@Test public void testSelectList(){ //selectList()根据MP内置的条件构造器查询一个list集合，null表示没有条件，即查询所有 userMapper.selectList(null).forEach(System.out::println); }
结果映射为map
@Testpublic void testSelectMaps(){ // 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，查询所有满足条件的用户，并将结果映射为 Map QueryWrapper queryWrapper = new QueryWrapper(); queryWrapper.gt(\"age\", 25); List<Map> userMaps = userMapper.selectMaps(queryWrapper); // 调用 selectMaps 方法 for (Map userMap : userMaps) { System.out.println(\"User Map: \" + userMap); }}
查询第一个字段
@Testpublic void testSelectObjs(){ // 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，查询所有满足条件的用户，并返回一个包含用户ID的列表 QueryWrapper queryWrapper = new QueryWrapper(); queryWrapper.gt(\"age\", 25); List userIds = userMapper.selectObjs(queryWrapper); // 调用 selectObjs 方法 for (Object userId : userIds) { System.out.println(\"User ID: \" + userId); }}
分页查询
要先写一个配置类
package com.qcby.mybatisplus1.config;import com.baomidou.mybatisplus.annotation.DbType;import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;@Configuration // 标识为配置类public class MyBatisPlusConfig { /** * 注册分页插件 */ @Bean public MybatisPlusInterceptor mybatisPlusInterceptor() { MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); // 添加分页插件，指定数据库类型（MySQL） interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); return interceptor; }}
//selectPage@Testpublic void testSelectPage(){ //SELECT * FROM user WHERE age > 25 LIMIT 2 OFFSET 0 // 假设要进行分页查询，每页显示2条记录，查询第1页，查询条件为 age > 25 IPage page = new Page(1, 2); QueryWrapper queryWrapper = new QueryWrapper(); queryWrapper.gt(\"age\", 25); IPage userPage = userMapper.selectPage(page, queryWrapper); // 调用 selectPage 方法 List userList = userPage.getRecords(); long total = userPage.getTotal(); System.out.println(\"Total users (age > 25): \" + total); for (User user : userList) { System.out.println(\"User: \" + user); }}
map
@Testpublic void testSelectMapsPage(){ // 假设要进行分页查询，每页显示2条记录，查询第1页，查询条件为 age > 25，并将结果映射为 Map IPage<Map> page= new Page(1, 2); QueryWrapper queryWrapper = new QueryWrapper(); queryWrapper.gt(\"age\", 25); IPage<Map> userPageMaps = userMapper.selectMapsPage(page, queryWrapper); // 调用 selectMapsPage 方法 List<Map> userMapList = userPageMaps.getRecords(); long total = userPageMaps.getTotal(); System.out.println(\"Total users (age > 25): \" + total); for (Map userMap : userMapList) { System.out.println(\"User Map: \" + userMap); }}
查询数量
@Testpublic void testSelectCount(){ //SELECT COUNT( * ) FROM user WHERE age > 25 QueryWrapper queryWrapper = new QueryWrapper(); queryWrapper.gt(\"age\", 25); long count = userMapper.selectCount(queryWrapper); // 调用 selectCount 方法 System.out.println(\"Count of users (age > 25): \" + count);}
查询是否存在
/** * 测试exists方法：验证符合条件的记录是否存在 */ @Test public void testExists() { // 1. 测试存在的情况：查询age > 30的用户是否存在 QueryWrapper existsWrapper = new QueryWrapper(); existsWrapper.gt(\"age\", 28); // 假设数据库中有age>28的用户 boolean isExists = userMapper.exists(existsWrapper); System.out.println(\"age > 28的用户是否存在：\" + isExists); // 如果确定有符合条件的数据，可以使用断言验证 assertTrue(isExists, \"age > 28的用户应该存在\");// // 2. 测试不存在的情况：查询name = \"不存在的用户\"的记录// QueryWrapper notExistsWrapper = new QueryWrapper();// notExistsWrapper.eq(\"name\", \"不存在的用户\"); // 假设该用户不存在// boolean isNotExists = userMapper.exists(notExistsWrapper);// System.out.println(\"name = \'不存在的用户\'的记录是否存在：\" + isNotExists); // 如果确定无符合条件的数据，可以使用断言验证 // assertFalse(isNotExists, \"name = \'不存在的用户\'的记录应该不存在\"); }
