Spring-Mybatis整合源码分析

本是古典何须时尚 2022-12-27 15:27 257阅读 0赞

### 文章目录 ###

*   *  Sprimg整合Mybatis步骤
     *  Spring中的重要接口
     *   *  BeanDefinition
         *  BeanDefinitionRegistry
         *  BeanFactory
         *  BeanFactoryPostProcessor
         *  ImportBeanDefinitionRegistrar
         *  BeanPostProcessor
         *  ClassPathBeanDefinitionScanner
         *  FactoryBean
     *  Spring容器的大致启动过程
     *  Spring Mybatis整合原理

## Sprimg整合Mybatis步骤 ##

Mybatis整体执行流程  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70]

> 这里数据源使用Druid

在分析源码前我们先梳理一下Spring整合Mybatis的流程

大致是如下步骤

1.  配置数据源

public DataSource dataSource() throws Exception { 
            Class classes = Class.forName(type);
            DruidDataSource dataSource = (DruidDataSource) DataSourceBuilder
                    .create()
                    .driverClassName(driverName)
                    .type(classes)
                    .url(url)
                    .username(username)
                    .password(password)
                    .build();
            dataSource.setMaxWait(maxWait);
            return dataSource;
        }

1.  配置SqlSessionFactory

> SqlSession 是 Mybatis提供的与数据库交互的接口，而SqlSession的创建依赖于SqlSessionFactory，所以我们需要创建SqlSessionFactory，并交给Spirng 管理

大致配置如下

@Bean
        public SqlSessionFactory sqlSessionFactoryBean() throws Exception { 
        	// Spring-Mybatis 模块提供的SqlSessionFactoryBean 
            SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
            factory.setDataSource(clickhouseDataSource());
            // 实体 model的 路径 比如 com.order.model 
            factory.setTypeAliasesPackage(MODEL_PACKAGE);
            //添加XML目录
            ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
            factory.setMapperLocations(resolver.getResources("classpath:mapper/*.xml"));
            //开启驼峰命名转换
            factory.getObject().getConfiguration().setMapUnderscoreToCamelCase(true);
            return factory.getObject();
        }

1.  在配置SqlSessionFactory后我们可以通过SqlSessionFactory.openSession()方法获取到SqlSession，然后通过SqlSession与数据库交互，在传统方式中每次获取到的SqlSession都是一个新对象，而在Spring-Mybatis中，提供了SqlSessionTemplate与数据库交互，在整个Spring容器中都只会存在一个SqlSessionTemplate实例，配置方式如下

@Bean(name="sqlSessionTemplate")
    	public SqlSessionTemplate sessionTemplate() { 
    	return new SqlSessionTemplate(sqlSessionFactoryBean())
    	}

1.  然后通过@MapperSacan(basePackages = \{“com.order.mapper”,sqlSessionTemplateRef=“sqlSessionTemplate”\}) 注解获取到Mapper接口，然后通过动态代理方式为每个Mapper对象生成代理实现对象，然后每次通过SqlSession.getMapper()方法都会获取到Spring容器中已生成好的代理对象。自此Spring和Mybatis的整合就完成了。

## Spring中的重要接口 ##

在分析理解整个Spring-Mybatis源码整合过程前，我们先来了解一下Spring中的一些重要接口和类

### BeanDefinition ###

BeanDefinition用于描述Spring中一些Bean的定义,即包含属性值、构造方法参数等各种属性。配置BeanDefinition通常有如下几种情况:xml配置(以前常用的，现在慢慢被弃用了)、Java注解(@Service、@Component、@Configuration),Spring容器在启动时就会将配置的Bean信息解析转换为BeanDefinition对象，BeanDefinitiont通过不同的回线路来描述不同方式配置的Bean信息，其中接口实现类大致如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 1]  
这里列举出BeanDefinition接口源码中部分方法供大家参考

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement { 
    
    	// 单例、原型标识符
    	String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
    	String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
    
        // 标识 Bean 的类别，分别对应 用户定义的 Bean、来源于配置文件的 Bean、Spring 内部的 Bean
    	int ROLE_APPLICATION = 0;
    	int ROLE_SUPPORT = 1;
    	int ROLE_INFRASTRUCTURE = 2;
    
        // 设置、返回 Bean 的父类名称
    	void setParentName(@Nullable String parentName);
    	String getParentName();
    
        // 设置、返回 Bean 的 className
    	void setBeanClassName(@Nullable String beanClassName);
    	String getBeanClassName();
    
        // 设置、返回 Bean 的作用域
    	void setScope(@Nullable String scope);
    	String getScope();
    
        // 设置、返回 Bean 是否懒加载
    	void setLazyInit(boolean lazyInit);
    	boolean isLazyInit();
    	
    	// 设置、返回当前 Bean 所依赖的其它 Bean 名称。
    	void setDependsOn(@Nullable String... dependsOn);
    	String[] getDependsOn();
    	
    	// 设置、返回 Bean 是否可以自动注入。只对 @Autowired 注解有效
    	void setAutowireCandidate(boolean autowireCandidate);
    	boolean isAutowireCandidate();
    	
    	// 设置、返回当前 Bean 是否为主要候选 Bean 。
    	// 当同一个接口有多个实现类时，通过该属性来配置某个 Bean 为主候选 Bean。
    	void setPrimary(boolean primary);
    	boolean isPrimary();
    
        // 设置、返回创建该 Bean 的工厂类。
    	void setFactoryBeanName(@Nullable String factoryBeanName);
    	String getFactoryBeanName();
    	
    	// 设置、返回创建该 Bean 的工厂方法
    	void setFactoryMethodName(@Nullable String factoryMethodName);
    	String getFactoryMethodName();
    	
    	// 返回该 Bean 构造方法参数值、所有属性
    	ConstructorArgumentValues getConstructorArgumentValues();
    	MutablePropertyValues getPropertyValues();
    
        // 返回该 Bean 是否是单例、是否是非单例、是否是抽象的
    	boolean isSingleton();
    	boolean isPrototype();
    	boolean isAbstract();
    
        // 返回 Bean 的类别。类别对应上面的三个属性值。
    	int getRole();
    
        ...
    }

