您的位置：首页 > 财经 > 金融 > 站长之家商城_中山外发加工网_网络市场营销策划书_专业全网优化

站长之家商城_中山外发加工网_网络市场营销策划书_专业全网优化

2024/12/27 11:40:21 来源：https://blog.csdn.net/qq_64183220/article/details/144603462  浏览:  次   关键词：站长之家商城_中山外发加工网_网络市场营销策划书_专业全网优化
站长之家商城_中山外发加工网_网络市场营销策划书_专业全网优化

 一、什么是持久层接口

        IService 是 MyBatis-Plus 提供的一个通用 Service 层接口，它封装了常见的 CRUD 操作，包括插入、删除、查询和分页等。通过继承 IService 接口，可以快速实现对数据库的基本操作，同时保持代码的简洁性和可维护性。

        IService 接口中的方法命名遵循了一定的规范，如 get 用于查询单行，remove 用于删除，list 用于查询集合，page 用于分页查询，这样可以避免与 Mapper 层的方法混淆。

注意：

  • 泛型 T 为任意实体对象

  • 建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的 IService 基类

  • 对象 Wrapper 为 条件构造器

 二、持久层中对表的增删改查（CRUD），page分页

注：灰色框中是底层代码

2.1 、save（增）

2.1.1 、插入一条记录

/*** 插入一条记录（选择字段，策略插入）** @param entity 实体对象*/
default boolean save(T entity) {return SqlHelper.retBool(getBaseMapper().insert(entity));
}

// 假设有一个 User 实体对象
User user = new User();
user.setName("John Doe");
user.setEmail("john.doe@example.com");
boolean result = userService.save(user); // 调用 save 方法

2.1.2 、批量插入

//默认批次提交数量
int DEFAULT_BATCH_SIZE = 1000;/** 插入（批量）** @param entityList 实体对象集合*/
@Transactional(rollbackFor = Exception.class)
default boolean saveBatch(Collection<T> entityList) {return saveBatch(entityList, DEFAULT_BATCH_SIZE);
}

// 假设有一组 User 实体对象
List<User> users = Arrays.asList(new User("Alice", "alice@example.com"),new User("Bob", "bob@example.com"),new User("Charlie", "charlie@example.com")
);
// 使用默认批次大小进行批量插入
boolean result = userService.saveBatch(users); // 调用 saveBatch 方法，默认批次大小

 2.1.3、自定义批次，批量插入

/*** 插入（批量）** @param entityList 实体对象集合* @param batchSize  插入批次数量*/
boolean saveBatch(Collection<T> entityList, int batchSize);

// 假设有一组 User 实体对象
List<User> users = Arrays.asList(new User("David", "david@example.com"),new User("Eve", "eve@example.com"),new User("Frank", "frank@example.com"),new User("Grace", "grace@example.com")
);
// 指定批次大小为 2进行批量插入
boolean result = userService.saveBatch(users, 2); // 调用 saveBatch 方法，指定批次大小

2.2、remove（删）

2.2.1、根据 entity 条件，删除记录

/*** 根据 entity 条件，删除记录** @param queryWrapper 实体包装类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}*/
default boolean remove(Wrapper<T> queryWrapper) {return SqlHelper.retBool(getBaseMapper().delete(queryWrapper));
}

// 假设有一个 QueryWrapper 对象，设置删除条件为 name = 'John Doe'
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "John Doe");
boolean result = userService.remove(queryWrapper); // 调用 remove 方法

2.2.2、removeById根据 ID 删除

/*** 根据 ID 删除** @param id 主键ID*/
default boolean removeById(Serializable id) {return SqlHelper.retBool(getBaseMapper().deleteById(id));
}
// 假设要删除 ID 为 1 的用户
boolean result = userService.removeById(1); // 调用 removeById 方法

2.2.3、根据 columnMap 条件，删除记录

/*** 根据 columnMap 条件，删除记录** @param columnMap 表字段 map 对象*/
default boolean removeByMap(Map<String, Object> columnMap) {Assert.notEmpty(columnMap, "error: columnMap must not be empty");return SqlHelper.retBool(getBaseMapper().deleteByMap(columnMap));
}

// 假设有一个 columnMap，设置删除条件为 age = 30
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("age", 30);
boolean result = userService.removeByMap(columnMap); // 调用 removeByMap 方法

2.2.4、删除（根据ID 批量删除）

/*** 删除（根据ID 批量删除）** @param idList 主键ID列表*/
default boolean removeByIds(Collection<? extends Serializable> idList) {if (CollectionUtils.isEmpty(idList)) {return false;}return SqlHelper.retBool(getBaseMapper().deleteBatchIds(idList));
}
// 假设有一组 ID 列表，批量删除用户
List<Integer> ids = Arrays.asList(1, 2, 3);
boolean result = userService.removeByIds(ids); // 调用 removeByIds 方法

2.3、update（改）

