mybatis plus 常用知识汇总(保姆级教程!~)
介绍:
MyBatis-Plus 是基于 MyBatis 框架的一个增强工具,主要目的是简化 MyBatis 的开发过程,提供更加简洁、方便的 CRUD 操作。它是在保留 MyBatis 强大功能的基础上,通过封装和优化一些常见操作来提高开发效率。
MyBatis-Plus 提供了许多开箱即用的功能,包括自动 CRUD 代码生成、分页查询、性能优化、以及支持多种数据库。与 MyBatis 相比,MyBatis-Plus 的 部分 核心特性包括:
- 无侵入设计:不会改变 MyBatis 原有的 API 和使用方式,你可以自由选择 MyBatis 和 MyBatis-Plus 的功能。
- 自动 CRUD:通过
BaseMapper
和ServiceImpl
接口,MyBatis-Plus 提供了一系列 CRUD 操作的方法,如insert
、delete
、update
和select
,减少了重复的 SQL 编写工作。 - 条件构造器:MyBatis-Plus 提供了条件构造器(如
QueryWrapper
),可以通过链式编程方式轻松构建复杂的查询条件。
1、准备工作
1.1 添加依赖
创建一个 springboot
项目, 在 pom.xml
文件中的 dependencies 标签中添加所需要的依赖。
打开 maven官网 搜索所需依赖。大家添加最新版本的就行
mybatis plus
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.7</version>
</dependency>
mysql
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>9.0.0</version>
</dependency>
mybatis spring
这个依赖最好加上,它可以解决部分 mybatis 和 spring 之间的兼容性问题
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>3.0.4</version>
</dependency>
1.2 创建数据表和数据
在 mybatis plus 官网 给的有 sql 语句, 执行生成数据表和数据
在 application.properties
文件中添加下面信息连接数据库
spring.datasource.url=jdbc:mysql://localhost:3306/yourDatabaseName?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=YourUserName
spring.datasource.password=YourPassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
idea连接数据库,创建pojo,mapper,service,controller文件就不多赘述了..
2、mapper层基本的操作
BaseMapper
是 MyBatis-Plus 提供的一个基础 Mapper 接口,它简化了数据访问层(Data Access Layer)的开发。BaseMapper
提供了一系列通用的数据库操作方法,这样你就不必手动编写常见的 SQL 语句,从而提升了开发效率。
1. 使用 BaseMapper
假设我们有一个用户实体类 User
,如下:
public class User {
private Long id;
private String name;
private Integer age;
private String email;
// Getter 和 Setter
}
你可以创建一个 UserMapper
接口来继承 BaseMapper<User>
:
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
public interface UserMapper extends BaseMapper<User> {
// 你可以在这里添加自定义方法
}
通过继承 BaseMapper<User>
,UserMapper
立即拥有了所有的 CRUD 操作方法。你可以在你的服务层(Service Layer)中直接使用这些方法,无需再编写任何 SQL 语句。
2. BaseMapper 提供的常用方法
2.1 增(Insert)
简单示例:
// 定义用户实体类
public class User {
private Long id;
private String username;
private String email;
}
// 使用 MyBatis-Plus 提供的 BaseMapper 接口
public interface UserMapper extends BaseMapper<User> {
}
// 插入一条记录
User user = new User();
user.setUsername("john_doe");
user.setEmail("john@example.com");
// 调用 insert 方法
userMapper.insert(user);
解释:这里的 insert
方法直接使用实体类对象 user
,将其插入到数据库中。MyBatis-Plus 自动生成的 insert
方法会根据实体类的属性映射到数据库表的字段。
2.2 删(Delete)
简单示例:
// 根据 ID 删除一条记录
userMapper.deleteById(1L);
解释:deleteById
方法通过传入用户的 id
删除该用户。这个方法直接删除主键为 1
的用户。
2.3 改(Update)
简单示例:
// 创建一个用户对象,设置要修改的字段
User user = new User();
user.setId(1L); // 设置要更新的用户 ID
user.setEmail("newemail@example.com"); // 修改用户邮箱
// 更新用户信息
userMapper.updateById(user);
解释:updateById
方法根据 id
更新用户记录,这里只更新了邮箱字段,其他字段保持不变。
2.4 查(Select)
简单示例:
// 根据 ID 查询用户
User user = userMapper.selectById(1L);
// 输出用户信息
System.out.println(user.getUsername());
解释:selectById
方法根据传入的 id
查询对应的用户信息,然后可以输出或使用这个用户信息。
2.5 条件查询
简单示例:
// 构建查询条件
QueryWrapper<User> queryWrapper = new QueryWrapper<>(); // <-------- 下面会讲到
queryWrapper.eq("username", "john_doe"); // 设置条件:用户名为 john_doe
// 执行查询
List<User> users = userMapper.selectList(queryWrapper);
// 输出查询结果
for (User u : users) {
System.out.println(u.getUsername());
}
解释:QueryWrapper
是 MyBatis-Plus 提供的一个工具类,用于构建查询条件。selectList
方法根据条件查询所有符合条件的记录。
3. 示例代码
以下是如何使用 UserMapper
执行一些常见操作的示例:
@Service
public class UserService {
@Autowired
private UserMapper userMapper;
// 插入一条记录
public void addUser(User user) {
userMapper.insert(user);
}
// 根据 ID 删除一条记录
public void deleteUserById(Long id) {
userMapper.deleteById(id);
}
// 更新用户信息
public void updateUser(User user) {
userMapper.updateById(user);
}
// 根据 ID 查询用户
public User getUserById(Long id) {
return userMapper.selectById(id);
}
// 查询所有用户
public List<User> getAllUsers() {
return userMapper.selectList(null);
}
}
3、service层基本的操作
ServiceImpl
和 IService
是 MyBatis-Plus 中用于服务层(Service Layer)的两个重要接口和类,它们帮助简化和规范了与数据库交互的业务逻辑。下面是它们的详细介绍:
1. IService 接口
IService
是 MyBatis-Plus 提供的一个通用服务接口。它定义了一些常见的 CRUD(Create, Read, Update, Delete)操作,并将这些操作抽象成方法。这意味着,当你使用 IService
接口时,你无需自己手动编写这些常见的数据库操作方法。
IService 中的一些常用方法:
boolean save(T entity)
: 保存一个实体类对象到数据库。boolean removeById(Serializable id)
: 根据 ID 删除数据。boolean updateById(T entity)
: 根据 ID 更新数据。T getById(Serializable id)
: 根据 ID 查询数据。List<T> list()
: 查询所有数据。Page<T> page(Page<T> page)
: 分页查询数据。
2. ServiceImpl 类
ServiceImpl
是 MyBatis-Plus 提供的一个基础实现类,它实现了 IService
接口中的方法。ServiceImpl
通常是被继承的,它提供了具体的数据库操作方法的实现。开发者只需在自己定义的服务实现类中继承 ServiceImpl
类,就可以获得默认的 CRUD 功能。
使用示例
假设你有一个用户表 User
,并为其定义了一个实体类 User
和一个 Mapper 接口 UserMapper
。你可以定义一个服务接口 UserService
和一个服务实现类 UserServiceImpl
。
1. 定义服务接口:
public interface UserService extends IService<User> {
// 可以定义一些自定义的服务方法
}
2. 定义服务实现类:
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
// 你可以重写 ServiceImpl 中的方法,或者定义更多的业务逻辑
}
在这个例子中,UserServiceImpl
继承了 ServiceImpl<UserMapper, User>
并实现了 UserService
接口。通过这种方式,UserServiceImpl
类可以直接使用 ServiceImpl
提供的基本 CRUD 方法。
Mapper 和 Service 中有很多的方法,具体用法可以参考 Mybatis plus 官网
4、字段映射
MyBatis-Plus 的自动映射规则主要涉及如何将数据库表和字段自动映射到 Java 实体类及其属性。
1. 表名与实体类名的映射
- 默认规则:MyBatis-Plus 默认使用实体类名作为数据库表名的前缀。比如,如果你的实体类名为
User
,那么它会映射到名为user
的数据库表。 - 自定义规则:你可以使用
@TableName
注解来指定自定义的表名。例如:@TableName("sys_user") public class User { // 属性和方法 }
2. @TableField 字段名与属性名的映射
- 默认规则:字段名和属性名默认是直接映射的。例如,数据库中的
user_name
字段会映射到实体类中的userName
属性。 - 驼峰命名规则:MyBatis-Plus 默认启用了驼峰命名转换。即,数据库中的下划线命名(如
user_name
)会被自动转换为 Java 属性的驼峰命名(如userName
)。 - 自定义字段映射:可以使用
@TableField
注解来指定自定义的字段名。例如:@TableField("user_name") private String userName;
@TableField
的其他用法:
如果表中字段存在
sql语句的关键词
,比如desc
, 那么需要按照下面的写法, 否则mybatis plus 拼接含有desc字段
的sql语句时会报错@TableField("`desc`") private String desc;
@TableField(select = false)
作用:用于指定某个字段在执行 SQL 查询时不参与查询,即在 SELECT 语句中不包含该字段。
用途:通常用于那些只需要在数据库操作中存在,但不需要在查询结果中显示的字段。例如,逻辑删除字段、内部使用的字段等@TableField(select = false) private Integer age;
@TableField(exist = false)
作用:用于指定某个字段不对应数据库中的任何字段,即在数据库表中不存在该字段。
用途:通常用于那些只在 Java 实体中存在的字段,但在数据库表中没有相应的字段。例如,用于计算或临时存储的数据。@TableField(exist = false) private Integer age;
3. 主键的自动映射
在 MyBatis-Plus 中,@TableId
注解用于标识实体类中的主键字段。@TableId
注解有两个主要属性:value
和 type
。它们分别用于指定字段名和主键生成策略。
@TableId
注解属性
value
:- 用途:指定数据库表中的主键列名。它的值应该是数据库表中实际的列名。
- 示例:如果数据库表中的主键列名是
user_id
,则在实体类中可以这样配置:@TableId(value = "user_id", type = IdType.ASSIGN_UUID) private String userId;
type
:用途:指定主键生成策略。MyBatis-Plus 提供了多种主键生成策略,
IdType
枚举类定义了这些策略。常用的生成策略:
IdType.AUTO
:数据库自动生成(通常是自增长 ID)。IdType.INPUT
:用户输入 ID(即需要手动设置)。IdType.ASSIGN_ID
:由 MyBatis-Plus 生成的 ID(通常是 UUID)。IdType.ASSIGN_UUID
:生成 UUID(字符串类型的唯一 ID)。
示例:如果你想使用 UUID 作为主键,你可以使用
IdType.ASSIGN_UUID
:@TableId(value = "user_id", type = IdType.ASSIGN_UUID) private String userId;
5、条件构造器 常用查询
MyBatis-Plus 提供了强大的条件构造器,使得在查询数据库时可以灵活地构建条件,而无需手动编写复杂的 SQL 语句。主要通过 Wrapper
接口及其常用实现类 QueryWrapper
和 LambdaQueryWrapper
来实现条件查询。
1. Wrapper
接口
Wrapper
是 MyBatis-Plus 提供的条件构造器接口,用于构建动态 SQL。它有多个实现类,其中最常用的是 QueryWrapper
和 LambdaQueryWrapper
。
2. QueryWrapper
QueryWrapper
是 MyBatis-Plus 提供的一个通用条件构造器,用于以非 Lambda 表达式的方式构建查询条件。
常用方法:
- eq: 等于
- ne: 不等于
- gt: 大于
- ge: 大于等于
- lt: 小于
- le: 小于等于
- between: 在两者之间
- like: 模糊查询
- or: 或条件
- and: 并且条件
- orderByAsc: 升序排序
- orderByDesc: 降序排序
- in: 在指定范围内
- inSql: 允许你使用子查询的结果集作为 IN 条件的范围
- isNull: 判断字段是否为 NULL
- isNotNull: 判断字段是否不为 NULL
示例:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper
.eq("name", "张三") // name 等于 张三。 eq也可以写三个参数, 第一个参数是boolean, false 表示这个条件不起作用, true 表示起作用
.ge("age", 18) // age 大于等于 18
.like("email", "gmail.com") // email 包含 gmail.com
.orderByDesc("create_time"); // 按 create_time 降序排列
List<User> users = userMapper.selectList(queryWrapper);
3. LambdaQueryWrapper
LambdaQueryWrapper
是 QueryWrapper
的 Lambda 版本,用于在构建条件时避免使用字符串来指定字段,增加了类型安全性。它推荐使用字段的 Lambda 表达式来构建条件。
示例:
LambdaQueryWrapper<User> lambdaQuery = new LambdaQueryWrapper<>();
lambdaQuery
.eq(User::getName, "张三") // name 等于 张三
.ge(User::getAge, 18) // age 大于等于 18
.like(User::getEmail, "gmail.com") // email 包含 gmail.com
.orderByDesc(User::getCreateTime); // 按 create_time 降序排列
List<User> users = userMapper.selectList(lambdaQuery);
4. UpdateWrapper
和 LambdaUpdateWrapper
这两个类分别是用于构建更新条件的构造器,功能与 QueryWrapper
和 LambdaQueryWrapper
类似,但用于 UPDATE
操作。
示例:
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper
.eq("name", "张三")
.set("age", 30); // 将年龄更新为 30
userMapper.update(null, updateWrapper);
具体用法可参考 Mybatis plus 官网
6、高级查询
6.1 分组查询
示例 :按 age
分组并统计人数
假设你想统计各个年龄段的人数,可以使用如下代码:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("age", "COUNT(*) as count");
queryWrapper.groupBy("age");
List<Map<String, Object>> result = userMapper.selectMaps(queryWrapper);
生成的 SQL:
SELECT age, COUNT(*) as count FROM user GROUP BY age;
6.2 聚合查询
示例 :按 age
分组并过滤统计结果(HAVING
)
如果你只想统计人数大于 1 的年龄段,可以添加 HAVING
条件:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("age", "COUNT(*) as count");
queryWrapper.groupBy("age");
queryWrapper.having("COUNT(*) > 1");
List<Map<String, Object>> result = userMapper.selectMaps(queryWrapper);
生成的 SQL:
SELECT age, COUNT(*) as count FROM user GROUP BY age HAVING COUNT(*) > 1;
6.3 排序查询
示例 1:按 age
升序和 name
升序排序
假设你想首先按用户的年龄升序排序,然后按姓名升序排序,可以使用如下代码:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByAsc("age").orderByAsc("name");
List<User> result = userMapper.selectList(queryWrapper);
生成的 SQL:
SELECT * FROM user ORDER BY age ASC, name ASC;
示例 2:按 age
降序排序
假设你想按用户的年龄降序排序,可以使用如下代码:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("age");
List<User> result = userMapper.selectList(queryWrapper);
生成的 SQL:
SELECT * FROM user ORDER BY age DESC;
示例 3:按 age
升序和 name
降序组合排序
假设你想先按年龄升序排序,再按姓名降序排序,可以使用如下代码:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByAsc("age").orderByDesc("name");
List<User> result = userMapper.selectList(queryWrapper);
生成的 SQL:
SELECT * FROM user ORDER BY age ASC, name DESC;
示例 4:按多字段排序,并指定是否为空
假设你想按 age
升序排序,并希望将 name
为空的记录排在前面,可以使用如下代码:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByAsc("age").orderByAsc("name", true);
List<User> result = userMapper.selectList(queryWrapper);
生成的 SQL:
SELECT * FROM user ORDER BY age ASC, name ASC;
6.4 逻辑查询
func
方法是 MyBatis-Plus 提供的一个非常灵活的功能,它允许你将一段自定义的逻辑包装到查询条件中。这对于需要根据不同的条件来动态构建查询的场景特别有用。下面是对 func
方法的详细解释。
1. func
方法的基本用法
func
方法接收一个 Consumer
,该 Consumer
的参数是 QueryWrapper
(或 LambdaQueryWrapper
)的一个实例。你可以在这个 Consumer
中编写自定义的逻辑,并根据不同的条件来动态地添加或修改查询条件。
语法结构
queryWrapper.func(wrapper -> {
// 在这里编写自定义逻辑
if (condition) {
wrapper.eq("column", value);
} else {
wrapper.ne("column", value);
}
});
主要参数
Consumer<QueryWrapper>
或Consumer<LambdaQueryWrapper>
:这是一个函数式接口,允许你传入一个 Lambda 表达式或方法引用。你可以在这个接口的accept
方法中实现自己的逻辑。
实际应用场景
假设你有一个用户查询接口,允许用户根据不同的条件来过滤结果,例如按 id
或按 name
。你可以使用 func
来根据用户输入动态地构建查询条件。
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.func(wrapper -> {
if (userInput != null && userInput.isValid()) {
wrapper.eq(User::getName, userInput.getName());
} else {
wrapper.ne(User::getId, 1);
}
});
List<User> users = userMapper.selectList(lambdaQueryWrapper);
- 示例解释:
- 如果
userInput
非空且有效,则查询条件为name = userInput.getName()
。 - 否则,查询条件为
id != 1
。
- 如果
2. and
和 or
的使用
在 MyBatis-Plus 中,and
和 or
用于在构建查询条件时处理多条件的逻辑运算。它们允许你在查询中组合多个条件,以实现复杂的查询逻辑。
and
方法
and
方法用于将多个查询条件通过逻辑“与” (AND
) 连接在一起。它将多个条件组合成一个大的 AND
条件,从而要求所有这些条件都必须满足。
示例
假设你有一个 User
表,你想查询年龄大于 20 且名字为 "Jack" 的用户。可以使用以下代码:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 20).and(wrapper -> wrapper.eq("name", "Jack"));
List<User> users = userMapper.selectList(queryWrapper);
生成的 SQL:
SELECT * FROM user WHERE age > 20 AND name = 'Jack';
在这个例子中,and
方法的作用是将 .gt("age", 20)
和 .eq("name", "Jack")
这两个条件通过 AND
组合在一起。
or
方法
or
方法用于将多个查询条件通过逻辑“或” (OR
) 连接在一起。它将多个条件组合成一个大的 OR
条件,只要其中一个条件满足,就会返回符合的结果。
示例
假设你有一个 User
表,你想查询年龄大于 20 或名字为 "Jack" 的用户。可以使用以下代码:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 20).or(wrapper -> wrapper.eq("name", "Jack"));
List<User> users = userMapper.selectList(queryWrapper);
生成的 SQL:
SELECT * FROM user WHERE age > 20 OR name = 'Jack';
在这个例子中,or
方法的作用是将 .gt("age", 20)
和 .eq("name", "Jack")
这两个条件通过 OR
组合在一起。
组合使用 and
和 or
你还可以结合使用 and
和 or
方法,以构建更复杂的查询。例如,如果你想查询年龄大于 20 且(名字为 "Jack" 或邮箱为 "test@example.com")的用户,可以使用以下代码:
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 20)
.and(wrapper -> wrapper.eq("name", "Jack")
.or().eq("email", "test@example.com"));
List<User> users = userMapper.selectList(queryWrapper);
生成的 SQL:
SELECT * FROM user WHERE age > 20 AND (name = 'Jack' OR email = 'test@example.com');
在这个例子中,and
和 or
方法的结合使用允许你在 age > 20
的基础上,增加一个组合条件 (name = 'Jack' OR email = 'test@example.com')
。
6.5 其他查询
apply
方法
apply
方法允许你直接在 QueryWrapper
中插入自定义的 SQL 片段。apply 方法中的 SQL 片段会被添加到 WHERE 子句的末尾。这允许你在现有的查询条件基础上,添加更复杂的条件或函数。
基本用法:
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.apply("DATE_FORMAT(create_time, '%Y-%m-%d') = {0}", "2024-09-01");
在这个示例中:
apply
方法接受一个 SQL 片段作为第一个参数,并可以通过{}
占位符来插入参数。- 这里使用了
DATE_FORMAT
函数来格式化create_time
字段,并将其与特定的日期进行比较。
last
方法
last
方法用于在生成的 SQL 查询的末尾添加额外的 SQL 片段。通常用于添加额外的 SQL 语句,如 ORDER BY
, LIMIT
, OFFSET
等,这些操作是在生成的 SQL 的最后部分进行的。
基本用法:
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.last("LIMIT 5");
在这个示例中:
last
方法添加了一个LIMIT 5
子句到查询的末尾,用于限制结果集的返回行数。
示例
假设你有一个 User
表,并且想要查询所有 age
大于 20 的用户,并且结果按照 id
降序排列,并且只返回前 10 条记录。你可以使用 apply
和 last
方法来实现这个需求:
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.gt("age", 20) // age > 20
.orderByDesc("id") // 按 id 降序排序
.last("LIMIT 10"); // 限制返回结果为前 10 条
以上内容包含了 mybatis plus
的大部分常用内容,基本能满足大部分需求。
其他内容 ... 待更~