Mybatis-Plus 官方神器发布

今天介绍一个 mybatis - plus 官方发布的神器：mybatis-mate 为 mp 企业级模块，支持分库分表，数据审计、数据敏感词过滤（ac算法），字段加密，字典回写（数据绑定），数据权限，表结构自动生成 sql 维护等，旨在更敏捷优雅处理数据。

1.主要功能

• 字典绑定
• 字段加密
• 数据脱敏
• 表结构动态维护
• 数据审计记录
• 数据范围（数据权限）
• 数据库分库分表、动态据源、读写分离、数- - 据库健康检查自动切换。

2、使用

2.1 依赖导入

spring boot 引入自动依赖注解包

<dependency>
  <groupid>com.baomidou</groupid>
  <artifactid>mybatis-mate-starter</artifactid>
  <version>1.0.8</version>
</dependency>

注解（实体分包使用）

<dependency>
  <groupid>com.baomidou</groupid>
  <artifactid>mybatis-mate-annotation</artifactid>
  <version>1.0.8</version>
</dependency>

2.2 字段数据绑定（字典回写）

例如 user_sex 类型 sex 字典结果映射到 sextext 属性

@fielddict(type = "user_sex", target = "sextext")
private integer sex;

private string sextext;

实现 idatadict 接口提供字典数据源，注入到 spring 容器即可。

@component
public class datadict implements idatadict {

    /**
     * 从数据库或缓存中获取
     */
    private map<string, string> sex_map = new concurrenthashmap<string, string>() {{
        put("0", "女");
        put("1", "男");
    }};

    @override
    public string getnamebycode(fielddict fielddict, string code) {
        system.err.println("字段类型：" + fielddict.type() + "，编码：" + code);
        return sex_map.get(code);
    }
}

2.3 字段加密

属性 @fieldencrypt 注解即可加密存储，会自动解密查询结果，支持全局配置加密密钥算法，及注解密钥算法，可以实现 iencryptor 注入自定义算法。

@fieldencrypt(algorithm = algorithm.pbewithmd5anddes)
private string password;

2.4 字段脱敏

属性 @fieldsensitive 注解即可自动按照预设策略对源数据进行脱敏处理，默认 sensitivetype 内置 9 种常用脱敏策略。
例如：中文名、银行卡账号、手机号码等 脱敏策略。也可以自定义策略如下：

@fieldsensitive(type = "teststrategy")
private string username;

@fieldsensitive(type = sensitivetype.mobile)
private string mobile;

自定义脱敏策略 teststrategy 添加到默认策略中注入 spring 容器即可。

@configuration
public class sensitivestrategyconfig {

    /**
     * 注入脱敏策略
     */
    @bean
    public isensitivestrategy sensitivestrategy() {
        // 自定义 teststrategy 类型脱敏处理
        return new sensitivestrategy().addstrategy("teststrategy", t -> t + "***test***");
    }
}

例如文章敏感词过滤

/**
 * 演示文章敏感词过滤
 */
@restcontroller
public class articlecontroller {
    @autowired
    private sensitivewordsmapper sensitivewordsmapper;

    // 测试访问下面地址观察请求地址、界面返回数据及控制台（ 普通参数 ）
    // 无敏感词 http://localhost:8080/info?content=tom&see=1&age=18
    // 英文敏感词 http://localhost:8080/info?content=my%20content%20is%20tomcat&see=1&age=18
    // 汉字敏感词 http://localhost:8080/info?content=%e7%8e%8b%e5%ae%89%e7%9f%b3%e5%94%90%e5%ae%8b%e5%85%ab%e5%a4%a7%e5%ae%b6&see=1
    // 多个敏感词 http://localhost:8080/info?content=%e7%8e%8b%e5%ae%89%e7%9f%b3%e6%9c%89%e4%b8%80%e5%8f%aa%e7%8c%abtomcat%e6%b1%a4%e5%a7%86%e5%87%af%e7%89%b9&see=1&size=6
    // 插入一个字变成非敏感词 http://localhost:8080/info?content=%e7%8e%8b%e7%8c%ab%e5%ae%89%e7%9f%b3%e6%9c%89%e4%b8%80%e5%8f%aa%e7%8c%abtomcat%e6%b1%a4%e5%a7%86%e5%87%af%e7%89%b9&see=1&size=6
    @getmapping("/info")
    public string info(article article) throws exception {
        return paramsconfig.tojson(article);
    }


