Spring源码分析

时间  2020-07-07
标签 spring 源码 分析 栏目 Spring 繁體版
原文   原文链接

本文采用的Spring版本是5.1.1spring

1. AnnotationConfigApplicationContext

首先咱们采用Spring官方推荐的JavaConfig风格+注解的方式来初始化Spring：缓存

// 配置类
@Configuration
@ComponentScan(basePackages = {"com.demo.learn.service"})
public class AppConfig {
}

// 入口类
public static void main(String[] args) {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
    DemoServiceImpl serviceImpl =  (DemoServiceImpl)applicationContext.getBean(DemoServiceImpl.class);
    System.out.println(serviceImpl);
}
复制代码

1.1 进入AnnotationConfigApplicationContext的构造方法

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    // 调用自身无参构造方法 -> 1.2
	this();
	register(annotatedClasses);
	refresh();
}
复制代码

1.2 点击this()进入无参构造方法,

AnnotationConfigApplicationContext继承了GenericApplicationContext因此此处隐式调用了父类的无参构造方法建立了一个Bean工厂：DefaultListableBeanFactorybash

GenericApplicationContext实现了BeanDefinitionRegistry接口，而AnnotationConfigApplicationContext继承了GenericApplicationContext，因此AnnotationConfigApplicationContext就是一个registryapp

BeanDefinitionRegistry 是一个接口，定义了关于 BeanDefinition 的注册、移除、查询等一系列的操做。该接口有三个实现类：DefaultListableBeanFactory、GenericApplicationContext、SimpleBeanDefinitionRegistry，其中 GenericApplicationContext 底层调用的是 DefaultListableBeanFactory 中的实现方法，因此严格意义上来讲，只有两个实现类。ide

public GenericApplicationContext() {
	this.beanFactory = new DefaultListableBeanFactory();
}
复制代码

此处初始化了一个读取器和一个扫描器post

// 注解形式bean的读取器
private final AnnotatedBeanDefinitionReader reader;

// ... 
public AnnotationConfigApplicationContext() {
    // 给注册表建立一个bean读取器
    // 初始化一个DefaultListableBeanFactory -> 1.3
	this.reader = new AnnotatedBeanDefinitionReader(this);
	//scanner的用处不是很大，它仅仅是在咱们外部手动调用 .scan 等方法才有用，常规方式是不会用到scanner对象的
	this.scanner = new ClassPathBeanDefinitionScanner(this);
}
复制代码

1.3 进入this.reader = new AnnotatedBeanDefinitionReader(this);一路点下去，咱们会看到一系列初始化过程

public ConditionContextImpl(@Nullable BeanDefinitionRegistry registry,
		@Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {

	this.registry = registry;
	this.beanFactory = deduceBeanFactory(registry);
	this.environment = (environment != null ? environment : deduceEnvironment(registry));
	this.resourceLoader = (resourceLoader != null ? resourceLoader : deduceResourceLoader(registry));
	this.classLoader = deduceClassLoader(resourceLoader, this.beanFactory);
}
复制代码

1.4 初始化DefaultListableBeanFactory并注册各类Processor

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
		BeanDefinitionRegistry registry, @Nullable Object source) {
    // 建立beanFactory
	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<>(8);

	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));
	}
    // ...
}
复制代码

BeanDefinition是什么，顾名思义，它是用来描述Bean的，里面存放着关于Bean的一系列信息，好比Bean的做用域，Bean所对应的Class，是否懒加载，是否Primary等等，这个BeanDefinition也至关重要ui

1.5 进入DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);

在此以前registry为AnnotationConfigApplicationContext，根据1.2得知是GenericApplicationContext的子类，执行1.5.1处代码this

@Nullable
private static DefaultListableBeanFactory unwrapDefaultListableBeanFactory(BeanDefinitionRegistry registry) {
	if (registry instanceof DefaultListableBeanFactory) {
		return (DefaultListableBeanFactory) registry;
	}
	// 1.5.1
	else if (registry instanceof GenericApplicationContext) {
		return ((GenericApplicationContext) registry).getDefaultListableBeanFactory();
	}
	else {
		return null;
	}
}
复制代码

1.5.2 进入1.5.1代码块，能够看到，返回的是GenericApplicationContext的beanFactory，beanFactory在1.2的时候已经被赋值为DefaultListableBeanFactory

public final DefaultListableBeanFactory getDefaultListableBeanFactory() {
	return this.beanFactory;
}
复制代码

