Spring学习(三十一)-Spring容器创建流程-01

朴灿烈づ我的快乐病毒、 2024-02-19 16:13 12阅读 0赞

由于[Spring学习(三)-spring容器初始化加载资源（注解版][Spring_-spring])写的内容有点乱，因而此处进行分部分析spring启动加载资源流程。

Spring容器的创建和初始化，需要向容器注入各种资源，加载配置文件，初始化单实例的Bean，这就离不开Spring核心容器Context Spring上下文对象。

启动类：如下

//web注解版启动类
    AnnotationConfigWebApplicationContext annotationConfigWebApplicationContext = new AnnotationConfigWebApplicationContext();
    
    //文件版
    FileSystemXmlApplicationContext fileSystemXmlApplicationContext = new FileSystemXmlApplicationContext();
    //xml版启动类
    ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("spring-context.xml");
    
    //注解版
    AnnotationConfigApplicationContext applicationContext  = new AnnotationConfigApplicationContext(ExtConfig.class);

。。。。。。。。。。。。。。。。。。。。。。。。。

以注解版来展开Spring启动分析。

@Test
    	public void test01(){
            //注解版
            AnnotationConfigApplicationContext applicationContext  = new AnnotationConfigApplicationContext(ExtConfig.class);
    
    		applicationContext.close();
    	}

AnnotationConfigApplicationContext：

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        //初始化后续用到的多个解析/扫描类
    	this();
    	//注册配置文件
    	register(annotatedClasses);
    	//容器启动进行刷新，加载各种所需要的资源
    	refresh();
    }

1.this():

public AnnotationConfigApplicationContext() {
        //在IOC容器中初始化一个 注解bean读取器AnnotatedBeanDefinitionReader
    	this.reader = new AnnotatedBeanDefinitionReader(this);
    	//在IOC容器中初始化一个 按类路径扫描注解bean的 扫描器
    	this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

1.1 AnnotatedBeanDefinitionReader的初始化创建

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);
    	//初始化 AnnotatedBeanDefinitionReader
    	AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    }
    public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
    		registerAnnotationConfigProcessors(registry, null);
    }
    
    	
    public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
    			BeanDefinitionRegistry registry, Object source) {
        //获取默认的beanDefactory ---》DefaultListableBeanFactory
    	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    	。。。。。。。。。。。
        //存储解析器
    	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(4);
        //判断该注册类是否包含了internalConfigurationAnnotationProcessor类
    	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
    	    //没有包含 创建顶级BeanDefinition 保存 ConfigurationClassPostProcessor的定义信息
    		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
    		//设置资源
    		def.setSource(source);
    		//保存关联关系
    		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    	}
    	。。。。。。。。。。。。。。。。。。。。。
    	return beanDefs;
    }
    
    private static BeanDefinitionHolder registerPostProcessor(
    			BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
        //设置BeanDefinition.ROLE_INFRASTRUCTURE 为2 
    	definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    	//在容器中 保存其关联关系
    	//DefaultListableBeanFactory --》
    	//Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);
    	registry.registerBeanDefinition(beanName, definition);
    	//创建要给bean的定义信息持有者
    	return new BeanDefinitionHolder(definition, beanName);
    }

1.2 ClassPathBeanDefinitionScanner创建和初始化：

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
        //调用本类方法   
    	this(registry, true);
    }
    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
        //调用本类方法  getOrCreateEnvironment：获取或者创建所需环境 
    	this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
    }
    private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
    	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    	//如果其注册定义的信息类是EnvironmentCapable的子类，则返回当前的环境否自创建
    	if (registry instanceof EnvironmentCapable) {
    		return ((EnvironmentCapable) registry).getEnvironment();
    	}
    	//有兴趣的可以看看，我没啥兴趣
    	return new StandardEnvironment();
    }

2.register(annotatedClasses);

AnnotationConfigApplicationContext：
    public void register(Class<?>... annotatedClasses) {
    	Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
    	//调用AnnotatedBeanDefinitionReader --->register 注册配置类
    	this.reader.register(annotatedClasses);
    }
    AnnotationConfigApplicationContext：
    //注册配置类
    public void register(Class<?>... annotatedClasses) {
    	for (Class<?> annotatedClass : annotatedClasses) {
    		registerBean(annotatedClass);
    	}
    }
    AnnotatedBeanDefinitionReader:
    //注册配置类
    public void registerBean(Class<?> annotatedClass, String name, Class<? extends Annotation>... qualifiers) {
    	AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
    	//判断是否跳过 根据condition条件 可以查看@Condition 注解原理
    	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));
    			}
    		}
    	}
    
    	BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    	definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    	//向容器中保存定义信息 关联关系
    	BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    }

3.refresh();容器环境与配置文件加载完毕，进行容器刷新等操作。

[Spring_-spring]: https://blog.csdn.net/weixin_43549578/article/details/86478337