MyBatis 拦截器 Interceptor 源码解析

冷不防 2023-10-02 10:01 31阅读 0赞

#### 文章目录 ####

*  1. MyBatis 拦截器 Interceptor 介绍
 *  2. Interceptor 实现源码分析
 *   *   *  2.1 拦截器 Interceptor 的注入
         *  2.2 拦截器 Interceptor 的应用
         *  2.3 拦截器 Interceptor 的生效

## 1. MyBatis 拦截器 Interceptor 介绍 ##

`MyBatis` 提供了基于 `Interceptor` 的扩展机制，给使用方实现自定义逻辑留下了余地。笔者在 [MyBatis @Intercepts 实现打印 SQL 语句][MyBatis _Intercepts _ SQL] 中介绍了拦截器的基本使用，实际上 `MyBatis` 拦截器的实现是基于 JDK 动态代理，使用方可以拦截切入如下表所示的 4个接口的所有方法

<table> 
 <thead> 
  <tr> 
   <th align="left">接口</th> 
   <th align="left">功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Executor</td> 
   <td align="left">数据库操作的执行器</td> 
  </tr> 
  <tr> 
   <td align="left">StatementHandler</td> 
   <td align="left">SQL 语句的处理器</td> 
  </tr> 
  <tr> 
   <td align="left">ParameterHandler</td> 
   <td align="left">SQL 语句中参数的处理器</td> 
  </tr> 
  <tr> 
   <td align="left">ResultHandler</td> 
   <td align="left">SQL 语句执行结果的处理器</td> 
  </tr> 
 </tbody> 
</table>

## 2. Interceptor 实现源码分析 ##

`MyBatis` 的拦截器 `Interceptor` 源码流程如下图所示，简单来说可以分为几个步骤：

> 1.  拦截器 `Interceptor` 的注入  
>     从源码来看，也就是 `InterceptorChain` 缓存 `Interceptor` 的处理过程
> 2.  拦截器 `Interceptor` 的应用  
>     简单说，就是使用 `Plugin` 将 `Interceptor` 作为增强逻辑给目标对象生成代理对象的过程
> 3.  拦截器 `Interceptor` 的生效  
>     这一部分其实就是 JDK 动态代理生效的逻辑，读者如不了解，可以参考 [Java 动态代理的底层原理][Java]

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6LCI6LCIMTk3NA_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

#### 2.1 拦截器 Interceptor 的注入 ####

1.  当使用方将继承了 `Interceptor` 接口的拦截器实例托管给 `SpringBoot` 框架后，在 `SpringBoot` 启动进行自动配置的时候，其实就会将 `Interceptor` 接口实例从容器中取出来使用。这部分逻辑在 Mybatis 自动配置类 `MybatisAutoConfiguration` 的构造方法中，可以看到该类的构造方法被调用的时候就会通过 `ObjectProvider` 去获取目标接口 `Interceptor` 的实例
    
        public MybatisAutoConfiguration(MybatisProperties properties, ObjectProvider<Interceptor[]> interceptorsProvider,
           ObjectProvider<TypeHandler[]> typeHandlersProvider, ObjectProvider<LanguageDriver[]> languageDriversProvider,
           ResourceLoader resourceLoader, ObjectProvider<DatabaseIdProvider> databaseIdProvider,
           ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider) {
              
         this.properties = properties;
         this.interceptors = interceptorsProvider.getIfAvailable();
         this.typeHandlers = typeHandlersProvider.getIfAvailable();
         this.languageDrivers = languageDriversProvider.getIfAvailable();
         this.resourceLoader = resourceLoader;
         this.databaseIdProvider = databaseIdProvider.getIfAvailable();
         this.configurationCustomizers = configurationCustomizersProvider.getIfAvailable();
        }
