2. 程式人生 > 其它 >spring 學習-bean建立-scan掃描bean

spring 學習-bean建立-scan掃描bean

阿新 • • 發佈：2021-08-01

概述

文章分析註解方式注入bean 的程式碼過程。本篇將介紹 AnnotationConfigApplicationContext 該類的關於掃描註釋關於 bean 的過程。

前言

我們使用過spring框架 ，知道了生成 bean 的方式可以有 XML 配置檔案， 也可以通過註解。我們分析原始碼前可以思考假如給你一個XML檔案最終要裝配到容器中去，你的步驟應該是如何的 ：

  • 讀取
  • 解析
  • 註冊

spring 中也是遵循這個思路的， 我們先看一下 BeanFactory 和 Context 的關係 ，並且瞭解一下他們的繼承關係 ， 這兩個類是生成 bean 重要的兩個介面。

註釋方式注入Bean 方式

註解式生成bean的過程，總的來說就是 ：

  1. 初始化一個Context

  2. 掃描生成 BeanDefinition

  3. 呼叫 refresh 方法

其中第一個步驟由於是註解類，利用第一步初始化生成的 Scan 類進行掃描特定包下的 bean ,然後根據屬性，例如作用域，單例模式還是模板模式等屬性生成 BeanDefinition ,最後呼叫 上下文 context 父類的refresh 方法，進行呼叫（BeanFactoryPostProcess）後置處理器處理方法和BeanPostProcess處理器處理方法。

Demo 1

    public static void main(String[] args) {
        AnnotationConfigApplicationContext consumerContext = new AnnotationConfigApplicationContext();
        //這裡看到我們註冊了一個 configuration 的類進行配置，然後重新整理一下容器得到最新的結果
        consumerContext.register(ConsumerConfiguration.class);
        consumerContext.refresh();

        //從容器中獲取類
        FooServiceConsumer service = consumerContext.getBean(FooServiceConsumer.class);

        ...

    }

Demo 2

idea 中new一個新的 spring專案，然後編寫兩個類 。

@Component
public class MyService {
    public String sayHello(){
        return "hello world ";
    }


}


public class SpringTest {

    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext("main");//A
        MyService myService = ctx.getBean(MyService.class);
        String s = myService.sayHello();
        System.out.println("s : "+ s);
    }
}

我們以例子二為原始碼閱讀，從 A 處 debug 進去，看一下 bean 的載入和建立

AnnotationConfigApplicationContext 的建立過程概述

構造方法很清晰 ： 初始化，掃描，重新整理三個步驟。

	public AnnotationConfigApplicationContext(String... basePackages) {
		//初始化
        this();
        //掃描包
		scan(basePackages);
        //重新整理 
		refresh();
	}

原始碼分析

需要知道的類 :

  • Resoure 對應讀取操作
  • BeanDefinitionRead 對應解析操作
  • Registry 對應註冊操作。

以AnnotationConfigApplicationContext為例子，檢視類圖主要包含三個型別的介面

  • AppContext介面 : 上下文相關
  • Lifecycle介面 ： 生命週期相關
  • Registry介面 ： 用於註冊 BeanDefinition

AnnotationConfigApplicationContext 的初始化建立的兩個類作用如下 ：

  • AnnotatedBeanDefinitionReader ：註冊幾個後置處理器
  • ClassPathBeanDefinitionScanner ：掃描包內的bean
	public AnnotationConfigApplicationContext(String... basePackages) {
        //初始化
		this();
        //掃描包
		scan(basePackages);
        //重新整理 
		refresh();
	}


	/**
	 * Create a new AnnotationConfigApplicationContext that needs to be populated
	 * through {@link #register} calls and then manually {@linkplain #refresh refreshed}.
     * 
     * 構造方法，從註釋也可以看到，構造完，需要呼叫  register 方法進行填充和 refresh 方法進行重新整理
	 */
	public AnnotationConfigApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}


	//============ 父類初始化  ==============

    //==========================
	//GenericApplicationContext
	public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}


	//AbstractApplicationContext
	public AbstractApplicationContext() {
		this.resourcePatternResolver = getResourcePatternResolver();
	}


	//DefaultResourceLoader
	public DefaultResourceLoader() {
		this.classLoader = ClassUtils.getDefaultClassLoader();
	}

	public static ClassLoader getDefaultClassLoader() {
		ClassLoader cl = null;
		try {
			cl = Thread.currentThread().getContextClassLoader();
		}
		catch (Throwable ex) {
			// Cannot access thread context ClassLoader - falling back...
		}
		if (cl == null) {
			// No thread context class loader -> use class loader of this class.
			cl = ClassUtils.class.getClassLoader();
			if (cl == null) {
				// getClassLoader() returning null indicates the bootstrap ClassLoader
				try {
					cl = ClassLoader.getSystemClassLoader();
				}
				catch (Throwable ex) {
					// Cannot access system ClassLoader - oh well, maybe the caller can live with null...
				}
			}
		}
		return cl;
	}


	//============ 父類初始化  ==============

	//============ 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;
		//步驟一 ： 用於解析 @Condition 註解相關
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
		//步驟二 ： 最終會呼叫 register&registerBeanDefinition方法註冊入幾個預設的 BeanDefinition 
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}

