Spring源码解析系列一:配置类的初始化过程

时间  2019-11-07
标签 spring 源码 解析 系列 配置 初始化 过程 栏目 Spring 繁體版
原文   原文链接

从今天开始,准备写关于Spring源码的博客,那么废话很少说, 我们开始搞!java

1.环境准备

1).看图:spring

PersonService类:数组

@Component
public class PersonService {
	public void run(){
		System.out.println("run方法执行了");
	}
}
复制代码

SpringConfiguration类:app

@ComponentScan("my.blog")
public class SpringConfiguration {

}
复制代码

Test01类:ide

public class Test01 {
	public static void main(String[] args) {
		//这个构造方法会把Spring全部的环境都准备好
		AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
		PersonService person = ac.getBean(PersonService.class);
		person.run();
	}
}
复制代码

2.介绍:注解配置应用上下文

AnnotationConfigApplicationContext 顾名思义:注解配置应用上下文, 我在演示当中使用的是注解的方式函数

因此须要 new AnnotationConfigApplicationContext 这个对象.ui

若是采用的是xml的配置方式 则须要 new ClassPathXmlApplicationContext ,这个应该我不用多说,我想你应该懂的!this

那么这个实例化对象的过程,Spring到底中干了哪些见不得人的事呢? 接下来跟着我一块儿去揭开他的神秘面纱!lua

咱们点击 new AnnotationConfigApplicationContext看一下他的构造方法:spa

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		//这个类有父类,因此会先初始化父类的构造方法,接着初始化本身的构造方法

		//调用无参构造方法进行初始化一个读取器和扫描仪
		this();
		
       //这个方法的做用:主要是把配置类的信息加载进工厂中
       //在这里须要你记住一个类:DefaultListableBeanFactory,后面会很是的重要
		register(annotatedClasses);

		//实例化全部被加了组件的对象
		refresh();
	}

复制代码

咱们发现这个构造函数的参数能够一次性传多个配置类,后面代码中其实会遍历annotatedClasses 这个数组

咱们看一下 this() 干了哪些事?

public AnnotationConfigApplicationContext() {
		//这里也会先初始化父类的构造方法
        
        //建立一个读取被加了注解的bean读取器 ,这个读取器到底什么鬼,不是这节的重点,能够先忽略
        //你就知道他建立了一个读取器就完事了
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}
复制代码

咱们回到 register(annotatedClasses);这个方法, 这个方法就是本节的大哥,咱们如今就要去看看,他为Spring干了哪些脏活!

3.加载配置类

咱们点击 register(annotatedClasses)

嗯....,好像没啥用!

点击 this.reader.register(annotatedClasses); 方法

这时候,咱们发现这个方法开始遍历annotatedClasses 数组,由此咱们能够一次性写多个配置文件传给构造方法的

开始遍历annotatedClasses(注意:本次演示中,我只添加了一个配置类), 调用 registerBean(annotatedClass);

咱们这时候点击 registerBean(annotatedClass);

点击 doRegisterBean(annotatedClass, null, null, null);

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
        //(1)(解析:查看下面图)
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
	 
        
        //这个不是重点,跳过
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}
        
         //这个不是重点,跳过 instanceSupplier为null值
		abd.setInstanceSupplier(instanceSupplier);

		//(2)获得类的做用域 单例仍是多例(解析:查看下面图)
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        
		//把类的做用域赋值给AnnotatedGenericBeanDefinition对象
		abd.setScope(scopeMetadata.getScopeName());

		//生成配置类的名称,若是@Component没有对应的名称 (我没有加名称)
        //默认是类的小驼峰式命名称 (全部此时beanName为springConfiguration)
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

		/** * (3)把AnnotatedGenericBeanDefinition对象传进 * 而后获取获取元数据metadata对象,判断元数据对象中是否存在lazy,DependsOn,Primary Role 等注解 * 若是有这些注解,则在AnnotatedGenericBeanDefinition对象中记录 */
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

		//qualifiers自己传过来的就是一个 null 值
		//若是不手动传,永远为空值,没有意义
		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));
				}
			}
		}
        
		//这个不是重点
		for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
			customizer.customize(abd);
		}
        
         //(4)把abd放进去,赋值给了成员变量beanDefinition
		//把BeanName赋值进去,能够说是加强版的abd对象
		//查看后面的代码发现,其实definitionHolder就只是起到一个临时容器的做用
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);

		//这个比较复杂,之后能够讲 和本节无关
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

		//(5)如今又把加强版的 definitionHolder 放到registry这个容器中
		//BeanDefinitionRegistry 顾名思义 就是注册BeanDefinition的
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}
复制代码

1).咱们查看代码AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);干了哪些事 ?

经过debug 查看 abd 对象内容

