依赖查找的来源

查找来源

Bean 名称 配置元数据 备注
Spring BeanDefinition
Spring BeanDefinition @Bean public User user(){}
单例对象 API 实现

Spring 內建 BeanDefintion

Bean 名称 Bean 实例 使用场景
org.springframework.context.
annotation.internalConfigur
ationAnnotationProcessor		 ConfigurationClassPostProcessor 对象 用来处理 Spring 配置类
org.springframework.context.
annotation.internalAutowire
dAnnotationProcessor		 AutowiredAnnotationBeanPostProcessor 对象 处理 @Autowired 以及 @Value
注解（构造器代码里 add 了上述两个注解）
org.springframework.context.
annotation.internalCommonAn
notationProcessor		 CommonAnnotationBeanPostProcessor 对象 （条件激活）处理 JSR-250 注解，
如 @PostConstruct 等
org.springframework.context.
event.internalEventListener
Processor		 EventListenerMethodProcessor 对象 处理标注 @EventListener 的
Spring 事件监听方法（直接标注在方法上就行，无需实现 ApplicationListener 接口）
org.springframework.context.
event.internalEventListener
Factory		 DefaultEventListenerFactory 对
象		 @EventListener 事件监听方法适
配为 ApplicationListener
org.springframework.context.
annotation.internalPersiste
nceAnnotationProcessor		 PersistenceAnnotationBeanPostProcessor 对象 （条件激活）处理 JPA 注解场景

相关代码

先在 xml 文件中配置以下内容（当前来说不用弄，直接跟源码就行）

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:context="http://www.springframework.org/schema/context"
  4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd
  7.        http://www.springframework.org/schema/context
  8.        http://www.springframework.org/schema/beans/spring-context.xsd">
  10.     <context:annotation-config/>
  11.     <context:component-scan base-package="mindartisan.blog.csdn.net.XXX"/>
  13.     <bean id="user" class="com.mindartisan.spring.geek.ioc.overview.domain.User" autowire="byName">
  14.         <property name="id" value="1"/>
  15.         <property name="name" value="Steve"/>
  16.     </bean>
  18.     <bean id="superUser" class="com.mindartisan.spring.geek.ioc.overview.domain.SuperUser" parent="user"
  19.           primary="true">
  20.         <property name="address" value="北京"/>
  21.     </bean>
  22.     <!-- 延迟查找使用 -->
  23.     <bean id="objectFactoryCreatingFactoryBean"
  24.           class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
  25.         <property name="targetBeanName" value="user"/>
  26.     </bean>
  27. </beans>

再来看 AnnotationConfigUtils.class

  1. public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
  2.             BeanDefinitionRegistry registry, @Nullable Object source) {
  4.         DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
  5.         if (beanFactory != null) {
  6.             if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
  7.                 beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
  8.             }
  9.             if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
  10.                 beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
  11.             }
  12.         }
  14.         Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
  16.         if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  17.             RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
  18.             def.setSource(source);
  19.             beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
  20.         }
  22.         if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  23.             RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
  24.             def.setSource(source);
  25.             beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
  26.         }
  28.         // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
  29.         if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  30.             RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
  31.             def.setSource(source);
  32.             beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
  33.         }
  35.         // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
  36.         if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  37.             RootBeanDefinition def = new RootBeanDefinition();
  38.             try {
  39.                 def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
  40.                         AnnotationConfigUtils.class.getClassLoader()));
  41.             }
  42.             catch (ClassNotFoundException ex) {
  43.                 throw new IllegalStateException(
  44.                         "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
  45.             }
  46.             def.setSource(source);
  47.             beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
  48.         }
  50.         if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
  51.             RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
  52.             def.setSource(source);
  53.             beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
  54.         }
  56.         if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
  57.             RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
  58.             def.setSource(source);
  59.             beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
  60.         }
  62.         return beanDefs;
  63.     }

这些会处理上述说的内容

Spring 内建单例对象

