- 关于Mybatis-Plus
- 快速开始
- 创建一个SpringBoot项目
- 导入Maven依赖
- 创建数据库和表
- 修改配置文件
- 创建实体类
- 创建mapper接口
- 添加MapperScan注解
- 编写测试类
- 配置日志输出
- 基本的CRUD
- 通用的Mapper
- 通用Service
- 自定义Mapper
- 自定义Service
- 常用注解
- 数据库分表
- 默认算法
- 背景
- 分表思路
- 主键自增
- Hash
- 雪花算法
- TableName
- TableId
- 指定主键列
- value属性
- type属性
- TableField
- value属性
- 非数据库字段
- 自动填充
- TableLogic
- 逻辑删除
- 实现逻辑删除
- 测试
- 插件
- 分页插件
- XML自定义分页
- 乐观锁
- 场景
- 乐观锁方案
- 乐观锁实现流程
- 优化流程
- 条件构造器
- Wrapper家族
- 创建测试类
- QueryWrapper
- 参数列表
- 例1:组装查询条件
- 例2:组装排序条件
- 例3:组装删除条件
- 例4:条件的优先级
- 例6:实现子查询
- UpdateWrapper
- 例7:需求同例4
- condition
- 例8:动态组装查询条件
- LambdaXxxWrapper
- 例9:Query - 需求同例8
- 例10:Update - 需求同例4
- 例10:Update - 需求同例4
学习一门技术,不去官网看一下直接开始肯定是耍流氓,官网地址
通过官网,我们可以看到,MyBatis-Plus的特点是,不会对原有的项目侵入,可以简化我们单表操作,具有丰富的功能。
===================================== ----------- Scan Entity ----------- | Reflection extraction | v -------------------------- ==============MybatisPlus============== Analysis Table Name Column -------------------------------- -------------------------- mybatis-plus-boot-starter | -------------------------------- SQL:Insert、Update、Delete、Select 《---- ------------ ------------ | annotation extension v ------------ ------------ --------------------------- ------------ ------------ Injection Mybatis Container core generator --------------------------- ------------ ------------ ===================================== ======================================
大概翻译一下,就是只要你导入了mybatis-plus-boot-starter的maven依赖,Mybatis-Plus会扫描你的实体类,通过反射机制,分析你的表名称,生成基本的CRUD语句,注入到Mybatis容器中。
mybatis-plus-boot-starter中的功能
- annotation
- extension
- core
- generator
org.springframework.boot spring-boot-starter-parent 2.3.4.RELEASE org.springframework.boot spring-boot-starter com.baomidou mybatis-plus-boot-starter 3.4.1 mysql mysql-connector-java runtime org.projectlombok lombok true org.springframework.boot spring-boot-starter-test test org.junit.vintage junit-vintage-engine
为什么有的依赖写了版本号,有的依赖没有写版本号呢?
不用写版本号的他的版本已经被父项目spring-boot-starter-parent管理了,你也可以自己指定版本,maven会优先使用你自己指定的版本。
创建数据库和表创建mybatis_plus数据库
创建数据表:user
CREATE TABLE user ( id BIGINT(20) NOT NULL COMMENT '主键ID', name VARCHAr(30) NULL DEFAULT NULL COMMENT '姓名', age INT(11) NULL DEFAULT NULL COMMENT '年龄', email VARCHAr(50) NULL DEFAULT NULL COMMENT '邮箱', PRIMARY KEY (id) ); INSERT INTO user (id, name, age, email) VALUES (1, 'Jone', 18, 'test1@baomidou.com'), (2, 'Jack', 20, 'test2@baomidou.com'), (3, 'Tom', 28, 'test3@baomidou.com'), (4, 'Sandy', 21, 'test4@baomidou.com'), (5, 'Billie', 24, 'test5@baomidou.com');修改配置文件
# mysql数据库连接 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.url=jdbc:mysql://192.168.5.123:3306/mybatis_plus?serverTimezone=GMT%2B8&characterEncoding=utf-8 spring.datasource.username=root spring.datasource.password=root
注意
-
- 如果你使用的是mysql8以上的版本,数据库驱动和我的一样,并且一定要url后面加入serverTimezone=GMT%2B8&配置
- 如果不是你的数据库驱动应该选择:com.mysql.jdbc.Driver
@Data
public class User {
private Long id;
private String name;
private Integer age;
private String email;
}
创建mapper接口
public interface UserMapper extends BaseMapper{ }
关于BaseMapper?
mapper映射器,在这里我的理解是映射Java接口和数据库操作。Base通用,所有BaseMapper是一个泛型接口。
两个合在一起就是通用的映射器。点进去一看,类的编写者告诉我们只要继承该接口后,无需编写 mapper.xml 文件,即可获得CRUD功能。
添加MapperScan注解可以在启动类上面添加,也可以抽取一个配置类专门写mybaits-plus注解
@MapperScan("com.zxl.mybatisplus.mapper")
@SpringBootApplication
public class MybatisPlusApplication {
public static void main(String[] args) {
SpringApplication.run(MybatisPlusApplication.class, args);
}
}
编写测试类
@SpringBootTest // 自动创建springboot运行环境
class MybatisPlusApplicationTests {
// @Autowired // 默认按类型装配。是spring的注解
@Resource // 默认按名称装配,找不到与名称匹配的bean,则按照类型装配。是J2EE的注解
private UserMapper userMapper;
@Test
void testSelectList() {
// selectList()方法的参数:封装了查询条件
// null:无任何查询条件
List users = userMapper.selectList(null);
users.forEach(System.out::println);
}
}
配置日志输出
# mybatis日志 mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl基本的CRUD 通用的Mapper
官方说明
- 通用 CRUD 封装BaseMapper(opens new window)接口,为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器
- 泛型 T 为任意实体对象
- 参数 Serializable 为任意类型主键 Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
- 对象 Wrapper 为 条件构造器
测试通用的Mapper接口
- 插入接口
@Test
public void testInsert() {
User user = new User();
user.setName("小霖");
user.setAge(18);
// 如果不设置email属性,则生成的动态sql中不包括email字段
user.setEmail("12345678@qq.com");
int result = userMapper.insert(user);
System.out.println("影响的行数:" + result); // 影响的行数
System.out.println("id:" + user.getId()); // id自动回填
}
- 删除接口
@Test
public void testDelete() {
int result = userMapper.deleteById(5);
System.out.println("影响的行数:" + result);
}
- 更新接口
@Test
public void testUpdate() {
User user = new User();
user.setId(1L);
user.setAge(28);
// 注意:update时生成的sql自动是动态sql
int result = userMapper.updateById(user);
System.out.println("影响的行数:" + result);
}
- 查询接口
@Test
public void testSelect() {
//按id查询
User user = userMapper.selectById(1);
System.out.println(user);
//按id列表查询
List users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
users.forEach(System.out::println);
//按条件查询
Map map = new HashMap<>();
map.put("name", "小霖"); //注意此处是表中的列名,不是类中的属性名
map.put("age", 18);
List userList = userMapper.selectByMap(map);
userList.forEach(System.out::println);
}
通用Service
官方说明
- 通用 Service CRUD 封装IService (opens new window)接口,进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆,
- 泛型 T 为任意实体对象
- 建议如果存在自定义通用 IService 方法的可能,请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
- 对象 Wrapper 为 条件构造器
快速上手
- 创建UserService接口实现Iservice接口,在IService接口中定义了需要实现的业务接口
public interface UserService extends IService{ }
- 创建UserServiceImpl方法实现UserService接口,Mybatis-Plus帮我们实现了IService接口,我们只需要按照规定继承ServiceImpl接口,传入指定泛型即可
@Service public class UserServiceImpl extends ServiceImplimplements UserService { }
关于IService中的方法
测试Service接口
- 创建测试类
@SpringBootTest
public class ServiceTests {
@Resource
private UserService userService;
}
- 测试统计数据
@Test
public void testCount() {
int count = userService.count();
System.out.println("总记录数:" + count);
}
- 测试批量保存
@Test
public void testSaveBatch() {
// SQL长度有限制,海量数据插入单条SQL无法实行,
// 因此MP将批量插入放在了通用Service中实现,而不是通用Mapper
ArrayList users = new ArrayList<>();
for (int i = 0; i < 5; i++) {
User user = new User();
user.setName("小霖" + i + "号");
user.setAge(10 + i);
users.add(user);
}
boolean result = userService.saveBatch(users);
System.out.print("批量插入:");
System.out.println(result ? "成功" : "失败");
}
自定义Mapper
- 在UserMapper接口中添加一个自定义方法
public interface UserMapper extends BaseMapper{ List selectAllByName(String name); }
- 在resource资源文件夹下创建mapper文件夹
- 在mapper文件夹创建UserMapper.xml文件
id, name, age, email
- 测试自定义Mapper
@Test
public void testSelectAllByName(){
List users = userMapper.selectAllByName("Helen");
users.forEach(System.out::println);
}
- 修改默认文件名称
如果是其他目录,需要配置在properties配置文件中配置mapper-locations属性
例如:修改mapper文件夹为xml文件夹
mybatis-plus.mapper-locations=classpath:xml IPage selectPageByPage(Page> page, Integer age);
- 定义XML
# Base_Column_List是上面定义了的 SELECTFROM user WHERe age > #{age}
- 测试
@Test
public void testSelectPageVo(){
Page pageParam = new Page<>(1,5);
userMapper.selectPageByPage(pageParam, 18);
List users = pageParam.getRecords();
users.forEach(System.out::println);
}
- SQL语句
# 先统计记录数是否大于0,小于0就不执行下面的语句了 SELECT COUNT(*) FROM t_user WHERe age > ? # mybatis-plus自动帮助我们添加了分页 SELECt uid, name, age, email FROM t_user WHERe age > ? LIMIT ?乐观锁 场景
一件商品,成本价是80元,售价是100元。老板先是通知小李,说你去把商品价格增加50元。小李正在玩游戏,耽搁了一个小时。正好一个小时后,老板觉得商品价格增加到150元,价格太高,可能会影响销量。又通知小王,你把商品价格降低30元。
此时,小李和小王同时操作商品后台系统。小李操作的时候,系统先取出商品价格100元;小王也在操作,取出的商品价格也是100元。小李将价格加了50元,并将100+50=150元存入了数据库;小王将商品减了30元,并将100-30=70元存入了数据库。是的,如果没有锁,小李的操作就完全被小王的覆盖了。
现在商品价格是70元,比成本价低10元。几分钟后,这个商品很快出售了1千多件商品,老板亏1万多。
接下来将我们演示这一过程:
step1:数据库中增加商品表
CREATE TABLE product ( id BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID', name VARCHAr(30) NULL DEFAULT NULL COMMENT '商品名称', price INT(11) DEFAULT 0 COMMENT '价格', version INT(11) DEFAULT 0 COMMENT '乐观锁版本号', PRIMARY KEY (id) ); INSERT INTO product (id, NAME, price) VALUES (1, '笔记本', 100);
step2:创建实体类
package com.zxl.mybatisplus.entity;
@Data
public class Product {
private Long id;
private String name;
private Integer price;
private Integer version;
}
step3:创建Mapper
package com.zxl.mybatisplus.mapper;
public interface ProductMapper extends BaseMapper {
}
step4:测试
@Resource
private ProductMapper productMapper;
@Test
public void testConcurrentUpdate() {
//1、小李
Product p1 = productMapper.selectById(1L);
//2、小王
Product p2 = productMapper.selectById(1L);
//3、小李将价格加了50元,存入了数据库
p1.setPrice(p1.getPrice() + 50);
int result1 = productMapper.updateById(p1);
System.out.println("小李修改结果:" + result1);
//4、小王将商品减了30元,存入了数据库
p2.setPrice(p2.getPrice() - 30);
int result2 = productMapper.updateById(p2);
System.out.println("小王修改结果:" + result2);
//最后的结果
Product p3 = productMapper.selectById(1L);
System.out.println("最后的结果:" + p3.getPrice());
}
乐观锁方案
# 小李取数据 version=0 SELECT id,name,price,version FROM product WHERe id=1 # 小王取数据 version=0 SELECt id,name,price,version FROM product WHERe id=1 # 小李改数据 price + 50 version=1 UPDATe product SET price=price+50, version=version + 1 WHERe id=1 AND version=0 # 小王改数据 price - 30 version=0 UPDATE product SET price=100-30, version=version + 1 WHERe id=1 AND version=0 # 小王修改失败,重新修改 # 小王重新获取数据version = 1, price = 150 SELECT id,name,price,version FROM product WHERe id=1 # 小王重新修改 UPDATe product SET price=150-30, version=1 + 1 WHERe id=1 AND version=1
接下来介绍如何在Mybatis-Plus项目中,使用乐观锁
乐观锁实现流程step1:修改实体类
添加 @Version 注解
@Version private Integer version;
step2:添加乐观锁插件
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());//乐观锁
step3:重新执行测试
小王的修改失败!
失败后重试
if(result2 == 0){//更新失败,重试
System.out.println("小王重试");
//重新获取数据
p2 = productMapper.selectById(1L);
//更新
p2.setPrice(p2.getPrice() - 30);
productMapper.updateById(p2);
}
条件构造器
Wrapper家族
在MP中我们可以使用通用Mapper(BaseMapper)实现基本查询,也可以使用自定义Mapper(自定义XML)来实现更高级的查询。当然你也可以结合条件构造器来方便的实现更多的高级查询。
继承结构
-
Wrapper : 条件构造抽象类,最顶端父类
-
- AbstractWrapper : 用于查询条件封装,生成 sql 的 where 条件
-
-
- QueryWrapper : 查询条件封装
- UpdateWrapper : Update 条件封装
-
-
- AbstractLambdaWrapper : 使用Lambda 语法
-
-
- LambdaQueryWrapper :用于Lambda语法使用的查询Wrapper
- LambdaUpdateWrapper : Lambda 更新封装Wrapper
-
@SpringBootTest
public class WrapperTests {
@Resource
private UserMapper userMapper;
}
QueryWrapper
参数列表
| allEq | 基于map的相等 |
|---|---|
| eq | 等于 = |
| ne | 不等于 <> |
| gt | 大于 > |
| ge | 大于等于 <= |
| lt | 小于 < |
| le | 小于等于 <= |
| between | BETWEEN 值 1 AND 值 2 |
| notBetween | NOT BETWEEN 值 1 AND 值 2 |
| like | LIKE ‘%值%’ |
| notLike | NOT LIKE ‘%值%’ |
| likeLeft | LIKE ‘%值’ |
| likeRight | LIKE ‘值%’ |
| isNull | 字段 IS NULL |
| isNotNull | 字段 IS NOT NULL |
| in | 字段 IN (value1,value2) |
| notLn | 字段 NOT IN (value1,value2) |
| inSql | 字段 IN (sql 语句) |
| notInSql | 字段 NOT IN (sql 语句) |
| groupBy | GROUP BY 字段 |
| orderByAsc | 升序 ORDER BY 字段,…ASC |
| orderByDASC | 降序 ORDER BY 字段,…DASC |
| having | 条件分组 |
| or | OR 语句 ,拼接 + OR 字段=值 |
| and | AND 语句 ,拼接 + AND 字段=值 |
| apply | 拼接 sql |
| last | 在 sql 语句后面拼接自定义条件 |
| exist | 拼接 EXOSTS (sql语句) |
| notExists | 拼接 NOT EXOSTS (sql语句) |
| nested | 正常嵌套 不带 AND 或者 OR |
查询名字中包含n,年龄大于等于10且小于等于20,email不为空的用户
@Test
public void test1() {
QueryWrapper queryWrapper = new QueryWrapper<>();
queryWrapper
.like("name", "小")
.between("age", 10, 15)
.isNotNull("email");
List userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
例2:组装排序条件
按年龄降序查询用户,如果年龄相同则按id升序排列
@Test
public void test2() {
QueryWrapper queryWrapper = new QueryWrapper<>();
queryWrapper
.orderByDesc("age")
.orderByAsc("id");
List users = userMapper.selectList(queryWrapper);
users.forEach(System.out::println);
}
例3:组装删除条件
删除email为空的用户
@Test
public void test3() {
QueryWrapper queryWrapper = new QueryWrapper<>();
queryWrapper.isNull("email");
int result = userMapper.delete(queryWrapper); //条件构造器也可以构建删除语句的条件
System.out.println("delete return count = " + result);
}
例4:条件的优先级
查询名字中包含小,且(年龄小于18或email为空的用户),并将这些用户的年龄设置为18,邮箱设置为user@yunzhan.com
@Test
public void test4() {
QueryWrapper queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "小")
.and(i -> i.lt("age", 18).or().isNull("email"));
// 组装更新条件
User user = new User();
user.setEmail("user@yunzhan.com");
user.setAge(18);
// 更新
int result = userMapper.update(user, queryWrapper);
System.out.println("update return count = " + result);
}
生成的SQL
UPDATE t_user SET age=?, email=?, update_time=? WHERe is_deleted=0 AND (name LIKE ? AND (age < ? OR email IS NULL))
例5:组装select子句
查询所有用户的用户名和年龄
@Test
public void test5() {
QueryWrapper queryWrapper = new QueryWrapper<>();
queryWrapper.select("name", "age");
//selectMaps()返回Map集合列表,通常配合select()使用,避免User对象中没有被查询到的列值为null
List
例6:实现子查询
查询id不大于3的所有用户的id列表
@Test
public void test6() {
QueryWrapper queryWrapper = new QueryWrapper<>();
queryWrapper.inSql("id", "select id from user where id <= 3");
//selectObjs的使用场景:只返回一列
List
但上面的方式容易引发sql注入
// 或插叙出所有用户id
queryWrapper.inSql("uid", "select id from t_user where uid <= 3 or true");
可是使用下面的查询方式替换
queryWrapper.in("uid", 1, 2, 3 );
// 或
queryWrapper.le("uid", 3 );
UpdateWrapper
例7:需求同例4
查询名字中包含小,且(年龄小于18或email为空的用户),并将这些用户的年龄设置为18,邮箱设置为 user@yunzhan.com
@Test
public void test7() {
//组装set子句
UpdateWrapper updateWrapper = new UpdateWrapper<>();
updateWrapper
.set("age", 18)
.set("email", "user@atguigu.com")
.like("name", "n")
.and(i -> i.lt("age", 18).or().isNull("email")); //lambda表达式内的逻辑优先运算
//这里必须要创建User对象,否则无法应用自动填充。如果没有自动填充,可以设置为null
User user = new User();
int result = userMapper.update(user, updateWrapper);
System.out.println(result);
}
condition
例8:动态组装查询条件
查询名字中包含n,年龄大于10且小于20的用户,查询条件来源于用户输入,是可选的
@Test
public void login() {
String name = "小";
Integer startAge = 10;
Integer endAge = 20;
test8(name, startAge, endAge);
}
@Test
public void test8(String name, Integer startAge, Integer endAge) {
QueryWrapper queryWrapper = new QueryWrapper<>();
if (StringUtils.isNotBlank(name)) {
queryWrapper.like("name", name);
}
if (startAge != null) {
queryWrapper.ge("age", startAge);
}
if (endAge != null) {
queryWrapper.le("age", endAge);
}
List users = userMapper.selectList(queryWrapper);
users.forEach(System.out::println);
}
SELECT uid AS id,name,age,email,create_time,update_time,is_deleted AS deleted FROM t_user WHERe is_deleted=0 AND (name = ? AND age >= ? AND age <= ?)
上面的实现方案没有问题,但是代码比较复杂,我们可以使用带condition参数的重载方法构建查询条件,简化代码的编写
@Test
public void login() {
String name = "小";
Integer startAge = 10;
Integer endAge = 20;
test8Condition(name, startAge, endAge);
}
@Test
public void test8Condition(String name, Integer startAge, Integer endAge) {
QueryWrapper queryWrapper = new QueryWrapper<>();
queryWrapper
.like(StringUtils.isNotBlank(name), "name", "小")
.ge(startAge != null, "age", startAge)
.le(endAge != null, "age", endAge);
List users = userMapper.selectList(queryWrapper);
users.forEach(System.out::println);
}
LambdaXxxWrapper
避免使用字符串表示字段,防止运行时错误
例9:Query - 需求同例8@Test
public void login() {
String name = "小";
Integer startAge = 10;
Integer endAge = 20;
test9(name, startAge, endAge);
}
@Test
public void test9() {
//定义查询条件,有可能为null(用户未输入)
String name = null;
Integer ageBegin = 10;
Integer ageEnd = 20;
LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
queryWrapper
//避免使用字符串表示字段,防止运行时错误
.like(StringUtils.isNotBlank(name), User::getName, "n")
.ge(ageBegin != null, User::getAge, ageBegin)
.le(ageEnd != null, User::getAge, ageEnd);
List users = userMapper.selectList(queryWrapper);
users.forEach(System.out::println);
}
例10:Update - 需求同例4
@Test
public void login() {
String name = "小";
Integer startAge = 10;
Integer endAge = 20;
test10(name, startAge, endAge);
}
@Test
public void test10(String name, Integer startAge, Integer endAge) {
// 组装set子句
LambdaUpdateWrapper updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.set(User::getAge, 18)
.set(User::getEmail, "user@yunzhan.com")
.like(User::getName, "小")
// lambda表达式内的逻辑优先运算
.and(i -> i.lt(User::getAge, 18).or().isNull(User::getEmail));
User user = new User();
int result = userMapper.update(user, updateWrapper);
System.out.println("update return count = " + result);
}
Integer startAge = 10;
Integer endAge = 20;
test9(name, startAge, endAge);
}
@Test
public void test9() {
//定义查询条件,有可能为null(用户未输入)
String name = null;
Integer ageBegin = 10;
Integer ageEnd = 20;
LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
queryWrapper
//避免使用字符串表示字段,防止运行时错误
.like(StringUtils.isNotBlank(name), User::getName, "n")
.ge(ageBegin != null, User::getAge, ageBegin)
.le(ageEnd != null, User::getAge, ageEnd);
List users = userMapper.selectList(queryWrapper);
users.forEach(System.out::println);
}
例10:Update - 需求同例4
@Test
public void login() {
String name = "小";
Integer startAge = 10;
Integer endAge = 20;
test10(name, startAge, endAge);
}
@Test
public void test10(String name, Integer startAge, Integer endAge) {
// 组装set子句
LambdaUpdateWrapper updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.set(User::getAge, 18)
.set(User::getEmail, "user@yunzhan.com")
.like(User::getName, "小")
// lambda表达式内的逻辑优先运算
.and(i -> i.lt(User::getAge, 18).or().isNull(User::getEmail));
User user = new User();
int result = userMapper.update(user, updateWrapper);
System.out.println("update return count = " + result);
}



