目录
1、逻辑删除
配置文件:
#逻辑未删除,设置为0
mybatis-plus.global-config.db-config.logic-not-delete-value=0
#逻辑删除,设置为1
mybatis-plus.global-config.db-config.logic-delete-value=1
实体类:对应的逻辑删除字段就上注解@TableLogic
测试:
@Autowired
private UserMapper userMapper;
@Test
public void deleteById(){
// UPDATE mp_user SET deleted=1 WHERE id=? AND deleted=0
//相当于上面的sql
int i = userMapper.deleteById(1344295715685326850L);
System.out.println("影响行数:"+i);
}
@Test
public void select(){
// SELECT id,name AS realName,age,email,manager_id,create_time,update_time,version,deleted FROM mp_user WHERE deleted=0
//查询的时候,会在where后面加上
List<User> userList = userMapper.selectList(null);
userList.forEach(System.out::println);
}
@Test
public void update(){
// UPDATE mp_user SET age=? WHERE id=? AND deleted=0
//更新的时候,也会加上 deleted=0
User user=new User();
user.setAge(26);
user.setId(1087982257332887553l);
int i = userMapper.updateById(user);
System.out.println("影响行数:"+i);
}
注意:
1、如果已经逻辑删除的行数据,想恢复为为删除状态
不可以直接使用updateById
,去恢复,需要自己重写sql
例如:
public interface UserMapper extends BaseMapper<User> {
/**
* 和Mybatis使用方法一致
*/
@Update("update mp_user set deleted=0 where id=#{id}")
void recover(@Param("id") Long id);
}
@Test
public void cover(){
userMapper.recover(1344295715685326850l);
}
2、在查询的时候,默认会在where条件上加deleted=0,但是select出来的结果,会包含deleted字段,实际上这个字段是没必要出现的
直接在实体类上加注解TableField(select = false)
//逻辑删除
@TableLogic
@TableField(select = false)
private Integer deleted;
3、自定义的sql中,不会在where条件后面加上deleted,要自己构造
存在软删除字段is_deleted,如何设置唯一约束?
很简单,数据未删除时,is_deleted设置为0,删除了设置为主键id,也就是大于0就是删除了,与需要唯一的字段,做组合的唯一约束即可。
@TableLogic(value = "0", delval = "id")
private Integer isDeleted;
2、自动填充
一般表都有创建时间,更新时间。
实体类:@TableField(fill = FieldFill.UPDATE)
实现接口MetaObjectHandler :
@Component
public class MyMataObjectHandle implements MetaObjectHandler {
@Override
public void insertFill(MetaObject metaObject) {
//过时了
// setInsertFieldValByName("createTime", LocalDateTime.now(), metaObject);
strictInsertFill(metaObject,"createTime",LocalDateTime.class,LocalDateTime.now());
}
@Override
public void updateFill(MetaObject metaObject) {
//过时了
// setUpdateFieldValByName("updateTime",LocalDateTime.now(), metaObject);
strictUpdateFill(metaObject,"updateTime",LocalDateTime.class,LocalDateTime.now());
}
}
测试:
新增
@Test
void insert(){
User user = new User();
user.setRealName("aaa");
user.setAge(123);
user.setEmail("123456@qq.com");
user.setManagerId(1087982257332887553l);
userMapper.insert(user);
}
创建时间自动填充上了
更新,也是一样的
@Test
void update(){
User user = new User();
user.setRealName("bbb");
user.setId(1344295715685326851l);
userMapper.updateById(user);
}
这个自动填充,使用场景,不仅仅是填充创建时间和更新时间,如果仅仅是这,我们在设计表的时候,就可以将创建时间的字段设置为now(),这个自动填充,比如,可以当前的登录人
优化:
@Component
public class MyMataObjectHandle implements MetaObjectHandler {
@Override
public void insertFill(MetaObject metaObject) {
//有createTime字段才进行自动填充
boolean createTime = metaObject.hasSetter("createTime");
if(createTime){
strictInsertFill(metaObject,"createTime",LocalDateTime.class,LocalDateTime.now());
}
}
@Override
public void updateFill(MetaObject metaObject) {
//updateTime字段没有设置值的时候,才进行自动填充
Object updateTime = getFieldValByName("updateTime", metaObject);
if(updateTime==null) {
System.out.println("xxx");
strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
}
}
}
3、乐观锁
例如:
UPDATE mp_user set `name`="boss",version=4 where version=3 and id=1087982257332887553
使用:
1、配置乐观锁插件
@Bean
public MybatisPlusInterceptor optimisticLockerInnerInterceptor(){
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
//注册乐观锁插件
interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
return interceptor;
}
2、实体类对应的version字段,加上注解 @Version
@Version
private Integer version;
测试:
@Test
void update(){
//从数据库里查出来的版本,假设是1
int version=1;
User user = new User();
user.setEmail("333@qq.com");
user.setId(1344295715685326856l);
user.setVersion(version);
userMapper.updateById(user);
}
注意:
- 仅支持 updateById(id) 与 update(entity, wrapper) 方法
- 在 update(entity, wrapper) 方法下, wrapper 不能复用!!!
4、执行sql分析打印
<!-- p6spy-->
<dependency>
<groupId>p6spy</groupId>
<artifactId>p6spy</artifactId>
<version>3.8.2</version>
</dependency>
配置文件:
驱动该为:com.p6spy.engine.spy.P6SpyDriver
url 前缀为 jdbc:p6spy 跟着冒号为对应数据库连接地址
spring.datasource.driver-class-name=com.p6spy.engine.spy.P6SpyDriver
spring.datasource.url=jdbc:p6spy:mysql://localhost:3306/mybatis-plus?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT
springboot工程,resources目录下添加一个配置文件spy.properties
#3.2.1以上使用
modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
#3.2.1以下使用或者不配置
#modulelist=com.p6spy.engine.logging.P6LogFactory,com.p6spy.engine.outage.P6OutageFactory
# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
#日志输出到控制台
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
#输出到文件,注释了appender,才能生效
#logfile=log.log
# 使用日志系统记录 sql
#appender=com.p6spy.engine.spy.appender.Slf4JLogger
# 设置 p6spy driver 代理
deregisterdrivers=true
# 取消JDBC URL前缀
useprefix=true
# 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,commit,resultset
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动可多个
#driverlist=org.h2.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 2 秒
outagedetectioninterval=2
测试:随便执行一个sql
@Test
public void select(){
// SELECT id,name AS realName,age,email,manager_id,create_time,update_time,version,deleted FROM mp_user WHERE deleted=0
List<User> userList = userMapper.selectList(null);
userList.forEach(System.out::println);
}
注意:平时开发的时候可以用,生产环境不要用,有性能损耗
5、多租户Saas
什么是多租户?
多租户技术或称多重租赁技术,简称SaaS,是一种软件架构技术,是实现如何在多用户环境下(此处的多用户一般是面向企业用户)共用相同的系统或程序组件,并且可确保各用户间数据的隔离性。
简单讲:在一台服务器上运行单个应用实例,它为多个租户(客户)提供服务。从定义中我们可以理解:多租户是一种架构,目的是为了让多用户环境下使用同一套程序,且保证用户间数据隔离。那么重点就很浅显易懂了,多租户的重点就是同一套程序下实现多用户数据的隔离。
数据隔离方案?
- 独立数据库:即一个租户一个数据库,这种方案的用户数据隔离级别最高,安全性最好,但成本较高。
- 优点:为不同的租户提供独立的数据库,有助于简化数据模型的扩展设计,满足不同租户的独特需求;如果出现故障,恢复数据比较简单。
- 缺点:增多了数据库的安装数量,随之带来维护成本和购置成本的增加。
- 共享数据库,独立 Schema:多个或所有租户共享Database,但是每个租户一个Schema(也可叫做一个user)。底层库比如是:DB2、ORACLE等,一个数据库下可以有多个SCHEMA。
- 优点:为安全性要求较高的租户提供了一定程度的逻辑数据隔离,并不是完全隔离;每个数据库可支持更多的租户数量。
- 缺点:如果出现故障,数据恢复比较困难,因为恢复数据库将牵涉到其他租户的数据;
- 共享数据库,共享 Schema,共享数据表
- 即租户共享同一个Database、同一个Schema,但在表中增加TenantID多租户的数据字段。这是共享程度最高、隔离级别最低的模式。
- 简单来讲,即每插入一条数据时都需要有一个客户的标识。这样才能在同一张表中区分出不同客户的数据,这也是我们系统目前用到的(provider_id)
- 优点:三种方案比较,第三种方案的维护和购置成本最低,允许每个数据库支持的租户数量最多。
- 缺点:隔离级别最低,安全性最低,需要在设计开发时加大对安全的开发量; 数据备份和恢复最困难,需要逐表逐条备份和还原。
第三种方式实现多租户,共享数据库,共享 Schema,共享数据表
依赖于分页插件
/**
* 分页插件
*
* @return
*/
@Bean
public PaginationInterceptor paginationInterceptor() {
PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
// 创建SQL解析器集合
List<ISqlParser> sqlParserList = new ArrayList<>();
// 创建租户SQL解析器
TenantSqlParser tenantSqlParser = new TenantSqlParser();
// 设置租户处理器
tenantSqlParser.setTenantHandler(new TenantHandler() {
// 设置当前租户ID,实际情况你可以从cookie/session、或者缓存中拿都行
@Override
public Expression getTenantId(boolean select) {
// 从当前系统上下文中取出当前请求的服务商ID,通过解析器注入到SQL中。
Long currentProviderId = 1344295715685326856L;
return new LongValue(currentProviderId);
}
@Override
public String getTenantIdColumn() {
// 对应数据库中租户ID的列名
return "manager_id";
}
@Override
public boolean doTableFilter(String tableName) {
// 是否需要需要过滤某一张表,某一张表不增加租户信息
/* List<String> tableNameList = Arrays.asList("sys_user");
if (tableNameList.contains(tableName)){
return true;
}*/
return false;
}
});
sqlParserList.add(tenantSqlParser);
paginationInterceptor.setSqlParserList(sqlParserList);
return paginationInterceptor;
}
测试:
@Test
public void select(){
// SELECT id,name AS realName,age,email,manager_id,create_time,update_time,version,deleted FROM mp_user WHERE deleted=0
List<User> userList = userMapper.selectList(null);
userList.forEach(System.out::println);
}
查询,会自动加上租户字段
更新,插入等也是会自动加入组合字段
如果某一张表不增加租户信息:
@Override
public boolean doTableFilter(String tableName) {
// 是否需要需要过滤某一张表,某一张表不增加租户信息
List<String> tableNameList = Arrays.asList("mp_user");
if (tableNameList.contains(tableName)){
return true;
}
return false;
}
测试:发现租户字段没加上了
5.1、特定sql过滤
可能我想某些方法,不加租户信息
方式一:
/**
* 分页插件
*
* @return
*/
@Bean
public PaginationInterceptor paginationInterceptor() {
PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
// 创建SQL解析器集合
List<ISqlParser> sqlParserList = new ArrayList<>();
// 创建租户SQL解析器
TenantSqlParser tenantSqlParser = new TenantSqlParser();
// 设置租户处理器
tenantSqlParser.setTenantHandler(new TenantHandler() {
// 设置当前租户ID,实际情况你可以从cookie/session、或者缓存中拿都行
@Override
public Expression getTenantId(boolean select) {
// 从当前系统上下文中取出当前请求的服务商ID,通过解析器注入到SQL中。
Long currentProviderId = 1087982257332887553L;
return new LongValue(currentProviderId);
}
@Override
public String getTenantIdColumn() {
// 对应数据库中租户ID的列名
return "manager_id";
}
@Override
public boolean doTableFilter(String tableName) {
// 是否需要需要过滤某一张表,某一张表不增加租户信息
// List<String> tableNameList = Arrays.asList("mp_user");
// if (tableNameList.contains(tableName)){
// return true;
// }
return false;
}
});
sqlParserList.add(tenantSqlParser);
paginationInterceptor.setSqlParserList(sqlParserList);
//特定sql过滤
paginationInterceptor.setSqlParserFilter(new ISqlParserFilter() {
@Override
public boolean doFilter(MetaObject metaObject) {
MappedStatement mappedStatement = SqlParserHelper.getMappedStatement(metaObject);
if("com.example.mybatisplusdemo.dao.UserMapper.selectById".equals(mappedStatement.getId())){
return true;
}
return false;
}
});
return paginationInterceptor;
}
测试:
@Test
public void selects(){
//1、根据主键id查询
User user = userMapper.selectById(1087982257332887553l);
System.out.println(user);
}
租户字段没被加上
方式二:Mapper上自定义的方法,可以使用注解 @SqlParser(filter = true)
public interface UserMapper extends BaseMapper<User> {
/**
* 和Mybatis使用方法一致
*/
@SqlParser(filter = true)
@Update("update mp_user set deleted=0 where id=#{id}")
void recover(@Param("id") Long id);
}
6、动态表
先来说下动态名表在什么场景下需要使用呢?
拿实际项目来说,公司手里掌握着国内各个部分地区的医院患者数据,那么一个医院的患者的数据流量肯定是很大的,这个时候如果全部放在同一张表中,那么可想而知数据量的庞大。所以数据库设计的时候可以一家医院对应一张表,分开来存储,表中的列名都是一样的,只是表名不同。
或者还可以做日志的存储,日志数据量也是很大的,可以分一个月对应一张表,比如:log_201907、log_201908等等之类的。
@Bean
public MybatisPlusInterceptor optimisticLockerInnerInterceptor(){
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
//动态表名sql解析器对象
DynamicTableNameInnerInterceptor dynamicTableNameInnerInterceptor = new DynamicTableNameInnerInterceptor();
//第一层括弧实际是定义了一个匿名内部类,第二层括弧实际上是一个实例初始化块
HashMap<String, TableNameHandler> map = new HashMap<>(2) {{
//Map的key就是需要替换的原始表名
put("mp_user", (sql, tableName) -> {
// 自定义表名规则,或者从配置文件、request上下文中读取
System.out.println("tableName:"+tableName);
return "sys_user_2019";
});
}};
dynamicTableNameInnerInterceptor.setTableNameHandlerMap(map);
//注册动态表名解析器对象
interceptor.addInnerInterceptor(dynamicTableNameInnerInterceptor);
return interceptor;
}
测试:
@Test
public void select(){
List<User> userList = userMapper.selectList(null);
userList.forEach(System.out::println);
}
7、sql注入器
使用它就可以自定义通用方法。
比如:自定义一个删除所有数据的方法,这个方法应该在所有的表都适用
1、创建自定义方法的类:
public class DeleteAllMethod extends AbstractMethod {
@Override
public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
//执行的sql,这个table会取到mapper上对应的表
String sql="delete from "+tableInfo.getTableName();
//mapper接口方法名
String method="deleteAll";
SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
return addDeleteMappedStatement(mapperClass,method,sqlSource);
}
}
2、添加sql注入器
@Component
public class MySqlInjector extends DefaultSqlInjector {
@Override
public List<AbstractMethod> getMethodList(Class<?> mapperClass) {
List<AbstractMethod> methodList = super.getMethodList(mapperClass);
methodList.add(new DeleteAllMethod());
return methodList;
}
}
3、定义通用Mapper
public interface MyMapper<T> extends BaseMapper<T> {
/**
* 删除所有
* @return
*/
int deleteAll();
}
4、需要使用通用mapper里的方法的mapper继承通用mapper,即可
public interface UserMapper extends MyMapper<User> {
}
5、测试
@Autowired
private UserMapper userMapper;
@Test
void injectorTest(){
userMapper.deleteAll();
}
8、代码生成器
BaseEntity没给生成出来,不知道啥问题
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.builder.ConfigBuilder;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.FileType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* @ClassName CodeGenerator
* @Description TODO
* @Author liuzhihui
* @Date 5/1/2021 下午 10:21
* @Version 1.0
**/
public class CodeGenerator {
/**
* <p>
* 读取控制台内容
* </p>
*/
public static String scanner(String tip) {
Scanner scanner = new Scanner(System.in);
StringBuilder help = new StringBuilder();
help.append("请输入" + tip + ":");
System.out.println(help.toString());
if (scanner.hasNext()) {
String ipt = scanner.next();
if (StringUtils.isNotBlank(ipt)) {
return ipt;
}
}
throw new MybatisPlusException("请输入正确的" + tip + "!");
}
public static void main(String[] args) {
// 代码生成器
AutoGenerator mpg = new AutoGenerator();
// 全局配置
GlobalConfig gc = new GlobalConfig();
//项目的路径
String projectPath = System.getProperty("user.dir");
//设置输出路径
gc.setOutputDir(projectPath + "/src/main/java");
//作者
gc.setAuthor("jobob");
//生成代码后,是否打开文件
gc.setOpen(false);
// gc.setSwagger2(true); 实体属性 Swagger2 注解
mpg.setGlobalConfig(gc);
// 数据源配置
DataSourceConfig dsc = new DataSourceConfig();
dsc.setUrl("jdbc:mysql://localhost:3306/mybatis-plus?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT");
// dsc.setSchemaName("public");
dsc.setDriverName("com.mysql.cj.jdbc.Driver");
dsc.setUsername("root");
dsc.setPassword("123456");
mpg.setDataSource(dsc);
// 包配置
PackageConfig pc = new PackageConfig();
pc.setModuleName(scanner("模块名"));
pc.setParent("com.imooc");
mpg.setPackageInfo(pc);
// 自定义配置
InjectionConfig cfg = new InjectionConfig() {
@Override
public void initMap() {
// to do nothing
}
};
// 如果模板引擎是 freemarker
String templatePath = "/templates/mapper.xml.ftl";
// 如果模板引擎是 velocity
// String templatePath = "/templates/mapper.xml.vm";
// 自定义输出配置
List<FileOutConfig> focList = new ArrayList<>();
// 自定义配置会被优先输出
focList.add(new FileOutConfig(templatePath) {
@Override
public String outputFile(TableInfo tableInfo) {
// 自定义输出文件名 , 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化!!
return projectPath + "/src/main/resources/mapper/" + pc.getModuleName()
+ "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
}
});
cfg.setFileCreate(new IFileCreate() {
//直接返回true,是覆盖之前生成的
@Override
public boolean isCreate(ConfigBuilder configBuilder, FileType fileType, String filePath) {
// 判断自定义文件夹是否需要创建
// checkDir("调用默认方法创建的目录,自定义目录用");
// if (fileType == FileType.MAPPER) {
// // 已经生成 mapper 文件判断存在,不想重新生成返回 false
// return !new File(filePath).exists();
// }
// 允许生成模板文件
return true;
}
});
cfg.setFileOutConfigList(focList);
mpg.setCfg(cfg);
// 配置模板
TemplateConfig templateConfig = new TemplateConfig();
// 配置自定义输出模板
//指定自定义模板路径,注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
// templateConfig.setEntity("templates/entity2.java");
// templateConfig.setService();
// templateConfig.setController();
templateConfig.setXml(null);
mpg.setTemplate(templateConfig);
// 策略配置
StrategyConfig strategy = new StrategyConfig();
strategy.setNaming(NamingStrategy.underline_to_camel);
strategy.setColumnNaming(NamingStrategy.underline_to_camel);
if (scanner("是否继承基类").equalsIgnoreCase("y")){
//实体类的父类,用来抽取各个实体类共同的字段
strategy.setSuperEntityClass("com.imooc.project.entity.BaseEntity");
// 写于父类中的公共字段
strategy.setSuperEntityColumns("create_time","update_time");
}
strategy.setEntityLombokModel(true);
strategy.setRestControllerStyle(false);
// 公共父类
// strategy.setSuperControllerClass("你自己的父类控制器,没有就不用设置!");
strategy.setInclude(scanner("表名,多个英文逗号分割").split(","));
strategy.setControllerMappingHyphenStyle(true);
// strategy.setTablePrefix(pc.getModuleName() + "_");
//设置逻辑删除字段,会在实体类上,上加上逻辑删除注解
strategy.setLogicDeleteFieldName("deleted");
//自动填充
ArrayList<TableFill> list = new ArrayList<>();
TableFill create_time = new TableFill("create_time", FieldFill.INSERT);
TableFill update_time = new TableFill("update_time", FieldFill.UPDATE);
list.add(create_time);
list.add(update_time);
strategy.setTableFillList(list);
mpg.setStrategy(strategy);
mpg.setTemplateEngine(new FreemarkerTemplateEngine());
mpg.execute();
}
}