    // 添加一个敏感词然后再去观察是否生效 http://localhost:8080/add
    // 观察【猫】这个词被过滤了 http://localhost:8080/info?content=%e7%8e%8b%e5%ae%89%e7%9f%b3%e6%9c%89%e4%b8%80%e5%8f%aa%e7%8c%abtomcat%e6%b1%a4%e5%a7%86%e5%87%af%e7%89%b9&see=1&size=6
    // 嵌套敏感词处理 http://localhost:8080/info?content=%e7%8e%8b%e7%8c%ab%e5%ae%89%e7%9f%b3%e6%9c%89%e4%b8%80%e5%8f%aa%e7%8c%abtomcat%e6%b1%a4%e5%a7%86%e5%87%af%e7%89%b9&see=1&size=6
    // 多层嵌套敏感词 http://localhost:8080/info?content=%e7%8e%8b%e7%8e%8b%e7%8c%ab%e5%ae%89%e7%9f%b3%e5%ae%89%e7%9f%b3%e6%9c%89%e4%b8%80%e5%8f%aa%e7%8c%abtomcat%e6%b1%a4%e5%a7%86%e5%87%af%e7%89%b9&see=1&size=6
    @getmapping("/add")
    public string add() throws exception {
        long id = 3l;
        if (null == sensitivewordsmapper.selectbyid(id)) {
            system.err.println("插入一个敏感词：" + sensitivewordsmapper.insert(new sensitivewords(id, "猫")));
            // 插入一个敏感词，刷新算法引擎敏感词
            sensitivewordsprocessor.reloadsensitivewords();
        }
        return "ok";
    }

    // 测试访问下面地址观察控制台（ 请求json参数 ）
    // idea 执行 resources 目录 testjson.http 文件测试
    @postmapping("/json")
    public string json(@requestbody article article) throws exception {
        return paramsconfig.tojson(article);
    }
}

2.5 ddl 数据结构自动维护

解决升级表结构初始化，版本发布更新 sql 维护问题，目前支持 mysql、postgresql。

@component
public class postgresddl implements iddl {

    /**
     * 执行 sql 脚本方式
     */
    @override
    public list<string> getsqlfiles() {
        return arrays.aslist(
                // 内置包方式
                "db/tag-schema.sql",
                // 文件绝对路径方式
                "d:\\db\\tag-data.sql"
        );
    }
}

不仅仅可以固定执行，也可以动态执行！！

ddlscript.run(new stringreader("delete from user;\n" +
                "insert into user (id, username, password, sex, email) values\n" +
                "(20, 'duo', '123456', 0, '[e-mail]');"));

它还支持多数据源执行！！！

@component
public class mysqlddl implements iddl {

    @override
    public void sharding(consumer<iddl> consumer) {
        // 多数据源指定，主库初始化从库自动同步
        string group = "mysql";
        shardinggroupproperty sgp = shardingkey.getdbgroupproperty(group);
        if (null != sgp) {
            // 主库
            sgp.getmasterkeys().foreach(key -> {
                shardingkey.change(group + key);
                consumer.accept(this);
            });
            // 从库
            sgp.getslavekeys().foreach(key -> {
                shardingkey.change(group + key);
                consumer.accept(this);
            });
        }
    }

    /**
     * 执行 sql 脚本方式
     */
    @override
    public list<string> getsqlfiles() {
        return arrays.aslist("db/user-mysql.sql");
    }
}

2.6 动态多数据源主从*切换

@sharding 注解使数据源不限制随意使用切换，你可以在 mapper 层添加注解，按需求指哪打哪！！

@mapper
@sharding("mysql")
public interface usermapper extends basemapper<user> {

    @sharding("postgres")
    long selectbyusername(string username);
}

你也可以自定义策略统一调兵遣将

@component
public class myshardingstrategy extends randomshardingstrategy {

    /**
     * 决定切换数据源 key {@link shardingdatasource}
     *
     * @param group 动态数据库组
     * @param invocation {@link invocation}
     * @param sqlcommandtype {@link sqlcommandtype}
     */
    @override
    public void determinedatasourcekey(string group, invocation invocation, sqlcommandtype sqlcommandtype) {
        // 数据源组 group 自定义选择即可， keys 为数据源组内主从多节点，可随机选择或者自己控制
        this.changedatabasekey(group, sqlcommandtype, keys -> choosekey(keys, invocation));
    }
}

可以开启主从策略，当然也是可以开启健康检查！具体配置：

mybatis-mate:
  sharding:
    health: true # 健康检测
    primary: mysql # 默认选择数据源
    datasource:
      mysql: # 数据库组
        - key: node1
          ...
        - key: node2
          cluster: slave # 从库读写分离时候负责 sql 查询操作，主库 master 默认可以不写
          ...
      postgres:
        - key: node1 # 数据节点
          ...

