【第3章】MyBatis-Plus持久层接口之Service Interface(上)

最新推荐文章于 2024-06-27 19:16:12 发布
最新推荐文章于 2024-06-27 19:16:12 发布
阅读量1.1k 收藏 23
点赞数 43
分类专栏： # mybatis-plus 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44824164/article/details/139905585
版权

文章目录

前言

接下来详细介绍了 MyBatis-Plus 进行持久化操作的各种方法，包括插入、更新、删除、查询和分页等。通过本文，您可以了解到 MyBatis-Plus 提供的各种方法是如何进行数据操作的，以及它们对应的 SQL 语句。

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

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

Service Interface：

  • save
  • saveOrUpdate
  • remove
  • update

一、save

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

功能描述： 插入记录，根据实体对象的字段进行策略性插入。
返回值： boolean，表示插入操作是否成功。
参数说明：

类型参数名描述
Tentity实体对象
CollectionentityList实体对象集合
intbatchSize插入批次数量

1. 示例（save）

// 假设有一个 User 实体对象
User user = new User();
user.setName("John Doe");
user.setEmail("john.doe@example.com");
boolean result = userService.save(user); // 调用 save 方法
if (result) {
    System.out.println("User saved successfully.");
} else {
    System.out.println("Failed to save user.");
}

生成的 SQL:

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

2. 示例（saveBatch）

// 假设有一组 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 方法，默认批次大小
if (result) {
    System.out.println("Users saved successfully.");
} else {
    System.out.println("Failed to save users.");
}

生成的 SQL（假设默认批次大小为 3）:

INSERT INTO user (name, email) VALUES
('Alice', 'alice@example.com'),
('Bob', 'bob@example.com'),
('Charlie', 'charlie@example.com')

3. 示例（saveBatch 指定批次大小）

// 假设有一组 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 方法，指定批次大小
if (result) {
    System.out.println("Users saved successfully.");
} else {
    System.out.println("Failed to save users.");
}

生成的 SQL（指定批次大小为 2）:

-- 第一批次
INSERT INTO user (name, email) VALUES
('David', 'david@example.com'),
('Eve', 'eve@example.com')

-- 第二批次
INSERT INTO user (name, email) VALUES
('Frank', 'frank@example.com'),
('Grace', 'grace@example.com')

通过上述示例，我们可以看到 save 系列方法是如何在 Service 层进行批量插入操作的，以及它们对应的 SQL 语句。这些方法大大简化了插入操作的代码编写，提高了开发效率。

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

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

类型参数名描述
Tentity实体对象
WrapperupdateWrapper实体对象封装操作类 UpdateWrapper
CollectionentityList实体对象集合
intbatchSize插入批次数量

1.示例（saveOrUpdate）

// 假设有一个 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 方法
if (result) {
    System.out.println("User updated or saved successfully.");
} else {
    System.out.println("Failed to update or save user.");
}

生成的 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.示例（saveOrUpdateBatch）

// 假设有一组 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 方法，默认批次大小
if (result) {
    System.out.println("Users updated or saved successfully.");
} else {
    System.out.println("Failed to update or save users.");
}

生成的 SQL（假设 id 为 1 和 2 的记录已存在，id 为 3 的记录不存在）:

UPDATE user SET name = 'Alice', email = 'alice@example.com' WHERE id = 1
UPDATE user SET name = 'Bob', email = 'bob@example.com' WHERE id = 2
INSERT INTO user (id, name, email) VALUES (3, 'Charlie', 'charlie@example.com')

3. 示例（saveOrUpdateBatch 指定批次大小）

// 假设有一组 User 实体对象
List<User> users = Arrays.asList(
    new User(4, "David", "david@example.com"),
    new User(5, "Eve", "eve@example.com"),
    new User(6, "Frank", "frank@example.com")
);
// 指定批次大小为 2进行批量修改插入
boolean result = userService.saveOrUpdateBatch(users, 2); // 调用 saveOrUpdateBatch 方法，指定批次大小
if (result) {
    System.out.println("Users updated or saved successfully.");
} else {
    System.out.println("Failed to update or save users.");
}

