spring 源码系列（四）- AnnotationConfigApplicationContext

最新推荐文章于 2024-03-15 08:45:00 发布

余冰涛

最新推荐文章于 2024-03-15 08:45:00 发布

阅读量1k

点赞数 2

分类专栏： spring

本文链接：https://blog.csdn.net/bintoYu/article/details/104268294

版权

spring 专栏收录该内容

17 篇文章 2 订阅

订阅专栏

0 介绍

在spring中，使用的入口就是在main函数中创建Spring容器，基于XML形式的是ClassPathXmlApplicationContext；而基于注解形式的是AnnotationConfigApplicationContext。本文将对AnnotationConfigApplicationContext进行详细讲解。

1 使用篇

在这里简单介绍一下AnnotationConfigApplicationContext该如何使用
创建一个Person类

public class Person {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + "]";
    }
}

创建PeopleConfig

@Configuration(value = "PeopleConfig")
public class PeopleConfig {
    @Bean(name="person1")
    public Person person1() {
        Person person= new Person();
        person.setName("person1");
        return person;
    }

    @Bean(name="person2")
    public Person person2() {
        Person person= new Person();
        person.setName("person2");
        return person;
    }
}

main函数创建AnnotationConfigApplicationContext容器，并获取person。

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(PeopleConfig.class);
        Person person1 = (Person)context.getBean("person1");
        System.out.println(person1);
        Person person2 = (Person)context.getBean("person2");
        System.out.println(person2);
    }

该类还有另一种使用方式，参数为package，此时会获取该package下所有注解过的类（包括@Configuration，@Component，@Controller，@Service等等）

ApplicationContext context = new AnnotationConfigApplicationContext("com.test");

接下来正式开始分析其原理

2 AnnotationConfigApplicationContext原理

2.1 AnnotationConfigApplicationContext的构造函数

从使用篇可以看到，创建AnnotationConfigApplicationContext有两种方式，一种是将Class作为参数，另一种将String… basePackagess作为参数，因此我们首先介绍这两个构造方法：

	public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		//调用无参构造方法
		this();
		register(annotatedClasses);
		refresh();
	}

	/**
	 * Create a new AnnotationConfigApplicationContext, scanning for bean definitions
	 * in the given packages and automatically refreshing the context.
	 * @param basePackages the packages to check for annotated classes
	 */
	public AnnotationConfigApplicationContext(String... basePackages) {
		//调用无参构造方法
		this();
		scan(basePackages);
		refresh();
	}

可以看到，两个不同参数的构造方法的具体实现基本相同，不同之处在于Class<?>为参数时调用的是register(class)方法，而参数为String时调用的scan。
先看共有的无参构造方法：

	public AnnotationConfigApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

可以看到，构造方法中设置了reader和scanner，实际上，reader负责实现构造方法中的register()，而scanner负责实现构造方法中的scan()，如下代码所示：

	public void register(Class<?>... annotatedClasses) {
		Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
		this.reader.register(annotatedClasses);
	}

	public void scan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		this.scanner.scan(basePackages);
	}

另外，在对reader和scanner进行讲解之前，还对AnnotationConfigApplicationContext进行补充讲解，这样才能更好地去理解后续的reader和scanner。

2.2 AnnotationConfigApplicationContext与BeanDefinitionRegistry

当我们进入new AnnotatedBeanDefinitionReader(this);时，会发现参数实际上是BeanDefinitionRegistry：

	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
		this(registry, getOrCreateEnvironment(registry));
	}

然而AnnotationConfigApplicationContext并没有实现BeanDefinitionRegistry接口：

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry

那这个是怎么实现的呢？
简单来说，AnnotationConfigApplicationContext的父类GenericApplicationContext实现了BeanDefinitionRegistry接口，因此AnnotationConfigApplicationContext也相当于实现了该接口。
关于BeanDefinitionRegistry和GenericApplicationContext的具体情况，建议阅读我的另一篇博客：
spring 之 BeanDefinition及注册:https://blog.csdn.net/bintoYu/article/details/104275827