2.  `ObjectProvider#getIfAvailable()` 是接口方法，实际由 `DefaultListableBeanFactory` 的内部匿名类实现，最终也是调用 `DefaultListableBeanFactory#resolveBean()` 方法从容器内取得目标实例
    
        @Override
         public <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType) {
              
         	return new BeanObjectProvider<T>() {
              
         		@Override
         		public T getObject() throws BeansException {
              
         			T resolved = resolveBean(requiredType, null, false);
         			if (resolved == null) {
              
         				throw new NoSuchBeanDefinitionException(requiredType);
         			}
         			return resolved;
         		}
         		@Override
         		public T getObject(Object... args) throws BeansException {
              
         			T resolved = resolveBean(requiredType, args, false);
         			if (resolved == null) {
              
         				throw new NoSuchBeanDefinitionException(requiredType);
         			}
         			return resolved;
         		}
         		@Override
         		@Nullable
         		public T getIfAvailable() throws BeansException {
              
         			return resolveBean(requiredType, null, false);
         		}
         		@Override
         		@Nullable
         		public T getIfUnique() throws BeansException {
              
         			return resolveBean(requiredType, null, true);
         		}
         		@Override
         		public Stream<T> stream() {
              
         			return Arrays.stream(getBeanNamesForTypedStream(requiredType))
         					.map(name -> (T) getBean(name))
         					.filter(bean -> !(bean instanceof NullBean));
         		}
         		@Override
         		public Stream<T> orderedStream() {
              
         			String[] beanNames = getBeanNamesForTypedStream(requiredType);
         			if (beanNames.length == 0) {
              
         				return Stream.empty();
         			}
         			Map<String, T> matchingBeans = new LinkedHashMap<>(beanNames.length);
         			for (String beanName : beanNames) {
              
         				Object beanInstance = getBean(beanName);
         				if (!(beanInstance instanceof NullBean)) {
              
         					matchingBeans.put(beanName, (T) beanInstance);
         				}
         			}
         			Stream<T> stream = matchingBeans.values().stream();
         			return stream.sorted(adaptOrderComparator(matchingBeans));
         		}
         	};
         }
        
        private <T> T resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) {
              
         	NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args, nonUniqueAsNull);
         	if (namedBean != null) {
              
         		return namedBean.getBeanInstance();
         	}
         	BeanFactory parent = getParentBeanFactory();
         	if (parent instanceof DefaultListableBeanFactory) {
              
         		return ((DefaultListableBeanFactory) parent).resolveBean(requiredType, args, nonUniqueAsNull);
         	}
         	else if (parent != null) {
              
         		ObjectProvider<T> parentProvider = parent.getBeanProvider(requiredType);
         		if (args != null) {
              
         			return parentProvider.getObject(args);
         		}
         		else {
              
         			return (nonUniqueAsNull ? parentProvider.getIfUnique() : parentProvider.getIfAvailable());
         		}
         	}
         	return null;
         }
3.  取得的 `Interceptor` 接口实例被缓存起来，将在 `MybatisAutoConfiguration#sqlSessionFactory()` 方法配置 `SqlSessionFactory` 时使用
    
    > 可以看到这里的处理是新建 `SqlSessionFactoryBean` 实例，然后调用 `SqlSessionFactoryBean#setPlugin()` 将拦截器列表缓存起来，这个拦截器列表之后将在 `SqlSessionFactoryBean#getObject()` 方法构建 `SqlSessionFactory` 实例过程中使用
    
        @Bean
        @ConditionalOnMissingBean
        public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
              
         SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
         factory.setDataSource(dataSource);
         factory.setVfs(SpringBootVFS.class);
         if (StringUtils.hasText(this.properties.getConfigLocation())) {
              
           factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
         }
         applyConfiguration(factory);
         if (this.properties.getConfigurationProperties() != null) {
              
           factory.setConfigurationProperties(this.properties.getConfigurationProperties());
         }
         if (!ObjectUtils.isEmpty(this.interceptors)) {
              
           factory.setPlugins(this.interceptors);
         }
         if (this.databaseIdProvider != null) {
              
           factory.setDatabaseIdProvider(this.databaseIdProvider);
         }
         if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
              
           factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
         }
         if (this.properties.getTypeAliasesSuperType() != null) {
              
           factory.setTypeAliasesSuperType(this.properties.getTypeAliasesSuperType());
         }
         if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
              
           factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
         }
         if (!ObjectUtils.isEmpty(this.typeHandlers)) {
              
           factory.setTypeHandlers(this.typeHandlers);
         }
         if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
              
           factory.setMapperLocations(this.properties.resolveMapperLocations());
         }
         Set<String> factoryPropertyNames = Stream
             .of(new BeanWrapperImpl(SqlSessionFactoryBean.class).getPropertyDescriptors()).map(PropertyDescriptor::getName)
             .collect(Collectors.toSet());
         Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
         if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) {
              
           // Need to mybatis-spring 2.0.2+
           factory.setScriptingLanguageDrivers(this.languageDrivers);
           if (defaultLanguageDriver == null && this.languageDrivers.length == 1) {
              
             defaultLanguageDriver = this.languageDrivers[0].getClass();
           }
         }
         if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {
              
           // Need to mybatis-spring 2.0.2+
           factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
         }
        
         return factory.getObject();
        }