2.7 分布式事务日志打印

部分配置如下：

/**
 * <p>
 * 性能分析拦截器，用于输出每条 sql 语句及其执行时间
 * </p>
 */
@slf4j
@component
@intercepts({@signature(type = statementhandler.class, method = "query", args = {statement.class, resulthandler.class}),
        @signature(type = statementhandler.class, method = "update", args = {statement.class}),
        @signature(type = statementhandler.class, method = "batch", args = {statement.class})})
public class performanceinterceptor implements interceptor {
    /**
     * sql 执行最大时长，超过自动停止运行，有助于发现问题。
     */
    private long maxtime = 0;
    /**
     * sql 是否格式化
     */
    private boolean format = false;
    /**
     * 是否写入日志文件<br>
     * true 写入日志文件，不阻断程序执行！<br>
     * 超过设定的最大执行时长异常提示！
     */
    private boolean writeinlog = false;

    @override
    public object intercept(invocation invocation) throws throwable {
        statement statement;
        object firstarg = invocation.getargs()[0];
        if (proxy.isproxyclass(firstarg.getclass())) {
            statement = (statement) systemmetaobject.forobject(firstarg).getvalue("h.statement");
        } else {
            statement = (statement) firstarg;
        }
        metaobject stmtmetaobj = systemmetaobject.forobject(statement);
        try {
            statement = (statement) stmtmetaobj.getvalue("stmt.statement");
        } catch (exception e) {
            // do nothing
        }
        if (stmtmetaobj.hasgetter("delegate")) {//hikari
            try {
                statement = (statement) stmtmetaobj.getvalue("delegate");
            } catch (exception e) {

            }
        }

        string originalsql = null;
        if (originalsql == null) {
            originalsql = statement.tostring();
        }
        originalsql = originalsql.replaceall("[\\s]+", " ");
        int index = indexofsqlstart(originalsql);
        if (index > 0) {
            originalsql = originalsql.substring(index);
        }

        // 计算执行 sql 耗时
        long start = systemclock.now();
        object result = invocation.proceed();
        long timing = systemclock.now() - start;

        // 格式化 sql 打印执行结果
        object target = pluginutils.realtarget(invocation.gettarget());
        metaobject metaobject = systemmetaobject.forobject(target);
        mappedstatement ms = (mappedstatement) metaobject.getvalue("delegate.mappedstatement");
        stringbuilder formatsql = new stringbuilder();
        formatsql.append(" time：").append(timing);
        formatsql.append(" ms - id：").append(ms.getid());
        formatsql.append("\n execute sql：").append(sqlformat(originalsql, format)).append("\n");
        if (this.iswriteinlog()) {
            if (this.getmaxtime() >= 1 && timing > this.getmaxtime()) {
                log.error(formatsql.tostring());
            } else {
                log.debug(formatsql.tostring());
            }
        } else {
            system.err.println(formatsql);
            if (this.getmaxtime() >= 1 && timing > this.getmaxtime()) {
                throw new runtimeexception(" the sql execution time is too large, please optimize ! ");
            }
        }
        return result;
    }

    @override
    public object plugin(object target) {
        if (target instanceof statementhandler) {
            return plugin.wrap(target, this);
        }
        return target;
    }

    @override
    public void setproperties(properties prop) {
        string maxtime = prop.getproperty("maxtime");
        string format = prop.getproperty("format");
        if (stringutils.isnotempty(maxtime)) {
            this.maxtime = long.parselong(maxtime);
        }
        if (stringutils.isnotempty(format)) {
            this.format = boolean.valueof(format);
        }
    }

    public long getmaxtime() {
        return maxtime;
    }

    public performanceinterceptor setmaxtime(long maxtime) {
        this.maxtime = maxtime;
        return this;
    }

    public boolean isformat() {
        return format;
    }

    public performanceinterceptor setformat(boolean format) {
        this.format = format;
        return this;
    }

    public boolean iswriteinlog() {
        return writeinlog;
    }

    public performanceinterceptor setwriteinlog(boolean writeinlog) {
        this.writeinlog = writeinlog;
        return this;
    }

    public method getmethodregular(class<?> clazz, string methodname) {
        if (object.class.equals(clazz)) {
            return null;
        }
        for (method method : clazz.getdeclaredmethods()) {
            if (method.getname().equals(methodname)) {
                return method;
            }
        }
        return getmethodregular(clazz.getsuperclass(), methodname);
    }