Bean 名称 Bean 实例 使用场景
environment Environment 对象 外部化配置：Java 系统的属性，比如 -D 参数
Profiles：比如 dev、test
systemProperties java.util.Properties 对象 Java 系统属性、系统路径或目录
systemEnvironment java.util.Map 对象 操作系统的环境变量（主要指当前用户环境变量）
messageSource MessageSource 对象 国际化文案
lifecycleProcessor LifecycleProcessor 对象 Lifecycle Bean 处理器（Bean 生命周期）
applicationEventMulticaster ApplicationEventMulticaster 对象 事件广播

相关代码

AbstractApplicationContext.class

  1.     protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  2.         // 无关代码
  4.         // Register default environment beans.
  5.         if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
  6.             beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
  7.         }
  8.         if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
  9.             beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
  10.         }
  11.         if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
  12.             beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
  13.         }
  14.     }
  16. /**
  17.      * Initialize the ApplicationEventMulticaster.
  18.      * Uses SimpleApplicationEventMulticaster if none defined in the context.
  19.      * @see org.springframework.context.event.SimpleApplicationEventMulticaster
  20.      */
  21.     protected void initApplicationEventMulticaster() {
  22.         ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  23.         if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
  24.             this.applicationEventMulticaster =
  25.                     beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
  26.             if (logger.isTraceEnabled()) {
  27.                 logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
  28.             }
  29.         }
  30.         else {
  31.             this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
  32.             beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
  33.             if (logger.isTraceEnabled()) {
  34.                 logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
  35.                         "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
  36.             }
  37.         }
  38.     }
  40.     /**
  41.      * Initialize the LifecycleProcessor.
  42.      * Uses DefaultLifecycleProcessor if none defined in the context.
  43.      * @see org.springframework.context.support.DefaultLifecycleProcessor
  44.      */
  45.     protected void initLifecycleProcessor() {
  46.         ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  47.         if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
  48.             this.lifecycleProcessor =
  49.                     beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
  50.             if (logger.isTraceEnabled()) {
  51.                 logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
  52.             }
  53.         }
  54.         else {
  55.             DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
  56.             defaultProcessor.setBeanFactory(beanFactory);
  57.             this.lifecycleProcessor = defaultProcessor;
  58.             beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
  59.             if (logger.isTraceEnabled()) {
  60.                 logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
  61.                         "[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
  62.             }
  63.         }
  64.     }
  67.     /**
  68.      * Initialize the MessageSource.
  69.      * Use parent's if none defined in this context.
  70.      */
  71.     protected void initMessageSource() {
  72.         ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  73.         if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
  74.             this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
  75.             // Make MessageSource aware of parent MessageSource.
  76.             if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
  77.                 HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
  78.                 if (hms.getParentMessageSource() == null) {
  79.                     // Only set parent context as parent MessageSource if no parent MessageSource
  80.                     // registered already.
  81.                     hms.setParentMessageSource(getInternalParentMessageSource());
  82.                 }
  83.             }
  84.             if (logger.isTraceEnabled()) {
  85.                 logger.trace("Using MessageSource [" + this.messageSource + "]");
  86.             }
  87.         }
  88.         else {
  89.             // Use empty MessageSource to be able to accept getMessage calls.
  90.             DelegatingMessageSource dms = new DelegatingMessageSource();
  91.             dms.setParentMessageSource(getInternalParentMessageSource());
  92.             this.messageSource = dms;
  93.             beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
  94.             if (logger.isTraceEnabled()) {
  95.                 logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
  96.             }
  97.         }
  98.     }

依赖注入的来源

注入来源

Bean 名称 配置元数据 备注
Spring BeanDefinition
Spring BeanDefinition @Bean public User user(){}
Spring BeanDefinition BeanDefinitionBuilder
单例对象 API 实现
非 Spring 容器管理对象（非推广对象；游离对象） ResolvaleDependency
外部化配置 @Value 注解读取配置文件

