依赖查找的前生

单一类型依赖查找

JNDI- javax.naming.Context#lookup(javax.naming.Name);
JNDI- javax.naming.Context#lookup(String);

JavaBeans - java.beans.beancontext.BeanContext
BeanContext 继承了 Collection 接口，BeanContext 中的所有成员都是 bean

集合类型依赖查找

通过一个 key，找到对应的多个实例

java.beans.beancontext.BeanContextServices 的 Iterator getCurrentServiceSelectors(Class serviceClass);

层级性依赖查找

image.png

单一类型依赖查找

用到了 BeanFactory接口

根据 Bean 名称查找

getBean(String)
Spring 2.5 覆盖默认参数：getBean(String,Object…)

根据 Bean 类型查找

Bean 实时查找

Spring 3.0 getBean(Class)
Spring 4.1 覆盖默认参数：getBean(Class,Object…)

Spring 5.1 Bean 延时查找

getBeanProvider(Class)
getBeanProvider(ResolvableType)

相关代码：

  1. /**
  2.  * 通过 ObjectProvider 依赖查找
  3.  *
  4.  * @author mindartisan.blog.csdn.net
  5.  * @date
  6.  *
  7.  * @commet @Bean 定义的类在当前类，当前类默认就是配置类，不用写 「@Configuration」注解，
  8.  *
  9.  * @Configuration 非必需注解：https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/context/annotation/Bean.html
  10.  */
  11. public class ObjectProviderDemo {
  12.     public static void main(String[] args) {
  13.         // 创建 BeanFactory 容器
  14.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  15.         // 将当前类作为配置类
  16.         applicationContext.register(ObjectProviderDemo.class);
  17.         // 启动应用上下文
  18.         applicationContext.refresh();
  19.         lookupByObjectProvider(applicationContext);
  21.         applicationContext.close();
  22.     }
  24.     @Bean
  25.     // 此时的 Bean 名称就是方法名称
  26.     public String helloWorld() {
  27.         return "Hello,World";
  28.     }
  30.     private static void lookupByObjectProvider(AnnotationConfigApplicationContext applicationContext) {
  31.         ObjectProvider<String> objectProvider = applicationContext.getBeanProvider(String.class);
  32.         System.out.println(objectProvider.getObject());
  33.     }
  34. }

根据 Bean 名称+类型查找

getBean(String,Class)

集合类型依赖查找

用到了ListableBeanFactory 接口，推荐使用 bean 名称判断 bean 是否存在。

根据 Bean 类型查找

Bean 名称可以先定义，但是实例必须得初始化

获取同类型 Bean 名称列表

getBeanNamesForType(Class)
Spring 4.2 getBeanNameForType(ResolvableType)

获取同类型的 Bean 实例列表

getBeansOfType(Class) 及其重载方法

根据注解类型查找

Spring 3.0 获取标注类型 Bean 名称列表

getBeanNamesForAnnotation(Class<?extends Annotation>)

Spring 3.0 获取标注类型 Bean 实例列表

getBeansWithAnnotation(Class<?extends Annotation>)

Spring 3.0 获取指定名称+标注类型 Bean 实例

findAnnotationOnBean(String,Class<?extends Annotation>)

层次性依赖查找

用到了HierarchicalBeanFactory接口，方法为 getParentBeanFactory()

注意下图中 ConfigurableListBeanFactory 继承 ConfigurableBeanFactory 以及 ListableBeanFactory 接口。
image.png

根据 Bean 名称查找

基于 containsLocalBean()实现

根据 Bean 类型查找实例列表

单一类型：使用BeanFactoryUtils#beanOfTypeIncludingAncestors
集合类型：使用BeanFactoryUtils#beansOfTypelncludingAncestors

