前言
上一篇文章已经学习了【依赖注入】相关的知识，这里详细的介绍一下【依赖来源】。
依赖来源
我们把依赖来源分为依赖查找的来源和依赖注入的来源分别讨论。
依赖查找的来源
1. Spring BeanDefinition
这里的Spring BeanDefinition又可以细分为：
- 1.1 客户端自建的Spring Bean：
如 UserService等等bean - 1.2 Spring容器启动时辅助的bean，可以称为Spring内建bean：
如 org.springframework.context.annotation.internalAutowiredAnnotationProcessor
这里的Spring内建bean是在AnnotationConfigUtils.registerAnnotationConfigProcessors()静态方法中所注册的，即注册到BeanDefinitionMap中。
点击查看[源码片段]
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
//省略。。。
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
//省略。。。
}
2. 单例对象
单例对象是指Spring容器启动时创建的一些单例bean，如容器中的Environment对象：
这里的Spring内建bean是在AbstractApplicationContext.prepareBeanFactory()中，添加到BeanFactory的。
点击查看[源码片段]
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
//省略...
// Register default environment beans.
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
//省略...
}
其中1.2【Spring内建bean】以及2【单例对象】中的Spring内建bean都是在 依赖查找 章节中介绍的【Spring内建依赖】中的依赖。
依赖注入的来源
1. Spring BeanDefinition
同上述【依赖查找的来源】。
2. 单例对象
同上述【依赖查找的来源】。
3. 非Spring容器管理对象(ResolvableDependency、非推广对象、游离对象)
这里的【非Spring容器管理对象】是在单例对象那个方法里面一起注册的：
AbstractApplicationContext.prepareBeanFactory()中：
点击查看[源码片段]
protected void 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);
//省略...
}
那这几个游离对象是怎么运用的呢？
在上一章依赖注入章节中的源码分析中，我们知道在解析注入的依赖的时候：有一个方法DefaultListableBeanFactory.doResolveDependency，
在该方法中，调用了：DefaultListableBeanFactory.findAutowireCandidates()，内部会处理我们这4个特殊的游离对象的注入。
这也就是为什么Spring框架中，我们可以直接用如下代码注入BeanFactory或者ApplicationContext：
@Autowired
ApplicationContext applicationContext;
4. 外部化配置
因为到此为止还没有系统整理以及学习到外部化配置章节，并且基于学习者都是有spring基础的前提下，下例默认在META-INF/default.properties中拥有部分配置。
点击查看[示例代码]
@Configuration
@PropertySource(value = "META-INF/default.properties",encoding="UTF-8")
public class ExternalConfigurationDependencySourceDemo {
@Value("${user.id:-1}")
private Long id;
@Value("${usr.name}")
private String name;
@Value("${user.resource:classpath://default.properties}")
private Resource resource;
public static void main(String[] args) {
// 创建 BeanFactory 容器
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
// 注册 Configuration Class（配置类） -> Spring Bean
applicationContext.register(ExternalConfigurationDependencySourceDemo.class);
// 启动 Spring 应用上下文
applicationContext.refresh();
// 依赖查找 ExternalConfigurationDependencySourceDemo Bean
ExternalConfigurationDependencySourceDemo demo = applicationContext.getBean(ExternalConfigurationDependencySourceDemo.class);
System.out.println("demo.id = " + demo.id);
System.out.println("demo.name = " + demo.name);
System.out.println("demo.resource = " + demo.resource);
// 显示地关闭 Spring 应用上下文
applicationContext.close();
}
}
依赖查找的来源 VS 依赖注入的来源
点击查看[示例代码]
public class DependencySourceDemo {
// 注入在 postProcessProperties 方法执行，早于 setter注入，也早于 @PostConstruct
@Autowired
private BeanFactory beanFactory;
@Autowired
private ResourceLoader resourceLoader;
@Autowired
private ApplicationContext applicationContext;
@Autowired
private ApplicationEventPublisher applicationEventPublisher;
@PostConstruct
public 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));
}
@PostConstruct
public 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) {
// 创建 BeanFactory 容器
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
// 注册 Configuration Class（配置类） -> Spring Bean
applicationContext.register(DependencySourceDemo.class);
// 启动 Spring 应用上下文
applicationContext.refresh();
// 依赖查找 DependencySourceDemo Bean
DependencySourceDemo demo = applicationContext.getBean(DependencySourceDemo.class);
// 显示地关闭 Spring 应用上下文
applicationContext.close();
}
运行结果：
beanFactory == applicationContext false
beanFactory == applicationContext.getBeanFactory() true
resourceLoader == applicationContext true
ApplicationEventPublisher == applicationContext true
当前类型org.springframework.beans.factory.BeanFactory 无法在 BeanFactory 中查找!
当前类型org.springframework.context.ApplicationContext 无法在 BeanFactory 中查找!
当前类型org.springframework.core.io.ResourceLoader 无法在 BeanFactory 中查找!
当前类型org.springframework.context.ApplicationEventPublisher 无法在 BeanFactory 中查找!
这里补充一下上图缺少的[外部化配置]的特点：
类型：非常规的Spring对象依赖来源
有无生命周期管理：无
能否延迟初始化：不能
能否依赖查找：不能
Spring BeanDefinition 注册的源码位置
BeanDefinitionRegistry
DefaultListableBeanFactory#registerBeanDefinition
BeanDefinitionBuilder
单例对象注册到Spring IOC 容器的过程 以及 在依赖查找过程中的所充当的角色
单例对象注册到Spring IOC 容器的过程
SingletonBeanRegistry
DefaultListableBeanFactory#registerSingleton
在依赖查找过程中的所充当的角色：
AbstractBeanFactory#getBean(java.lang.String)
非Spring容器管理对象的应用
public class ResolvableDependencySourceDemo {
@Autowired
private String value;
@PostConstruct
public void init() {
System.out.println(value);
}
public static void main(String[] args) {
// 创建 BeanFactory 容器
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
// 注册 Configuration Class（配置类） -> Spring Bean
applicationContext.register(ResolvableDependencySourceDemo.class);
applicationContext.addBeanFactoryPostProcessor(beanFactory -> {
// 注册 Resolvable Dependency，必须在refresh()方法之后执行，但是又必须在aitowired（bean初始化）之前执行
beanFactory.registerResolvableDependency(String.class, "Hello,World");
});
// 启动 Spring 应用上下文
applicationContext.refresh();
// 显示地关闭 Spring 应用上下文
applicationContext.close();
}
}
注：游离对象可以被应用人员随意注册到spring中，但是需要保证游离对象只能被依赖注入，不能被依赖查找。
外部化配置在spring启动过程中的源码位置
org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
org.springframework.beans.factory.support.DefaultListableBeanFactory#doResolveDependency
DefaultListableBeanFactory#doResolveDependency源码片段
//下面的type在上例中第一个获取到java.lang.Long
Class<?> type = descriptor.getDependencyType();
//下面的getAutowireCandidateResolver()方法会得到一个ContextAnnotationAutowireCandidateResolver解析类
//该解析类会在下面的getSuggestedValue()方法中解析value的值，此时还是占位符
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
if (value instanceof String) {
//这里会把@Value注解的默认值解析出来
String strVal = resolveEmbeddedValue((String) value);
ContextAnnotationAutowireCandidateResolver.super.getSuggestedValue(DependencyDescriptor descriptor)源码：
public Object getSuggestedValue(DependencyDescriptor descriptor) {
Object value = findValue(descriptor.getAnnotations());
if (value == null) {
MethodParameter methodParam = descriptor.getMethodParameter();
if (methodParam != null) {
value = findValue(methodParam.getMethodAnnotations());
}
}
return value;
}