【Spring】IoC容器 - 依赖注入
前言
上一篇文章已经学习了【依赖查找】相关的知识,这里详细的介绍一下【依赖注入】。
依赖注入 - 分类
因为自己是基于小马哥的脉络来学习,并且很认可小马哥梳理的分类方式,下面按照小马哥思想为【依赖注入】分类:
- Setter方法注入
- 构造器注入
- 字段注入
- 方法注入
- 接口回调注入
1. Setter方法注入
1.1 手动模式
1.1.1 XML配置
<bean class="org.geekbang.thinking.in.spring.ioc.dependency.injection.UserHolder">
<property name="user" ref="superUser" />
</bean>
Spring容器里面有另外一个bean,名字是superUser。
这里user bean的注入就是使用的setter注入。可以在set方法上打断点验证。
后续我们会进行源码分析。
1.1.2 Java注解配置
@Bean
public UserHolder userHolder(User user) {
UserHolder userHolder = new UserHolder();
userHolder.setUser(user);
return userHolder;
}
1.1.3 API配置
/**
* 为 UserHolder 生成 BeanDefinition
*/
private static BeanDefinition createUserHolderBeanDefinition() {
BeanDefinitionBuilder definitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(UserHolder.class);
definitionBuilder.addPropertyReference("user", "superUser");
return definitionBuilder.getBeanDefinition();
}
1.2 自动模式
1.2.1 byName
<bean class="org.geekbang.thinking.in.spring.ioc.dependency.injection.UserHolder" autowire="byName">
</bean>
自动装配默认是byType,不是byName
1.2.2 byType
<bean class="org.geekbang.thinking.in.spring.ioc.dependency.injection.UserHolder" autowire="byType">
</bean>
2. 构造器注入
2.1 手动模式
2.1.1 XML配置
<bean class="org.geekbang.thinking.in.spring.ioc.dependency.injection.UserHolder">
<constructor-arg name="user" ref="superUser" />
</bean>
Spring容器里面有另外一个bean,名字是superUser。
2.1.2 Java注解配置
@Bean
public UserHolder userHolder(User user) {
return new UserHolder(user);
}
2.1.3 API配置
/**
* 为 UserHolder 生成 BeanDefinition
*/
private static BeanDefinition createUserHolderBeanDefinition() {
BeanDefinitionBuilder definitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(UserHolder.class);
definitionBuilder.addConstructorArgReference("superUser");
return definitionBuilder.getBeanDefinition();
}
2.2 自动模式
2.2.1 constructor
<bean class="org.geekbang.thinking.in.spring.ioc.dependency.injection.UserHolder"
autowire="constructor">
</bean>
这里的UserHolder类中存在如下构造器:
public UserHolder(User user) {
this.user = user;
}
构造器自动注入的时候会去spring容器中获取type为User的bean,自动注入。
3. 字段注入
字段注入只有手动模式,并且只支持Java注解配置。
@Autowired
@Resource
@Inject(可选)
@Autowired
private UserHolder userHolder;
@Resource(name = "xxxx")
private UserHolder userHolder2;
@Inject
private UserHolder userHolder2;
4. 方法注入
方法注入只有手动模式,并且只支持Java注解配置。
@Autowired
@Resource
@Inject(可选)
@Bean
@Autowired
public void init1(UserHolder userHolder) {
this.userHolder = userHolder;
}
@Resource
public void init2(UserHolder userHolder2) {
this.userHolder2 = userHolder2;
}
@Bean
public UserHolder userHolder(User user) {
return new UserHolder(user);
}
项目中有使用到如下的一种方法注入:
@Autowired
public MyClass(Map<String, MyApplicationEvent> eventMap) {
//any logic
}
这里是自己的bean的构造器,参数eventMap会被容器自动构建一个map,所有MyApplicationEvent类型的bean都会被装载,map的key是bean的名字。
5. 接口回调注入Aware
public class AwareInterfaceDependencyInjectionDemo implements BeanFactoryAware, ApplicationContextAware {
private static BeanFactory beanFactory;
private static ApplicationContext applicationContext;
public static void main(String[] args) {
// 创建 BeanFactory 容器
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
// 注册 Configuration Class(配置类) -> Spring Bean
context.register(AwareInterfaceDependencyInjectionDemo.class);
// 启动 Spring 应用上下文
context.refresh();
System.out.println(beanFactory == context.getBeanFactory());
System.out.println(applicationContext == context);
// 显示地关闭 Spring 应用上下文
context.close();
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
AwareInterfaceDependencyInjectionDemo.beanFactory = beanFactory;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
AwareInterfaceDependencyInjectionDemo.applicationContext = applicationContext;
}
}
之前倒是熟悉这个接口项目中也在使用,但是没想到分类居然是依赖注入相关的。
各种注入方式的比较
上面介绍来大部分注入方式,其实在我自己的项目中用得最多的自然就是字段注入。相信大部分Java开发都是,但是熟悉其他注入方式对spring应用的扩展与理解有更好的帮助。
注入方式 | 适合于 |
---|---|
构造器注入 | 低依赖 |
Setter | 多依赖 |
字段注入 | 便利性 |
方法注入 | 声明类 |
依赖注入 - 特殊注入方式说明
基础类型注入
集合类型注入
限定注入
延迟依赖注入
依赖处理过程
依赖处理过程基础知识
入口:org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency
依赖描述符:org.springframework.beans.factory.config.DependencyDescriptor
自动绑定候选对象处理器:org.springframework.beans.factory.support.AutowireCandidateResolver
依赖处理过程解析
我们先来分析一下DefaultListableBeanFactory.resolveDependency()的方法:
点击查看代码
/**
* 参数1:DependencyDescriptor是依赖描述符
* 参数2:requestingBeanName,待注入的bean名称
*/
@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
//注入类型如果是Optional,特殊处理。
if (Optional.class == descriptor.getDependencyType()) {
return createOptionalDependency(descriptor, requestingBeanName);
}
//注入类型如果是ObjectFactory或ObjectProvider,特殊处理。
else if (ObjectFactory.class == descriptor.getDependencyType() ||
ObjectProvider.class == descriptor.getDependencyType()) {
return new DependencyObjectProvider(descriptor, requestingBeanName);
}
//注入类型如果是javax.inject.Provider,特殊处理。
else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
}
else {
//常规依赖处理,使用[自动绑定候选对象处理器]处理一个事情,先放着。。。
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
if (result == null) {
//真正的处理依赖在这里
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
}
然后是:DefaultListableBeanFactory.doResolveDependency
点击查看代码
@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
//处理嵌套注入时候的一个保护点,获取上次注入点(InjectionPoint),
//内部使用的是ThreadLocal去存储InjectionPoint,所以这里获取的是单线程内的上次的注入点
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
//获取描述符的shortcut
Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
return shortcut;
}
//获取注入类型,未深入
Class<?> type = descriptor.getDependencyType();
//获取建议值,未深入
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
if (value instanceof String) {
String strVal = resolveEmbeddedValue((String) value);
BeanDefinition bd = (beanName != null && containsBean(beanName) ?
getMergedBeanDefinition(beanName) : null);
value = evaluateBeanDefinitionString(strVal, bd);
}
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
try {
return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
}
catch (UnsupportedOperationException ex) {
// A custom TypeConverter which does not support TypeDescriptor resolution...
return (descriptor.getField() != null ?
converter.convertIfNecessary(value, type, descriptor.getField()) :
converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
}
}
//判断是不是处理多个bean,比如Map,Array,List的注入就是在这里处理。
Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
return multipleBeans;
}
//重点:根据要注入的描述符,bean的名字,获取可以注入的容器上下文里面可以注入的候选bean
//20210926分析到这里,接下来进入该方法分析
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null;
}
String autowiredBeanName;
Object instanceCandidate;
if (matchingBeans.size() > 1) {
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
if (autowiredBeanName == null) {
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
}
else {
// In case of an optional Collection/Map, silently ignore a non-unique case:
// possibly it was meant to be an empty collection of multiple regular beans
// (before 4.3 in particular when we didn't even look for collection beans).
return null;
}
}
instanceCandidate = matchingBeans.get(autowiredBeanName);
}
else {
// We have exactly one match.
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
if (autowiredBeanNames != null) {
autowiredBeanNames.add(autowiredBeanName);
}
if (instanceCandidate instanceof Class) {
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
Object result = instanceCandidate;
if (result instanceof NullBean) {
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
result = null;
}
if (!ClassUtils.isAssignableValue(type, result)) {
throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
}
return result;
}
finally {
ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
}
}
依赖描述符DependencyDescriptor类定义:
点击查看代码
/**
* Descriptor for a specific dependency that is about to be injected.
* Wraps a constructor parameter, a method parameter or a field,
* allowing unified access to their metadata.
* (一个特定被注入的依赖的描述符。包含一个构造器、方法或者字段。包装构造函数参数、方法参数或字段,允许对其元数据进行统一访问。)
* @author Juergen Hoeller
* @since 2.5
*/
public class DependencyDescriptor extends InjectionPoint implements Serializable {
注入原理
- @Autowired注入
- @Inject注入
- @Resource注入
- 自定义依赖注入
【Spring】IoC容器 - 依赖注入的更多相关文章
- Ioc容器依赖注入-Spring 源码系列(2)
Ioc容器依赖注入-Spring 源码系列(2) 目录: Ioc容器beanDefinition-Spring 源码(1) Ioc容器依赖注入-Spring 源码(2) Ioc容器BeanPostPr ...
- Spring源码之IOC容器创建、BeanDefinition加载和注册和IOC容器依赖注入
总结 在SpringApplication#createApplicationContext()执行时创建IOC容器,默认DefaultListableBeanFactory 在AbstractApp ...
- SpringBoot启动流程分析(六):IoC容器依赖注入
SpringBoot系列文章简介 SpringBoot源码阅读辅助篇: Spring IoC容器与应用上下文的设计与实现 SpringBoot启动流程源码分析: SpringBoot启动流程分析(一) ...
- TinyFrame续篇:整合Spring IOC实现依赖注入
上一篇主要讲解了如何搭建基于CodeFirst的ORM,并且在章节末我们获取了上下文对象的实例:BookContext.这节主要承接上一篇,来讲解如何整合Spring IOC容器实现控制反转,依赖注入 ...
- 【Spring IoC】依赖注入DI(四)
平常的Java开发中,程序员在某个类中需要依赖其它类的方法.通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理. Spring提出了依赖注入的思想,即依赖类不由程 ...
- Spring Ioc和依赖注入
总结一下近来几天的学习,做个笔记 以下是Spring IoC相关内容: IoC(Inversion of Control):控制反转: 其主要功能可简单概述为:将 用 new 去创建实例对象,转换为让 ...
- Spring IOC容器中注入bean
一.基于schema格式的注入 1.基本的注入方式 (属性注入方式) 根据setXxx()方法进行依赖注入,Spring只会检查是否有setter方法,是否有对应的属性不做要求 <bean id ...
- Spring IOC容器创建bean过程浅析
1. 背景 Spring框架本身非常庞大,源码阅读可以从Spring IOC容器的实现开始一点点了解.然而即便是IOC容器,代码仍然是非常多,短时间内全部精读完并不现实 本文分析比较浅,而完整的IOC ...
- Spring IOC源代码具体解释之容器依赖注入
Spring IOC源代码具体解释之容器依赖注入 上一篇博客中介绍了IOC容器的初始化.通过源代码分析大致了解了IOC容器初始化的一些知识.先简单回想下上篇的内容 加载bean定义文件的过程.这个过程 ...
随机推荐
- Spring系列.Environment接口
Environment 接口介绍 在 Spring 中,Environment 接口主要管理应用程序两个方面的内容:profile 和 properties. profile 可以简单的等同于环境,比 ...
- Windows Server安装MySQL
1.下载zip包 https://dev.mysql.com/downloads/file/?id=467269 2.直接解压zip包到指定路径下 3.添加环境变量 在系统变量path后面添加mysq ...
- Robot Framework(6)- BuiltIn 测试库常用的关键字列表
如果你还想从头学起Robot Framework,可以看看这个系列的文章哦! https://www.cnblogs.com/poloyy/category/1770899.html 前言 所有关键字 ...
- Cython 模块扩展 - 编程语言 替代实现 应用领域 汇总一览
Python 本身只是一种编程语言规范,可以使用其它编程语言实现它或扩展它:譬如:采有 Python C Java .Net 等重实现 Python,而采用 Python C/C++ C# Java ...
- oh,我的老伙计,你看看这近五十个dapr视频
oh,我的老伙计,你看看这近五十个 dapr 视频.这不就是你想要的视频资料吗?快来捡走吧! 开始了,但是没完全开始 Dapr 是一个可移植的.事件驱动的运行时,它使任何开发人员能够轻松构建出弹性的. ...
- Python - 虚拟环境 venv
什么是虚拟环境 这是 Python 3.3 的新特性:https://www.python.org/dev/peps/pep-0405/ 假设自己电脑主机的 Python 环境称为系统环境,而默认情况 ...
- ARM架构安装ubuntu系统
一.简介 arm开发板制作系统是比较麻烦,不论使用busybox还是yocto制作根文件系统对新手都比太友好,除非深度定制,否则使用ubuntu系统既可以满足,把更多的精力放在应用开发上. 二.准备材 ...
- node实战小例子
第一章 2020-2-6 留言小本子 思路(由于本章没有数据库,客户提交的数据放在全局变量,接收请求用的是bodyParser, padyParser使用方法 app.use(bodyParser.u ...
- k8s 部署elasticsearch报 max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]
1.由于登不上云的节点 不采用修改节点配置的方式 修改部署的stateful 加上 initContainers 它和 containers 同一层级的 initContainers: - name: ...
- 开源物联网平台(Thingsboard)-编译
环境准备 Jdk8+ (3.2.2版本开始使用Jdk11) Maven3.2.1+ release-3.2分支 获取代码 ##get source from mirror git clone http ...