weixin_40725706

这个屌丝很懒，什么也没留下！

热门标签

MyBatisPlus又在搞事了！一个依赖轻松搞定权限问题！堪称神器_mybatisplus执行ddl

作者：weixin_40725706 | 2024-04-05 06:35:03

踩

mybatisplus执行ddl

前言：

今天介绍一个 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;
privateString sexText;

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


@Componentpublicclass DataDict implements IDataDict {
 
    /**
     * 从数据库或缓存中获取
     */private Map<String, String> SEX_MAP = new ConcurrentHashMap<String, String>() {{
        put("0", "女");
        put("1", "男");
    }};
 
    @OverridepublicString 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")
privateString username;
 
@FieldSensitive(type = SensitiveType.mobile)
privateString mobile;

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


@ConfigurationpublicclassSensitiveStrategyConfig{
 
    /**
     * 注入脱敏策略
     */@Beanpublic ISensitiveStrategy sensitiveStrategy(){
        // 自定义 testStrategy 类型脱敏处理returnnew 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。


@ComponentpublicclassPostgresDdlimplementsIDdl{
 
    /**
     * 执行 SQL 脚本方式
     */@Overridepublic List<String> getSqlFiles(){
        return Arrays.asList(
                // 内置包方式"db/tag-schema.sql",
                // 文件绝对路径方式"D:\\db\\tag-data.sql"
        );
    }
}

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


ddlScript.run(new StringReader("DELETEFROMuser;\n" +
                "INSERTINTOuser (id, username, password, sex, email) VALUES\n" +
                "(20, 'Duo', '123456', 0, 'Duo@baomidou.com');"));

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


 
@Component
publicclassMysqlDdlimplementsIDdl {
 
    @Override
    publicvoidsharding(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);
}

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


@ComponentpublicclassMyShardingStrategyextendsRandomShardingStrategy{
 
    /**
     * 决定切换数据源 key {@link ShardingDatasource}
     *
     * @param group 动态数据库组
     * @param invocation {@link Invocation}
     * @param sqlCommandType {@link SqlCommandType}
     */@OverridepublicvoiddetermineDatasourceKey(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:node2cluster: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})})
publicclassPerformanceInterceptorimplementsInterceptor{
   /**
    * SQL 执行最大时长，超过自动停止运行，有助于发现问题。
    */privatelong maxTime = 0;
   /**
    * SQL 是否格式化
    */privateboolean format = false;
   /**
    * 是否写入日志文件<br>
    * true 写入日志文件，不阻断程序执行！<br>
    * 超过设定的最大执行时长异常提示！
    */privateboolean writeInLog = false;
 
   @Overridepublic 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")) {//Hikaritry {
               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()) {
               thrownew RuntimeException(" The SQL execution time is too large, please optimize ! ");
           }
       }
       return result;
   }
 
   @Overridepublic Object plugin(Object target){
       if (target instanceof StatementHandler) {
           return Plugin.wrap(target, this);
       }
       return target;
   }
 
   @OverridepublicvoidsetProperties(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);
       }
   }
 
   publiclonggetMaxTime(){
       return maxTime;
   }
 
   public PerformanceInterceptor setMaxTime(long maxTime){
       this.maxTime = maxTime;
       returnthis;
   }
 
   publicbooleanisFormat(){
       return format;
   }
 
   public PerformanceInterceptor setFormat(boolean format){
       this.format = format;
       returnthis;
   }
 
   publicbooleanisWriteInLog(){
       return writeInLog;
   }
 
   public PerformanceInterceptor setWriteInLog(boolean writeInLog){
       this.writeInLog = writeInLog;
       returnthis;
   }
 
   public Method getMethodRegular(Class<?> clazz, String methodName){
       if (Object.class.equals(clazz)) {
           returnnull;
       }
       for (Method method : clazz.getDeclaredMethods()) {
           if (method.getName().equals(methodName)) {
               return method;
           }
       }
       return getMethodRegular(clazz.getSuperclass(), methodName);
   }
 
   /**
    * 获取sql语句开头部分
    *
    * @param sql
    * @return
    */privateintindexOfSqlStart(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);
   }
 
   privatefinalstatic SqlFormatter sqlFormatter = new SqlFormatter();
 
   /**
    * 格式sql
    *
    * @param boundSql
    * @param format
    * @return
    */publicstatic String sqlFormat(String boundSql, boolean format){
       if (format) {
           try {
               return sqlFormatter.format(boundSql);
           } catch (Exception ignored) {
           }
       }
       return boundSql;
   }
}

使用：


@RestController@AllArgsConstructor
public class TestController {
    privateBuyServicebuyService;
 