### BeanDefinitionRegistry ###

BeanDefinitionRegistry是BeanDefinition容器，所有的Bean配置解析后生成的BeanDefinition对象都会注册到BeanDefinitionRegistry对象中。Spring提供了扩展机制，允许用户在Spring框架启动时，动态地往BeanDefinitionRegistry容器中注册BeanDefinition对象  
源码如下：

public interface BeanDefinitionRegistry extends AliasRegistry { 
    
    	// 往注册表中注册一个新的 BeanDefinition 实例 
    	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException;
    	// 移除注册表中已注册的 BeanDefinition 实例
    	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    	// 从注册中心取得指定的 BeanDefinition 实例
    	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    	// 判断 BeanDefinition 实例是否在注册表中（是否注册）
    	boolean containsBeanDefinition(String beanName);
    	
    	// 取得注册表中所有 BeanDefinition 实例的 beanName（标识）
    	String[] getBeanDefinitionNames();
    	// 返回注册表中 BeanDefinition 实例的数量
    	int getBeanDefinitionCount();
    	// beanName（标识）是否被占用
    	boolean isBeanNameInUse(String beanName);
    }

### BeanFactory ###

BeanFactory是Spring的Bean工厂，负责Bean的创建及属性注入。它同时是一个Bean容器，Spring框架启动后，会根据BeanDefinition对象创建Bean实例，所有的单例Bean都会注册到BeanFactory容器中  
源码：

public interface BeanFactory { 
    
        // 用来区分FactoryBean和其产生的对象
        String FACTORY_BEAN_PREFIX = "&";
    
        // 通过BeanName获取Bean
        Object getBean(String name) throws BeansException;
    
        // 通过beanName和bean 的Class类型来获取Bean
        <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException;
    
        // 通过bean 去容器中获取一个bean对象
        //args 这个是用于指定传入获取bean的构造函数的参数,通过传入该参数，那么就可以明确的知道去调用哪个构造函数是实例化对象
        Object getBean(String name, Object... args) throws BeansException;
    
        // 通过指定的bean的类型去容器中获取对象
        <T> T getBean(Class<T> requiredType) throws BeansException;
    
        // 和上面一样的道理
        <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    
        // 判断容器中是否包含某个Bean
        boolean containsBean(String name);
    
        // 判断当前的bean是不是单例
        boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    
        // bean是否是prototype
        boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    
        //查询指定了名字的Bean的Class类型是否与指定类型匹配
        boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    
        // 同上
        boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
    
        //获取指定名字bean的Class类型
        @Nullable
        Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    
        // 获取bean的所有的别名
        String[] getAliases(String name);
    
    }

### BeanFactoryPostProcessor ###

BeanFactoryPostProcessor是Spring提供的扩展机制，用于在所有的Bean配置信息解析完成后修改Bean工厂信息。例如，向BeanDefinitionRegistry容器中增加额外的BeanDefinition对象，或者修改原有的BeanDefinition对象。BeanFactoryPostProcessor是一个接口，该接口中只有一个方法，具体如下：

@FunctionalInterface
    public interface BeanFactoryPostProcessor { 
    	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
    }

当我们配置的Bean实现该接口后，Spring在解析完Bean，就会调用BeanFactoryPostProcessor 实现类的postProcessBeanFactory()方法。注意这个方法是在Bean初始化前调用

### ImportBeanDefinitionRegistrar ###

