Spring 原始碼（9）Spring Bean的建立過程的前期準備

阿新 • • 發佈：2022-05-07

回顧總結

到目前為止，Spring原始碼中AbstractApplicationContext#refresh方法的已經解讀到第11個方法finishBeanFactoryInitialization,前10個方法介紹了：

BeanFactory的準備，建立，重新整理，個性化BeanFactory的擴充套件點，自定義屬性解析；
環境資訊Environment的載入（包括環境變數、系統變數等）；
BeanDefinition的載入，解析，自定義xml的方式；
BeanFactoryPostProcessor的註冊與執行流程，BeanDefinitionRegistryPostProcessor

的解析，ConfigurationClassPostProcessor對Spring註解的解析過程（@Component、@PropertySources、@PropertySource、@ComponentScans、@ComponentScan、@Import等註解的解析），Spring Boot 是如何通過@Configuration+@Import + ImportSelector進行自動裝配的等；
BeanPostProcessor的註冊流程；
國際化，Spring事件驅動的載入執行過程；

finishBeanFactoryInitialization 解析過程

接下來開始解析Spring

對Bean的建立過程，上原始碼：

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  // Initialize conversion service for this context.
  if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
      beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
    // 設定轉換服務，轉換服務用來對屬性值進行解析的
    beanFactory.setConversionService(
      beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
  }

  // Register a default embedded value resolver if no BeanFactoryPostProcessor
  // (such as a PropertySourcesPlaceholderConfigurer bean) registered any before:
  // at this point, primarily for resolution in annotation attribute values.
  // 如果之前沒有註冊過任何 BeanFactoryPostProcessor（例如 PropertySourcesPlaceholderConfigurer bean），
  // 則註冊一個預設的嵌入值解析器：此時，主要用於解析註釋屬性值。
  if (!beanFactory.hasEmbeddedValueResolver()) {
    beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
  }

  // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
  String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  for (String weaverAwareName : weaverAwareNames) {
    getBean(weaverAwareName);
  }

  // Stop using the temporary ClassLoader for type matching.
  beanFactory.setTempClassLoader(null);

  // Allow for caching all bean definition metadata, not expecting further changes.
  // 允許快取所有 bean 定義元資料，而不是期望進一步的更改
  beanFactory.freezeConfiguration();

  // Instantiate all remaining (non-lazy-init) singletons.
  // 例項化所有剩餘的（非惰性初始化）單例
  beanFactory.preInstantiateSingletons();
}

判斷是否存在轉換服務，有就設定
判斷是否有內建的值解析器，沒有就建立一個處理佔位符的解析器
例項化LoadTimeWeaverAware，進行早期的Bean的建立
停止使用臨時的類載入器
凍結BeanDefinition的元資料資訊，防止被修改
開始例項化所有的單例bean物件

除了beanFactory.preInstantiateSingletons() 方法，其他都是Bean建立的準備，接下來一個一個分析，首先是轉換服務的設定。

轉換服務ConversionService的初始化

方法一開始設定了一個轉換服務，這個轉換服務在Spring中還是非常的重要的，比如我們xml中配置一個String 型別的屬性值，但是在Bean的定義中是一個Integer型別的，這時Spring就會自動幫我們轉出來，他是怎麼做的呢？

在Spring中有幾個比較重要的介面:

Converer 用於將物件S轉換為物件T
ConverterFactory 一個轉換工廠，能夠將物件S轉成一類物件R的子集T，比如可以將字串S轉換為T（Integer、Long等）Number型別R的子集
GenericConverter支援多種型別之間互相轉換。

Spring轉換器介面ConversionService 的預設實現是DefaultConversionService,這個預設的轉換器實現中，內建了很多的轉換器，比如：

public static void addDefaultConverters(ConverterRegistry converterRegistry) {
  addScalarConverters(converterRegistry);
  addCollectionConverters(converterRegistry);

  converterRegistry.addConverter(new ByteBufferConverter((ConversionService) converterRegistry));
  converterRegistry.addConverter(new StringToTimeZoneConverter());
  converterRegistry.addConverter(new ZoneIdToTimeZoneConverter());
  converterRegistry.addConverter(new ZonedDateTimeToCalendarConverter());

  converterRegistry.addConverter(new ObjectToObjectConverter());
  converterRegistry.addConverter(new IdToEntityConverter((ConversionService) converterRegistry));
  converterRegistry.addConverter(new FallbackObjectToStringConverter());
  converterRegistry.addConverter(new ObjectToOptionalConverter((ConversionService) converterRegistry));
}