其中步驟二中注入的類包括 ：

作用：內部託管配置註釋處理器。
對應的類：ConfigurationClassPostProcessor.class

作用：內部管理的自動注入註解處理器
對應的類：AutowiredAnnotationBeanPostProcessor.class

作用：內部管理的JSR-250註釋處理器
對應的類：CommonAnnotationBeanPostProcessor.class

作用：內部管理的JPA註釋處理器（不一定注入）。
對應的類：PersistenceAnnotationBeanPostProcessor.class

作用：內部管理的@EventListener註釋處理器
對應的類：EventListenerMethodProcessor.class

作用：內部管理的EventListenerFactory。
對應的類：DefaultEventListenerFactory.class

BeanDefinition 是個介面，我們看一下 ClassPathBeanDefinitionScanner 會掃描我們專案中的 bean

該類註解 ： 

A bean definition scanner that detects bean candidates on the classpath, registering corresponding bean definitions with a given registry (BeanFactory or ApplicationContext).
Candidate classes are detected through configurable type filters. The default filters include classes that are annotated with Spring's @Component, @Repository, @Service, or @Controller stereotype.

下面我們看一下核心的scan 方法，它的呼叫棧挺長的，我們只需要知道scan 中會進行 ：

  • 掃描所有 bean
  • 新增幾個postprocess（後置處理器）作為 beanDefinition ,方便後續的
	

    @Override
	public void scan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
        //使用上面構造方法生成的 scan 物件，執行 scan 方法 
		this.scanner.scan(basePackages);
	}

	public int scan(String... basePackages) {
		int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

		doScan(basePackages);

		// Register annotation config processors, if necessary.
		if (this.includeAnnotationConfig) {
			AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
		}

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


	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		for (String basePackage : basePackages) {
			//這裡會把配置檔案中的 bean 讀取出來，然後進行註冊
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					//為每個 BeanDefinition 填充作為 BeanDefinition 的屬性值 
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				//檢查這個 BeanDefinition 是否一件存在，因為預設是單例，可以想象得到肯定是去 DefaultListableBeanFactory 中判斷尋找
				if (checkCandidate(beanName, candidate)) {
					//封裝成 BeanDefinitionHolder 物件
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					// register 註冊  
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}		



	protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
		//這裡呼叫的一個工具類的靜態方法
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
	}	

	//BeanDefinitionReaderUtils 類方法 
	public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// Register bean definition under primary name.
		String beanName = definitionHolder.getBeanName();
		//最終呼叫的是 registry 的 registerBeanDefinition 方法 
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// Register aliases for bean name, if any.
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}

繼續看 ， 也就是說我們掃描到的類跑到了 registry ，而這個 registry 是在哪裡傳進來的呢?

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {

	private final AnnotatedBeanDefinitionReader reader;

	private final ClassPathBeanDefinitionScanner scanner;


	/**
	 * Create a new AnnotationConfigApplicationContext that needs to be populated
	 * through {@link #register} calls and then manually {@linkplain #refresh refreshed}.
	 */
	public AnnotationConfigApplicationContext() {
		StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
		this.reader = new AnnotatedBeanDefinitionReader(this);
		createAnnotatedBeanDefReader.end();
		// context 把自己傳給了我們上面的掃描物件 
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}
    
    ...
}


	//看一下我們剛才上面分析的掃描物件 
	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
			Environment environment, @Nullable ResourceLoader resourceLoader) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;

		if (useDefaultFilters) {
			registerDefaultFilters();
		}
		setEnvironment(environment);
		setResourceLoader(resourceLoader);
	}
	...
}

ok, scan 方法我們就瞭解這麼多，下篇我們看一下 refresh方法。

總結

該篇文章我們介紹了 AnnotationConfigApplicationContext 的初始化過程，剩下的 refresh 方法將會留到下一篇文章進行講解。

參考資料

參考資料

相關推薦

spring 學習-bean建立-scan掃描bean

概述 文章分析註解方式注入bean 的程式碼過程。本篇將介紹 AnnotationConfigApplicationContext該類的關於掃描註釋關於 bean 的過程。