相关代码：
HierarchicalDependencyLookupDemo.class

  1. /**
  2.  * 层次性依赖查找示例
  3.  *
  4.  * @author mindartisan.blog.csdn.net
  5.  * @date
  6.  */
  7. public class HierarchicalDependencyLookupDemo {
  8.     public static void main(String[] args) {
  9.         // 创建 BeanFactory 容器
  10.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  11.         // 将当前类作为配置类，此处不用也行，因为当前类里没有 @Bean
  12.         applicationContext.register(HierarchicalDependencyLookupDemo.class);
  14.         // 1. 获取 HierarchicalBeanFactory <- ConfigurableBeanFactory <- ConfigurableListBeanFactory
  15.         ConfigurableListableBeanFactory beanFactory = applicationContext.getBeanFactory();
  16.         System.out.println("当前 BeanFactory 的 parent BeanFactory：" + beanFactory.getParentBeanFactory());
  18.         // 2. 设置 parent BeanFactory
  19.         ConfigurableListableBeanFactory parentBeanFactory = createParentBeanFactory();
  20.         beanFactory.setParentBeanFactory(parentBeanFactory);
  21.         System.out.println("当前 BeanFactory 的 parent BeanFactory：" + beanFactory.getParentBeanFactory());
  23.         System.out.println("------------------------");
  25.         displayContainsLocalBean(beanFactory,"user");
  26.         displayContainsLocalBean(parentBeanFactory,"user");
  28.         displayContainsBean(beanFactory,"user");
  29.         displayContainsBean(parentBeanFactory,"user");
  31.         // 启动应用上下文
  32.         applicationContext.refresh();
  34.         applicationContext.close();
  35.     }
  37.     private static void displayContainsBean(HierarchicalBeanFactory beanFactory,String beanName) {
  38.         System.out.printf("当前 BeanFactory[%s] 是否包含 Bean[name： %s] : %s\n", beanFactory, beanName,
  39.                 containsBean(beanFactory, beanName));
  40.     }
  42.     private static boolean containsBean(HierarchicalBeanFactory beanFactory,String beanName) {
  43.         BeanFactory parentBeanFactory = beanFactory.getParentBeanFactory();
  44.         if (parentBeanFactory instanceof HierarchicalBeanFactory) {
  45.             HierarchicalBeanFactory hierarchicalBeanFactory = HierarchicalBeanFactory.class.cast(parentBeanFactory);
  46.             if (containsBean(hierarchicalBeanFactory, beanName)) {
  47.                 return true;
  48.             }
  49.         }
  51.         return beanFactory.containsLocalBean(beanName);
  52.     }
  54.     private static void displayContainsLocalBean(HierarchicalBeanFactory beanFactory, String beanName) {
  55.         System.out.printf("当前 BeanFactory[%s] 是否包含 LocalBean[name： %s] : %s\n", beanFactory, beanName,
  56.                 beanFactory.containsLocalBean(beanName));
  57.     }
  59.     private static ConfigurableListableBeanFactory createParentBeanFactory() {
  60.         // 创建 BeanFactory 容器
  61.         DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();
  63.         XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(defaultListableBeanFactory);
  64.         String location = "classpath:/META-INF/dependency-lookup-context.xml";
  65.         // 加载配置
  66.         reader.loadBeanDefinitions(location);
  67.         return defaultListableBeanFactory;
  68.     }
  69. }

注意 pom.xml 的依赖要「 复用 ioc-container-overview 」

根据 Java 注解查找名称列表

使用 BeanFactoryUtils#beanNamesForTypeIncludingAncestors

延迟依赖查找

通过 org.springframework.beans.factory.ObjectFactory接口以及org.springframework.beans.factory.ObjectProvider接口实现，后者继承了前者，可以调用前者的getObject()获取当前关联的 bean。
image.png
其中使用到了 Java 8 的新特性：

  1. 函数式接口
  2. Stream

相关代码：
ObjectProviderDemo.class

  1. /**
  2.  * 通过 ObjectProvider 依赖查找
  3.  *
  4.  * @author mindartisan.blog.csdn.net
  5.  * @date
  6.  *
  7.  * @commet @Bean 定义的类在当前类，当前类默认就是配置类，不用写 「@Configuration」注解，
  8.  *
  9.  * @Configuration 非必需注解：https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/context/annotation/Bean.html
  10.  */
  11. public class ObjectProviderDemo {
  12.     public static void main(String[] args) {
  13.         // 创建 BeanFactory 容器
  14.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  15.         // 将当前类作为配置类
  16.         applicationContext.register(ObjectProviderDemo.class);
  17.         // 启动应用上下文
  18.         applicationContext.refresh();
  19.         lookupByObjectProvider(applicationContext);
  20.         lookupIfAvaiable(applicationContext);
  21.         lookupByStreamOps(applicationContext);
  23.         applicationContext.close();
  24.     }
  26.     private static void lookupByStreamOps(AnnotationConfigApplicationContext applicationContext) {
  27.         ObjectProvider<String> objectProvider = applicationContext.getBeanProvider(String.class);
  28.         // Iterable<String> stringIterable = objectProvider;
  29.         // for (String string : stringIterable) {
  30.         //     System.out.println(string);
  31.         // }
  32.         objectProvider.stream().forEach(System.out::println);
  34.     }
  36.     private static void lookupIfAvaiable(AnnotationConfigApplicationContext applicationContext) {
  37.         ObjectProvider<User> userObjectProvider = applicationContext.getBeanProvider(User.class);
  38.         // 这里演示的是如果 User 不存在的话，进行兜底：
  39.         // 此时「getIfAvailable(User::createUser)」会创建一个新的 User，如果是 getIfAvailable()，则会输出 null
  40.         User user = userObjectProvider.getIfAvailable(User::createUser);
  41.         System.out.println("当前 User 对象：" + user);
  42.     }
  44.     private static void lookupByObjectProvider(AnnotationConfigApplicationContext applicationContext) {
  45.         ObjectProvider<String> objectProvider = applicationContext.getBeanProvider(String.class);
  46.         System.out.println(objectProvider.getObject());
  47.     }
  49.     @Bean
  50.     @Primary
  51.     // 此时的 Bean 名称就是方法名称
  52.     public String helloWorld() {
  53.         return "Hello,World";
  54.     }
  56.     @Bean
  57.     public String message() {
  58.         return "Message";
  59.     }
  61. }