    /**
     * 获取sql语句开头部分
     *
     * @param sql
     * @return
     */
    private int indexofsqlstart(string sql) {
        string uppercasesql = sql.touppercase();
        set<integer> set = new hashset<>();
        set.add(uppercasesql.indexof("select "));
        set.add(uppercasesql.indexof("update "));
        set.add(uppercasesql.indexof("insert "));
        set.add(uppercasesql.indexof("delete "));
        set.remove(-1);
        if (collectionutils.isempty(set)) {
            return -1;
        }
        list<integer> list = new arraylist<>(set);
        collections.sort(list, integer::compareto);
        return list.get(0);
    }

    private final static sqlformatter sqlformatter = new sqlformatter();

    /**
     * 格式sql
     *
     * @param boundsql
     * @param format
     * @return
     */
    public static string sqlformat(string boundsql, boolean format) {
        if (format) {
            try {
                return sqlformatter.format(boundsql);
            } catch (exception ignored) {
            }
        }
        return boundsql;
    }
}

使用：

@restcontroller
@allargsconstructor
public class testcontroller {
    private buyservice buyservice;

    // 数据库 test 表 t_order 在事务一致情况无法插入数据，能够插入说明多数据源事务无效
    // 测试访问 http://localhost:8080/test
    // 制造事务回滚 http://localhost:8080/test?error=true 也可通过修改表结构制造错误
    // 注释 shardingconfig 注入 datasourceprovider 可测试事务无效情况
    @getmapping("/test")
    public string test(boolean error) {
        return buyservice.buy(null != error && error);
    }
}

2.8 数据权限

mapper 层添加注解:

// 测试 test 类型数据权限范围，混合分页模式
@datascope(type = "test", value = {
        // 关联表 user 别名 u 指定部门字段权限
        @datacolumn(alias = "u", name = "department_id"),
        // 关联表 user 别名 u 指定手机号字段（自己判断处理）
        @datacolumn(alias = "u", name = "mobile")
})
@select("select u.* from user u")
list<user> selecttestlist(ipage<user> page, long id, @param("name") string username);

模拟业务处理逻辑：

@bean
public idatascopeprovider datascopeprovider() {
    return new abstractdatascopeprovider() {
        @override
        protected void setwhere(plainselect plainselect, object[] args, datascopeproperty datascopeproperty) {
            // args 中包含 mapper 方法的请求参数，需要使用可以自行获取
            /*
                // 测试数据权限，最终执行 sql 语句
                select u.* from user u where (u.department_id in ('1', '2', '3', '5'))
                and u.mobile like '%1533%'
             */
            if ("test".equals(datascopeproperty.gettype())) {
                // 业务 test 类型
                list<datacolumnproperty> datacolumns = datascopeproperty.getcolumns();
                for (datacolumnproperty datacolumn : datacolumns) {
                    if ("department_id".equals(datacolumn.getname())) {
                        // 追加部门字段 in 条件，也可以是 sql 语句
                        set<string> deptids = new hashset<>();
                        deptids.add("1");
                        deptids.add("2");
                        deptids.add("3");
                        deptids.add("5");
                        itemslist itemslist = new expressionlist(deptids.stream().map(stringvalue::new).collect(collectors.tolist()));
                        inexpression inexpression = new inexpression(new column(datacolumn.getaliasdotname()), itemslist);
                        if (null == plainselect.getwhere()) {
                            // 不存在 where 条件
                            plainselect.setwhere(new parenthesis(inexpression));
                        } else {
                            // 存在 where 条件 and 处理
                            plainselect.setwhere(new andexpression(plainselect.getwhere(), inexpression));
                        }
                    } else if ("mobile".equals(datacolumn.getname())) {
                        // 支持一个自定义条件
                        likeexpression likeexpression = new likeexpression();
                        likeexpression.setleftexpression(new column(datacolumn.getaliasdotname()));
                        likeexpression.setrightexpression(new stringvalue("%1533%"));
                        plainselect.setwhere(new andexpression(plainselect.getwhere(), likeexpression));
                    }
                }
            }
        }
    };
}

最终执行 sql 输出：

select u.* from user u
  where (u.department_id in ('1', '2', '3', '5'))
  and u.mobile like '%1533%' limit 1, 10

目前仅有付费版本，了解更多 mybatis-mate 使用示例详见：

https://gitee.com/baomidou/mybatis-mate-examples

到此这篇关于mybatis-plus 官方神器发布的文章就介绍到这了,更多相关mybatis-plus 官方神器内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！