生成的 SQL（假设指定批次大小为 2）:

-- 第一批次
UPDATE user SET name = 'David', email = 'david@example.com' WHERE id = 4
UPDATE user SET name = 'Eve', email = 'eve@example.com' WHERE id = 5

-- 第二批次
INSERT INTO user (id, name, email) VALUES (6, 'Frank', 'frank@example.com')

通过上述示例，我们可以看到 saveOrUpdate 系列方法是如何在 Service 层进行批量修改插入操作的，以及它们对应的 SQL 语句。这些方法提供了高效的数据操作方式，可以根据不同的条件进行更新或插入操作。

本质上就是先去根据主键id去查询数据是否存在,存在则根据id去更新,不存在就新增。

三、remove

// 根据 queryWrapper 设置的条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

功能描述： 通过指定条件删除符合条件的记录。
返回值： boolean，表示删除操作是否成功。
参数说明：

类型参数名描述
WrapperqueryWrapper实体包装类 QueryWrapper
Serializableid主键 ID
Map<String, Object>columnMap表字段 map 对象
Collection<? extends Serializable>idList主键 ID 列表

1. 示例（remove）

// 假设有一个 QueryWrapper 对象，设置删除条件为 name = 'John Doe'
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "John Doe");
boolean result = userService.remove(queryWrapper); // 调用 remove 方法
if (result) {
    System.out.println("Record deleted successfully.");
} else {
    System.out.println("Failed to delete record.");
}

生成的 SQL:

DELETE FROM user WHERE name = 'John Doe'

2. 示例（removeById）：

// 假设要删除 ID 为 1 的用户
boolean result = userService.removeById(1); // 调用 removeById 方法
if (result) {
    System.out.println("User deleted successfully.");
} else {
    System.out.println("Failed to delete user.");
}

生成的 SQL:

DELETE FROM user WHERE id = 1

3. 示例（removeByMap）：

// 假设有一个 columnMap，设置删除条件为 age > 30
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("age", 30);
boolean result = userService.removeByMap(columnMap); // 调用 removeByMap 方法
if (result) {
    System.out.println("Records deleted successfully.");
} else {
    System.out.println("Failed to delete records.");
}

生成的 SQL:

DELETE FROM user WHERE age > 30

4. 示例（removeByIds）：

// 假设有一组 ID 列表，批量删除用户
List<Integer> ids = Arrays.asList(1, 2, 3);
boolean result = userService.removeByIds(ids); // 调用 removeByIds 方法
if (result) {
    System.out.println("Users deleted successfully.");
} else {
    System.out.println("Failed to delete users.");
}

生成的 SQL:

DELETE FROM user WHERE id IN (1, 2, 3)

通过上述示例，我们可以看到 remove 系列方法是如何在 Service 层进行删除操作的，以及它们对应的 SQL 语句。这些方法提供了灵活的数据操作方式，可以根据不同的条件进行删除操作。

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

功能描述： 通过指定条件更新符合条件的记录。
返回值： boolean，表示更新操作是否成功。
参数说明：

类型参数名描述
WrapperupdateWrapper实体对象封装操作类 UpdateWrapper
Tentity实体对象
CollectionentityList实体对象集合
intbatchSize更新批次数量

1. 示例（update 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 方法
if (result) {
    System.out.println("Record updated successfully.");
} else {
    System.out.println("Failed to update record.");
}

生成的 SQL:

UPDATE user SET email = 'john.doe@newdomain.com' WHERE name = 'John Doe'

2. 示例（update WhereWrapper 形式）：

// 假设有一个 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 方法
if (result) {
    System.out.println("Record updated successfully.");
} else {
    System.out.println("Failed to update record.");
}

生成的 SQL:

UPDATE user SET name = 'Updated Name' WHERE id = 1

整数类型如无特殊要求，可使用包装类

3. 示例（updateById）：

// 假设有一个 User 实体对象，设置更新字段为 email，根据 ID 更新
User updateEntity = new User();
updateEntity.setId(1);
updateEntity.setEmail("updated.email@example.com");
boolean result = userService.updateById(updateEntity); // 调用 updateById 方法
if (result) {
    System.out.println("Record updated successfully.");
} else {
    System.out.println("Failed to update record.");
}