ImportBeanDefinitionRegistrar是一个接口，该接口的实现类作用于Spring解析Bean的配置阶段，当解析@Configuration注解时，可以通过ImportBeanDefinitionRegistrar接口的实现类向BeanDefinitionRegistry容器中添加额外的BeanDefinition对象。ImportBeanDefinitionRegistrar接口定义如下：

public interface ImportBeanDefinitionRegistrar { 
    	void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);
    }

其实现类如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 2]  
其中registerBeanDefinitions()方法会在Spring解析@Configuration注解时调用。ImportBeanDefinitionRegistrar接口需要配合@Import注解使用，importingClassMetadata参数为@Import所在注解的配置信息，registry参数为BeanDefinition容器

### BeanPostProcessor ###

Bean的后置处理器，在Bean初始化方法（init-method属性指定的方法或afterPropertiesSet()方法）调用前后，会执行BeanPostProcessor中定义的拦截逻辑。BeanPostProcessor接口定义如下：

public interface BeanPostProcessor { 
        //bean初始化方法调用前被调用
        Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
        //bean初始化方法调用后被调用
        Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
    }

### ClassPathBeanDefinitionScanner ###

ClassPathBeanDefinitionScanner是BeanDefinition扫描器，能够对指定包下的Class进行扫描，将Class信息转换为BeanDefinition对象注册到BeanDefinitionRegistry容器中，支持自定义的过滤规则，例如我们可以只对使用某种注解的类进行扫描。MyBatis-Spring模块中Mapper接口的扫描使用就是使用ClassPathBeanDefinitionScanner类

### FactoryBean ###

FactoryBean是Spring中的工厂Bean，通常用于处理Spring中配置较为复杂或者由动态代理生成的Bean实例。实现了该接口的Bean不能作为普通的Bean使用，而是作为单个对象的工厂。当我们通过Bean名称获取FactoryBean实例时，获取到的并不是FactoryBean对象本身，而是FactoryBean对象的getObject()方法返回的实例  
SqlSessionFactoryBean是一个FactoryBean，通过名称sqlSessionFactory从Spring容器中获取Bean时，获取到的实际上是SqlSessionFactoryBean对象的getObject()方法返回的对象。

## Spring容器的大致启动过程 ##

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

## Spring Mybatis整合原理 ##

在使用了Spring Mybatis整合后，我们所有的Mapper接口，在使用的时候都只需要通过

@Autowired
        private UserMapper userMapper;

这种方式获取Mapper对象，然后就可以操作数据库了，所有我们的核心关注点就是Mybatis的代理对象是如何放入到Spring容器中的

而实现这个核心的关键就是MapperScan注解。该注解用于扫描指定包中的Mapper接口并创建Mapper动态代理对象，然后放入Spring 容器中。

我们来具体看看 MapperScan注解做了什么。首先是MapperScan注解的源码

@Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @Documented
    @Import(MapperScannerRegistrar.class)
    @Repeatable(MapperScans.class)
    public @interface MapperScan { 
    // 扫描包路径
    String[] value() default { };
    // 扫描包路径
    String[] basePackages() default { };
    // 扫描Mapper接口对应的Class对象
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
    // Bean名称生成策略
    Class<? extends Annotation> annotationClass() default Annotation.class;
    // 只扫描某种类型的子类型
    Class<?> markerInterface() default Class.class;
    // 指定使用哪个sqlSessionTemplateRef
    String sqlSessionTemplateRef() default "";
    //指定使用哪个sqlSessionFactoryRef
    String sqlSessionFactoryRef() default "";
    //指定使用自定义的MapperFactoryBean返回Mybatis代理对象作为Spring的Bean
    Class<? extends MapperFactoryBean> factoryBean() default MapperFactoryBean.class;
    
    }

MapperScan注解通过@Import注解导入了一个BeanDefinition注册类MapperScannerRegistrar  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 4]  
MapperScannerRegistrar 实现了 ImportBeanDefinitionRegistrar，ImportBeanDefinitionRegistrar在上面已经介绍过，就是在Spring解析Bean的配置阶段动态的向BeanDefinitionRegistry容器中注册额外的BeanDefinition对象

其中 MapperScannerRegistrar 的核心方法

