Spring源码解析(3)之容器前期准备

偏执的太偏执、 2022-08-28 06:47 265阅读 0赞

写了BeanFactoryPostProcessor的博客才发现，需要提前先介绍spring在解析之前做的容器准备，要不然感觉直接介绍解析源码的话，会有一点懵逼，这里会介绍Spring容器前期准备。

这里问题问题：AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);这句代码相信很多人都用过并且很熟悉，但是大家有思考过，它为了我们做了哪些事情？

#         一AnnotationConfigApplicationContext的构造函数 #

##         **i1:org.springframework.context.annotation.AnnotationConfigApplicationContext\#AnnotationConfigApplicationContext** ##

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    		// 调用无参的构造器，会调用父类的无参构造器
            this();
            // 注册配合类
    		register(annotatedClasses);
            // 容器刷新
    		refresh();
    	}

##        i2>org.springframework.context.support.GenericApplicationContext\#GenericApplicationContext() ##

然后我们看下父类的构造函数，调用父类的构造函数，创建一个IOC容器。

/**
    	 * Create a new GenericApplicationContext.
    	 * @see #registerBeanDefinition
    	 * @see #refresh
    	 */
    	public GenericApplicationContext() {
    		this.beanFactory = new DefaultListableBeanFactory();
    	}

##        **i3>org.springframework.context.annotation.AnnotationConfigApplicationContext\#AnnotationConfigApplicationContext()** ##

然后调用自己的构造方法：

/**
    	 * Create a new AnnotationConfigApplicationContext that needs to be populated
    	 * through {@link #register} calls and then manually {@linkplain #refresh refreshed}.
    	 */
    	public AnnotationConfigApplicationContext() {
            // 为IOC容器赋值，AnnotatedBeanDefinitionReader(注解bean定义的读取器)
    		this.reader = new AnnotatedBeanDefinitionReader(this);
            // 为IOC容器赋值 类路径下的bean定义扫描器
    		this.scanner = new ClassPathBeanDefinitionScanner(this);
    	}

###         ** i3.1>org.springframework.context.annotation.AnnotatedBeanDefinitionReader\#AnnotatedBeanDefinitionReader**         ###

**        org.springframework.context.annotation.AnnotatedBeanDefinitionReader\#AnnotatedBeanDefinitionReader 为bean定义读取器赋值**

/**
    	 * Create a new {@code AnnotatedBeanDefinitionReader} for the given registry.
    	 * If the registry is {@link EnvironmentCapable}, e.g. is an {@code ApplicationContext},
    	 * the {@link Environment} will be inherited, otherwise a new
    	 * {@link StandardEnvironment} will be created and used.
    	 * @param registry the {@code BeanFactory} to load bean definitions into,
    	 * in the form of a {@code BeanDefinitionRegistry}
    	 * @see #AnnotatedBeanDefinitionReader(BeanDefinitionRegistry, Environment)
    	 * @see #setEnvironment(Environment)
    	 */
    	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
    		this(registry, getOrCreateEnvironment(registry));
    	}

**i3.1.1>org.springframework.context.annotation.AnnotatedBeanDefinitionReader\#getOrCreateEnvironment**

**        org.springframework.context.annotation.AnnotatedBeanDefinitionReader\#getOrCreateEnvironment 创建环境**

/**
    	 * Get the Environment from the given registry if possible, otherwise return a new
    	 * StandardEnvironment.
    	 */
    	private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
    		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    		if (registry instanceof EnvironmentCapable) {
    			return ((EnvironmentCapable) registry).getEnvironment();
    		}
    		return new StandardEnvironment();
    	}

** i3.2>org.springframework.context.annotation.ConditionEvaluator 创建一个条件计算器对象**

/**
    	 * Create a new {@code AnnotatedBeanDefinitionReader} for the given registry and using
    	 * the given {@link Environment}.
    	 * @param registry the {@code BeanFactory} to load bean definitions into,
    	 * in the form of a {@code BeanDefinitionRegistry}
    	 * @param environment the {@code Environment} to use when evaluating bean definition
    	 * profiles.
    	 * @since 3.1
    	 */
    	public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
    		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    		Assert.notNull(environment, "Environment must not be null");
    		this.registry = registry;
    		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    	}

条件计算器对象。

public ConditionContextImpl(BeanDefinitionRegistry registry, Environment environment, ResourceLoader resourceLoader) {
    			this.registry = registry;
    			this.beanFactory = deduceBeanFactory(registry);
    			this.environment = (environment != null ? environment : deduceEnvironment(registry));
    			this.resourceLoader = (resourceLoader != null ? resourceLoader : deduceResourceLoader(registry));
    		}

