第七章：Spring IoC依赖来源（Dependency Sources）

依赖查找的来源

• 查找来源

来源	配置元数据
Spring BeanDefinition	<bean id="user" class="..."/>
Spring BeanDefinition	@Bean public User user(){…}
Spring BeanDefinition	BeanDefinitionBuilder
单例对象	API 实现

• Spring 内建 BeanDefinition

Bean 名称	Bean 实例	使用场景
org.springframework.context.annotation.internalConfigurationAnnotationProcessor	ConfigurationClassPostProcessor 对象	处理 Spring 配置类
org.springframework.context.annotation.internalAutowiredAnnotationProcessor	AutowiredAnnotationBeanPostProcessor 对象	处理 @Autowired 以及 @Value 注解
org.springframework.context.annotation.internalCommonAnnotationProcessor	CommonAnnotationBeanProcessor 对象	(条件激活)处理 JSR-250 注解，如 @PostContruct
org.springframework.context.event.internalEventListenerProcessor	EventListenerMethodProcessor 对象	处理标注 @EventListener 的 Spring 事件监听方法
org.springframework.context.event.internalEventListenerFactory	DefaultEventListenerFactory 对象	@EventListener 事件监听方法适配为 ApplicationListener
org.springframework.context.annotation.internalPersistenceAnnotationProcessor	PersistenceAnnotationBeanPostProcessor 对象	(条件激活)处理 JPA 注解

org.springframework.context.annotation.AnnotationConfigUtils

• Spring 内建单例对象

Bean 名称	Bean 实例	使用场景
environment	Environment 对象	外部化配置以及 Profiles
systemProperties	java.util.Properties 对象	Java 系统属性
systemEnvironment	java.util.Map 对象	操作系统环境变量
messageSource	MessageSource 对象	国际化文案
lifecycleProcessor	LifecycleProcessor 对象	Lifecycle Bean 处理器
applicationEventMulticaster	ApplicationEventMulticaster 对象	Spring 事件广播器

org.springframework.context.support.AbstractApplicationContext

依赖注入的来源

• 注入来源

来源	配置元数据
Spring BeanDefinition	<bean id="user" class="..."/>
Spring BeanDefinition	@Bean public User user(){…}
Spring BeanDefinition	BeanDefinitionBuilder
单例对象	API 实现
非 Spring 容器管理对象 （ResolvableDependency 又称：可处理的依赖、非推广对象、游离对象 ）	xxx

        AbstractApplicationContext#prepareBeanFactory(ConfigurableListableBeanFactory beanFactory)// 无法应用依赖查找// BeanFactory interface not registered as resolvable type in a plain factory.// MessageSource registered (and found for autowiring) as a bean.beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);beanFactory.registerResolvableDependency(ResourceLoader.class, this);beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);beanFactory.registerResolvableDependency(ApplicationContext.class, this);

---

public class DependencySourceDemo {// 注入在 postProcessProperties 方法执行，早于 setter注入，也早于 @PostConstruct@Autowiredprivate BeanFactory beanFactory;@Autowiredprivate ResourceLoader resourceLoader;@Autowiredprivate ApplicationContext applicationContext;@Autowiredprivate ApplicationEventPublisher applicationEventPublisher;@PostConstructpublic void initByInjection() {System.out.println("beanFactory == applicationContext " + (beanFactory == applicationContext));System.out.println("beanFactory == applicationContext.getBeanFactory() " + (beanFactory == applicationContext.getAutowireCapableBeanFactory()));System.out.println("resourceLoader == applicationContext " + (resourceLoader == applicationContext));System.out.println("ApplicationEventPublisher == applicationContext " + (applicationEventPublisher == applicationContext));}@PostConstructpublic void initByLookup() {getBean(BeanFactory.class);getBean(ApplicationContext.class);getBean(ResourceLoader.class);getBean(ApplicationEventPublisher.class);}private <T> T getBean(Class<T> beanType) {try {return beanFactory.getBean(beanType);} catch (NoSuchBeanDefinitionException e) {System.err.println("当前类型" + beanType.getName() + " 无法在 BeanFactory 中查找!");}return null;}public static void main(String[] args) {AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();applicationContext.register(DependencySourceDemo.class);applicationContext.refresh();DependencySourceDemo demo = applicationContext.getBean(DependencySourceDemo.class);applicationContext.close();}
}