总结:

  1. 根据指定的配置类,建立一个GenericBeanDefinition对象
  2. 这个GenericBeanDefinition对象包含了该类的一些元信息,例如注解信息: scope,lazy,ComponentScan等注解
  3. 这些注解存储在 GenericBeanDefinition中的 元数据(metadata)对象中
  4. 元数据对象有一个注解集合 annotations ,存储全部的注解信息

2).接下来查看 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);

执行完这个abd.setScope(scopeMetadata.getScopeName());方法后

3).查看 AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

点击进入

额..., 这个方法好像也没啥...

把传进的abd对象拆开,又传了abd对象和abd.getMetadata()元数据对象

点击 processCommonDefinitionAnnotations(abd, abd.getMetadata());

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
		//判断当前的类是否加了lazy注解
		AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
        
		//若是不为null,则把AnnotatedBeanDefinition中的 lazyInit 默认的false 修改成true
		if (lazy != null) {
			abd.setLazyInit(lazy.getBoolean("value"));
		}
		else if (abd.getMetadata() != metadata) {
			lazy = attributesFor(abd.getMetadata(), Lazy.class);
			if (lazy != null) {
				abd.setLazyInit(lazy.getBoolean("value"));
			}
		}
        
		//判断元数据对象中时候有@Primary,默认时候primary是 false ,若是有则该为true
		if (metadata.isAnnotated(Primary.class.getName())) {
			abd.setPrimary(true);
		}
        
		//判断时候有@DependsOn注解
		AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
		if (dependsOn != null) {
			abd.setDependsOn(dependsOn.getStringArray("value"));
		}

		//判断时候有@Role注解
		AnnotationAttributes role = attributesFor(metadata, Role.class);
		if (role != null) {
			abd.setRole(role.getNumber("value").intValue());
		}
        
		//判断时候有@Description注解
		AnnotationAttributes description = attributesFor(metadata, Description.class);
		if (description != null) {
			abd.setDescription(description.getString("value"));
		}
	}
复制代码

总结:

  1. 把AnnotatedGenericBeanDefinition对象传进去
  2. 获取元数据metdata对象,判断元数据对象中是否存在lazy,DependsOn,Primary Role 等注解
  3. 若是有这些注解,则在AnnotatedGenericBeanDefinition对象中记录

4).查看 BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);

debug 发现

5).查看 BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);

点击进入

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

		
		//在这里又获取beanName的名称
		String beanName = definitionHolder.getBeanName();
    
		//如今把definitionHolder拆分了,又把abd对象拿出来了
		//彷佛definitionHolder就只是封装了一下,而后又给拆分, 能够理解为一个临时的容器
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		 //这个不重要,spring当中处理别名的
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}
复制代码

咱们点击 registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

发现是一个接口, 按住快捷键 Ctrl + Alt + B ,有三个实现类,前面叫你留意的 DefaultListableBeanFactory 在这里出现了,

选择 DefaultListableBeanFactory

@Override
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
   //-------------------------------------------------------------------------------
		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");
     
		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}
        //查看该bean时候在map集合中存储过
		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		if (existingDefinition != null) {
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (logger.isInfoEnabled()) {
					logger.info("Overriding user-defined bean definition for bean '" + beanName +
							"' with a framework-generated bean definition: replacing [" +
							existingDefinition + "] with [" + beanDefinition + "]");
				}
			}
			else if (!beanDefinition.equals(existingDefinition)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					removeManualSingletonName(beanName);
				}
			}
     //---------------------------------------------------------------------------------------
            //前面的代码都是一些判断,验证不是重点
            //重点是这里的代码,前方高能
			else {
				//在这个方法中就把 beanDefinition 存储在 DefaultListableBeanFactory的map集合中
				//顾名思义,beanDefinitionMap就是一个存储beanDefinition的map集合
				//在这个集合当中还有Spring当中自己已经初始好的对象
				this.beanDefinitionMap.put(beanName, beanDefinition);
				//把beanName存储在这个list集合中
				this.beanDefinitionNames.add(beanName);
				//这个是去重的,不是重点
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
	}
复制代码

this.beanDefinitionMap.put(beanName, beanDefinition); 以前

this.beanDefinitionMap.put(beanName, beanDefinition); 以后

this.beanDefinitionNames.add(beanName); 以前

this.beanDefinitionNames.add(beanName); 以后

整个配置类的加载过程就执行完了,最后总结一下 register(annotatedClasses); 都干了哪些事?

  1. 加载配置类的元数据 AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
  2. 给abd对象设置做用域
  3. 遍历元数据注解 ,判断时候存在某注解
  4. 把配置类信息对象存储到 DefaultListableBeanFactory的beanDefinitionMap集合中
  5. 把配置类的名称存储到 DefaultListableBeanFactory的 beanDefinitionNames 集合中
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程