    // 数据库 test 表 t_order 在事务一致情况无法插入数据，能够插入说明多数据源事务无效// 测试访问 http://localhost:8080/test// 制造事务回滚 http://localhost:8080/test?error=true 也可通过修改表结构制造错误// 注释 ShardingConfig 注入 dataSourceProvider 可测试事务无效情况
    @GetMapping("/test")
    publicStringtest(Boolean error) {
        returnbuyService.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);

模拟业务处理逻辑：


@Beanpublic IDataScopeProvider dataScopeProvider(){
    returnnew AbstractDataScopeProvider() {
        @OverrideprotectedvoidsetWhere(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));
                        }
                    } elseif ("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.* FROMuser u
  WHERE (u.department_id IN ('1', '2', '3', '5'))
  AND u.mobile LIKE'%1533%'LIMIT1, 10

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

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

MyBatisPlus快速入门

MyBatisPlus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。

特性：

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑

损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作

强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求

支持 Lambda 形式调用：通过 Lambda 表达式，方便地编写各类查询条件，无需再担心字段写错支持主件自动生成：支持多达 4 主键策略（内含分布式唯一 ID 生成器 Sequence），可自由配置，完美解决主键问题

支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 即可进行强大的 CRUD 操作支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）

内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用

内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List查询

分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、

SQLServer 等多种数据库

内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询

内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

1、mybatis-plus 快速使用

1.1 、引入mybatis-plus相关maven依赖


<!‐‐https://mvnrepository.com/artifact/com.baomidou/mybatis‐plus ‐‐>
2 <dependency>
3 <groupId>com.baomidou</groupId>
4 <artifactId>mybatis‐plus</artifactId>
5 <version>3.3.1</version>
6 </dependency>

引入mybatis-plus在spring boot中的场景启动器


1 <!‐‐https://mvnrepository.com/artifact/com.baomidou/mybatis‐plus‐boot‐starter ‐‐>
2 <dependency>
3 <groupId>com.baomidou</groupId>
4 <artifactId>mybatis‐plus‐boot‐starter</artifactId>
5 <version>3.3.1</version>
6 </dependency>

ps:切记不可再在pom.xml文件中引入mybatis与mybatis-spring的maven依赖,这一点,mybatis-plus的官方文档中已经

说明的很清楚了

1.2、创建数据表

(1)SQL语句


1 ‐‐ 创建表
2 CREATETABLE tbl_employee(
3idINT(11) PRIMARY KEY AUTO_INCREMENT,
4 last_name VARCHAR(50),
5 email VARCHAR(50),
6 gender CHAR(1),
7 age INT8 );
9 INSERTINTO tbl_employee(last_name,email,gender,age) VALUES('Tom','tom@atguigu.com',1,22);
10 INSERTINTO tbl_employee(last_name,email,gender,age) VALUES('Jerry','jerry@atguigu.com',0,25);
11 INSERTINTO tbl_employee(last_name,email,gender,age) VALUES('Black','black@atguigu.com',1,30);
12 INSERTINTO tbl_employee(last_name,email,gender,age) VALUES('White','white@atguigu.com',0,35);

(2) 数据表结构

1.3、创建java bean

根据数据表新建相关实体类


1package com.example.demo.pojo;
23publicclassEmployee{
4private Integer id;
5private String lastName;
6private String email;
7private Integer gender;
8private Integer age;
9publicEmployee(){
10super();
11// TODO Auto‐generated constructor stub12 }
13publicEmployee(Integer id, String lastName, String email, Integer gender, Integer age){
14super();
15this.id = id;
16this.lastName = lastName;
17this.email = email;
18this.gender = gender;
19this.age = age;
20 }
21public Integer getId(){
22return id;
23 }
24publicvoidsetId(Integer id){
25this.id = id;
26 }
27public String getLastName(){
28return lastName;
29 }
30publicvoidsetLastName(String lastName){
31this.lastName = lastName;
32 }
33public String getEmail(){
34return email;
35 }
36publicvoidsetEmail(String email){
37this.email = email;
38 }
39public Integer getGender(){
40return gender;
41 }
42publicvoidsetGender(Integer gender){
43this.gender = gender;
44 }
45public Integer getAge(){
46return age;
47 }
48publicvoidsetAge(Integer age){
49this.age = age;
50 }
51@Override52public String toString(){
53return"Employee [id=" + id + ", lastName=" + lastName + ", email=" + email + ", gender=" + gender +
", age="54 + age + "]";
55 }
565758 }

1.4、配置application.proprties

数据源使用druid

1spring.datasource.username=root2spring.datasource.password=201820223spring.datasource.url=jdbc:mysql://127.0.0.1:3306/my?useUnicode=true&characterEncoding=UTF‐8&useSSL=false&serverTimezone=GMT%2B84spring.datasource.driver‐class‐name=com.mysql.cj.jdbc.Driver56spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

2、基于mybatis-plus的入门helloworld---CRUD实验

ps:在进行crud实验之前,简单对mybatis与mybatis-plus做一个简单的对比

2.1、mybatis与mybatis-plus实现方式对比

(1)提出问题: 假设我们已存在一张 tbl_employee 表，且已有对应的实体类 Employee，实现 tbl_employee 表的 CRUD

操作我们需要做什么呢？

(2)实现方式: 基于 Mybatis 需要编写 EmployeeMapper 接口，并手动编写 CRUD 方法提供 EmployeeMapper.xml 映

射文件，并手动编写每个方法对应的 SQL 语句. 基于 Mybatis-plus 只需要创建 EmployeeMapper 接口, 并继承

BaseMapper 接口.这就是使用 mybatis-plus 需要完成的所有操作，甚至不需要创建 SQL 映射文件。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/363959