4.  `SqlSessionFactoryBean#getObject()` 方法逻辑简单，只是调用 `SqlSessionFactoryBean#afterPropertiesSet()` 方法，接下来的核心步骤是调用 `SqlSessionFactoryBean#buildSqlSessionFactory()` 方法创建一个 `SqlSessionFactory` 实例
    
        public SqlSessionFactory getObject() throws Exception {
              
         if (this.sqlSessionFactory == null) {
              
           afterPropertiesSet();
         }
        
         return this.sqlSessionFactory;
        }
        
        public void afterPropertiesSet() throws Exception {
              
         notNull(dataSource, "Property 'dataSource' is required");
         notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
         state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
             "Property 'configuration' and 'configLocation' can not specified with together");
        
         this.sqlSessionFactory = buildSqlSessionFactory();
        }
5.  `SqlSessionFactoryBean#buildSqlSessionFactory()` 方法比较长，但是和本文相关的主要逻辑如下：
    
    > 如果 `SqlSessionFactoryBean` 内部缓存的 `Interceptor` 列表不为空，则遍历该列表，调用 `Configuration#addInterceptor()` 方法将其添加到 MyBatis 的 `Configuration` 配置类中去
    
        protected SqlSessionFactory buildSqlSessionFactory() throws Exception {
              
        
         final Configuration targetConfiguration;
        
         XMLConfigBuilder xmlConfigBuilder = null;
         if (this.configuration != null) {
              
           targetConfiguration = this.configuration;
           if (targetConfiguration.getVariables() == null) {
              
             targetConfiguration.setVariables(this.configurationProperties);
           } else if (this.configurationProperties != null) {
              
             targetConfiguration.getVariables().putAll(this.configurationProperties);
           }
         } else if (this.configLocation != null) {
              
           xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
           targetConfiguration = xmlConfigBuilder.getConfiguration();
         } else {
              
           LOGGER.debug(
               () -> "Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");
           targetConfiguration = new Configuration();
           Optional.ofNullable(this.configurationProperties).ifPresent(targetConfiguration::setVariables);
         }
        
         ......
        
         if (!isEmpty(this.plugins)) {
              
           Stream.of(this.plugins).forEach(plugin -> {
              
             targetConfiguration.addInterceptor(plugin);
             LOGGER.debug(() -> "Registered plugin: '" + plugin + "'");
           });
         }
        
         ......
         
         return this.sqlSessionFactoryBuilder.build(targetConfiguration);
        }
6.  `Configuration#addInterceptor()` 方法逻辑简练，核心是调用 `InterceptorChain#addInterceptor()` 方法缓存 `Interceptor` 实例
    
        public void addInterceptor(Interceptor interceptor) {
              
         interceptorChain.addInterceptor(interceptor);
        }
7.  `InterceptorChain` 类定义如下，可以知道该类其实就是个拦截器列表封装而已，至此使用方在 SpringBoot 框架中定义的 `Interceptor` 拦截器注入到了 MyBatis 的 Configuration 配置中
    
        public class InterceptorChain {
              
        
        private final List<Interceptor> interceptors = new ArrayList<>();
        
        public Object pluginAll(Object target) {
              
         for (Interceptor interceptor : interceptors) {
              
           target = interceptor.plugin(target);
         }
         return target;
        }
        
        public void addInterceptor(Interceptor interceptor) {
              
         interceptors.add(interceptor);
        }
        
        public List<Interceptor> getInterceptors() {
              
         return Collections.unmodifiableList(interceptors);
        }
        
        }

#### 2.2 拦截器 Interceptor 的应用 ####