2.3.1、根据 UpdateWrapper 条件，更新记录

/*** 根据 UpdateWrapper 条件，更新记录 需要设置sqlset** @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}*/
default boolean update(Wrapper<T> updateWrapper) {return update(null, updateWrapper);
}

// 假设有一个 UpdateWrapper 对象，设置更新条件为 name = 'John Doe'，更新字段为 email
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("name", "John Doe").set("email", "john.doe@newdomain.com");
boolean result = userService.update(updateWrapper); // 调用 update 方法

2.3.2、根据 实体类和Wrapper 条件，更新记录

/*** 根据 whereEntity 条件，更新记录** @param entity        实体对象* @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}*/
default boolean update(T entity, Wrapper<T> updateWrapper) {return SqlHelper.retBool(getBaseMapper().update(entity, updateWrapper));
}
// 假设有一个 User 实体对象，设置更新字段为 name，以及一个 whereWrapper 设置更新条件为 id = 1
User updateEntity = new User();
updateEntity.setName("Updated Name");
QueryWrapper<User> whereWrapper = new QueryWrapper<>();
whereWrapper.eq("id", 1);
boolean result = userService.update(updateEntity, whereWrapper); // 调用 update 方法

2.3.3、根据 ID 选择修改

/*** 根据 ID 选择修改** @param entity 实体对象*/
default boolean updateById(T entity) {return SqlHelper.retBool(getBaseMapper().updateById(entity));
}
// 假设有一个 User 实体对象，设置更新字段为 email，根据 ID 更新
User updateEntity = new User();
updateEntity.setId(1);
updateEntity.setEmail("updated.email@example.com");
boolean result = userService.updateById(updateEntity); // 调用 updateById 方法

2.3.4、根据ID 批量更新

/*** 根据ID 批量更新** @param entityList 实体对象集合*/
@Transactional(rollbackFor = Exception.class)
default boolean updateBatchById(Collection<T> entityList) {return updateBatchById(entityList, DEFAULT_BATCH_SIZE);
}

// 假设有一组 User 实体对象，批量更新
List<User> users = Arrays.asList(new User(1, null, "new.email1@example.com"),new User(2, null, "new.email2@example.com")
);
boolean result = userService.updateBatchById(users); // 调用 updateBatchById 方法，默认批次大小

2.3.5、根据ID 批量，分批次跟新

/*** 根据ID 批量更新** @param entityList 实体对象集合* @param batchSize  更新批次数量*/
boolean updateBatchById(Collection<T> entityList, int batchSize);
// 假设有一组 User 实体对象，批量更新，并指定批次大小为 1
List<User> users = Arrays.asList(new User(1, null, "new.email1@example.com"),new User(2, null, "new.email2@example.com")
);
boolean result = userService.updateBatchById(users, 1); // 调用 updateBatchById 方法，指定批次大小

2.4、get（查）

2.4.1、getById根据 ID 查询

/*** 根据 ID 查询** @param id 主键ID*/
default T getById(Serializable id) {return getBaseMapper().selectById(id);
}
// 假设要查询 ID 为 1 的用户
User user = userService.getById(1); // 调用 getById 方法

2.4.2、getOne根据 Wrapper，查询一条记录。

/*** 根据 Wrapper，查询一条记录 <br/>* <p>结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")</p>** @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}*/
default T getOne(Wrapper<T> queryWrapper) {return getOne(queryWrapper, true);
}
// 假设有一个 QueryWrapper 对象，设置查询条件为 name = 'John Doe'
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "John Doe");
User user = userService.getOne(queryWrapper); // 调用 getOne 方法

2.4.3、getMap根据 Wrapper，查询一条记录

/*** 根据 Wrapper，查询一条记录** @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}*/
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 假设有一个 QueryWrapper 对象，设置查询条件为 name = 'John Doe'，并将结果映射为 Map
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "John Doe");
Map<String, Object> userMap = userService.getMap(queryWrapper); // 调用 getMap 方法

2.4.4、GetObj根据 Wrapper，查询一条记录（表中的单条记录的首个字段的值）

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("username","周星驰");
Object obj = userService.getObj(queryWrapper, o -> o);
System.out.println(obj);

2.5、page分页

2.5.1、无条件分页查询

/*** 无条件翻页查询** @param page 翻页对象* @see Wrappers#emptyWrapper()*/
default <E extends IPage<T>> E page(E page) {return page(page, Wrappers.emptyWrapper());
}

@Test//无条件分页查询public void page(){IPage<User> page=new Page<>(1,3);IPage<User> userIPage = userService.page(page);List<User> records = userIPage.getRecords();records.forEach(System.out::println);}

2.5.2、条件分页查询

/*** 翻页查询** @param page         翻页对象* @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}*/
default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper) {return getBaseMapper().selectPage(page, queryWrapper);
}
@Test// 条件分页查询public void pageByCondition(){IPage<User> page=new Page<>(1,2);QueryWrapper queryWrapper=new QueryWrapper();queryWrapper.gt("id",3);IPage page1 = userService.page(page, queryWrapper);List<User> records = page1.getRecords();records.forEach(System.out::println);}