public static void addCollectionConverters(ConverterRegistry converterRegistry) {
  ConversionService conversionService = (ConversionService) converterRegistry;
  // 陣列轉集合
  converterRegistry.addConverter(new ArrayToCollectionConverter(conversionService));
  // 集合轉陣列
  converterRegistry.addConverter(new CollectionToArrayConverter(conversionService));

  converterRegistry.addConverter(new ArrayToArrayConverter(conversionService));
  converterRegistry.addConverter(new CollectionToCollectionConverter(conversionService));
  converterRegistry.addConverter(new MapToMapConverter(conversionService));
  // 陣列轉字串
  converterRegistry.addConverter(new ArrayToStringConverter(conversionService));
  converterRegistry.addConverter(new StringToArrayConverter(conversionService));

  converterRegistry.addConverter(new ArrayToObjectConverter(conversionService));
  converterRegistry.addConverter(new ObjectToArrayConverter(conversionService));

  converterRegistry.addConverter(new CollectionToStringConverter(conversionService));
  converterRegistry.addConverter(new StringToCollectionConverter(conversionService));

  converterRegistry.addConverter(new CollectionToObjectConverter(conversionService));
  converterRegistry.addConverter(new ObjectToCollectionConverter(conversionService));

  converterRegistry.addConverter(new StreamConverter(conversionService));
}

private static void addScalarConverters(ConverterRegistry converterRegistry) {
  converterRegistry.addConverterFactory(new NumberToNumberConverterFactory());

  converterRegistry.addConverterFactory(new StringToNumberConverterFactory());
  converterRegistry.addConverter(Number.class, String.class, new ObjectToStringConverter());

  converterRegistry.addConverter(new StringToCharacterConverter());
  converterRegistry.addConverter(Character.class, String.class, new ObjectToStringConverter());

  converterRegistry.addConverter(new NumberToCharacterConverter());
  converterRegistry.addConverterFactory(new CharacterToNumberFactory());

  converterRegistry.addConverter(new StringToBooleanConverter());
  converterRegistry.addConverter(Boolean.class, String.class, new ObjectToStringConverter());

  converterRegistry.addConverterFactory(new StringToEnumConverterFactory());
  converterRegistry.addConverter(new EnumToStringConverter((ConversionService) converterRegistry));

  converterRegistry.addConverterFactory(new IntegerToEnumConverterFactory());
  converterRegistry.addConverter(new EnumToIntegerConverter((ConversionService) converterRegistry));

  converterRegistry.addConverter(new StringToLocaleConverter());
  converterRegistry.addConverter(Locale.class, String.class, new ObjectToStringConverter());

  converterRegistry.addConverter(new StringToCharsetConverter());
  converterRegistry.addConverter(Charset.class, String.class, new ObjectToStringConverter());

  converterRegistry.addConverter(new StringToCurrencyConverter());
  converterRegistry.addConverter(Currency.class, String.class, new ObjectToStringConverter());

  converterRegistry.addConverter(new StringToPropertiesConverter());
  converterRegistry.addConverter(new PropertiesToStringConverter());

  converterRegistry.addConverter(new StringToUUIDConverter());
  converterRegistry.addConverter(UUID.class, String.class, new ObjectToStringConverter());
}

可以說是非常的豐富的，基本上常見都是Spring提供了，非常貼心。

那麼怎麼使用呢？

不懂當然是上官網：https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#core-convert ，這裡可以看到我們只需要將ConversionServiceFactoryBean 配置到Spring容器中就可以了，Spring內建的轉換器就可以工作了，非常方便。

ConversionServiceFactoryBean實現了FactoryBean介面和InitializingBean 介面，而InitializingBean#afterPropertiesSet是初始化Bean過程中需要執行的。ConversionServiceFactoryBean原始碼中：

@Override
public void afterPropertiesSet() {
  this.conversionService = createConversionService();
  ConversionServiceFactory.registerConverters(this.converters, this.conversionService);
}

protected GenericConversionService createConversionService() {
  return new DefaultConversionService();
}

// 建構函式
public DefaultConversionService() {
  // 新增預設的轉換器
  addDefaultConverters(this);
}

可以看到這個ConversionServiceFactroyBean就是用來初始化轉換器的，並且這個類還提供了擴充套件，可以自定義轉換器加入到轉換器集合中。

自定義轉換器

自定義String轉Integer型別的轉換器：

/**
 * @author <a href="https://www.cnblogs.com/redwinter/">redwinter</a>
 * @since 1.0
 **/
public class StringToIntegerConverter implements Converter<String,Integer> , ConditionalConverter {
	@Override
	public Integer convert(String source) {
		return NumberUtils.parseNumber(source,Integer.class);
	}

	@Override
	public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
		System.out.println(sourceType.getType());
		System.out.println(targetType.getType());
		return true;
	}
}

邏輯非常簡單，直接呼叫Spring提供的工具類進行轉換。

配置xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

	<context:component-scan base-package="com.redwinter.selfconverter"/>
	<!--配置轉化器-->
	<bean class="org.springframework.context.support.ConversionServiceFactoryBean">
		<property name="converters">
			<set>
				<bean class="com.redwinter.selfconverter.StringToIntegerConverter"/>
			</set>
		</property>
	</bean>

</beans>

建立轉換器客戶端：

/**
 * @author <a href="https://www.cnblogs.com/redwinter/">redwinter</a>
 * @since 1.0
 **/
@Service
public class MyConverter {

	private final ConversionService conversionService;

	public MyConverter(ConversionService conversionService) {
		this.conversionService = conversionService;
	}

	public void test(String source){
		System.out.println(conversionService.convert(source, Integer.class));
	}
}