接下来，正式对reader和scanner进行介绍，按顺序，我们先看AnnotatedBeanDefinitionReader。

3 AnnotatedBeanDefinitionReader

AnnotatedBeanDefinitionReader的主要功能有以下两点：

注册一些与注解相关的后置处理器
注册相关的BeanDefinition

3.1 注册内置BeanPostProcessor

首先，在构造方法中注册内置的BeanPostProcessor：

	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
		this(registry, getOrCreateEnvironment(registry));
	}

	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
		...
		this.registry = registry;
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}

可以看到，构造方法的最后会进入AnnotationConfigUtils.registerAnnotationConfigProcessors()方法，该方法将会注册6个后置处理器，代码如下：

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, Object source) {

		//获取registry中的DefaultListableBeanFactory
		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		...
		
		//声明一个名为beanDefs的Set，用于存储这些后置处理器的BeanDefinition，这里的4实际上并不好，因为处理器最少5个，最多7个
		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(4);

		//注：下面所有的注册都按照以下步骤：
		//1. 将后置处理器封装成BeanDefinition
		//2. 设置source，因为参数source==null,所以这步没意义
		//3. 将BeanDefinition存放到beanDefs中
		
		//注册ConfigurationAnnotationProcessor：BeanName为internalConfigurationAnnotationProcessor
		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		//注册AutowiredAnnotationBeanPostProcessor
		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// 注册RequiredAnnotationBeanPostProcessor
		if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		//如果支持JSR250,则注册CommonAnnotationBeanPostProcessor
		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// 如果支持spring jpa，则注册PersistenceAnnotationProcessor
		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition();
			try {
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// 注册EventListenerMethodProcessor
		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}
		// 注册DefaultEventListenerFactory
		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}

因为代码很长，所以我在这里总结一下可能会注册的后置处理器有：

ConfigurationClassPostProcessor
AutowiredAnnotationBeanPostProcessor
RequiredAnnotationBeanPostProcessor
CommonAnnotationBeanPostProcessor（有设置JSR250才会注册）
PersistenceAnnotationProcessor（有设置JPA才会注册）
EventListenerMethodProcessor
DefaultEventListenerFactory

这7个后置处理器中，前两个比较重要，尤其是第一个ConfigurationClassPostProcessor，它是spring中最最最最！最重要的后置处理器！关于该类，传送门：
spring 之最重要的后置处理器ConfigurationClassPostProcessor

3.2 注册相关的BeanDefinition

我们先回顾一下，以Class<?>作为参数构造AnnotationConfigApplicationContext时，最终会调用reader.register()方法：

	public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		//调用无参构造方法
		this();
		register(annotatedClasses);
		refresh();
	}

	public void register(Class<?>... annotatedClasses) {
		Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
		this.reader.register(annotatedClasses);
	}

	//对每一个class都进行注册
	public void register(Class<?>... annotatedClasses) {
		for (Class<?> annotatedClass : annotatedClasses) {
			registerBean(annotatedClass);
		}
	}

	public void registerBean(Class<?> annotatedClass) {
		registerBean(annotatedClass, null, (Class<? extends Annotation>[]) null);
	}
	
	public void registerBean(Class<?> annotatedClass, String name, Class<? extends Annotation>... qualifiers) {
		//1. 将class转换为AnnotatedGenericBeanDefinition
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
	
		//2. 过滤一些Bean，只有在Bean标有@Conditional并且不满足Conditional条件的情况下，才会直接return;
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}

		//3. 设置scope
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		abd.setScope(scopeMetadata.getScopeName());

		//4. 获取beanName，如果没有的话，则系统自动生成bean，比如类名是HelloWorld，则生成的beanName是helloWorld。
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
		//5.从BeanDefinition的metadata中获取Lazy、Primary、DependsOn等属性，然后设置到BeanDefinition中
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

		//因为qualifiers为null，所以省略一些无关代码


		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		//6. 注册BeanDefinition到Registry中
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