代码示例

  1. /**
  2.  * 依赖来源示例
  3.  *
  4.  * @author mindartisan.blog.csdn.net
  5.  * @date
  6.  */
  7. public class DependencySourceDemo {
  9.     // 注入在 postProcessProperties 方法执行，早于 setter 注入，也早于 @PostConstrut
  11.     @Autowired
  12.     private BeanFactory beanFactory;
  14.     @Autowired
  15.     private ResourceLoader resourceLoader;
  17.     @Autowired
  18.     private ApplicationContext applicationContext;
  20.     @Autowired
  21.     private ApplicationEventPublisher applicationEventPublisher;
  23.     @PostConstruct
  24.     public void initByInjection() {
  26.         System.out.println("beanFactory == applicationContext -> " + (beanFactory == applicationContext));
  27.         System.out.println("beanFactory == applicationContext.getBeanFactory -> " + (beanFactory == applicationContext.getAutowireCapableBeanFactory()));
  28.         System.out.println("resourceLoader == applicationContext -> " + (resourceLoader == applicationContext));
  29.         System.out.println("applicationEventPublisher == applicationContext -> " + (applicationEventPublisher == applicationContext));
  31.     }
  33.     @PostConstruct
  34.     public void initByLookUp() {
  35.         getBean(BeanFactory.class);
  36.         getBean(ApplicationContext.class);
  37.         getBean(ResourceLoader.class);
  38.         getBean(ApplicationEventPublisher.class);
  40.     }
  43.     public <T> T getBean(Class<T> beanType) {
  44.         try {
  45.            return beanFactory.getBean(beanType);
  46.         } catch (NoSuchBeanDefinitionException e) {
  47.             System.err.println("当前类型：" + beanType.getName() +" 无法在 BeanFactory 中查找！");
  48.         }
  49.         return null;
  50.     }
  53.     public static void main(String[] args) {
  54.         // 创建 BeanFactory 容器
  55.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  56.         // 注册 配置类（配置类也是 Spring 的 Bean）
  57.         applicationContext.register(DependencySourceDemo.class);
  60.         // 启动 Spring 应用上下文
  61.         applicationContext.refresh();
  63.         // 依赖查找 AnnotationDependencyFieldInjectionDemo bean
  64.         DependencySourceDemo demoBean = applicationContext.getBean(DependencySourceDemo.class);
  67.         // 关闭 Spring 应用上下文
  68.         applicationContext.close();
  69.     }
  70. }

此 demo 的含义是为了证明 resolvableDependencies中的 bean 不是依赖查找中的来源，而是依赖注入中的来源。

源码分析

AbstractApplicationContext#refresh() -> AbstractApplicationContext#prepareBeanFactory()

  1. protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {      
  2.     // 无关代码
  4.     // BeanFactory interface not registered as resolvable type in a plain factory.
  5.     // MessageSource registered (and found for autowiring) as a bean.
  6.     beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
  7.     beanFactory.registerResolvableDependency(ResourceLoader.class, this);
  8.     beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
  9.     beanFactory.registerResolvableDependency(ApplicationContext.class, this);
  10. }

DefaultListableBeanFactory#registerResolvableDependency()

  1.     @Override
  2.     public void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue) {
  3.         Assert.notNull(dependencyType, "Dependency type must not be null");
  4.         if (autowiredValue != null) {
  5.             if (!(autowiredValue instanceof ObjectFactory || dependencyType.isInstance(autowiredValue))) {
  6.                 throw new IllegalArgumentException("Value [" + autowiredValue +
  7.                         "] does not implement specified dependency type [" + dependencyType.getName() + "]");
  8.             }
  9.             this.resolvableDependencies.put(dependencyType, autowiredValue);
  10.         }
  11.     }

DefaultListableBeanFactory#resolveDependency() -> DefaultListableBeanFactory#doResolveDependency() -> DefaultListableBeanFactory#findAutowireCandidates()：

  1. protected Map<String, Object> findAutowireCandidates(
  2.             @Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
  4.         String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
  5.                 this, requiredType, true, descriptor.isEager());
  6.         Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
  8.         // 重点是这玩意：this.resolvableDependencies.entrySet()
  10.         // 断点位置下一行
  11.         for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
  12.             Class<?> autowiringType = classObjectEntry.getKey();
  13.             if (autowiringType.isAssignableFrom(requiredType)) {
  14.                 Object autowiringValue = classObjectEntry.getValue();
  15.                 autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
  16.                 if (requiredType.isInstance(autowiringValue)) {
  17.                     result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
  18.                     break;
  19.                 }
  20.             }
  21.         }