2.6、saveOrUpdate

功能描述： 根据实体对象的主键 ID 进行判断，存在则更新记录，否则插入记录。
返回值： boolean，表示插入或更新操作是否成功。

2.6.1、TableId 注解属性值存在则更新记录，否插入一条记录

/*** TableId 注解存在更新记录，否插入一条记录** @param entity 实体对象*/
boolean saveOrUpdate(T entity);

// 假设有一个 User 实体对象，其中 id 是 TableId 注解的属性
User user = new User();
user.setId(1);
user.setName("John Doe");
user.setEmail("john.doe@example.com");
boolean result = userService.saveOrUpdate(user); // 调用 saveOrUpdate 方法

 生成的 SQL（假设 id 为 1 的记录已存在）:

        UPDATE user SET name = 'John Doe', email = 'john.doe@example.com' WHERE id = 1

 生成的 SQL（假设 id 为 1 的记录不存在）:

        INSERT INTO user (id, name, email) VALUES (1, 'John Doe', 'john.doe@example.com'

2.6.2、saveOrUpdateBatch 批量修改插入

/*** 批量修改插入** @param entityList 实体对象集合*/
@Transactional(rollbackFor = Exception.class)
default boolean saveOrUpdateBatch(Collection<T> entityList) {return saveOrUpdateBatch(entityList, DEFAULT_BATCH_SIZE);
}
// 假设有一组 User 实体对象，每个对象都有 id 属性
List<User> users = Arrays.asList(new User(1, "Alice", "alice@example.com"),new User(2, "Bob", "bob@example.com"),new User(3, "Charlie", "charlie@example.com")
);
// 使用默认批次大小进行批量修改插入
boolean result = userService.saveOrUpdateBatch(users); // 调用 saveOrUpdateBatch 方法，默认批次大小

2.7、List（查询所有）

2.7.1、无条件查询所有

// 查询所有用户
List<User> users = userService.list(); // 调用 list 方法
for (User user : users) {System.out.println("User: " + user);
}

2.7.2、按条件查询列表

@Test//按条件查询所有的记录public void List1(){QueryWrapper<User> queryWrapper = new QueryWrapper<>();queryWrapper.ge("id",2);List<User> list = userService.list(queryWrapper);list.forEach(System.out::println);}

2.7.3、根据ID批量查询

@Test//根据id批量查询public void listByIDS(){List<Integer> idList=new ArrayList<>();idList.add(1);idList.add(2);idList.add(3);userService.listByIds(idList);}

2.7.4、根据columnMap查询

// 假设有一个 columnMap，设置查询条件为 age = 30
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("age", 30);
Collection<User> users = userService.listByMap(columnMap); // 调用 listByMap 方法
for (User user : users) {System.out.println("User: " + user);
}

2.7.5、查询所有列表

@Test//查询所有列表public void listMaps1(){userService.listMaps();}

2.7.6、查询全部记录

@Test//查询全部记录public void listObject1(){// 查询所有用户，并将结果转换为 String 列表List<Object> userNames = userService.listObjs(obj ->  obj); // 调用 listObjs 方法for (Object userName : userNames) {System.out.println("User Name: " + userName);}}

2.7.7、按照queryWrapper条件查询

@Test//按照queryWrapper条件查询public void listObject2(){QueryWrapper<User> queryWrapper=new QueryWrapper<>();queryWrapper.lt("id",10);List<Object> objects = userService.listObjs(queryWrapper);objects.forEach(System.out::println);}

        这里我只记录了最近练习的小部分，如果大家感兴趣的话，可以访问mybatis-Plus官网进一步学习：持久层接口 | MyBatis-Plus。

版权声明:

本网仅为发布的内容提供存储空间，不对发表、转载的内容提供任何形式的保证。凡本网注明“来源：XXX网络”的作品，均转载自其它媒体，著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处。

我们尊重并感谢每一位作者，均已注明文章来源和作者。如因作品内容、版权或其它问题，请及时与我们联系，联系邮箱：809451989@qq.com，投稿邮箱：809451989@qq.com

最新新闻

热搜词

vue3+ts+setup中定义组件 【YashanDB知识库】YAS-00004 feature create user has not been implemented yet 使用css3绘制一款动态的耳机音乐阶梯动画 青云QingCloud与陕中二院联手打造智慧医院范本 哈尔滨工业大学，计算机专业就业情况分享！ springboot毕设贵港高铁站志愿者活动服务平台程序+论文

声明：本站所有新闻及新闻图片来源于其他网站，如有侵权，请及时联系我们！

客户服务 | 关于我们 | 版权声明

版权所有：

Copyright 2024 尧图网 All Rights Reserved.QQ:809451989