生成的 SQL:

UPDATE user SET email = 'updated.email@example.com' WHERE id = 1

4. 示例（updateBatchById）：

// 假设有一组 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 方法，默认批次大小
if (result) {
    System.out.println("Records updated successfully.");
} else {
    System.out.println("Failed to update records.");
}

生成的 SQL（假设默认批次大小为 2）:

UPDATE user SET email = 'new.email1@example.com' WHERE id = 1
UPDATE user SET email = 'new.email2@example.com' WHERE id = 2

更新成功一条，即返回true

5. 示例（updateBatchById 指定批次大小）：

// 假设有一组 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 方法，指定批次大小
if (result) {
    System.out.println("Records updated successfully.");
} else {
    System.out.println("Failed to update records.");
}

生成的 SQL（假设指定批次大小为 1）:

-- 第一批次
UPDATE user SET email = 'new.email1@example.com' WHERE id = 1
-- 第二批次
UPDATE user SET email = 'new.email2@example.com' WHERE id = 2

当值为null时不会更新该字段，可使用空字符串""代替

通过上述示例，我们可以看到 update 系列方法是如何在 Service 层进行更新操作的，以及它们对应的 SQL 语句。这些方法提供了灵活的数据操作方式，可以根据不同的条件进行更新操作。

总结

回到顶部

大家可以继承mybatis-plus提供的ServiceImpl<UserMapper, User>,它实现了IService,提供更多了方法。

官方给的用例太多了，一方面懒得复制想水一下，一方面又想把案例的每个用法带给兄弟们，好纠结啊！！！

虽然都是官方案例，但是还是建议大家跑一下，熟悉下API，查看API执行后打印的sql语句日志，代码写完之后多做测试，避免不必要的问题。