image.png

Spring容器管理和游离对象

来源 Spring Bean 对象 生命周期管理 配置元信息 使用场景 备注
Spring BeanDefinition √ √ 有 查找、注入
Spring 内建单例对象 √ × 无 查找、注入
Resolvable Dependency × × 无 注入

Spring BeanDefinition 作为依赖来源

通过 BeanDefinitionRegistry#registerBeanDefinition 传递 BeanDefinition 

  1. /**
  2.  * Register a new bean definition with this registry.
  3.  * Must support RootBeanDefinition and ChildBeanDefinition.
  4.  * @param beanName the name of the bean instance to register
  5.  * @param beanDefinition definition of the bean instance to register
  6.  * @throws BeanDefinitionStoreException if the BeanDefinition is invalid
  7.  * @throws BeanDefinitionOverrideException if there is already a BeanDefinition
  8.  * for the specified bean name and we are not allowed to override it
  9.  * @see GenericBeanDefinition
  10.  * @see RootBeanDefinition
  11.  * @see ChildBeanDefinition
  12.  */
  13. void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
  14.         throws BeanDefinitionStoreException;

源码分析

DefaultListableBeanFactory#registerBeanDefinition(String beanName, BeanDefinition beanDefinition)

  1.     @Override
  2.     public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
  3.             throws BeanDefinitionStoreException {
  5.         Assert.hasText(beanName, "Bean name must not be empty");
  6.         Assert.notNull(beanDefinition, "BeanDefinition must not be null");
  8.         if (beanDefinition instanceof AbstractBeanDefinition) {
  9.             try {
  10.                 // validate() 方法在 BeanDefinitionBuilder 中也使用了
  11.                 ((AbstractBeanDefinition) beanDefinition).validate();
  12.             }
  13.             catch (BeanDefinitionValidationException ex) {
  14.                 throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
  15.                         "Validation of bean definition failed", ex);
  16.             }
  17.         }
  18.         // map 由来：private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
  19.         BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
  20.         if (existingDefinition != null) {
  21.             if (!isAllowBeanDefinitionOverriding()) {
  22.                 throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
  23.             }
  24.             else if (existingDefinition.getRole() < beanDefinition.getRole()) {
  25.                 // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
  26.                 if (logger.isInfoEnabled()) {
  27.                     logger.info("Overriding user-defined bean definition for bean '" + beanName +
  28.                             "' with a framework-generated bean definition: replacing [" +
  29.                             existingDefinition + "] with [" + beanDefinition + "]");
  30.                 }
  31.             }
  32.             else if (!beanDefinition.equals(existingDefinition)) {
  33.                 if (logger.isDebugEnabled()) {
  34.                     logger.debug("Overriding bean definition for bean '" + beanName +
  35.                             "' with a different definition: replacing [" + existingDefinition +
  36.                             "] with [" + beanDefinition + "]");
  37.                 }
  38.             }
  39.             else {
  40.                 if (logger.isTraceEnabled()) {
  41.                     logger.trace("Overriding bean definition for bean '" + beanName +
  42.                             "' with an equivalent definition: replacing [" + existingDefinition +
  43.                             "] with [" + beanDefinition + "]");
  44.                 }
  45.             }
  46.             this.beanDefinitionMap.put(beanName, beanDefinition);
  47.         }
  48.         else {
  49.             if (hasBeanCreationStarted()) {
  50.                 // Cannot modify startup-time collection elements anymore (for stable iteration)
  51.                 synchronized (this.beanDefinitionMap) {
  52.                     this.beanDefinitionMap.put(beanName, beanDefinition);
  53.                     List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
  54.                     updatedDefinitions.addAll(this.beanDefinitionNames);
  55.                     updatedDefinitions.add(beanName);
  56.                     this.beanDefinitionNames = updatedDefinitions;
  57.                     removeManualSingletonName(beanName);
  58.                 }
  59.             }
  60.             else {
  61.                 // Still in startup registration phase
  62.                 this.beanDefinitionMap.put(beanName, beanDefinition);
  63.                 // beanDefinitionNames 由来：
  64.                 /** List of bean definition names, in registration order. */
  65.                 // private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
  66.                 // beanDefinitionNames 作用：保证注册的顺序
  67.                 this.beanDefinitionNames.add(beanName);
  68.                 removeManualSingletonName(beanName);
  69.             }
  70.             this.frozenBeanDefinitionNames = null;
  71.         }
  73.         if (existingDefinition != null || containsSingleton(beanName)) {
  74.             resetBeanDefinition(beanName);
  75.         }
  76.     }