@Override
      public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { 
        AnnotationAttributes mapperScanAttrs = AnnotationAttributes
            .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
        if (mapperScanAttrs != null) { 
          //调用下面的registerBeanDefinitions方法注册BeanDefinition对象到BeanDefinitionRegistry容器中
          registerBeanDefinitions(mapperScanAttrs, registry);
        }
      }
    
      void registerBeanDefinitions(AnnotationAttributes annoAttrs, BeanDefinitionRegistry registry) { 
    	// Mybatis-Srping中自定义的BeanDefintion扫描器
        ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    
        // this check is needed in Spring 3.1
        Optional.ofNullable(resourceLoader).ifPresent(scanner::setResourceLoader);
    	
        Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
        if (!Annotation.class.equals(annotationClass)) { 
          scanner.setAnnotationClass(annotationClass);
        }
    
        Class<?> markerInterface = annoAttrs.getClass("markerInterface");
        if (!Class.class.equals(markerInterface)) { 
          scanner.setMarkerInterface(markerInterface);
        }
    
        Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");
        if (!BeanNameGenerator.class.equals(generatorClass)) { 
          scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));
        }
    
        Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
        if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) { 
          scanner.setMapperFactoryBean(BeanUtils.instantiateClass(mapperFactoryBeanClass));
        }
    	// 获取MapperSacn注解的属性信息
        scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));
        scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));
    
        List<String> basePackages = new ArrayList<>();
        //添加需要扫描的包
        basePackages.addAll(
            Arrays.stream(annoAttrs.getStringArray("value"))
                .filter(StringUtils::hasText)
                .collect(Collectors.toList()));
    
        basePackages.addAll(
            Arrays.stream(annoAttrs.getStringArray("basePackages"))
                .filter(StringUtils::hasText)
                .collect(Collectors.toList()));
    
        basePackages.addAll(
            Arrays.stream(annoAttrs.getClassArray("basePackageClasses"))
                .map(ClassUtils::getPackageName)
                .collect(Collectors.toList()));
    	// 添加扫描过滤规则
        scanner.registerFilters();
        //对包中的类进行扫描生成BeanDefinition对象
        scanner.doScan(StringUtils.toStringArray(basePackages));
      }

然后来看看 方法 `scanner.doScan(StringUtils.toStringArray(basePackages))`

public Set<BeanDefinitionHolder> doScan(String... basePackages) { 
    	//调用父类的doScan方法将Vlass转化为BeanDefinitionHolder对象
        Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
    
        if (beanDefinitions.isEmpty()) { 
          LOGGER.warn(() -> "No MyBatis mapper was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
        } else { 
          //对BeanDefinitionHolder进行处理
          processBeanDefinitions(beanDefinitions);
        }

`processBeanDefinitions(beanDefinitions);`方法

private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) { 
    	// GenericBeanDefinition 是beanDefinition接口的一个实现类
        GenericBeanDefinition definition;
        for (BeanDefinitionHolder holder : beanDefinitions) { 
          //获取beanDefinition对象
          definition = (GenericBeanDefinition) holder.getBeanDefinition();
          String beanClassName = definition.getBeanClassName();
          LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName()
              + "' and '" + beanClassName + "' mapperInterface");
    
          // the mapper interface is the original class of the bean
          // but, the actual class of the bean is MapperFactoryBean
          definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
          //将beanDefinition对象的BeanClass属性设置为MapperFactoryBean
          // 在Spring根据beanDefinition实例化对象会将这里所有的Bean实例化为MapperFactoryBean对象(核心)
          definition.setBeanClass(this.mapperFactoryBean.getClass());
    	  // 修改BeanDefinition对象的propertyValues属性，将sqlSessionFactory注入到MapperFactoryBean中(核心)
          definition.getPropertyValues().add("addToConfig", this.addToConfig);
    
          boolean explicitFactoryUsed = false;
          if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) { 
            definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
            explicitFactoryUsed = true;
          } else if (this.sqlSessionFactory != null) { 
            definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
            explicitFactoryUsed = true;
          }
    
          if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) { 
            if (explicitFactoryUsed) { 
              LOGGER.warn(() -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
            }
            definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
            explicitFactoryUsed = true;
          } else if (this.sqlSessionTemplate != null) { 
            if (explicitFactoryUsed) { 
              LOGGER.warn(() -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
            }
            definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
            explicitFactoryUsed = true;
          }
    
          if (!explicitFactoryUsed) { 
            LOGGER.debug(() -> "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
            definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
          }
        }
      }

值得注意的是MapperFactoryBean实现了FactoryBean接口，所以当我们根据Mapper类型从Spring容器中获取FactoryBean时，获取到的并不是FactoryBean本身，而是FactoryBean的getObject()方法返回的对象

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> { 
    public T getObject() throws Exception { 
            return this.getSqlSession().getMapper(this.mapperInterface);
        }
    }

这里我们终于找到了我们的答案。在MapperFactoryBean的getObject()方法中，调用SqlSession对象的getMapper()方法返回一个Mapper动态代理对象

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70]: /images/20221120/2e42283ee43e4bcb968145522f0d6df3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 1]: /images/20221120/225b69212ba04a248a97c21c63d9ff50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 2]: /images/20221120/247b1a2f5e9c4616930ecf1f9ee04158.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 3]: /images/20221120/0ef7a4c12a824b5fabab9d633fdb4ead.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 4]: /images/20221120/da9859be3ff54678bd0de0416e98125b.png