1.  在上一节中，`MybatisAutoConfiguration#sqlSessionFactory()` 方法最终返回的是一个 `DefaultSqlSessionFactory` 对象。我们使用 Mapper 与数据库交互都需要创建一个 `SqlSession` ，而这个创建动作将在 `DefaultSqlSessionFactory#openSession()` 方法被调用时触发。读者如果对上层触发执行 `DefaultSqlSessionFactory#openSession()` 方法的流程不清楚，可参考 [MyBatis 缓存实现源码分析][MyBatis] 中的流程图
    
    > 从源码可以看到，这里的核心是调用 `DefaultSqlSessionFactory#openSessionFromDataSource()` 方法。这个方法会创建一个 `DefaultSqlSession` 对象返回给调用方，与此同时，也会通过 `Configuration#newExecutor()` 方法新建一个 SQL 执行器对象，这里就是拦截器功能实现的关键
    
        @Override
        public SqlSession openSession() {
              
         return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
        }
        
        private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
              
         Transaction tx = null;
         try {
              
           final Environment environment = configuration.getEnvironment();
           final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
           tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
           final Executor executor = configuration.newExecutor(tx, execType);
           return new DefaultSqlSession(configuration, executor, autoCommit);
         } catch (Exception e) {
              
           closeTransaction(tx); // may have fetched a connection so lets call close()
           throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
         } finally {
              
           ErrorContext.instance().reset();
         }
        }
2.  `Configuration#newExecutor()` 方法的重要逻辑分为两步：
    
    > 1.  根据参数创建正常的`Executor` 接口实例，本文以 `SimpleExecutor` 为例
    > 2.  调用 `InterceptorChain#pluginAll()`方法以正常的 `Executor` 实例为目标，为其创建代理对象，织入拦截器逻辑
    
        public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
              
         executorType = executorType == null ? defaultExecutorType : executorType;
         executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
         Executor executor;
         if (ExecutorType.BATCH == executorType) {
              
           executor = new BatchExecutor(this, transaction);
         } else if (ExecutorType.REUSE == executorType) {
              
           executor = new ReuseExecutor(this, transaction);
         } else {
              
           executor = new SimpleExecutor(this, transaction);
         }
         if (cacheEnabled) {
              
           executor = new CachingExecutor(executor);
         }
         executor = (Executor) interceptorChain.pluginAll(executor);
         return executor;
        }
3.  `InterceptorChain#pluginAll()`方法的核心逻辑是遍历内部的拦截器列表，以目标对象为入参，为目标对象加载拦截器。需注意，该循环中每个 Interceptor 加载拦截器后返回的代理对象都将成为下一个 Interceptor 的目标对象 target，也就是说，下一个 Interceptor 拦截器创建的代理对象将以 target 属性保存上一个代理对象，形成了嵌套结构
    
        public Object pluginAll(Object target) {
              
         for (Interceptor interceptor : interceptors) {
              
           target = interceptor.plugin(target);
         }
         return target;
        }
4.  `Interceptor#plugin()` 方法核心是调用 `Plugin#wrap()` 方法返回一个动态代理对象
    
        default Object plugin(Object target) {
              
         return Plugin.wrap(target, this);
        }
5.  `Plugin#wrap()` 方法采用了 JDK 提供的动态代理 API，核心逻辑如下：
    
    > 1.  调用`Plugin#getSignatureMap()`解析拦截器实例上 `@Intercepts` 注解标注的信息，确定要拦截的目标接口及其方法列表
    > 2.  新建包含了`Interceptor` 拦截器的 `Plugin` 对象作为动态代理处理器， 调用 JDK 动态代理 API 为 `Executor` 实例创建代理对象
    
        public static Object wrap(Object target, Interceptor interceptor) {
              
         Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
         Class<?> type = target.getClass();
         Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
         if (interfaces.length > 0) {
              
           return Proxy.newProxyInstance(
               type.getClassLoader(),
               interfaces,
               new Plugin(target, interceptor, signatureMap));
         }
         return target;
        }
        
        private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
              
         Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
         // issue #251
         if (interceptsAnnotation == null) {
              
           throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());
         }
         Signature[] sigs = interceptsAnnotation.value();
         Map<Class<?>, Set<Method>> signatureMap = new HashMap<>();
         for (Signature sig : sigs) {
              
           Set<Method> methods = signatureMap.computeIfAbsent(sig.type(), k -> new HashSet<>());
           try {
              
             Method method = sig.type().getMethod(sig.method(), sig.args());
             methods.add(method);
           } catch (NoSuchMethodException e) {
              
             throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
           }
         }
         return signatureMap;
        }
