Spring bean的实例化和IOC依赖注入详解
作者:清幽之地 发布时间:2023-11-23 23:57:15
前言
我们知道,IOC是Spring的核心。它来负责控制对象的生命周期和对象间的关系。
举个例子,我们如何来找对象的呢?常见的情况是,在路上要到处去看哪个MM既漂亮身材又好,符合我们的口味。就打听她们的电话号码,制造关联想办法认识她们,然后...这里省略N步,最后谈恋爱结婚。
IOC在这里就像婚介所,里面有很多适婚男女的资料,如果你有需求,直接告诉它你需要个什么样的女朋友就好了。它会给我们提供一个MM,直接谈恋爱结婚,完美!
下面就来看Spring是如何生成并管理这些对象的呢?
1、方法入口
org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons()方法是今天的主角,一切从它开始。
public void preInstantiateSingletons() throws BeansException {
//beanDefinitionNames就是上一节初始化完成后的所有BeanDefinition的beanName
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//getBean是主力中的主力,负责实例化Bean和IOC依赖注入
getBean(beanName);
}
}
}
2、Bean的实例化
在入口方法getBean中,首先调用了doCreateBean方法。第一步就是通过反射实例化一个Bean。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//createBeanInstance就是实例化Bean的过程,无非就是一些判断加反射,最后调用ctor.newInstance(args);
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
}
3、Annotation的支持
在Bean实例化完成之后,会进入一段后置处理器的代码。从代码上看,过滤实现了MergedBeanDefinitionPostProcessor接口的类,调用其postProcessMergedBeanDefinition()方法。都是谁实现了MergedBeanDefinitionPostProcessor接口呢?我们重点看三个
AutowiredAnnotationBeanPostProcessor
CommonAnnotationBeanPostProcessor
RequiredAnnotationBeanPostProcessor
记不记得在Spring源码分析(一)Spring的初始化和XML这一章节中,我们说Spring对annotation-config标签的支持,注册了一些特殊的Bean,正好就包含上面这三个。下面来看它们偷偷做了什么呢?
从方法名字来看,它们做了相同一件事,加载注解元数据。方法内部又做了相同的两件事
ReflectionUtils.doWithLocalFields(targetClass, new ReflectionUtils.FieldCallback()
ReflectionUtils.doWithLocalMethods(targetClass, new ReflectionUtils.MethodCallback()
看方法的参数,targetClass就是Bean的Class对象。接下来就可以获取它的字段和方法,判断是否包含了相应的注解,最后转成InjectionMetadata对象,下面以一段伪代码展示处理过程。
public static void main(String[] args) throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.viewscenes.netsupervisor.entity.User");
Field[] fields = clazz.getFields();
Method[] methods = clazz.getMethods();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
if (field.isAnnotationPresent(Autowired.class)) {
//转换成AutowiredFieldElement对象,加入容器
}
}
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
if (method.isAnnotationPresent(Autowired.class)) {
//转换成AutowiredMethodElement对象,加入容器
}
}
return new InjectionMetadata(clazz, elements);
}
InjectionMetadata对象有两个重要的属性:targetClass ,injectedElements,在注解式的依赖注入的时候重点就靠它们。
public InjectionMetadata(Class<?> targetClass, Collection<InjectedElement> elements) {
//targetClass是Bean的Class对象
this.targetClass = targetClass;
//injectedElements是一个InjectedElement对象的集合
this.injectedElements = elements;
}
//member是成员本身,字段或者方法
//pd是JDK中的内省机制对象,后面的注入属性值要用到
protected InjectedElement(Member member, PropertyDescriptor pd) {
this.member = member;
this.isField = (member instanceof Field);
this.pd = pd;
}
说了这么多,最后再看下源码里面是什么样的,以Autowired 为例。
ReflectionUtils.doWithLocalFields(targetClass, new ReflectionUtils.FieldCallback() {
@Override
public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
AnnotationAttributes ann = findAutowiredAnnotation(field);
if (ann != null) {
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation is not supported on static fields: " + field);
}
return;
}
boolean required = determineRequiredStatus(ann);
currElements.add(new AutowiredFieldElement(field, required));
}
}
});
ReflectionUtils.doWithLocalMethods(targetClass, new ReflectionUtils.MethodCallback() {
@Override
public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
if (Modifier.isStatic(method.getModifiers())) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation is not supported on static methods: " + method);
}
return;
}
if (method.getParameterTypes().length == 0) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation should be used on methods with parameters: " + method);
}
}
boolean required = determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new AutowiredMethodElement(method, required, pd));
}
}
});
4、依赖注入
前面完成了在doCreateBean()方法Bean的实例化,接下来就是依赖注入。
Bean的依赖注入有两种方式,一种是配置文件,一种是注解式。
4.1、 注解式的注入过程
在上面第3小节,Spring已经过滤了Bean实例上包含@Autowired、@Resource等注解的Field和Method,并返回了包含Class对象、内省对象、成员的InjectionMetadata对象。还是以@Autowired为例,这次调用到AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues()。
首先拿到InjectionMetadata对象,再判断里面的InjectedElement集合是否为空,也就是说判断在Bean的字段和方法上是否包含@Autowired。然后调用InjectedElement.inject()。InjectedElement有两个子类AutowiredFieldElement、AutowiredMethodElement,很显然一个是处理Field,一个是处理Method。
4.1.1 AutowiredFieldElement
如果Autowired注解在字段上,它的配置是这样。
public class User {
@Autowired
Role role;
}
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
//以User类中的@Autowired Role role为例,这里的field就是
//public com.viewscenes.netsupervisor.entity.Role com.viewscenes.netsupervisor.entity.User.role
Field field = (Field) this.member;
Object value;
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
TypeConverter typeConverter = beanFactory.getTypeConverter();
try {
//这里的beanName因为Bean,所以会重新进入populateBean方法,先完成Role对象的注入
//value == com.viewscenes.netsupervisor.entity.Role@7228c85c
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
if (value != null) {
//设置可访问,直接赋值
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
4.1.2 AutowiredFieldElement
如果Autowired注解在方法上,就得这样写。
public class User {
@Autowired
public void setRole(Role role) {}
}
它的inject方法和上面类似,不过最后是method.invoke。感兴趣的小伙伴可以去翻翻源码。
ReflectionUtils.makeAccessible(method);
method.invoke(bean, arguments);
4.2、配置文件的注入过程
先来看一个配置文件,我们在User类中注入了id,name,age和Role的实例。
<bean id="user" class="com.viewscenes.netsupervisor.entity.User">
<property name="id" value="1001"></property>
<property name="name" value="网机动车"></property>
<property name="age" value="24"></property>
<property name="role" ref="role"></property>
</bean>
<bean id="role" class="com.viewscenes.netsupervisor.entity.Role">
<property name="id" value="1002"></property>
<property name="name" value="中心管理员"></property>
</bean>
在Spring源码分析(一)Spring的初始化和XML这一章节的4.2 小节,bean标签的解析,我们看到在反射得到Bean的Class对象后,会设置它的property属性,也就是调用了parsePropertyElements()方法。在BeanDefinition对象里有个MutablePropertyValues属性。
MutablePropertyValues:
//propertyValueList就是有几个property 节点
List<PropertyValue> propertyValueList:
PropertyValue:
name //对应配置文件中的name ==id
value //对应配置文件中的value ==1001
PropertyValue:
name //对应配置文件中的name ==name
value //对应配置文件中的value ==网机动车
上图就是BeanDefinition对象里面MutablePropertyValues属性的结构。既然已经拿到了property的名称和值,注入就比较简单了。从内省对象PropertyDescriptor中拿到writeMethod对象,设置可访问,invoke即可。PropertyDescriptor有两个对象readMethodRef、writeMethodRef其实对应的就是get set方法。
public void setValue(final Object object, Object valueToApply) throws Exception {
//pd 是内省对象PropertyDescriptor
final Method writeMethod = this.pd.getWriteMethod());
writeMethod.setAccessible(true);
final Object value = valueToApply;
//以id为例 writeMethod == public void com.viewscenes.netsupervisor.entity.User.setId(java.lang.String)
writeMethod.invoke(getWrappedInstance(), value);
}
5、initializeBean
在Bean实例化和IOC依赖注入后,Spring留出了扩展,可以让我们对Bean做一些初始化的工作。
5.1、Aware
Aware是一个空的接口,什么也没有。不过有很多xxxAware继承自它,下面来看源码。如果有需要,我们的Bean可以实现下面的接口拿到我们想要的。
//在实例化和IOC依赖注入完成后调用
private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
//让我们的Bean可以拿到自身在容器中的beanName
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
//可以拿到ClassLoader对象
if (bean instanceof BeanClassLoaderAware) {
((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
}
//可以拿到BeanFactory对象
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
......未完
}
}
做法如下:
public class AwareTest1 implements BeanNameAware,BeanClassLoaderAware,BeanFactoryAware{
public void setBeanName(String name) {
System.out.println("BeanNameAware:" + name);
}
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("BeanFactoryAware:" + beanFactory);
}
public void setBeanClassLoader(ClassLoader classLoader) {
System.out.println("BeanClassLoaderAware:" + classLoader);
}
}
//输出结果
BeanNameAware:awareTest1
BeanClassLoaderAware:WebappClassLoader
context: /springmvc_dubbo_producer
delegate: false
repositories:
/WEB-INF/classes/
----------> Parent Classloader:
java.net.URLClassLoader@2626b418
BeanFactoryAware:org.springframework.beans.factory.support.DefaultListableBeanFactory@5b4686b4: defining beans ...未完
5.2、初始化
Bean的初始化方法有三种方式,按照先后顺序是,@PostConstruct、afterPropertiesSet、init-method
5.2.1 @PostConstruct
这个注解隐藏的比较深,它是在CommonAnnotationBeanPostProcessor的父类InitDestroyAnnotationBeanPostProcessor调用到的。这个注解的初始化方法不支持带参数,会直接抛异常。
if (method.getParameterTypes().length != 0) {
throw new IllegalStateException("Lifecycle method annotation requires a no-arg method: " + method);
}
public void invoke(Object target) throws Throwable {
ReflectionUtils.makeAccessible(this.method);
this.method.invoke(target, (Object[]) null);
}
5.2.2 afterPropertiesSet
这个要实现InitializingBean接口。这个也不能有参数,因为它接口方法就没有定义参数。
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isDebugEnabled()) {
logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
((InitializingBean) bean).afterPropertiesSet();
}
5.2.3 init-method
ReflectionUtils.makeAccessible(initMethod);
initMethod.invoke(bean);
6、注册
registerDisposableBeanIfNecessary()完成Bean的缓存注册工作,把Bean注册到Map中。
来源:https://www.jianshu.com/p/00f1a6739a9e
猜你喜欢
- 日期和时间格式由 日期和时间模式字符串 指定。在 日期和时间模式字符串 中,未加引号的字母 'A' 到 'Z'
- 概念理解Properties 继承于 Hashtable。表示一个持久的属性集,属性列表以key-value的形式存在,key和value都
- mysql实现配置中心本公司配置数据的管理是通过mysql进行配置管理,因为已经搭建好了,所以自己动手重新搭建一遍,熟悉整个流程。有关项目源
- 前言本文准确来讲是探讨如何用 Jackson 来序列化 Apache avro 对象,因为简单用 Jackson 来序列化 Apache a
- 本文实例为大家分享了C++实现俄罗斯方块的具体代码,供大家参考,具体内容如下先是效果图:主菜单:游戏:设置:错误处理:代码:#include
- CompletableFuture 介绍CompletableFuture是1.8引入的新特性,一些比较复杂的异步计算场景,尤其是需要串联多
- 多数据源的目的在于一个代码模块可调用多个数据库的数据进行某些业务操作。MyBatis-Plus开发者写了一个多数据源叫dynamic-dat
- 前言近期有个业务需求,涉及用户付费相关的计算,需要一个日历组件,组件功能如下:仅支持从明天开始选择预定日期仅支持可选范围内的日期日期的选择是
- 一、使用Optional引言1.1、代码问题引出在写程序的时候一般都遇到过 NullPointerException,所以经常会对程序进行非
- spring-boot-devtools是一个为开发者服务的一个模块,其中最重要的功能就是自动应用代码更改到最新的App上面去。原理是在发现
- 程序的结构分类:顺序结构:按照写代码的顺序 一次执行选择结构:根据条件的不同有选择的执行不同的代码循环结构:在一定条件下 反复执行某一片代码
- 在spring中有很多以XXXAware命名的接口,很多人也不清楚这些接口都是做什么用的,这篇文章将描述常用的一些接口。一,Applicat
- 开始学习WebSocket,准备用它来实现一个在页面实时输出log4j的日志以及控制台的日志。首先知道一些基础信息:1.java7 开始支持
- 本文实例讲述了C#创建临时文件的方法。分享给大家供大家参考。具体分析如下:C#可以通过Path.GetTempFileName获得一个临时文
- Java8 LocalDateTime与timestamp转换将timestamp转为LocalDateTimepublic LocalDa
- 在使用springMVC框架构建web应用,客户端常会请求字符串、整型、json等格式的数据,通常使用@ResponseBody注解使 co
- 前言Mybatis真正强大的地方在于SQL映射语句,这也是它的魅力所在。相对于它强大的功能,SQL映射文件的配置却非常简单,我上篇文章语句讲
- 相关知识:Java中三种简单注解介绍和代码实例一、作用用 @Deprecated注解的程序元素,不鼓励程序员使用这样的元素,通常是因为它很危
- 很多学习Android程序设计的人都会发现每个人对代码的写法都有不同的偏好,比较明显的就是对控件响应事件的写法的不同。因此本文就把这些写法总
- Java 使用getClass().getResourceAsStream()方法获取资源之前想获取一个资源文件做一些处理,使用getCla