安全依赖查找

此处的安全是指是否抛出异常

单一类型查找

BeanFactory#getBean -> 不安全
ObjectFactory#getObject -> 不安全
ObjectProvider#getIfAvailable -> 安全

集合类型查找

ListableBeanFactory#getBeansOfType -> 安全
ObjectProvider#stream -> 安全

层级类型依赖

依赖于其扩展的单一或者集合类型的接口。

相关代码

TypeSafetyDependencyLookupDemo.class：

  1. **
  2.  * 类型安全依赖查找示例
  3.  *
  4.  * @author mindartisan.blog.csdn.net
  5.  * @date
  6.  */
  7. public class TypeSafetyDependencyLookupDemo {
  8.     public static void main(String[] args) {
  9.         // 创建 BeanFactory 容器
  10.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  11.         // 将当前类作为配置类
  12.         applicationContext.register(TypeSafetyDependencyLookupDemo.class);
  13.         // 启动应用上下文
  14.         applicationContext.refresh();
  16.         // 演示 beanFactory#getBean 安全性
  17.         displayBeanFactoryGetBean(applicationContext);
  18.         // 演示 ObjectFactory#getObject 安全性
  19.         displayObjectFactoryGetBean(applicationContext);
  20.         // 演示 ObjectProvider#getIfAvaiable 方法的安全性
  21.         displayObjectProviderIfAvailable(applicationContext);
  23.         // 演示 ListableBeanFactory#getBeansOfType 方法的安全性
  24.         displayListableBeanFactoryGetBeansOfType(applicationContext);
  25.         // 演示 ObjectProvider Stream 操作的安全性
  26.         displayObjectProviderStreamOps(applicationContext);
  28.         // 关闭应用上下文
  29.         applicationContext.close();
  30.     }
  32.     /**
  33.      * 演示 ObjectProvider Stream 操作的安全性
  34.      *
  35.      * @param beanFactory bean工厂
  36.      */
  37.     private static void displayObjectProviderStreamOps(BeanFactory beanFactory) {
  38.         // 不抛异常
  39.         ObjectProvider<User> userObjectProvider = beanFactory.getBeanProvider(User.class);
  40.         printBeansException("displayObjectProviderStreamOps", () -> userObjectProvider.forEach(System.out::println));
  41.     }
  43.     /**
  44.      * 演示 ListableBeanFactory#getBeansOfType 方法的安全性
  45.      *
  46.      * @param beanFactory bean工厂
  47.      */
  48.     private static void displayListableBeanFactoryGetBeansOfType(ListableBeanFactory beanFactory) {
  49.         // 不抛异常
  50.         printBeansException("displayListableBeanFactoryGetBeansOfType", () -> beanFactory.getBeansOfType(User.class));
  51.     }
  53.     /**
  54.      * 演示 ObjectProvider#getIfAvaiable 方法的安全性
  55.      *
  56.      * @param beanFactory bean工厂
  57.      */
  58.     private static void displayObjectProviderIfAvailable(BeanFactory beanFactory) {
  59.         // 不抛异常
  60.         ObjectProvider<User> userObjectProvider = beanFactory.getBeanProvider(User.class);
  61.         printBeansException("displayObjectProviderIfAvailable", () -> userObjectProvider.getIfAvailable());
  62.     }
  64.     /**
  65.      * 演示 ObjectFactory#getObject 安全性
  66.      *
  67.      * @param beanFactory bean工厂
  68.      */
  69.     private static void displayObjectFactoryGetBean(BeanFactory beanFactory) {
  70.         // 抛出「org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com
  71.         // .mindartisan.spring.geek.ioc.overview.domain.User' 」异常
  72.         ObjectProvider<User> userObjectProvider = beanFactory.getBeanProvider(User.class);
  73.         printBeansException("displayObjectFactoryGetBean", userObjectProvider::getObject);
  74.     }
  76.     /**
  77.      * 演示 beanFactory#getBean 安全性
  78.      *
  79.      * @param beanFactory bean工厂
  80.      */
  81.     public static void displayBeanFactoryGetBean(BeanFactory beanFactory) {
  82.         // 此时并无 User 对应的 bean，抛出「org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.mindartisan.spring.geek.ioc.overview.domain.User' available」异常
  83.         printBeansException("displayBeanFactoryGetBean", () -> beanFactory.getBean(User.class));
  84.     }
  86.     public static void printBeansException(String source, Runnable runnable) {
  87.         System.err.println("==========================================");
  88.         System.err.println("Source from :" + source);
  89.         try {
  90.             runnable.run();
  91.         } catch (BeansException exception) {
  92.             exception.printStackTrace();
  93.         }
  94.     }
  95. }

