mybatis-plus
入门案例
建表
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');
导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.1</version>
</dependency>
<!--导入mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.17</version>
</dependency>
<!--简化实体类,用@Data代替getset方法-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.8</version>
</dependency>
数据源配置
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8
username: root
password: mzf200314
type: com.zaxxer.hikari.HikariDataSource
pojo
package com.fate.demo1.pojo;
import lombok.Data;
/**
* @author m
*/
@Data
public class User {
private Long id;
private String name;
private Integer age;
private String email;
public User(Long id, String name, Integer age, String email) {
this.id = id;
this.name = name;
this.age = age;
this.email = email;
}
}
mapper
继承直接用
package com.fate.demo1.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.fate.demo1.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
/**
* @author m
*/
@Repository
@Mapper
public interface UserMapper extends BaseMapper<User> {
}
开启日志信息
#日志配置
mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
添加
@Test
void add(){
User user = new User(null, "fate", 17, "asdhjfgah");
System.out.println(mapper.insert(user));
System.out.println(user);
}
会获取主键(默认雪花算法生成id)
删除
@Test
void delete(){
int i = mapper.deleteById(1521849298382331905L);
System.out.println(i);
}
@Test
void deleteByMap(){
HashMap<String, Object> stringObjectHashMap = new HashMap<>();
//会匹配map中设置的条件进行删除操作
stringObjectHashMap.put("name","张三");
stringObjectHashMap.put("age",16);
int i = mapper.deleteByMap(stringObjectHashMap);
System.out.println(i);
}
@Test
void deleteB(){
//批量删除
LinkedList<Integer> integers = new LinkedList<>();
for (int i = 9; i < 100; i++) {
integers.add(i);
}
int i = mapper.deleteBatchIds(integers);
System.out.println(i);
}
修改
@Test
void update(){
//属性如果为null的话该属性不会进行更新
User fate = new User(11L, "fate", null, null);
int i = mapper.updateById(fate);
}
查找
@Test
void select(){
//根据id查询
User user = mapper.selectById(1);
//根据id集合查询
List<Long> asList = Arrays.asList(1L, 2L, 3L, 4L);
List<User> users = mapper.selectBatchIds(asList);
//根据map中的条件查询
HashMap<String, Object> map = new HashMap<>();
map.put("name","fate");
List<User> userList = mapper.selectByMap(map);
//根据条件构造器查询
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
mapper.selectList(wrapper);
//自定义查询(mybatis怎么写,它就怎么写)
Map<String, Object> mapById = mapper.selectMapById(1L);
}
Service CRUD接口
-
通用Service CRUD封装IService (opens new window)接口,进一步封装CRUD采用get查询单行remove删除list查询集合page分页 前缀命名方式区分Mapper层避免混淆
-
泛型T为任意实体对象
-
建议如果存在自定义通用Service方法的可能,请创建自己的IBaseService继承Mybatis-Plus提供的基类
-
对象 Wrapper 为 条件构造器
public interface UserService extends IService<User> {
}
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}
测试
获取记录
@Test
void getCount(){
System.out.println(userService.count());
}
批量添加
@Test
void insert(){
//批量添加
LinkedList<User> users = new LinkedList<User>();
for (int i = 0; i < 10; i++) {
User user = new User(null, "test" + i, i, i + "@fate.com");
users.add(user);
}
userService.saveBatch(users);
}
底层采取每个记录分别添加的方式
常见注解
@TableName注解
用于标识实体类在数据库中对应的表名
@Data
@TableName("user")
public class User {
private Long id;
private String name;
private Integer age;
private String email;
public User(Long id, String name, Integer age, String email) {
this.id = id;
this.name = name;
this.age = age;
this.email = email;
}
}
使用全局配置,配置表名前缀
global-config:
db-config:
table-prefix: 前缀
@TableId注解
- 用于标识主键(mp默认将id作为主键)
- 通过value属性可以设置该属性在表中对应的字段名
- type属性表示主键生成的策略
- IdType.AUTO(常用):数据库ID自增
该类型需要确保数据库设置了 ID自增 否则无效 - IdType.NONE:该类型为未设置主键类型
- IdType.INPUT:用户输入ID,该类型可以通过自己注册自动填充插件进行填充
- IdType.ASSIGN_ID(常用):分配ID (主键类型为number或string), 默认实现类 com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator(雪花算法)
- IdType.ASSIGN_UUID:分配UUID (主键类型为 string) 默认实现类 com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator(UUID.replace(“-”,“”))
- IdType.AUTO(常用):数据库ID自增
可以使用全局配置来修改主键生成策略
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xpvfyJC3-1651797024023)(https://gitee.com/fatem/markdown_imgs/raw/master/img/202205051101322.png)]
雪花算法
- 背景
需要选择合适的方案去应对数据规模的增长,以应对逐渐增长的访问压力和数据量
数据库的扩展方式主要包括:业务分库、主从复制,数据库分表 - . 数据库分表
将不同业务数据分散存储到不同的数据库服务器,能够支撑百万甚至千万用户规模的业务,但如果业务继续发展,同一业务的单表数据也会达到单台数据库服务器的处理瓶颈。例如,淘宝的几亿用户数据,如果全部存放在一台数据库服务器的一张表中,肯定是无法满足性能要求的,此时就需要对单表数据进行拆分。
单表数据拆分有两种方式:垂直分表和水平分表。示意图如下:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XPz9g0RH-1651797024024)(https://gitee.com/fatem/markdown_imgs/raw/master/img/202205051109112.png)] - 垂直分表
垂直分表适合将表中某些不常用且占了大量空间的列拆分出去
例如,前面示意图中的nickname和description字段,假设我们是一个婚恋网站,用户在筛选其他用户的时候,主要是用age和sex两个字段进行查询,而nickname和description两个字段主要用于展示,一般不会在业务查询中用到。description本身又比较长,因此我们可以将这两个字段独立到另外一张表中,这样在查询age和sex时,就能带来一定的性能提升 - 水平分表
水平分表适合表行数特别大的表,有的公司要求单表行数超过5000万就必须进行分表,这个数字可以作为参考,但并不是绝对标准,关键还是要看表的访问性能。对于一些比较复杂的表,可能超过1000万就要分表了。而对于一些简单的表,即使存储数据超过1亿行,也可以不分表。
但不管怎样,当看到表的数据量达到千万级别时,作为架构师就要警觉起来,因为这很可能是架构的性能瓶颈或者隐患。
水平分表相比垂直分表,会引入更多的复杂性,例如要求全局唯一的数据id该如何处理 - 主键自增
以最常见的用户ID为例,可以按照1000000 的范围大小进行分段,1 ~ 999999 放到表 1中,1000000 ~ 1999999 放到表2中,以此类推
复杂点:分段大小的选取。分段太小会导致切分后子表数量过多,增加维护复杂度;分段太大可能会导致单表依然存在性能问题,一般建议分段大小在100万至2000万之间,具体需要根据业务选取合适的分段大小。
优点:可以随着数据的增加平滑地扩充新的表。例如,现在的用户是100万,如果增加到1000万,只需要增加新的表就可以了,原有的数据不需要动。
缺点:分布不均匀。假如按照1000万来进行分表,有可能某个分段实际存储的数据量只有1条,而另外一个分段实际存储的数据量有1000万条。 - 取模
同样以用户ID为例,假如我们一开始就规划了10个数据库表,可以简单地用user_id%10的值来表示数据所属的数据库表编号,ID为985的用户放到编号为5的子表中,ID为10086的用户放到编号为6的子表中。
复杂点:初始表数量的确定。表数量太多维护比较麻烦,表数量太少又可能导致单表性能存在问题。
优点:表分布比较均匀。
缺点:扩充新的表很麻烦,所有数据都要重分布。 - 雪花算法:是由Twitter公布的分布式主键生成算法,它能够保证不同表的主键的不重复性,以及相同表的主键的有序性
长度共64bit(一个long型)。
首先是一个符号位,1bit标识,由于long基本类型在Java中是带符号的,最高位是符号位,正数是0,负数是1,所以id一般是正数,最高位是0。
41bit时间截(毫秒级),存储的是时间截的差值(当前时间截-开始时间截),结果约等于69.73年。
10bit作为机器的ID(5个bit是数据中心,5个bit的机器ID,可以部署在1024个节点)。
12bit作为毫秒内的流水号(意味着每个节点在每毫秒可以产生4096个ID)
@TableField(“name”)
通过@TableField
注解表示属性在数据库中的字段名
@TableLogic(逻辑删除)
设置此注解时,调用删除方法,仅仅只会将对应的属性设置为1,并不会真正删除
wrapper
见名知意
package com.fate.demo1.wapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.fate.demo1.mapper.UserMapper;
import com.fate.demo1.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
import java.util.Map;
@SpringBootTest
public class WapperTest {
@Autowired
private UserMapper userMapper;
@Test
void select(){
//条件查询
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.like("name","1")
.between("age",1,10)
.isNotNull("email");
userMapper.selectList(wrapper).forEach(System.out::println);
}
@Test
void select1(){
// SELECT id,name,age,email,is_deleted FROM user WHERE is_deleted=0 ORDER BY age ASC,id ASC
// 排序查询
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.orderByAsc("age").orderByAsc("id");
userMapper.selectList(wrapper).forEach(System.out::println);
}
@Test
void delete(){
// UPDATE user SET is_deleted=1 WHERE is_deleted=0 AND (age BETWEEN ? AND ?)
// 因为设置了逻辑删除,删除语句变为了update
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.between("age",0,1);
userMapper.delete(wrapper);
}
@Test
void update(){
// UPDATE user SET age=? WHERE is_deleted=0 AND (age > ? AND email IS NOT NULL)
// 条件修改,修改需要的参数,由实体类传入
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age",20).isNotNull("email");
User user = new User(null,null,100,null);
userMapper.update(user,queryWrapper);
}
@Test
void update1(){
//lambda表达式中的条件优先执行
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.and(i->i.gt("age",99));
}
@Test
void selectForSome(){
// SELECT name,age FROM user WHERE is_deleted=0
// 仅查询了部分指定字段
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("name","age");
List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
maps.forEach(System.out::println);
}
@Test
void selectSon(){
// 子查询
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.inSql("id","SELECT id FROM user");
userMapper.selectList(queryWrapper).forEach(System.out::println);
}
@Test
void updateByWrapper(){
// UPDATE user SET email=? WHERE is_deleted=0 AND (name LIKE ? AND (age > ? OR age BETWEEN ? AND ?))
// 修改属性直接写在wrapper里面
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.like("name","test").
and(i->i.gt("age",5).or().between("age",10,100));
updateWrapper.set("email","12345@test.com");
userMapper.update(null,updateWrapper);
}
@Test
void condition(){
// SELECT id,name,age,email,is_deleted FROM user WHERE is_deleted=0
String name=null;
// SELECT id,name,age,email,is_deleted FROM user WHERE is_deleted=0 AND (name LIKE ?)
name="test";
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like(StringUtils.isNotBlank(name),"name",name);
userMapper.selectList(queryWrapper).forEach(System.out::println);
}
@Test
void lambdaQueryWrapper(){
//基本使用大差不差(把字段名改成了User::getName格式)LambdaUpdateWrapper同理
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.like(User::getName,"test");
userMapper.selectList(wrapper).forEach(System.out::println);
}
}
插件
添加插件之前需要创建配置类
@Configuration
@MapperScan("com.fate.demo1.mapper")
public class MPConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor(){
MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
//添加分页插件(设置数据库类型)
mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
return mybatisPlusInterceptor;
}
}
分页插件
@Test
void page(){
Page<User> userPage = new Page<>(1,5);
mapper.selectPage(userPage,null).getRecords().forEach(System.out::println);
System.out.println(userPage);
}
拦截SQL并添加分页语句
自定义查询的分页操作
IPage<User> getUserToPage(@Param("page") IPage<User> page);
<select id="getUserToPage" resultType="com.fate.demo1.pojo.User">
select id,name,age,email from user
</select>
@Test
void page2(){
Page<User> userPage = new Page<>(1,5);
mapper.getUserToPage(userPage).getRecords().forEach(System.out::println);
System.out.println(userPage);
}
mp会自动识别你的方法是否是需要返回分页数据
乐观锁
场景
一件商品,成本价是80元,售价是100元。老板先是通知小李,说你去把商品价格增加50元。小李正在玩游戏,耽搁了一个小时。正好一个小时后,老板觉得商品价格增加到150元,价格太高,可能会影响销量。又通知小王,你把商品价格降低30元。
此时,小李和小王同时操作商品后台系统。小李操作的时候,系统先取出商品价格100元;小王也在操作,取出的商品价格也是100元。小李将价格加了50元,并将100+50=150元存入了数据库;小王将商品减了30元,并将100-30=70元存入了数据库。是的,如果没有锁,小李的操作就完全被小王的覆盖了。
现在商品价格是70元,比成本价低10元。几分钟后,这个商品很快出售了1千多件商品,老板亏1万多。
乐观锁与悲观锁
上面的故事,如果是乐观锁,小王保存价格前,会检查下价格是否被人修改过了。如果被修改过了,则重新取出的被修改后的价格,150元,这样他会将120元存入数据库。
如果是悲观锁,小李取出数据后,小王只能等小李操作完之后,才能对价格进行操作,也会保证最终的价格是120元。
模拟修改冲突
CREATE TABLE t_product
(
id BIGINT(20)NOT NULL COMMENT'主键ID',
NAME VARCHAR(30)NULL DEFAULT NULL COMMENT'商品名称',
price INT(11) DEFAULT 0 COMMENT'价格',
VERSION INT(11)DEFAULT 0 COMMENT'乐观锁版本号',PRIMARY KEY(id)
);
pojo,Mapper,service三件套
@TableName("t_product")
@Data
public class Product {
private Long id;
private String name;
private Integer price;
private Integer version;
public Product() {
}
public Product(Long id, String name, Integer price, Integer version) {
this.id = id;
this.name = name;
this.price = price;
this.version = version;
}
}
@Version
表示版本号(表示乐观锁的识别字段)
添加插件
@Configuration
@MapperScan("com.fate.demo1.mapper")
public class MPConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor(){
MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
//添加分页插件(设置数据库类型)
mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
//添加乐观锁插件
mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
return mybatisPlusInterceptor;
}
}
通用枚举
@EnumValue
将枚举对应的值添加到数据库里
#扫描通用枚举的包
type-enums-package: com.fate.demo1.enums
代码生成器
依赖
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.5.1</version>
</dependency>
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>2.3.31</version>
</dependency>
运行代码
public class FastAutoGeneratorTest {
public static void main(String[] args) {
FastAutoGenerator.create("jdbc:mysql://127.0.0.1:3306/mybatis_plus?characterEncoding=utf-8&userSSL=false", "root", "123456").globalConfig(builder -> {
builder.author("atguigu") // 设置作者
//.enableSwagger() // 开启 swagger 模式
.fileOverride() // 覆盖已生成文件
.outputDir("D://mybatis_plus"); // 指定输出目录
})
.packageConfig(builder -> {
builder.parent("com.atguigu") // 设置父包名
.moduleName("mybatisplus") // 设置父包模块名
.pathInfo(Collections.singletonMap(OutputFile.mapperXml,
"D://mybatis_plus"));
// 设置mapperXml生成路径
})
.strategyConfig(builder -> {
builder.addInclude("t_user") // 设置需要生成的表名
.addTablePrefix("t_", "c_"); // 设置过滤表前缀
})
.templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker
引擎模板,默认的是Velocity引擎模板
.execute();
}
}
多数据源
创建数据库mybatis_plus_1和表product
CREATE DATABASE mybatis_plus_1;
USE mybatis_plus_1;
CREATE TABLE product
(
id BIGINT(20) NOT NULL COMMENT '主键id',
NAME VARCHAR(30) NULL DEFAULT NULL COMMENT '商品名称',
price INT(11) DEFAULT 0 COMMENT '价格',
VERSION INT(11) DEFAULT 0 COMMENT '乐观锁版本号',
PRIMARY KEY (id)
);
依赖
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
<version>3.5.0</version>
</dependency>
配置
spring:
# 配置数据源信息
datasource:
dynamic:
# 设置默认的数据源或数据源组,默认值即为master
primary: master
# 严格匹配数据源,默认false,true未匹配到指定数据源时抛异常,false使用默认数据源
strict: false
datasource:
master:
url: jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&serverTimezone=GMT%2B8
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: root
save_1:
url: jdbc:mysql://localhost:3306/mybatis_plus_1?useSSL=false&serverTimezone=GMT%2B8
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: root
service
@DS("master")
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}
@DS("slave_1")
@Service
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements ProductService {
}