前四步不需要详细讲解，这里直接看第五步的processCommonDefinitionAnnotations()：

public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
		//获取BeanDefinition的metadata，并作为参数传入方法
		processCommonDefinitionAnnotations(abd, abd.getMetadata());
	}

	static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
		//1. 从metadata中获取lazy，并设置到beanDefinition中
		if (metadata.isAnnotated(Lazy.class.getName())) {
			abd.setLazyInit(attributesFor(metadata, Lazy.class).getBoolean("value"));
		}
		else if (abd.getMetadata() != metadata && abd.getMetadata().isAnnotated(Lazy.class.getName())) {
			abd.setLazyInit(attributesFor(abd.getMetadata(), Lazy.class).getBoolean("value"));
		}

		//2. 设置Primary
		if (metadata.isAnnotated(Primary.class.getName())) {
			abd.setPrimary(true);
		}
		//3. 设置DependsOn
		if (metadata.isAnnotated(DependsOn.class.getName())) {
			abd.setDependsOn(attributesFor(metadata, DependsOn.class).getStringArray("value"));
		}

		//4. 设置Role和Description
		if (abd instanceof AbstractBeanDefinition) {
			AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
			if (metadata.isAnnotated(Role.class.getName())) {
				absBd.setRole(attributesFor(metadata, Role.class).getNumber("value").intValue());
			}
			if (metadata.isAnnotated(Description.class.getName())) {
				absBd.setDescription(attributesFor(metadata, Description.class).getString("value"));
			}
		}
	}

接下来是真正的注册：BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);

	public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// 1. 注册beanDefinition到Registry中
		String beanName = definitionHolder.getBeanName();
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// 2. 如果该bean存在别名aliases，则别名也要注册上。
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}

可以看到，注册BeanDefinition实际上是通过registry.registerBeanDefinition();来实现的，对于BeanDefinitionRegistry，2.2小节已经进行了介绍。

3.3 AnnotatedBeanDefinitionReader与ConfigurationClassPostProcessor

在3.1小节中，我们有提及最重要的后置处理器ConfigurationClassPostProcessor，现在来对两者的关系进行总结：

AnnotatedBeanDefinitionReader在构造时会将ConfigurationClassPostProcessor进行注册。
AnnotatedBeanDefinitionReader和ConfigurationClassPostProcessor有将BeanDefinition注册到BeanDefinitionRegistry的功能。
AnnotatedBeanDefinitionReader只会对构造方法参数中的Class转成BeanDefinition并进行注册，而ConfigurationClassPostProcessor会将BeanDefinitionRegistry中的所有BeanDefinition重新提取出来，寻找这些BeanDefinition中内部还有的别的BeanDefinition，并将它们提取出来，注册到BeanDefinitionRegistry中。

3.4总结：（流程图）

注意：从方法的流程可以看到，其并没有判断annotatedClasses上是否有注解，因此即使annotatedClasses上没有注解也能被注册上（本人亲测）。
在这里插入图片描述

4 ClassPathBeanDefinitionScanner

ClassPathBeanDefinitionScanner主要由两部分组成：

构造方法注册过滤器
doScan()扫描指定路径，最终注册BeanDefinition。
注册一些与注解相关的后置处理器（同AnnotatedBeanDefinitionReader）

4.1 构造方法：

	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
		this(registry, true);
	}
	
	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
		this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
	}

	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
			Environment environment) {

		this(registry, useDefaultFilters, environment,
				(registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
	}

	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
			Environment environment, ResourceLoader resourceLoader) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;
	
		/**
		* 注册spring扫描类过滤器
		* 加了特定注解的类会被扫描到
		* 包括@Component(注意@Service等也算Component)、@ManagedBean、@Named（后面两个得有设置jar包才会添加）
		*/
		if (useDefaultFilters) {
			registerDefaultFilters();
		}
		setEnvironment(environment);
		setResourceLoader(resourceLoader);
	}