spring學習（二）配置bean

Spring可以分為6大模組： Spring Core spring的核心功能： IOC容器, 解決物件建立及依賴關係

Spring學習筆記——第六部分 Bean的自動裝配

技術標籤：Spring學習筆記springjava Spring學習筆記——第六部分 Bean的自動裝配 1. byName2. byType3. 使用註解實現自動裝配3.1 @Autowired3.2 @Resource3.3 @Autowired和@Resource的區別

Spring原始碼學習(五) 建立Bean過程中的擴充套件點

引言 上班挺累 事事都煩 寫篇文章 兌現諾言 一圖勝所有 getbean的擴充套件點 綠色的部一般用於Spring內部擴充套件，黃色的部分可用於自定義例項化。 本文僅僅聊聊InitializingBean，對於綠色部分，建議您檢視，其他

Spring啟動和Bean建立過程中的可擴充套件介面

1.前言 Spring中有一些可以擴充套件的介面，可以用來在工作中更深度的使用Spring，這些介面大多分佈在AbstractApplicationContext.refresh() 和 AbstractAutowireCapableBeanFactory.createBean()這兩個方法的執行過

Spring Ioc原始碼分析 之 Bean的載入（三）：各個 scope 的 Bean 建立

在Spring中Bean有許多不同的作用域，例如：singleton、prototype、request等等，本篇文章就來分析一下各個scope的Bean是怎麼建立的

Spring-Bean建立物件的步驟方式詳解

1.通過無參建構函式建立（預設） 2.通過有參構造建立 1.constructor 的index賦值 <bean id=\"user\" class=\"com.c.pojo.user\">

Spring框架花式建立Bean的n種方法(小結)

常用的從容器中獲取bean例項使用這樣的方式： @Test public void test() { Persion p = (Persion) ioc.getBean(\"p1\");

Spring 學習筆記（三）：Spring Bean

1 Bean配置 Spring可以看做是一個管理Bean的工廠，開發者需要將Bean配置在XML或者Properties配置檔案中。實際開發中常使用XML的格式，其中<bean>中的屬性或子元素如下：

Spring 學習(六)：Sprig Bean 自動注入

技術標籤：SSMspringjava 一、Sprig Bean 自動注入 一、自動注入二、Sprig 自動注入 byName三、Sprig 自動注入 byType四、設定預設方式

Spring原始碼分析系列——bean建立過程分析（二）——有參構造方法建立bean

技術標籤：原始碼springspringjava 前言 spring建立bean的方式createBeanInstance()方法分析autowireConstructor()方法分析構造方法引數賦值createArgumentArray()方法解析resolveAutowiredArgument（）方法實

Spring學習之七——Bean的自動裝配

技術標籤：自我學習springjava Bean的自動裝配 Spring學習之七——Bean的自動裝配 自動裝配是Spring媽祖bean依賴的一種方式Spring會在上下文中自動尋找，並自動給bean配置屬性

Spring Bean的包掃描的實現方法

我們知道，Spring可以通過包掃描將使用@Component註解定義的Bean定義到容器中。今天就來探究下他實現的原理。

Spring學習總結（四）：基於XML的Bean裝配中常見操作

技術標籤：Spring學習javaspringbean 一、注入空值和特殊符號 1、注入空值 （1）建立實體類User，提供私有屬性name、age和address，並提供它們的set方法和toString()。

Spring學習 -- Bean的依賴注入方式

技術標籤：springjava UserDao怎樣注入到UserService內部呢？ 1.設值注入（主要） 1）編寫User類

關於Spring Bean建立的一些問題

技術標籤：SpringspringSpring單例Bean建立 最近看到了邏輯大概像下面這樣的程式碼：

Spring學習總結（五）：基於XML裝配Bean（3）

技術標籤：Spring學習javaspringbean 一、bean的生命週期 所謂生命週期，就是指物件從建立到銷燬的整個過程。Spring容器可以管理bean的生命週期，當一個bean被載入到Spring容器中，它就具有了生命，並且Spring在

spring bean建立程式碼走讀和迴圈依賴程式碼分析

1.入口 初始化所有非懶載入單例，如果是FactoryBean是isEagerInit也要進行載入FactoryBean生成的單例

Spring bean建立之迴圈依賴與三級快取

Spring bean建立之迴圈依賴與三級快取 迴圈依賴 多個物件之間互相引用形成環 如果使用普通new方法建立，物件之間會迴圈建立導致OOM

Spring學習筆記（五）--基於註解的Bean操作管理

接下來來學習註解 什麼是註解 註解是程式碼特殊標記，格式：@註解名稱（屬性名稱=屬性值）