内容简介:我们知道,IOC是Spring的核心。它来负责控制对象的生命周期和对象间的关系。 举个例子,我们如何来找对象的呢?常见的情况是,在路上要到处去看哪个MM既漂亮身材又好,符合我们的口味。就打听她们的电话号码,制造关联想办法认识她们,然后...这里省略N步,最后谈恋爱结婚。 IOC在这里就像婚介所,里面有很多适婚男女的资料,如果你有需求,直接告诉它你需要个什么样的女朋友就好了。它会给我们提供一个MM,直接谈恋爱结婚,完美! 下面就来看Spring是如何生成并管理这些对象的呢?在入口方法getBean中,首先调用
我们知道,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"); } 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"); } return; } if (method.getParameterTypes().length == 0) { if (logger.isWarnEnabled()) { logger.warn("Autowired annotation should be used on methods with parameters:" ); } } 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(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 ResourceLoaderAware) { ((ResourceLoaderAware) bean).setResourceLoader(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.DefaultListableBean Factory@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"); } 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中。
以上所述就是小编给大家介绍的《Spring源码分析(二)bean的实例化和IOC依赖注入》,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对 码农网 的支持!
猜你喜欢:- Laravel 依赖注入源码解析
- mybatis-plus源码分析之sql注入器
- Python中从服务端模板注入到沙盒逃逸的源码探索 (一)
- Angular 4 依赖注入教程之二 组件中注入服务
- 服务端注入之Flask框架中服务端模板注入问题
- 服务器端电子表格注入 - 从公式注入到远程代码执行
本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们。
Foundation Web Standards
Jonathan Lane、Steve Smith / Friends of ED / 21st July 2008 / $34.99
Foundation Web Standards explores the process of constructing a web site from start to finish. There is more to the process than just knowing HTML! Designers and developers must follow a proper proces......一起来看看 《Foundation Web Standards》 这本书的介绍吧!