1.入门案例
1.建库&建表&添加数据
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` bigint(0) NOT NULL AUTO_INCREMENT COMMENT '主键id',
`name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '姓名',
`age` int(0) NULL DEFAULT NULL COMMENT '年龄',
`email` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, '张三', 17, NULL);
INSERT INTO `user` VALUES (2, '李四', 16, '123456@163.net');
INSERT INTO `user` VALUES (3, '王五', 15, '352641@qq.com');
INSERT INTO `user` VALUES (4, '赵六', 14, NULL);
INSERT INTO `user` VALUES (5, '陈七', 13, '951463@263.net');
SET FOREIGN_KEY_CHECKS = 1;
2.新建springboot项目
-
依赖
<!--mybatis-plus--> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.4.1</version> </dependency> <!--mysql驱动--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> <!--druid数据源--> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.8</version> </dependency> <!--lombok--> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </dependency> -
application.yml
spring: # 配置数据源信息 datasource: # 配置数据源类型 type: com.alibaba.druid.pool.DruidDataSource # 配置连接数据库的信息 driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT&characterEncoding=utf-8&useSSL=false username: root password: admin- 注意：
- spring boot 2.0（内置jdbc5驱动），spring boot 2.1及以上（内置jdbc8驱动）
- jdbc5驱动：driver-class-name:
com.mysql.jdbc.Driver - jdbc8驱动：driver-class-name:
com.mysql.cj.jdbc.Driver
- jdbc5驱动：driver-class-name:
- mysql连接地址url
- mysql5.7：
jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8&useSSL=false - mysql8.0：
jdbc:mysql://localhost:3306/mybatis_plus? serverTimezone=UTC&characterEncoding=utf-8&useSSL=false
- mysql5.7：
- spring boot 2.0（内置jdbc5驱动），spring boot 2.1及以上（内置jdbc8驱动）
- 注意：
3.新建实体类
@Data
public class User {
private Long id;
private String name;
private Integer age;
private String email;
}
@Data lombok注解，内容如下：
无参构造 + setter + getter + equals( hashCode ) + toString
4.创建mapper接口并扫描
UserMapper 接口：
@Repository
public interface UserMapper extends BaseMapper<User> {
}
- UserMapper继承BaseMapper接口
@Repository
将类或接口标识为持久层组件
启动类扫描 UserMapper 接口：
@SpringBootApplication
@MapperScan("com.chenjy.mp_demo.mapper")
public class MpDemoApplication {
public static void main(String[] args) {
SpringApplication.run(MpDemoApplication.class, args);
}
}
@MapperScan
扫描mapper所在包或接口- 右键——copy path/xxx
5.测试类测试
@SpringBootTest
class MpDemoApplicationTests {
@Resource
private UserMapper userMapper;
/**
* @Description 查询一个list集合，如果没有条件，就直接传参 null
*/
@Test
public void testGetAll() {
List<User> users = userMapper.selectList(null);
users.forEach(System.out::println);
}
}
6.添加日志，显示查询语句
配置文件：
mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
重新启动测试类，可以在控制台打印SQL语句：
7.测试增删改查
1.插入单条数据
@Test
public void testInsert() {
User user = new User();
user.setName("李华");
System.out.println("flag: " + userMapper.insert(user));
}
注意： mybatisplus默认使用雪花算法生成主键，如下图，这就是为啥要把id设为bigint类型并用Long接收。
2.删除
-
deleteById@Test public void testDelete() { userMapper.deleteById(1569870313976463362L); } -
deleteByMap@Test public void testDeleteByMap() { Map<String, Object> map = new HashMap<>(); map.put("name", "张三"); map.put("id", 1); userMapper.deleteByMap(map); }
-
testDeleteBatchIds@Test public void testDeleteBatchIds() { List<Long> list = Arrays.asList(2L, 3L); userMapper.deleteBatchIds(list); }
3.修改
updateById@Test public void testUpdate() { User user = new User(); user.setId(4L); user.setName("小明"); userMapper.updateById(user); }
4.查询
-
selectById@Test public void testSelect() { userMapper.selectById(4L); } -
selectList@Test public void testSelectList() { userMapper.selectList(null); }
-
selectBatchIds@Test public void testSelectBatch() { List<Long> list = Arrays.asList(4L, 5L); userMapper.selectBatchIds(list); }
-
selectByMap@Test public void testSelectByMap() { Map<String, Object> map = new HashMap<>(); map.put("id", 4); map.put("name", "小明"); userMapper.selectByMap(map); }
8.测试自定义功能
mybatis-plus.mapper-locations的默认路径是： classpath*:/mapper/**/*.xml，所以需要配置一下：
mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
mapper-locations: classpath:/mapper/*.xml
-
在 resources.mapper 下创建一个映射文件 UserMapper
<?xml version="1.0" encoding="utf-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <mapper namespace="com.chenjy.mp_demo.mapper.UserMapper"> </mapper> -
在 UserMapper 接口中自定义方法
Map<String, Object> selectMapById(Long id); -
在 UserMapper 中写SQL语句
<select id="selectMapById" resultType="map"> select id, name, age, email from user where id = #{id} </select> -
测试方法
@Test public void testSelectMapById() { Map<String, Object> map = userMapper.selectMapById(4L); System.out.println(map); }
9.通用Service
1.Service
- 新建 UserService接口继承 IService<T> 接口
public interface UserService extends IService<User> { }- IService 接口：封装了常见的业务层逻辑，其实现类为 ServiceImpl
- 新建 UserServiceImpl 实现 UserService接口
@Service public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService { }- 继承 ServiceImpl 是因为，UserService 继承了 IService 接口，如果不继承 ServiceImpl，则必须去实现 IService 接口的方法
- 这时候， UserServiceImpl 既可以直接使用通用Service的功能，也能自定义新功能
2.测试
-
count@SpringBootTest public class MPServiceTest { @Resource private UserService userService; @Test public void testGetCount() { userService.count(); } }
-
saveBatch@Test public void testInsertBatch() { ArrayList<User> users = new ArrayList<>(); for (int i = 0; i < 5; i++) { User user = new User(); user.setName("张三" + i + "号"); user.setAge(13 + i); users.add(user); } userService.saveBatch(users); }
2.Mybatis-plus常用注解
1.@TableName
@TableName 当数据库表名与实体类名不一致的时候使用
-
场景演示，将数据库的表名更改为 mp_user，实体类名依然保持为 User，执行测试代码，报错如下：
-
如何使用
@TableName来解决上述报错：直接在实体类上添加@TableName("mp_user")@Data @TableName("mp_user") public class User { private Long id; private String name; private Integer age; private String email; }
2.全局配置表名前缀
当数据库所有的表的表名都有一个统一前缀的时候，如果使用@TableName就会显得繁琐，那么就需要用到 mybatis-plus全局配置 了。
配置如下：
mybatis-plus:
# 设置mybatis-plus全局配置
global-config:
db-config:
# 设置表名统一前缀
table-prefix: mp_
3.@TableId
@TableId 将某个成员变量指定为数据表主键
- 当实体类的主键字段名（id）与表中主键字段名（uid）不同时，使用
@TableId("uid") private Long id; value- 仅传入一个参数的时候的默认属性
- 设置对应的数据库表的字段名
type- 设置id自增生成策略，默认使用雪花算法
IdType type() default IdType.NONE;
- 如何设置为id自动递增算法？
- 首先设置主键字段递增
- 将
type设置为递增策略@TableId(value = "uid", type = IdType.AUTO) private Long id;
- 测试一下自动递增算法
- 注意：先使用Navicat截断一下表（右键表名—截断表，即
truncate清除数据，保留结构，不写日志）
- 注意：先使用Navicat截断一下表（右键表名—截断表，即
- 设置id自增生成策略，默认使用雪花算法
注意： 当表中字段名为小驼峰写法时，mybatis-plus中会将其识别为_格式，如：userId（表名）→ user_id（mybatis-plus识别出来的名字）。
4.全局配置主键生成策略
mybatis-plus:
global-config:
db-config:
# 配置主键生成策略
id-type: auto
5.雪花算法概述
雪花算法：
- 概念：
分布式环境下的一ID生成算法，能够保证不同表的主键的不重复性，以及相同表的主键的有序性 - 应对场景：
数据量和访问压力较大的场景 - 核心思想
- 长度共64bit（一个long型）
- 首先是一个符号位，1bit标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0
- 41bit时间截(毫秒级)，存储的是时间截的差值（当前时间截 - 开始时间截)，结果约等于69.73年
- 10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID，可以部署在1024个节点）
- 12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID）
- 优点：整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞，并且效率较高
数据库的扩展方式
- 业务分库
- 主从复制
- 数据库分表
单表数据拆分有两种方式：垂直分表和水平分表
- 垂直分表： 拆分 不常用且占了大量空间 的字段到其他表
- 水平分表： 将 表行数据量特别大 的进行分表存储数据
- 主键自增： 以最常见的用户 ID 为例，可以按照 1000000 的范围大小进行分段，1 ~ 999999 放到表 1中，1000000 ~ 1999999 放到表2中，以此类推
- 复杂点：分段大小的选取
- 优点：可以随着数据的增加平滑地扩充新的表
- 缺点：分布不均匀
- 取模： 同样以用户 ID 为例，假如我们一开始就规划了 10 个数据库表，可以简单地用 user_id % 10 的值来表示数据所属的数据库表编号，ID 为 985 的用户放到编号为 5 的子表中，ID 为 10086 的用户放到编号为 6 的子表中
- 复杂点：初始表数量的确定
- 优点：表分布比较均匀
- 缺点：扩充新的表很麻烦，所有数据都要重分布
- 主键自增： 以最常见的用户 ID 为例，可以按照 1000000 的范围大小进行分段，1 ~ 999999 放到表 1中，1000000 ~ 1999999 放到表2中，以此类推
6.@TableFiled
@TableFIled 解决实体类属性名与表的字段名不一致的问题。
@Data
public class User {
@TableId(value = "uid")
private Long id;
@TableField("user_name")
private String name;
private Integer age;
private String email;
}
7.@TargetLogic
逻辑删除：
- 假删除，将对应数据中代表是否被删除字段的状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录
- 可以进行数据恢复
代码演示：
-
逻辑删除：
@TableLogic(value = "1", delval = "0") private Integer status; -
测试代码：
@Test public void testDelete() { userMapper.deleteById(1); }
@Test public void testGetAll() { List<User> users = userMapper.selectList(null); }
3.条件构造器和常用接口
1.Wapper简介
Wapper 条件构造抽象类，最顶端父类
- AbstractWrapper： 用于查询条件封装，生成 sql 的
where 条件- QueryWrapper: 查询条件封装
- UpdateWrapper：update条件封装
- AbstractLambdaWrapper： 使用Lambda 语法
- LambdaQueryWrapper： 用于Lambda语法使用的查询Wrapper
- LambdaUpdateWrapper： Lambda 更新封装Wrapper
2.QueryWrapper
1.模糊查询
@SpringBootTest
public class MPMapperTest {
@Resource
private UserMapper userMapper;
@Test
public void test_01() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// user_name模糊查询，age在13到20之间，email不为空
queryWrapper.like("user_name", "张")
.between("age", 13, 19)
.isNotNull("email");
List<User> list = userMapper.selectList(queryWrapper);
}
}
2.排序
@Test
public void test_02() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 查询用户信息，并按照年龄降序排序，若年龄相同，则按照id升序排序
queryWrapper.orderByDesc("age")
.orderByAsc("uid");
List<User> list = userMapper.selectList(queryWrapper);
}
3.删除
@Test
public void test_03() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.isNull("email");
userMapper.delete(queryWrapper);
}
4.更新
@Test
public void test_04() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 将邮箱为空，且名字中有赵或周的用户的邮箱设置为testDemo04.net
queryWrapper.isNull("email")
.like("user_name", "赵")
.or()
.like("user_name", "周");
// 会将实体类中设置的字段作为修改后的值
User user = new User();
user.setEmail("testDemo04.net");
userMapper.update(user, queryWrapper);
}
注意： 不能添加逻辑删除标志位为判断条件！！！
5.条件优先级
@Test
public void test_05() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 将用户名中包含张，且年龄大于15或email为空的用户的email设为testDemo05.net
// lambda表达式中的条件会优先执行
queryWrapper.like("user_name", "张")
.and(el -> el.gt("age", 15).or().isNull("email"));
// 会将实体类中设置的字段作为修改后的值
User user = new User();
user.setEmail("testDemo05.net");
userMapper.update(user, queryWrapper);
}
6.组装select语句
@Test
public void test_06() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 查询用户名、年龄、邮箱
queryWrapper.select("user_name", "age", "email");
List<Map<String, Object>> map = userMapper.selectMaps(queryWrapper);
map.forEach(System.out::println);
}
7.组装子查询
@Test
public void test_07() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// 查询id <= 5 的用户id
queryWrapper.inSql("uid", "select uid from mp_user where uid < 5");
List<User> list = userMapper.selectList(queryWrapper);
}
3.UpdateWrapper
UpdateWrapper 不同于 QueryWrapper，UpdateWrapper 不仅可以设置修改条件，还能设置修改字段，也就不用去实例化一个对象来存储修改后的数据。
1.修改
@Test
public void test_08() {
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
// 修改用户名中有张，并且年龄大于15，id小于6
updateWrapper.like("user_name", "张")
.and(el -> el.gt("age", 15)
.or()
.lt("uid", 6));
updateWrapper.set("user_name", "宋青书").set("email", "95682314@163.net");
userMapper.update(null, updateWrapper);
}
4.模拟按需组装条件
开发中，常常需要根据用户的选择来组装SQL语句。
1.写法1.0
@Test
public void test_09() {
// 模拟从前台接收的数据
String name = "";
Integer ageBegin = 14;
Integer ageEnd = 17;
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
/*
判断如何组装条件
选择mybatis-plus的StringUtils
*/
if (StringUtils.isNotBlank(name)) {
queryWrapper.like("user_name", name);
}
if (ageBegin != null) {
queryWrapper.gt("age", ageBegin);
}
if (ageEnd != null) {
queryWrapper.lt("age", ageEnd);
}
List<User> list = userMapper.selectList(queryWrapper);
}
2.写法2.0
对写法1.0进行简化升级。
@Test
public void test_10() {
// 模拟从前台接收的数据
String name = "";
Integer ageBegin = 14;
Integer ageEnd = 17;
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
/*
判断如何组装条件
选择mybatis-plus的StringUtils
*/
queryWrapper.like(StringUtils.isNotBlank(name), "user_name", name)
.gt(ageBegin != null, "age", ageBegin)
.lt(ageEnd != null, "age", ageEnd);
List<User> list = userMapper.selectList(queryWrapper);
}
5.LambdaQueryWrapper
1.模拟按需组装条件
使用Lambda表达式简化代码，可以避免写错表字段名：
@Test
public void test_11() {
// 模拟从前台接收的数据
String name = "";
Integer ageBegin = 14;
Integer ageEnd = 17;
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
/*
判断如何组装条件
选择mybatis-plus的StringUtils
*/
queryWrapper.like(StringUtils.isNotBlank(name), User::getName, name)
.gt(ageBegin != null, User::getAge, ageBegin)
.lt(ageEnd != null, User::getAge, ageEnd);
List<User> list = userMapper.selectList(queryWrapper);
}
6.LambdaUpdateWrapper
1.修改
@Test
public void test_12() {
LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
// 修改用户名中有张，并且年龄大于15，id小于6
updateWrapper.like(User::getName, "张")
.and(el -> el.gt(User::getAge, 15)
.or()
.lt(User::getId, 6));
updateWrapper.set(User::getName, "宋青书").set(User::getEmail, "95682314@163.net");
userMapper.update(null, updateWrapper);
}
4.插件
1.分页插件
MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能
1.添加配置类
@Configuration
@MapperScan("com.chenjy.mp_demo.mapper")
public class MPConfig {
@Bean
public MybatisPlusInterceptor plusInterceptor() {
// 使用插件需要使用到的类
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
// 添加分页插件（PaginationInnerInterceptor）到interceptor实例中
// DbType 指定数据库类型为 MySQL
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
// 返回实例
return interceptor;
}
}
2.测试分页插件
@SpringBootTest
public class MPPluginsTest {
@Resource
private UserMapper userMapper;
@Test
public void testPage() {
Page<User> page = new Page<>(1, 5);
userMapper.selectPage(page, null);
System.out.println(page);
}
}
3.Page常用方法
getRecords查询数据列表getPages查询当前分页总页数getTotal查询数据总数hasNext判断是否存在下一页hasPrevious是否存在上一页
4.自定义分页功能
1.自定义分页方法
-
UserMapper 中自定义方法：
/** * @Description 通过年龄查询用户信息并返回 * @param page mp提供的分页对象，必须是参数列表第一个参数 * @param age * @return Page<User> */ Page<User> selectPagePo(@Param("page") Page<User> page, @Param("age") Integer age); -
UserMapper.xml 中写SQL
<select id="selectPagePo" resultType="com.chenjy.mp_demo.pojo.User"> select uid, user_name, age, email from mp_user where age > #{age} </select>
2.测试类
@Test
public void testPagePo(){
Page<User> page = new Page<>(1, 5);
userMapper.selectPagePo(page, 15);
System.out.println(page.getRecords());
}
配置类型别名：
-
在 application.yml 中配置包的类型别名
mybatis-plus: type-aliases-package: com.chenjy.mp_demo.pojo -
之后，包下的类就可以直接将类名作为别名传入 resultType 中
<select id="selectPagePo" resultType="User"> select uid, user_name, age, email from mp_user where age > #{age} </select>
3.注意事项
- 自定义分页方法，其返回类型必须是
Page<T> - 自定义分页方法的参数列表第一个参数必须是
Page<T> page @Parammybatis注解- 作用——给参数命名
如：@Param("id") int uid，就是外部想要给 uid 赋值或取值，只需要取它的参数名 id 就可以了，然后在SQL语句中，通过#{id}进行取值给SQL的参数赋值 - 注意：
- 使用
@Param，SQL语句取值可以使用#{}或${} - 不使用
@Param- SQL语句取值只能使用
#{} - 参数只能有一个，并且是Javabean
- SQL语句取值只能使用
- 使用
- 作用——给参数命名
2.乐观锁插件
1.乐观锁与悲观锁的概念
乐观锁：
- 在操作数据时非常乐观，认为别人不会同时修改数据
- 操作数据时不会上锁，只是在执行更新的时候判断一下在此期间别人是否修改了数据：如果别人修改了数据则放弃操作，否则执行操作
悲观锁：
- 在操作数据时比较悲观，认为别人会同时修改数据
- 操作数据时直接把数据锁住，直到操作完成后才会释放锁；上锁期间其他人不能修改数据
两锁详解：https://zhuanlan.zhihu.com/p/95296289
2.演示数据不一致
-
数据库搭建:
-- ---------------------------- -- Table structure for mp_product -- ---------------------------- DROP TABLE IF EXISTS `mp_product`; CREATE TABLE `mp_product` ( `id` bigint(0) NOT NULL AUTO_INCREMENT COMMENT '主键ID', `NAME` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '商品名称', `price` int(0) NULL DEFAULT 0 COMMENT '价格', `VERSION` int(0) NULL DEFAULT 0 COMMENT '乐观锁版本号', PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic; -- ---------------------------- -- Records of mp_product -- ---------------------------- INSERT INTO `mp_product` VALUES (1, '蓝牙耳机', 198, 0); -
实体类：
@Data public class Product { private Long id; private String name; private Integer price; private Integer version; } -
ProductMapper 接口：
@Repository public interface ProductMapper extends BaseMapper<Product> { } -
测试类：
@Test public void testProduct01(){ //小李查询商品价格 Product productLi = productMapper.selectById(1); System.out.println("小李查询的商品价格："+productLi.getPrice()); //小王查询商品价格 Product productWang = productMapper.selectById(1); System.out.println("小王查询的商品价格："+productWang.getPrice()); //小李将商品价格+50 productLi.setPrice(productLi.getPrice()+50); productMapper.updateById(productLi); //小王将商品价格-30 productWang.setPrice(productWang.getPrice()-30); int result = productMapper.updateById(productWang); //老板查询商品价格 Product productLaoban = productMapper.selectById(1); System.out.println("老板查询的商品价格："+productLaoban.getPrice()); }
分析： 没有保证数据的一致性，发生了数据冲突
-
理想情况：
-
实际情况：
3.乐观锁优化上述案例
-
给实体类的 version 属性加上
@Version标识乐观锁的版本号@Version //标识乐观锁版本号字段 private Integer version; -
在配置类中添加上乐观锁插件
@Configuration @MapperScan("com.chenjy.mp_demo.mapper") public class MPConfig { @Bean public MybatisPlusInterceptor plusInterceptor() { // 使用插件需要使用到的类 MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); // 添加分页插件（PaginationInnerInterceptor）到interceptor实例中 // DbType 指定数据库类型为 MySQL interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); // 添加乐观锁插件 interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor()); // 返回实例 return interceptor; } } -
优化测试方法，让小王第一次修改之后，能再次获取版本号，继续修改
@Test public void testProduct_01() { //小李查询商品价格 Product productLi = productMapper.selectById(1); System.out.println("小李查询的商品价格："+productLi.getPrice()); //小王查询商品价格 Product productWang = productMapper.selectById(1); System.out.println("小王查询的商品价格："+productWang.getPrice()); //小李将商品价格+50 productLi.setPrice(productLi.getPrice()+50); productMapper.updateById(productLi); //小王将商品价格-30 productWang.setPrice(productWang.getPrice()-30); int result = productMapper.updateById(productWang); if(result == 0){ /* 操作失败，重试 即之前版本号已被修改，现在重新获取一个版本号，再来修改 */ Product productNew = productMapper.selectById(1); productNew.setPrice(productNew.getPrice()-30); productMapper.updateById(productNew); } //老板查询商品价格 Product productLaoban = productMapper.selectById(1); System.out.println("老板查询的商品价格："+productLaoban.getPrice()); } -
恢复数据库数据为 198，重新启动测试方法
注意：
- 测试乐观锁插件的时候，一定要保证数据库中的version字段有值（不能为null），否则插件无法生效
- 不使用乐观锁的更新语句：
- 使用乐观锁之后的更新语句
5.通用枚举
表中的有些字段值是固定的，例如性别（男或女），此时我们可以使用MyBatis-Plus的通用枚举来实现
1.mp_user表新添sex字段
-
表：
-
实体类：
@Data // @TableName("mp_user") public class User { @TableId(value = "uid") private Long id; @TableField("user_name") private String name; private Integer age; private String email; @TableLogic(value = "1", delval = "0") private Integer status; private SexEnum sex;// 枚举sex字段 }
2.新建枚举类
@Getter
public enum SexEnum {
MALE(1, "男"),
FEMALE(0, "女");
@EnumValue // 将注解所标识的值存储到数据库中
private Integer sex;
private String sexName;
SexEnum(Integer sex, String sexName) {
this.sex = sex;
this.sexName = sexName;
}
}
3.配置文件配置扫描枚举
-
application.yml 配置扫描通用枚举的包
mybatis-plus: # 扫描通用枚举的包 type-enums-package: com.chenjy.mp_demo.enums
4.测试类
@SpringBootTest
public class MPEnumTest {
@Resource
private UserMapper userMapper;
@Test
public void testEnum() {
User user = new User();
user.setSex(SexEnum.MALE);
user.setName("王重阳");
user.setAge(39);
userMapper.insert(user);
}
}
6.代码生成器
1.引入依赖
<!--mp代码生成器-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.5.1</version>
</dependency>
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
</dependency>
2.测试类
@SpringBootTest
public class MPAutoGeneratorTest {
public static void main(String[] args) {
FastAutoGenerator.create("jdbc:mysql://127.0.0.1:3306/mybatis_plus?characterEncoding=utf-8&userSSL=false", "root", "admin")
.globalConfig(builder -> {
builder.author("chenjy") // 设置作者
//.enableSwagger() // 开启 swagger 模式
.fileOverride() // 覆盖已生成文件
.outputDir("D:\\mybatisplus\\demo1"); // 指定输出目录
})
// 最终生成的代码会存在com.chenjy.mybatisplus之下
.packageConfig(builder -> {
builder.parent("com.chenjy") // 设置父包名
.moduleName("mybatisplus") // 设置父包模块名
.pathInfo(Collections.singletonMap(OutputFile.mapperXml, "D:\\Study\\projects\\se\\mp_demp")); // 设置mapperXml生成路径
})
.strategyConfig(builder -> {
builder.addInclude("mp_user", "mp_product") // 设置需要生成的表名
.addTablePrefix("mp_", "t_"); // 设置过滤表前缀（可以设置多个前缀）
})
.templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
.execute();// 执行
}
}
7.多数据源
1.搭建两个数据库
USE mp_demo1;
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` bigint(0) NOT NULL AUTO_INCREMENT COMMENT '主键id',
`name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '姓名',
`age` int(0) NULL DEFAULT NULL COMMENT '年龄',
`email` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, '张三', 17, NULL);
INSERT INTO `user` VALUES (2, '李四', 16, '123456@163.net');
INSERT INTO `user` VALUES (3, '王五', 15, '352641@qq.com');
INSERT INTO `user` VALUES (4, '赵六', 14, NULL);
INSERT INTO `user` VALUES (5, '陈七', 13, '951463@263.net');
USE mp_demo2;
-- ----------------------------
-- Table structure for mp_product
-- ----------------------------
DROP TABLE IF EXISTS `mp_product`;
CREATE TABLE `mp_product` (
`id` bigint(0) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`NAME` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '商品名称',
`price` int(0) NULL DEFAULT 0 COMMENT '价格',
`VERSION` int(0) NULL DEFAULT 0 COMMENT '乐观锁版本号'
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of mp_product
-- ----------------------------
INSERT INTO `mp_product` VALUES (1, '蓝牙耳机', 188, 0);
2.新建springboot项目
1.依赖
<!--mybatis-plus-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.1</version>
</dependency>
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<!--druid数据源-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.8</version>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!--多数据源依赖-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
<version>3.1.0</version>
</dependency>
2.配置文件
spring:
# 配置数据源信息
datasource:
# 使用druid数据源
type: com.alibaba.druid.pool.DruidDataSource
dynamic:
# 设置默认的数据源或者数据源组,默认值即为master
primary: master
# 严格匹配数据源,默认false.true未匹配到指定数据源时抛异常,false使用默认数据源
strict: true
datasource:
master: # 可随意取名
url: jdbc:mysql://localhost:3306/mp_demo1?characterEncoding=utf-8&useSSL=false&serverTimezone=GMT
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: admin
slave_1: # 可随意取名
url: jdbc:mysql://localhost:3306/mp_demo2?characterEncoding=utf-8&useSSL=false&serverTimezone=GMT
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: admin
# druid配置，可直接使用默认值
druid:
#初始化时建立物理连接的个数
initialSize: 1
#池中最大连接数
maxActive: 20
#最小空闲连接
minIdle: 1
#获取连接时最大等待时间，单位毫秒
maxWait: 60000
server:
port: 8089
3.实体类
@Data
@TableName("mp_product")
public class Product {
private Integer id;
private String name;
private Integer price;
private Integer version;
}
@Data
public class User {
private Integer id;
private String name;
private Integer age;
private String email;
}
4.mapper接口
@Repository
public interface ProductMapper extends BaseMapper<Product> {
}
@Repository
public interface UserMapper extends BaseMapper<User> {
}
4.service
1.接口
public interface ProductService extends IService<Product> {
}
public interface UserService extends IService<User> {
}
2.实现类
@Service
@DS("slave_1")// 设置要操作的数据源
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements ProductService {
}
@Service
@DS("master") // 设置要操作的数据源
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}
@DS
- 切换数据源
- 可以写在方法上或类上
@Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface DS { String value(); }
5.测试类
@SpringBootTest
class MpDemo1ApplicationTests {
@Resource
private UserService userService;
@Resource
private ProductService productService;
@Test
public void testSelect() {
System.out.println(userService.getById(1));
System.out.println(productService.getById(1));
}
}
注意： 别忘了在启动类上添加 @MapperScan 注解扫描mapper包。
8.MyBatisX插件
MyBatis-Plus为我们提供了强大的mapper和service模板，能够大大的提高开发效率。
但是在真正开发过程中，MyBatis-Plus并不能为我们解决所有问题，例如一些复杂的SQL，多表联查，我们就需要自己去编写代码和SQL语句，我们该如何快速的解决这个问题呢，这个时候可以使用MyBatisX插件。
最简单且实用功能：
- 快速定位 mapper接口 及其 mapper.xml映射文件
点击小鸟，可以飞来飞去
1.代码快速生成
1.案例
1.新建springboot项目导入依赖
-
依赖
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.4.1</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.8</version> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </dependency>
2.连接database，快速生成代码
-
快速生成流程
-
配置：
spring: datasource: # 配置数据源类型 type: com.alibaba.druid.pool.DruidDataSource driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT&characterEncoding=utf-8&useSSL=false username: root password: admin
2.快速生成CRUD
-
插入：
-
删除：
-
修改
-
查询
9.代码下载地址
https://github.com/Crashinging/mybatis-plus
git@github.com:Crashinging/mybatis-plus.git
扫一扫
101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