你知道“铁甲小宝”吗丶
关注
  • 43
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【SpringBoot】26、SpringBoot中整合MyBatis-Plus实现数据库操作
Asurplus
07-23 21万+
MyBatis 框架相信大家都用过，虽然 MyBatis 可以直接在 xml 中通过 SQL 语句操作数据库，很是灵活。但正其操作都要通过 SQL 语句进行，就必须写大量的 xml 文件，很是麻烦。于是 MyBatis-Plus 应运而生，作为 MyBatis 的增强工具，更是为我们开发效率得到了质的飞跃。 一、简介 1、MyBatis MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBa
MyBatis-Plus 在 Controller 层注入 Service 接口，让您的业务操作更便捷！
奇妙的Bug之旅
01-05 595
在使用 MyBatis-Plus 的过程中，我们经常需要在 Controller 层注入 Service 接口来进行业务操作。假设我们要操作一个名为 User 的实体类，我们创建一个 UserService 接口和一个 UserServiceImpl 实现类。接下来，我们创建一个 Controller 类，用于处理客户端的请求，并调用相应的 Service 接口方法进行业务操作。通过以上步骤，我们成功地在 Controller 层注入了 Service 接口，可以通过调用相应的方法进行业务操作。
【第4章】MyBatis-Plus持久层接口之Service Interface(下)
zjg
06-27 1019
getlistpagecount回到顶部建议大家使用官方推荐的版本或者稳定的版本，有些官方示例没有及时更新，就报错或者直接编译过不去，建议大家仔细阅读官方文档或直接查看相关源码处理流程。
【第5章】MyBatis-Plus持久层接口之Mapper Interface
zjg
06-27 839
BaseMapper 是 Mybatis-Plus 提供的一个通用 Mapper 接口，它封装了一系列常用的数据库操作方法，包括增、删、改、查等。通过继承 BaseMapper，开发者可以快速地对数据库进行操作，而无需编写繁琐的 SQL 语句。insertdeleteupdateselect泛型T为任意实体对象参数为任意类型主键Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键对象Wrapper为条件构造器回到顶部。
深入解析Mybatis-Plus框架：简化Java持久层开发(三)
powerbiubiu的博客
02-19 1531
Mybatis-Plus代码生成器
Mybatis-Plus详解
热门推荐
有头发还能学的博客
10-29 18万+
Mybatis-Plus介绍 简介 MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 特性（官网提供） 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作，BaseMapper 强大的 CRUD 操作：内置通用 Mapper、通用 Serv
MyBatis-Plus 自定义sql语句
贱男
06-12 10万+
一、引言 Good Good Study，Day Day Up，童鞋点个关注，不迷路，么么哒～～～
Spring Boot 集成MyBatis-Plus
长路漫漫，以勤作车
06-25 1036
本文以最小功能集的方式讲解了如何在Spring Boot项目中集成MyBatis-Plus，并且通过接口的创建验证了集成的结果。同时还分享了实际开发中的一些小技巧，希望对大家有所帮助。
Java之Mybatis-Plus
每天进步一点点...
01-02 2814
Java之MyBatis-Plus
持久层开源工具MyBatis-Plus快速入门，Spring Boot整合MyBatis-Plus简化开发示例代码
06-27
MyBatis-Plus是一个在MyBatis基础上进行扩展的轻量级框架，它极大地简化了对数据库的操作，提供了包括插入、删除、更新、...总之，MyBatis-Plus是Java开发中一个非常实用的持久层工具，值得在你的项目中尝试和使用。
Mybatis-plus基于redis实现二级缓存过程解析
08-18
Mybatis-plus是一款基于Java语言的持久层框架，旨在简化数据库交互操作。然而，在高并发、高性能的应用场景中，数据库的查询操作可能会成为性能瓶颈。为了解决这个问题，Mybatis-plus提供了基于Redis的二级缓存机制...
快速CRUD的秘诀之SpringBoot整合MyBatis-Plus
12-21
4. **创建DAO层**：创建MyBatis-Plus的Mapper接口，继承`BaseMapper`接口，无需编写XML配置文件，即可完成基本的CRUD操作。MyBatis-Plus会根据实体类自动生成对应的SQL。 ```java package com.guqueyue.mapper; ...
spring-boot-starter-mybatis-spring-boot-2.3.1.zip
04-19
MyBatis作为一款优秀的持久层框架，简化了SQL操作，使得数据库访问更为便捷。当这两者结合，便形成了Spring Boot Starter MyBatis，它为开发者提供了一种快速整合Spring Boot与MyBatis的方式。本文将深入探讨Spring ...
spring-boot-starter-mybatis-spring-boot-2.1.4.tar.gz
04-19
而MyBatis作为轻量级持久层框架，以其灵活的SQL映射和强大的数据访问能力深受开发者喜爱。本文将深入探讨Spring Boot如何与MyBatis集成，并以`spring-boot-starter-mybatis-spring-boot-2.1.4`为例，解析集成过程...
Crypto_30_vHsm_Types.h
07-09
Crypto_30_vHsm_Types
vmware虚拟机安装教程.pdf
最新发布
07-10
VMware虚拟机安装教程是一个详细且系统的过程，涵盖了从下载、安装到配置虚拟机的多个步骤。以下是一个详尽的VMware虚拟机安装教程，旨在帮助用户顺利搭建自己的虚拟环境。
11111111111
07-10
11111111111
nvidia平台torch-2.0.0.nv23.05-cp38-cp38-linux-aarch64安装包
07-09
特定版本的 PyTorch 包，专为 NVIDIA 的 Jetson 平台优化，并且适用于使用 Python 3.8 的 ARM64 架构（如 NVIDIA Jetson 系列设备）上的 Linux 操作系统 PyTorch 是一个广泛使用的开源机器学习库，主要用于深度学习和神经网络的构建和训练。它由 Facebook's AI Research Lab (FAIR) 开发和维护。 提供了强大的张量计算功能以及支持 GPU 加速的计算能力。
springboot mybatis-plus 登录接口
09-22
Spring Boot和MyBatis-Plus是一种常见的Java开发框架和库，用于快速构建基于Spring框架和MyBatis持久层的应用程序。下面是一个简单的登录接口实现示例： 首先，我们需要创建一个用户实体类，用来表示用户的登录信息...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值