Spring 容器管理和游离对象

• 依赖对象

来源	Spring bean 对象	生命周期管理	配置元信息	使用场景
Spring Beandifinition	是	是	有	依赖查找、依赖注入
单体对象	是	否	无	依赖查找、依赖注入
ResolvableDependency	否	否	无	依赖注入

Spring BeanDefinition 作为依赖来源

• 要素
  • 元数据 ： BeanDifinition
  • 注册 ： BeanDifinitionRegistry#registerBeanDifinition
  • 类型 ： 延迟和非延迟
  • 顺序 ： Bean 生命周期顺序按照注册顺序

---

DefaultListableBeanFactory 是 BeanDifinitionRegistry 的一个基本实现类

			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 {// Still in startup registration phasethis.beanDefinitionMap.put(beanName, beanDefinition);this.beanDefinitionNames.add(beanName);removeManualSingletonName(beanName);}this.frozenBeanDefinitionNames = null;

单例对象作为依赖来源

• 要素
  • 来源：外部普通 Java 对象（不一定 POJO）
  • 注册: SingletonBeanRegistry#registerSingleton
  • 可用于依赖查找和依赖注入
• 限制
  • 生命周期不由 Spring 上下文来管理
  • 无法实现延迟初始化 Bean

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

	@Overridepublic void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {Assert.notNull(beanName, "Bean name must not be null");Assert.notNull(singletonObject, "Singleton object must not be null");synchronized (this.singletonObjects) {Object oldObject = this.singletonObjects.get(beanName);if (oldObject != null) {throw new IllegalStateException("Could not register object [" + singletonObject +"] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");}addSingleton(beanName, singletonObject);}}protected void addSingleton(String beanName, Object singletonObject) {synchronized (this.singletonObjects) {this.singletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);}}

---

public class SingletonBeanRegistrationDemo {public static void main(String[] args) throws InterruptedException {AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();SingletonBeanRegistry singletonBeanRegistry = applicationContext.getBeanFactory();// 创建一个外部 UserFactory 对象UserFactory userFactory = new DefaultUserFactory();// 注册外部单例对象singletonBeanRegistry.registerSingleton("userFactory", userFactory);// 启动 Spring 应用上下文applicationContext.refresh();// 通过依赖查找的方式来获取 UserFactoryUserFactory userFactoryByLookup = applicationContext.getBean("userFactory", UserFactory.class);System.out.println("userFactory  == userFactoryByLookup : " + (userFactory == userFactoryByLookup));// 关闭 Spring 应用上下文applicationContext.close();}}

非 Spring 容器管理对象作为依赖来源

• 要素
  • 注册：ConfigurableListableBeanFactory#registerResolvableDependency
• 限制
  • 生命周期不由 Spring 上下文来管理
  • 无法实现延迟初始化 Bean
  • 无法通过依赖查找

默认实现：DefaultListableBeanFactory

	//---------------------------------------------------------------------// Implementation of ConfigurableListableBeanFactory interface//---------------------------------------------------------------------@Overridepublic void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue) {Assert.notNull(dependencyType, "Dependency type must not be null");if (autowiredValue != null) {if (!(autowiredValue instanceof ObjectFactory || dependencyType.isInstance(autowiredValue))) {throw new IllegalArgumentException("Value [" + autowiredValue +"] does not implement specified dependency type [" + dependencyType.getName() + "]");}this.resolvableDependencies.put(dependencyType, autowiredValue);}}

---

public class ResolvableDependencySourceDemo {@Autowiredprivate String value;@PostConstructpublic void init() {System.out.println(value);}public static void main(String[] args) {AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();applicationContext.register(ResolvableDependencySourceDemo.class);applicationContext.addBeanFactoryPostProcessor(beanFactory -> {// 注册 Resolvable DependencybeanFactory.registerResolvableDependency(String.class, "Hello,World");});applicationContext.refresh();applicationContext.close();}}

外部化配置作为依赖来源

总结