1.6 上面方法中有一个registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)方法，咱们点进去能够看到这个方法中给RootBeanDefinition设置了一个角色BeanDefinition.ROLE_INFRASTRUCTURE, 此角色表名用此方法注册的bean彻底是spring的内部bean，与最终用户无关

1.6.1 角色

  • 0: 用户自定义的Bean
  • 1：来源于配置文件的Bean
  • 2：Spring内部的Bean
private static BeanDefinitionHolder registerPostProcessor(
		BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

	definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
	registry.registerBeanDefinition(beanName, definition);
	return new BeanDefinitionHolder(definition, beanName);
}
复制代码

1.7 点击进入registry.registerBeanDefinition(beanName, definition)方法

能够看到这个方法是一个接口，先来看下此接口都有哪些方法spa

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;
    // 根据bean name判断是否存在BeanDefinition
    boolean containsBeanDefinition(String beanName);
    // 获取全部的BeanDefinition
    String[] getBeanDefinitionNames();
    // 获取BeanDefinition数量
    int getBeanDefinitionCount();
    // 判断bean name是否被占用
    boolean isBeanNameInUse(String beanName);
}
复制代码

此时咱们须要找它的实现类（由1.5.2得知为DefaultListableBeanFactory）debug

这个类就是咱们的Bean容器所在的位置

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
复制代码
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

    // 存储全部的BeanDefinition，key就是bean name，这个Map就是咱们一直所说的Bean容器
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
    // 存储全部的bean name
    private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
    
    /**
     * 注册bean
     * @param beanName          bean name
     * @param BeanDefinition    bean对应的BeanDefinition
     */
    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 {
    		     // 验证：
    		        1. 验证是否重写了方法
    		        2. 若是重写了方法，经过beanName获取方法，若是为0则方法不存在，抛出异常，为1则设置overload属性为false
    			((AbstractBeanDefinition) beanDefinition).validate();
    		}
    		catch (BeanDefinitionValidationException ex) {
    			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
    					"Validation of bean definition failed", ex);
    		}
    	}
    
        // 从bean容器（beanDefinitionMap）中经过beanName获取beanDefinition
    	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    	if (existingDefinition != null) {
    	    // 判断是否容许重写beanDefinition，不容许则抛出异常
    		if (!isAllowBeanDefinitionOverriding()) {
    			throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
    		}
    		// 当原beanDefinition的角色小于新的beanDefinition角色时，输出warn日志，提示beanDefinition被覆盖
    		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 + "]");
    			}
    		}
    		// 当新beanDefinition的属性值不等于原beanDefinition的属性值时，输出info提示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 + "]");
    			}
    		}
    		// 添加至bean容器，并覆盖原beanDefinition
    		this.beanDefinitionMap.put(beanName, beanDefinition);
    	} 
    	// 容器中无对应的beanDefinition则直接注册
    	else {
    	    // 判断此工厂bean建立流程是否已经开始
    		if (hasBeanCreationStarted()) {
    			// Cannot modify startup-time collection elements anymore (for stable iteration)
    			synchronized (this.beanDefinitionMap) {
    			    // 添加beanDefinition至bean容器
    				this.beanDefinitionMap.put(beanName, beanDefinition);
    				// 建立新的beanNames集合，并将已经存在的beanNames放入该集合
    				List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
    				updatedDefinitions.addAll(this.beanDefinitionNames);
    				updatedDefinitions.add(beanName);
    				this.beanDefinitionNames = updatedDefinitions;
    				// 在手动建立bean的集合中，若是存在同名的beanName，则将集合中已经存的beanName移除
    				if (this.manualSingletonNames.contains(beanName)) {
    					Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
    					updatedSingletons.remove(beanName);
    					this.manualSingletonNames = updatedSingletons;
    				}
    			}
    		}
    		else {
    			// Still in startup registration phase
    			// 将当前bean对应的beanDefinition放入容器中
    			this.beanDefinitionMap.put(beanName, beanDefinition);
    			// 将当前beanName放入beanDefinitionNames中
    			this.beanDefinitionNames.add(beanName);
    			// 删除同名的beanName
    			this.manualSingletonNames.remove(beanName);
    		}
    		// 将保存冻结beanDefinition的Map设为null
    		this.frozenBeanDefinitionNames = null;
    	}
    
        // 若是当前注册的beanDefinition已经存在，或者在（缓存单例bean实例map）中存在
    	if (existingDefinition != null || containsSingleton(beanName)) {
    	    // 重置给定bean的全部bean定义缓存，包括从其派生的bean的缓存
    		resetBeanDefinition(beanName);
    	}
    }
}
复制代码

参考 juejin.im/post/5c637d…

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程