注意：依赖注入阶段的延迟注入是用代理的方式；依赖查找是 bean 已经 ready 了，延迟非延迟没啥大区别

单例对象作为依赖来源

来源：外部的普通 Java 对象
注册方式：SingletonBeanRegistry#registerSingletion
限制：无生命周期管理以及无法延迟初始化 Bean（因为单体对象是外部已初始化对象，所以不存在 Lazy 的问题，Lazy 针对于 BeanDefinition，而非具体对象。）

源码分析

SingletonBeanRegistry#registerSingleton(String beanName, Object singletonObject) 由 DefaultSingletonBeanRegistry#registerSingleton(String beanName, Object singletonObject) 实现

  1.     /** Cache of singleton objects: bean name to bean instance. */
  2.     private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  4.     /** Cache of singleton factories: bean name to ObjectFactory. */
  5.     private final Map<String, r<?>> singletonFactories = new HashMap<>(16);
  7.     /** Cache of early singleton objects: bean name to bean instance. */
  8.     private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
  10.     /** Set of registered singletons, containing the bean names in registration order. */
  11.     private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
  13.     @Override
  14.     public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
  15.         Assert.notNull(beanName, "Bean name must not be null");
  16.         Assert.notNull(singletonObject, "Singleton object must not be null");
  17.         // 此处加锁是因为是一个二元操作：get、add
  18.         synchronized (this.singletonObjects) {
  19.             Object oldObject = this.singletonObjects.get(beanName);
  20.             if (oldObject != null) {
  21.                 throw new IllegalStateException("Could not register object [" + singletonObject +
  22.                         "] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
  23.             }
  24.             addSingleton(beanName, singletonObject);
  25.         }
  26.     }
  28.     /**
  29.      * Add the given singleton object to the singleton cache of this factory.
  30.      * <p>To be called for eager registration of singletons.
  31.      * @param beanName the name of the bean
  32.      * @param singletonObject the singleton object
  33.      */
  34.     protected void addSingleton(String beanName, Object singletonObject) {
  35.         // 此处加锁的原因是可能会被单独调用
  36.         synchronized (this.singletonObjects) {
  37.             this.singletonObjects.put(beanName, singletonObject);
  38.             this.singletonFactories.remove(beanName);
  39.             this.earlySingletonObjects.remove(beanName);
  40.             this.registeredSingletons.add(beanName);
  41.         }
  42.     }

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

限制：无生命周期管理、无法实现延迟初始化 bean、无法依赖查找（只能依赖注入）

源码分析

  1. /**
  2.  * Resolvable Dependency 示例
  3.  *
  4.  * @author mindartisan.blog.csdn.net
  5.  * @date
  6.  */
  7. public class ResolvableDependencySourceDemo {
  9.     @Autowired
  10.     private String value;
  12.     @PostConstruct
  13.     public void init() {
  14.         System.out.println(value);
  15.     }
  18.     public static void main(String[] args) {
  19.         // 创建 BeanFactory 容器
  20.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  21.         // 注册 配置类（配置类也是 Spring 的 Bean）
  22.         applicationContext.register(ResolvableDependencySourceDemo.class);
  24.         // 下行代码执行晚于 refresh 方法，可以 debug 发现
  25.         // invokeBeanFactoryPostProcessors() 方法早于 bean 初始化「finishBeanFactoryInitialization()」之前
  26.         applicationContext.addBeanFactoryPostProcessor(beanFactory -> beanFactory.registerResolvableDependency(String.class, "Hello,World"));
  28.         // 启动 Spring 应用上下文
  29.         applicationContext.refresh();
  31.         // AutowireCapableBeanFactory autowireCapableBeanFactory = applicationContext.getAutowireCapableBeanFactory();
  32.         // if ((autowireCapableBeanFactory instanceof ConfigurableListableBeanFactory)) {
  33.         //     ConfigurableListableBeanFactory configurableListableBeanFactory = ConfigurableListableBeanFactory.class.cast(autowireCapableBeanFactory);
  34.         //     configurableListableBeanFactory.registerResolvableDependency(String.class, "Hello,World");
  35.         // }
  37.         // 关闭 Spring 应用上下文
  38.         applicationContext.close();
  39.     }
  40. }