内建可查找的依赖

基本上所有的上下文的实现都是基于AbstractApplicationContext此抽象类实现，会在上下文启动的过程中会初始化一些内部的依赖，称为内建的可查询依赖。

AbstractApplicationContext 内建可查找的依赖

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 对象 事件广播

注解驱动 Spring 应用上下文内建可查找的依赖

AnnotationConfigUtils 里的常量

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 注解场景

依赖查找中的经典异常

异常类型 触发条件 场景举例
NoSuchBeanDefinitionException 当查找 Bean 不存在于 IoC 容器时 BeanFactory#getBean
ObjectFactory#getObject
NoUniqueBeanDefinitionException 类型依赖查找时，IoC 容器存在多
个 Bean 实例		 BeanFactory#getBean(Clas
s
BeanInstantiationException 当 Bean 所对应的类型非具体类时 BeanFactory#getBean
BeanCreationException 当 Bean 初始化过程中 Bean 初始化方法执行异常
时
BeanDefinitionStoreException 当 BeanDefinition 配置元信息非
法时		 XML 配置资源无法打开时

相关代码：
NoUniqueBeanDefinitionExceptionDemo.class

  1. /**
  2.  * 没有具体的 bean 定义异常示例
  3.  *
  4.  * @author mindartisan.blog.csdn.net
  5.  * @date
  6.  */
  7. public class NoUniqueBeanDefinitionExceptionDemo {
  8.     public static void main(String[] args) {
  9.         // 创建 BeanFactory 容器
  10.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  11.         // 将当前类作为配置类
  12.         applicationContext.register(NoUniqueBeanDefinitionExceptionDemo.class);
  13.         // 启动应用上下文
  14.         applicationContext.refresh();
  15.         try {
  16.             applicationContext.getBean(String.class);
  17.         } catch (NoUniqueBeanDefinitionException e) {
  18.             System.err.printf("Spring 应用上下文当前存在 %d 个 %s 类型的 Bean，具体原因：%s",
  19.                     e.getNumberOfBeansFound(),
  20.                     String.class.getName(),
  21.                     e.getMessage());
  22.         }
  24.         // 关闭应用上下文
  25.         applicationContext.close();
  26.     }
  28.     @Bean
  29.     public String bean1() {
  30.         return "bean1";
  31.     }
  33.     @Bean
  34.     public String bean2() {
  35.         return "bean2";
  36.     }
  38. }

BeanInstantiationException.class

  1. /**
  2.  * bean 实例化异常示例
  3.  *
  4.  * @author mindartisan.blog.csdn.net
  5.  * @date
  6.  */
  7. public class BeanInstantiationExceptionDemo {
  8.     public static void main(String[] args) {
  9.         // 创建 BeanFactory 容器
  10.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  12.         BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(Character.class);
  14.         // 下面的不会有异常
  15.         // BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(String.class);
  16.         applicationContext.registerBeanDefinition("errorBean",beanDefinitionBuilder.getBeanDefinition());
  17.         // 启动应用上下文
  18.         applicationContext.refresh();
  20.         // 关闭应用上下文
  21.         applicationContext.close();
  22.     }
  23. }

BeanCreationExceptionDemo.class

  1. **
  2.  * bean 创建异常示例
  3.  *
  4.  * @author mindartisan.blog.csdn.net
  5.  * @date
  6.  */
  7. public class BeanCreationExceptionDemo {
  8.     public static void main(String[] args) {
  9.         // 创建 BeanFactory 容器
  10.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  12.         // 注册 BeanDefinition Bean Class 是一个 POJO 普通类，不过初始化方法回调时抛出异常
  13.         BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(POJO.class);
  14.         applicationContext.registerBeanDefinition("errorBean", beanDefinitionBuilder.getBeanDefinition());
  16.         // 启动应用上下文
  17.         applicationContext.refresh();
  19.         // 关闭应用上下文
  20.         applicationContext.close();
  21.     }
  23.     static class POJO implements InitializingBean {
  25.         @PostConstruct // CommonAnnotationBeanPostProcessor
  26.         public void init() throws Throwable {
  27.             throw new Throwable("init() : For purposes...");
  28.         }
  30.         @Override
  31.         public void afterPropertiesSet() throws Exception {
  32.             throw new Exception("afterPropertiesSet() : For purposes...");
  33.         }
  34.     }
  35. }