构造方法中唯一需要关心的是registerDefaultFilters();方法，该方法实际上是父类ClassPathScanningCandidateComponentProvider的方法，UML图如下所示：

	private final List<TypeFilter> includeFilters = new LinkedList<TypeFilter>();
	private final List<TypeFilter> excludeFilters = new LinkedList<TypeFilter>();

	protected void registerDefaultFilters() {
		//往includeFilters中添加@Component的过滤器
		this.includeFilters.add(new AnnotationTypeFilter(Component.class));
		ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
		try {
		//往includeFilters中添加@ManagedBean的过滤器
			this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
			logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
		}
		catch (ClassNotFoundException ex) {

		}
		try {
			//往includeFilters中添加@Named的过滤器
			this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
			logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
		}
		catch (ClassNotFoundException ex) {
		}
	}

需要注意两点：

@Component实际上不止它本身，例如@Repository、@Service、@Controller等属于Component
@ManagedBean和@Named得在有配置特定jar包的情况下才会添加，例如本文就没有添加这两个过滤器。

4.2 scan()扫描指定路径

先看scan()代码：

	public int scan(String... basePackages) {
		int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
		
		//1. 生成BeanDefinition并注册到BeanDefinitionRegistry中
		doScan(basePackages);

		//注册后置处理器
		if (this.includeAnnotationConfig) {
			AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
		}

		return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
	}

scan()主要由两部分组成：

doScan()进行扫描，该方法的功能可以概括为：扫描指定路径，先将路径中的所有java文件转成resouce，然后根据过滤器筛选出满足条件的类，设置属性后转成BeanDefinition，最后注册到BeanDefinitionRegistry中。
注册一些与注解相关的后置处理器，和AnnotatedBeanDefinitionReader时讲到的实际上是同一个方法，因此这里不进行介绍。

接下来看doScan()的代码：

	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
		for (String basePackage : basePackages) {
			//1.扫描basePackage路径下的java文件
			//先全部转为Resource,然后再判断拿出符合条件的beanDefinition
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				//2.解析scope
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				//3.获取beanName
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				//4. 如果是AbstractBeanDefinition类型，则设置默认值，比如lazy/init/destroy
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				//5. 如果是AnnotatedBeanDefinition类型，从BeanDefinition的metadata中获取Lazy、Primary、DependsOn等属性，然后设置到BeanDefinition中，3.2小节已介绍过该方法
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					//6.注册到registry中
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

需要关注主要是第一步findCandidateComponents()方法，该方法会扫描basePackage路径下的java文件，先全部转为Resource,然后再判断拿出符合条件的beanDefinition：

	public Set<BeanDefinition> findCandidateComponents(String basePackage) {
		Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
		try {
			//1. 确认路径
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
			//2. 将路径下的所有java转成Resource
			Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
			for (Resource resource : resources) {

				if (resource.isReadable()) {
					try {
						//3. 获得resource的元数据metadata，
						MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
						// 4. 根据excludeFilters与includeFilters来判断是否满足条件
						// 因为在构造方法中，已经将@Component加入到includeFilters中，所以能筛选出@Component的类
						if (isCandidateComponent(metadataReader)) {
							//5. 构造beanDefinition
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
							sbd.setResource(resource);
							sbd.setSource(resource);
							//6. 添加到set中
							if (isCandidateComponent(sbd)) {
								candidates.add(sbd);
							}
			//...略
		return candidates;
	}

4.3 总结

在这里插入图片描述

5 AnnotationConfigApplicationContext总结

在这里插入图片描述

余冰涛

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
spring 源码系列（四）- AnnotationConfigApplicationContext

在spring中，使用的入口就是在main函数中创建Spring容器，基于XML形式的是ClassPathXmlApplicationContext；而基于注解形式的是AnnotationConfigApplicationContext。本文将对AnnotationConfigApplicationContext进行详细讲解。使用篇在这里简单介绍一下AnnotationConfigApplic...
复制链接

扫一扫