总结：

注册非 Spring 管理的依赖对象时,可以通过两种方式实现：

  1. 通过 ApplicationContext.getBeanFactory() 获取 AnnotationConfigApplicationContext 创建时初始化的 DefaultListableBeanFactory 对象，然后调用 registryResolveableDependency 来注册，为啥不能通过 getAutowireCapableBeanFactory() 来获取beanFactory对象，因为方法中需要 beanFactory 已被激活即执行了 ApplicationContext的refresh() 操作之后
  2. 通过 addBeanFactoryPostProcessor 回调方式实现,因为当 refresh() 方法执行 invokeBeanFactoryPostProcessors() 时会遍历已创建的 beanFactoryPostProcessors 集合对象来执行 postProcessBeanFactory() 方法

外部化配置作为依赖来源

用到了 @Value注解，处理类似 @Autowired处理流程

相关代码：
ExternalConfigurationDependencySourceDemo.class

  1. /**
  2.  * 外部化配置作为依赖来源 示例
  3.  *
  4.  * @author mindartisan.blog.csdn.net
  5.  * @date
  6.  */
  7. @Configuration
  8. @PropertySource(value = "META-INF/default.properties",encoding="UTF-8")
  9. public class ExternalConfigurationDependencySourceDemo {
  11.     @Value("${user.id:-1}")
  12.     private Long id;
  14.     @Value("${usr.name}")
  15.     private String name;
  17.     @Value("${user.resource:classpath://default.properties}")
  18.     private Resource resource;
  20.     public static void main(String[] args) {
  22.         // 创建 BeanFactory 容器
  23.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  24.         // 注册 Configuration Class（配置类） -> Spring Bean
  25.         applicationContext.register(ExternalConfigurationDependencySourceDemo.class);
  27.         // 启动 Spring 应用上下文
  28.         applicationContext.refresh();
  30.         // 依赖查找 ExternalConfigurationDependencySourceDemo Bean
  31.         ExternalConfigurationDependencySourceDemo demo = applicationContext.getBean(ExternalConfigurationDependencySourceDemo.class);
  33.         System.out.println("demo.id = " + demo.id);
  34.         System.out.println("demo.name = " + demo.name);
  35.         System.out.println("demo.resource = " + demo.resource);
  37.         // 显示地关闭 Spring 应用上下文
  38.         applicationContext.close();
  39.     }
  40. }

default.properties

  1. user.id = 1
  2. usr.name = mindartisan.blog.csdn.net
  3. user.resource = classpath://META-INF/default.properties

源码分析

DefaultListableBeanFactory#doResolveDependency()

  1.     @Nullable
  2.     public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
  3.             @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
  4.             // 无关代码
  6.             Class<?> type = descriptor.getDependencyType();
  7.             // 在下行代码处理注入的值
  8.             Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
  9.             if (value != null) {
  10.                 if (value instanceof String) {
  11.                     String strVal = resolveEmbeddedValue((String) value);
  12.                     BeanDefinition bd = (beanName != null && containsBean(beanName) ?
  13.                             getMergedBeanDefinition(beanName) : null);
  14.                     value = evaluateBeanDefinitionString(strVal, bd);
  15.                 }
  16.                 TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
  17.                 try {
  18.                     return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
  19.                 }
  20.                 catch (UnsupportedOperationException ex) {
  21.                     // A custom TypeConverter which does not support TypeDescriptor resolution...
  22.                     return (descriptor.getField() != null ?
  23.                             converter.convertIfNecessary(value, type, descriptor.getField()) :
  24.                             converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
  25.                 }
  26.             }
  28.         // 无关代码
  29.     }