建立測試：

/**
 * @author <a href="[email protected]">redwinter</a>
 * @since 1.0
 **/
public class FactoryBeanTest {

	@Test
	public void test(){
		MyClassPathXmlApplicationContext context = new MyClassPathXmlApplicationContext("spring-factory.xml");
		MyConverter myConverter = context.getBean(MyConverter.class);
		myConverter.test("12345");
	}
}

輸出：

class java.lang.String
class java.lang.Integer
12345

分析完轉換服務，接下來分析值解析器的新增。

預設的值解析器

// 省略程式碼.....
// Register a default embedded value resolver if no BeanFactoryPostProcessor
// (such as a PropertySourcesPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
// 如果之前沒有註冊過任何 BeanFactoryPostProcessor（例如 PropertySourcesPlaceholderConfigurer bean），
// 則註冊一個預設的嵌入值解析器：此時，主要用於解析註釋屬性值。
if (!beanFactory.hasEmbeddedValueResolver()) {
  beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 省略程式碼.....

首先判斷了容器中是否存在嵌入的值解析器，如果沒有就新增一個進去，這裡新增進去的是StringValueResolver，點選resolvePlaceHolders方法進去，最終會在AbstractPropertyResolver#resolvePlaceholders中建立一個PropertyPlaceholderHelper類

private PropertyPlaceholderHelper createPlaceholderHelper(boolean ignoreUnresolvablePlaceholders) {
  // 字首為 ${ ，字尾為 }，值的分隔符為 : ,比如 ${username:zhansan} username沒有的話，後面的為預設的值
  return new PropertyPlaceholderHelper(this.placeholderPrefix, this.placeholderSuffix,
                                       this.valueSeparator, ignoreUnresolvablePlaceholders);
}

如果已經註冊過一個BFPP的佔位符解析器的話，就不需要在註冊了，BFPP的佔位符解析器就是PropertySourcesPlaceholderConfigurer ，專門用於解析佔位符的，比如在xml中或者yaml中，配置類似於${jdbc.username} 這種格式的，就會被解析器解析。PropertySourcesPlaceholderConfigurer 這個解析器實現了BeanFactoryPostProcessor介面，能夠對BeanDefinition進行處理，當然也可以對屬性值進行處理。

分析完值解析器，繼續往下分析。

Bean建立前的其他準備

// 省略程式碼.....
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
// 在prepareBeanFactory 準備BeanFactory時設定進去的，如果存在，則開始早期Bean的建立
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
  getBean(weaverAwareName);
}

// Stop using the temporary ClassLoader for type matching.
// 停止使用臨時的類載入器，這裡也是在準備BeanFactory時設定進去的
beanFactory.setTempClassLoader(null);

// Allow for caching all bean definition metadata, not expecting further changes.
// 允許快取所有 bean 定義元資料，而不是期望進一步的更改
beanFactory.freezeConfiguration();
// 省略程式碼.....

這裡從容器中獲取了AOP的織入，如果有的話就開始進行早期的Bean的建立；然後停止了臨時的類載入器；然後就是凍結BeanDefinition的元資料資訊。

public void freezeConfiguration() {
  this.configurationFrozen = true;
  this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
}

點選進來，其實就是設定了標識，防止後期對BeanDefinition的修改。

這前面的幾個判斷和方法實際上都是Bean建立的準備工作，接下來開始分析preInstantiateSingletons 預例項化所有的單例Bean。

Spring 原始碼（9）Spring Bean的建立過程的前期準備

回顧總結

finishBeanFactoryInitialization 解析過程

轉換服務ConversionService的初始化

自定義轉換器

預設的值解析器

Bean建立前的其他準備

Spring 原始碼（9）Spring Bean的建立過程的前期準備

Spring 原始碼（11）Spring Bean 的建立過程（2）

Spring 原始碼（12）Spring Bean 的建立過程（3）

Spring 原始碼（3）Spring BeanFactory 是怎麼建立的？

Spring 原始碼（一）Spring 容器的入口及簡單介紹

Spring 原始碼（8）Spring BeanPostProcessor的註冊、國際化及事件釋出機制

spring學習（二）配置bean

Spring原始碼（2）注入

Spring筆記（三）：IOC建立物件方式

細讀Spring原始碼（三）---深度剖析動態代理底層原理

Spring學習（五）Spring 基於註解裝配Bean

Spring基礎知識（9）- Spring 整合 AspectJ

Spring MVC（一）Spring MVC 工作流程及重要元件解析

Spring學習（六）Spring AOP

Spring學習（一）Spring初識

Spring學習（二）Spring框架結構

Spring學習（七）Spring JdbcTemplate

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

Spring IoC 原始碼分析 (基於註解)（三）之 Bean的解析與註冊

spring aop 原始碼分析（三） @Scope註解建立代理物件

Spring 原始碼（9）Spring Bean的建立過程的前期準備

回顧總結

finishBeanFactoryInitialization 解析過程

轉換服務ConversionService的初始化

自定義轉換器

預設的值解析器

Bean建立前的其他準備

相關推薦