**  i3.3> AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);**为容器注册系统的bean定义信息

1.  首先获取一个IOC容器
2.  注册一个配置类解析器的bean定义ConfigurationClassPostProcessor
3.  设置@AutoWired注解解析器的bean定义
4.  设置@Required注解处理器
5.  检查是否支持JSR250规范，如果支持则注册解析JSR250规范的注解
6.  检查是否支持jpa，若支持则注册jpa规范的注解
7.  注册解析@EventListener的注解

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
    			BeanDefinitionRegistry registry, Object source) {
    		
    		// 获取一个IOC容器
    		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    		if (beanFactory != null) {
    			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
    				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
    			}
    			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
    				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
    			}
    		}
    
    		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(8);
    		
    		// 注册一个配置类解析器的bean定义ConfigurationClassPostProcessor
    		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));
    		}
    		
    		// 设置AutoWired注解解析器的bean定义信息
    		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));
    		}

// 注册解析@Required注解的处理器
    		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规范，如果支持则注册JSR250规范的注解
    		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));
    		}
    
    		// 检查是否支持jpa，若支持注册解析jpa注解的规范
    		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));
    		}
    		
    		// 注册解析@EventListener的注解
    		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));
    		}
    
    		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;
    	}

**i4>:    this.scanner = new ClassPathBeanDefinitionScanner(this);创建类路径下的bean定义扫描器**

/**
    	 * Create a new {@code ClassPathBeanDefinitionScanner} for the given bean factory and
    	 * using the given {@link Environment} when evaluating bean definition profile metadata.
    	 * @param registry the {@code BeanFactory} to load bean definitions into, in the form
    	 * of a {@code BeanDefinitionRegistry}
    	 * @param useDefaultFilters whether to include the default filters for the
    	 * {@link org.springframework.stereotype.Component @Component},
    	 * {@link org.springframework.stereotype.Repository @Repository},
    	 * {@link org.springframework.stereotype.Service @Service}, and
    	 * {@link org.springframework.stereotype.Controller @Controller} stereotype annotations
    	 * @param environment the Spring {@link Environment} to use when evaluating bean
    	 * definition profile metadata
    	 * @param resourceLoader the {@link ResourceLoader} to use
    	 * @since 4.3.6
    	 */
    	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
    			Environment environment, ResourceLoader resourceLoader) {
    
    		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    		this.registry = registry;
              
            // 使用默认的规则
    		if (useDefaultFilters) {
    			registerDefaultFilters();
    		}
            // 设置环境
    		setEnvironment(environment);
            // 设置资源加载器
    		setResourceLoader(resourceLoader);
    	}

**  i4.1>: org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider\#registerDefaultFilters注册包扫描默认的规则 **

/**
    	 * Register the default filter for {@link Component @Component}.
    	 * <p>This will implicitly register all annotations that have the
    	 * {@link Component @Component} meta-annotation including the
    	 * {@link Repository @Repository}, {@link Service @Service}, and
    	 * {@link Controller @Controller} stereotype annotations.
    	 * <p>Also supports Java EE 6's {@link javax.annotation.ManagedBean} and
    	 * JSR-330's {@link javax.inject.Named} annotations, if available.
    	 *
    	 */
    	@SuppressWarnings("unchecked")
    	protected void registerDefaultFilters() {
    		this.includeFilters.add(new AnnotationTypeFilter(Component.class));
    		ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
    		try {
    			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) {
    			// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
    		}
    		try {
    			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) {
    			// JSR-330 API not available - simply skip.
    		}
    	}

**        i5>org.springframework.context.annotation.AnnotatedBeanDefinitionReader\#register 使用**

**        i3.1步生成的bean定义读取器注册配置类**

public void registerBean(Class<?> annotatedClass, String name, Class<? extends Annotation>... qualifiers) {
    		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
    		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
    			return;
    		}
    
    		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
    		abd.setScope(scopeMetadata.getScopeName());
    		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
    		if (qualifiers != null) {
    			for (Class<? extends Annotation> qualifier : qualifiers) {
    				if (Primary.class == qualifier) {
    					abd.setPrimary(true);
    				}
    				else if (Lazy.class == qualifier) {
    					abd.setLazyInit(true);
    				}
    				else {
    					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
    				}
    			}
    		}
            
            // 注册自己传入的主配置类bean定义到容器中
    		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    	}