6.  经过以上步骤，如果有多个应用在 `Executor` 上的拦截器，则其创建的 `Executor` 代理对象的结构示意如下图所示。需注意，除了 Executor 以外，StatementHandler 、ParameterHandler 、ResultHandler 的拦截器应用逻辑皆与此相同，MyBatis 在新建这些接口的实例时也会通过 Configuration 提供的方法完成，并由 Configuration 调用 `InterceptorChain#pluginAll()` 完成拦截器逻辑的织入
    
        public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
              
         ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
         parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
         return parameterHandler;
        }
        
        public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
           ResultHandler resultHandler, BoundSql boundSql) {
              
         ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
         resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
         return resultSetHandler;
        }
        
        public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
              
         StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
         statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
         return statementHandler;
        }
    
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6LCI6LCIMTk3NA_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

#### 2.3 拦截器 Interceptor 的生效 ####

1.  在上一节中，`DefaultSqlSessionFactory#openSession()` 方法最终创建了一个封装了 `Executor` 代理对象的 `DefaultSqlSession` 对象。当使用方进行数据库操作，例如调用 `SqlSession#selectList()` 方法时，其实是调用子类实现的 `DefaultSqlSession#selectList()` 方法
    
    > 可以看到此处的核心是调用 `Executor#query()`，因为 `DefaultSqlSession` 持有的是动态代理创建的 `Executor` 代理对象，则此处进入了动态代理处理流程，动态代理处理器 `Plugin#invoke()` 方法被触发，不清楚动态代理实现原理的读者可参考 [Java 动态代理的底层原理][Java]
    
        @Override
        public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
              
         try {
              
           MappedStatement ms = configuration.getMappedStatement(statement);
           return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
         } catch (Exception e) {
              
           throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
         } finally {
              
           ErrorContext.instance().reset();
         }
        }
2.  `Plugin#invoke()` 的处理逻辑很清晰，核心步骤如下：
    
    > 1.  根据当前执行方法的接口 Class 从拦截方法 Map 中获取拦截方法列表
    > 2.  如果拦截方法列表不为空并且包含当前执行的方法，则调用当前代理对象中的拦截器 `Interceptor#intercept()` 方法执行拦截逻辑，否则调用当前被代理对象 target 的对应方法。此处注意，执行拦截逻辑的入参为 `Invocation` 对象
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
              
         try {
              
           Set<Method> methods = signatureMap.get(method.getDeclaringClass());
           if (methods != null && methods.contains(method)) {
              
             return interceptor.intercept(new Invocation(target, method, args));
           }
           return method.invoke(target, args);
         } catch (Exception e) {
              
           throw ExceptionUtil.unwrapThrowable(e);
         }
        }
3.  `Interceptor#intercept()` 的方法体就是使用方自定义的逻辑，通常在执行完自定义逻辑后，为了让其他拦截器的逻辑能够得到执行，都会在自定义逻辑末尾调用 `Invocation#proceed` 方法。这个方法比较简单，就是执行当前代理对象中保存的被代理对象 target 的对应方法，这个步骤读者结合2.2节步骤6的说明应该很容易理解，至此 MyBatis 拦截器 Interceptor 的核心原理分析基本结束
    
        public Object proceed() throws InvocationTargetException, IllegalAccessException {
              
         return method.invoke(target, args);
        }

[MyBatis _Intercepts _ SQL]: https://blog.csdn.net/weixin_45505313/article/details/104685417
[Java]: https://blog.csdn.net/weixin_45505313/article/details/106399906
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6LCI6LCIMTk3NA_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://img-blog.csdnimg.cn/66bd9c7298ec435cb5aa3d3ee8c1d6fd.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA6LCI6LCIMTk3NA==,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[MyBatis]: https://blog.csdn.net/weixin_45505313/article/details/114832865
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6LCI6LCIMTk3NA_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: https://img-blog.csdnimg.cn/4e22d40adb854df09325d931bb1569ed.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA6LCI6LCIMTk3NA==,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center