皮皮网
皮皮网

【android源码排版】【shop 3源码】【web界面 源码】spring源码populatebean

来源:作业管理源码 发表时间:2024-12-24 09:30:43

1.从源码层面带你实现一个自动注入注解
2.Spring AOP(2)代理类的创建ProxyFactoryBean
3.@Lazy注解源码分析
4.Spring创建bean详解--实例化bean

spring源码populatebean

从源码层面带你实现一个自动注入注解

       首先,源码需要了解到的源码是。SpringBean的源码生命周期

       在生命周期中。注入bean属性的源码位置是在以下代码:populateBean位置中

       那么我们在项目中使用注解产生一个bean的时候必定会经过以下代码进行一个bean的创建流程

/**省略代码**///开始初始化bean实例对象ObjectexposedObject=bean;try{ //<5>对bean进行填充,将各个属性值注入,源码其中,源码android源码排版可能存在依赖于其他bean的源码属性populateBean(beanName,mbd,instanceWrapper);//<6>调用初始化方法exposedObject=initializeBean(beanName,exposedObject,mbd);}catch(Throwableex){ if(exinstanceofBeanCreationException&&beanName.equals(((BeanCreationException)ex).getBeanName())){ throw(BeanCreationException)ex;}else{ thrownewBeanCreationException(mbd.getResourceDescription(),beanName,"Initializationofbeanfailed",ex);}}/**省略代码**/

       在生命周期中populateBean进行填充bean数据。把其他依赖引入进来

       BeanPostProcessor是源码一个bean创建时候的一个钩子。

       以下代码是源码循环调用实现了BeanPostProcessor子类InstantiationAwareBeanPostProcessor#postProcessProperties方法

       Spring在以下代码中有自动注入的拓展点。关键就是源码实现InstantiationAwareBeanPostProcessor#postProcessProperties

/**省略代码**/for(BeanPostProcessorbp:getBeanPostProcessors()){ if(bpinstanceofInstantiationAwareBeanPostProcessor){ InstantiationAwareBeanPostProcessoribp=(InstantiationAwareBeanPostProcessor)bp;//对所有需要依赖检查的属性进行后处理PropertyValuespvsToUse=ibp.postProcessProperties(pvs,bw.getWrappedInstance(),beanName);if(pvsToUse==null){ //从bw对象中提取PropertyDescriptor结果集//PropertyDescriptor:可以通过一对存取方法提取一个属性if(filteredPds==null){ filteredPds=filterPropertyDescriptorsForDependencyCheck(bw,mbd.allowCaching);}pvsToUse=ibp.postProcessPropertyValues(pvs,filteredPds,bw.getWrappedInstance(),beanName);if(pvsToUse==null){ return;}}pvs=pvsToUse;}}/**省略代码**/

       我们展开来讲一下@Autowired的实现是怎么样的吧:

       实现类为AutowiredAnnotationBeanPostProcessor.java

       从上面可以得知,填充bean的源码时候。时调用了方法ibp.postProcessPropertyValues()

       那么AutowiredAnnotationBeanPostProcessor#postProcessPropertyValues()则会被调用

       调用findAutowiringMetadata获取class以及父类带有@Autowired或者@Value的源码属性或者方法:

/**省略代码**/publicPropertyValuespostProcessProperties(PropertyValuespvs,Objectbean,StringbeanName){ //获取所有可以注入的元数据InjectionMetadatametadata=findAutowiringMetadata(beanName,bean.getClass(),pvs);try{ //注入数据metadata.inject(bean,beanName,pvs);}catch(BeanCreationExceptionex){ throwex;}catch(Throwableex){ thrownewBeanCreationException(beanName,"Injectionofautowireddependenciesfailed",ex);}returnpvs;}privateInjectionMetadatafindAutowiringMetadata(StringbeanName,Class<?>clazz,@NullablePropertyValuespvs){ //缓存名字获取StringcacheKey=(StringUtils.hasLength(beanName)?beanName:clazz.getName());InjectionMetadatametadata=this.injectionMetadataCache.get(cacheKey);//获取是否已经读取过这个class类的InjectionMetadata有的话直接从缓存中获取出去if(InjectionMetadata.needsRefresh(metadata,clazz)){ synchronized(this.injectionMetadataCache){ //双重检查metadata=this.injectionMetadataCache.get(cacheKey);if(InjectionMetadata.needsRefresh(metadata,clazz)){ if(metadata!=null){ metadata.clear(pvs);}//构建自动注入的元数据metadata=buildAutowiringMetadata(clazz);this.injectionMetadataCache.put(cacheKey,metadata);}}}returnmetadata;}privateInjectionMetadatabuildAutowiringMetadata(finalClass<?>clazz){ if(!AnnotationUtils.isCandidateClass(clazz,this.autowiredAnnotationTypes)){ returnInjectionMetadata.EMPTY;}List<InjectionMetadata.InjectedElement>elements=newArrayList<>();Class<?>targetClass=clazz;do{ finalList<InjectionMetadata.InjectedElement>currElements=newArrayList<>();//循环targetClass的所有field并执FieldCallback逻辑(函数式编程接口,传入的源码是一个执行函数)ReflectionUtils.doWithLocalFields(targetClass,field->{ //获得字段上面的Annotation注解MergedAnnotation<?>ann=findAutowiredAnnotation(field);if(ann!=null){ //判断是否为静态属性如果是,则不进行注入if(Modifier.isStatic(field.getModifiers())){ if(logger.isInfoEnabled()){ logger.info("Autowiredannotationisnotsupportedonstaticfields:"+field);}return;}//注解是源码否为必须依赖项booleanrequired=determineRequiredStatus(ann);currElements.add(newAutowiredFieldElement(field,required));}});//循环targetClass的所有Method并执MethodCallback逻辑(函数式编程接口,传入的源码shop 3源码是一个执行函数)ReflectionUtils.doWithLocalMethods(targetClass,method->{ MethodbridgedMethod=BridgeMethodResolver.findBridgedMethod(method);if(!BridgeMethodResolver.isVisibilityBridgeMethodPair(method,bridgedMethod)){ return;}MergedAnnotation<?>ann=findAutowiredAnnotation(bridgedMethod);if(ann!=null&&method.equals(ClassUtils.getMostSpecificMethod(method,clazz))){ //判断是否为静态方法如果是,则不进行注入if(Modifier.isStatic(method.getModifiers())){ if(logger.isInfoEnabled()){ logger.info("Autowiredannotationisnotsupportedonstaticmethods:"+method);}return;}//判断静态方法参数是否为0if(method.getParameterCount()==0){ if(logger.isInfoEnabled()){ logger.info("Autowiredannotationshouldonlybeusedonmethodswithparameters:"+method);}}booleanrequired=determineRequiredStatus(ann);PropertyDescriptorpd=BeanUtils.findPropertyForMethod(bridgedMethod,clazz);currElements.add(newAutowiredMethodElement(method,required,pd));}});//数据加到数组最前方父类的的注解都放在靠前的位置elements.addAll(0,currElements);//如果有父类则设置targetClass为父类。如此循环targetClass=targetClass.getSuperclass();}while(targetClass!=null&&targetClass!=Object.class);returnInjectionMetadata.forElements(elements,clazz);}/**省略代码**/

       真正注入数据的是metadata.inject(bean,beanName,pvs);

       调用的是InjectionMetadata#inject方法

publicvoidinject(Objecttarget,@NullableStringbeanName,@NullablePropertyValuespvs)throwsThrowable{ Collection<InjectedElement>checkedElements=this.checkedElements;//带有注解的方法或者属性列表Collection<InjectedElement>elementsToIterate=(checkedElements!=null?checkedElements:this.injectedElements);if(!elementsToIterate.isEmpty()){ for(InjectedElementelement:elementsToIterate){ element.inject(target,beanName,pvs);}}}

       循环调用之前加入的带有注解的方法或者属性构建的对象AutowiredFieldElement#inject,AutowiredMethodElement#inject

/***属性上有注解构建的处理对象*/privateclassAutowiredFieldElementextendsInjectionMetadata.InjectedElement{ privatefinalbooleanrequired;privatevolatilebooleancached;@NullableprivatevolatileObjectcachedFieldValue;publicAutowiredFieldElement(Fieldfield,booleanrequired){ super(field,null);this.required=required;}@Overrideprotectedvoidinject(Objectbean,@NullableStringbeanName,@NullablePropertyValuespvs)throwsThrowable{ //获取属性名Fieldfield=(Field)this.member;Objectvalue;//Bean不是单例的话,会重复进入注入的这个操作,if(this.cached){ try{ value=resolvedCachedArgument(beanName,this.cachedFieldValue);}catch(NoSuchBeanDefinitionExceptionex){ //Unexpectedremovaloftargetbeanforcachedargument->re-resolvevalue=resolveFieldValue(field,bean,beanName);}}else{ //首次创建的时候进入该方法value=resolveFieldValue(field,bean,beanName);}if(value!=null){ //属性如果不为public的话,则设置为可访问ReflectionUtils.makeAccessible(field);field.set(bean,value);}}@NullableprivateObjectresolveFieldValue(Fieldfield,Objectbean,@NullableStringbeanName){ //构建DependencyDescriptor对象DependencyDescriptordesc=newDependencyDescriptor(field,this.required);desc.setContainingClass(bean.getClass());//注入bean的数量。有可能字段上是一个ListSet<String>autowiredBeanNames=newLinkedHashSet<>(1);Assert.state(beanFactory!=null,"NoBeanFactoryavailable");//获得beanFactory类型转换类TypeConvertertypeConverter=beanFactory.getTypeConverter();Objectvalue;try{ //查找依赖关系value=beanFactory.resolveDependency(desc,beanName,autowiredBeanNames,typeConverter);}catch(BeansExceptionex){ thrownewUnsatisfiedDependencyException(null,beanName,newInjectionPoint(field),ex);}synchronized(this){ if(!this.cached){ ObjectcachedFieldValue=null;if(value!=null||this.required){ cachedFieldValue=desc;//填入依赖关系registerDependentBeans(beanName,autowiredBeanNames);//判断如果注入依赖是只有一个if(autowiredBeanNames.size()==1){ StringautowiredBeanName=autowiredBeanNames.iterator().next();if(beanFactory.containsBean(autowiredBeanName)&&beanFactory.isTypeMatch(autowiredBeanName,field.getType())){ cachedFieldValue=newShortcutDependencyDescriptor(desc,autowiredBeanName,field.getType());}}}this.cachedFieldValue=cachedFieldValue;this.cached=true;}}returnvalue;}}/***方法上有注解构建的处理对象*/privateclassAutowiredMethodElementextendsInjectionMetadata.InjectedElement{ privatefinalbooleanrequired;privatevolatilebooleancached;@NullableprivatevolatileObject[]cachedMethodArguments;publicAutowiredMethodElement(Methodmethod,booleanrequired,@NullablePropertyDescriptorpd){ super(method,pd);this.required=required;}@Overrideprotectedvoidinject(Objectbean,@NullableStringbeanName,@NullablePropertyValuespvs)throwsThrowable{ //检查属性是不会在之前就已经注入过了。如果主如果则不进行二次覆盖if(checkPropertySkipping(pvs)){ return;}Methodmethod=(Method)this.member;Object[]arguments;if(this.cached){ try{ arguments=resolveCachedArguments(beanName);}catch(NoSuchBeanDefinitionExceptionex){ //Unexpectedremovaloftargetbeanforcachedargument->re-resolvearguments=resolveMethodArguments(method,bean,beanName);}}else{ //首次创建的时候进入该方法arguments=resolveMethodArguments(method,bean,beanName);}if(arguments!=null){ try{ //属性如果不为public的话,则设置为可访问ReflectionUtils.makeAccessible(method);//调用方法并传入参数method.invoke(bean,arguments);}catch(InvocationTargetExceptionex){ throwex.getTargetException();}}}@NullableprivateObject[]resolveCachedArguments(@NullableStringbeanName){ Object[]cachedMethodArguments=this.cachedMethodArguments;if(cachedMethodArguments==null){ returnnull;}Object[]arguments=newObject[cachedMethodArguments.length];for(inti=0;i<arguments.length;i++){ arguments[i]=resolvedCachedArgument(beanName,cachedMethodArguments[i]);}returnarguments;}@NullableprivateObject[]resolveMethodArguments(Methodmethod,Objectbean,@NullableStringbeanName){ //获取方法上有几个参数intargumentCount=method.getParameterCount();Object[]arguments=newObject[argumentCount];DependencyDescriptor[]descriptors=newDependencyDescriptor[argumentCount];Set<String>autowiredBeans=newLinkedHashSet<>(argumentCount);Assert.state(beanFactory!=null,"NoBeanFactoryavailable");TypeConvertertypeConverter=beanFactory.getTypeConverter();for(inti=0;i<arguments.length;i++){ //方法参数,从方法参数中取出i构造MethodParameter对象MethodParametermethodParam=newMethodParameter(method,i);DependencyDescriptorcurrDesc=newDependencyDescriptor(methodParam,this.required);currDesc.setContainingClass(bean.getClass());descriptors[i]=currDesc;try{ //获取方法中i参数的内容Objectarg=beanFactory.resolveDependency(currDesc,beanName,autowiredBeans,typeConverter);if(arg==null&

Spring AOP(2)代理类的创建ProxyFactoryBean

       åœ¨ Spring IOC(9) 里面介绍了三级缓存的时候,提到了AOP创建代理类的内容,有两个地方会去调用AbstractAutoProxyCreator.wrapIfNecessary()去创建代理类。

        这里面声明了三个bean,一个真实对象RealSubject,一个Advice,还有一个ProxyFactoryBean。

        三个bean创建的时机是不一样的,测试main通过getBean()创建subjectProxy,在populateBean的时候,会去创建subject对应的bean,而testAdvice是在initializeAdvisorChain的过程中通过getBean()进行实例化。

        再回顾一下FactoryBean的getObject流程:

        正常beanFactory.getBean("subjectProxy")创建的是ProxyFactoryBean,在populateBean的过程中,创建subject的实例,在这之后会调用getObjectForBeanInstance()方法,这里面就是Bean和FactoryBean的区别之处:

        上述流程简述了利用ProxyFactoryBean来创建代理对象的过程,通过XML来演示会比较直白,下面就通过spring aop配置看看是如何创建代理对象。

@Lazy注解源码分析

       @Lazy注解是Spring框架3.0版本后引入的,用于控制bean的懒加载行为,主要用途是延迟依赖注入的初始化。默认情况下,当ApplicationContext启动和刷新时,web界面 源码所有的单例bean会被立即初始化。然而,有时可能希望某些bean在首次使用时才被初始化。实现这一目标的方法是将@Lazy注解应用到bean或注入点,如@Autowired,以创建懒解析代理,从而实现延迟注入。

       @Lazy注解对@Bean、@Component或@Bean定义的bean的延迟初始化特别有用。当用在@Configuration类上时,它会影响该配置中的所有@Bean定义。通过在启动类入口使用AnnotationConfigApplicationContext并提供MyConfiguration组件类,从MyService bean获取并调用其show方法,可以观察到MyBean在首次被请求时才被初始化,汉字转成源码而MyService的初始化则立即进行。MyBean类的构造函数在被调用时打印"MyBean的构造函数被调用了!",show方法则打印"hello world!"。MyService类通过@Autowired注入MyBean,由于在注入点上添加了@Lazy注解,myBean的实际注入被延迟,直到首次尝试访问它时。

       源码分析表明,在启动类构造函数中,执行了三个步骤以初始化实例。在refresh方法中,重点关注了finishBeanFactoryInitialization方法,该方法会对所有剩余非懒加载的单例bean对象进行初始化,除非它们显式标记为懒加载。basic 2015源码在preInstantiateSingletons方法中,确保所有非懒加载的单例bean在容器启动时被初始化,除非它们被标记为懒加载。这使得@Lazy注解对于希望推迟bean初始化的场景非常有用。

       在getBean()方法中,通过doGetBean方法执行了创建bean的过程。在doCreateBean方法中,对bean的属性进行注入。在populateBean方法中,如果一个属性被标记为@Autowired,并且与@Lazy结合使用,那么实际的懒加载逻辑会在其他部分处理,特别是通过AutowiredAnnotationBeanPostProcessor。在resolveFieldValue方法中,解析@Autowired字段的值,并确定应为目标字段注入哪个bean。在resolveDependency方法中,如果依赖关系标记为懒加载,它将返回一个懒加载代理,只有在应用程序真正访问该依赖时,实际的bean才会被初始化。

       总结而言,@Lazy注解提供了在Spring容器中控制bean初始化的灵活性,允许开发者根据需要延迟依赖注入的初始化,从而优化应用性能和资源管理。在实践过程中,注意合理使用@Lazy注解,确保代码的清晰性和可维护性。同时,理解Spring容器在bean初始化过程中的工作原理,可以帮助开发者更有效地利用该框架的特性,实现更高效的应用开发。

Spring创建bean详解--实例化bean

       Spring框架中,创建bean是一个核心过程,下面将详细阐述其步骤。

       首先,进入createBean的入口,需要参考Spring的初始化单例池的相关内容。

       接下来,确认当前的bean定义已经解析了class,并复制当前的bean定义,这一步骤在AbstractAutowireCapableBeanFactory.createBean方法中执行。

       在实例化bean之前,会执行实现了InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法。如果该方法返回了对象,则会跳过实例化后的方法,并设置对象已实例化,返回当前bean。

       在实例化bean时,首先需要获取构造方法。这一过程包括以下步骤:从工厂bean的缓存中获取并移除缓存,如果不存在实例化bean,则进行推断构造方法。Spring使用SmartInstantiationAwareBeanPostProcessor的determineCandidateConstructors方法来推断构造方法。如果推断出有参数的构造方法,则使用有参构造方法进行初始化;否则,使用无参构造方法。

       对于无参实例化,使用CglibSubclassingInstantiationStrategy的instantiate方法。该方法包括获取Class、获取默认无参构造方法和创建实例对象并返回等步骤。

       在有参实例化时,基于bean工厂创建构造方法解析器,并对多个构造方法进行排序(根据参数的个数),使用第一个。接下来,获取有参构造方法的构造参数的参数数量,并判断是否使用ConstructorProperties指定参数的名字。如果没有指定,则获取参数的名字。然后,获取构造参数用于实例化bean,执行Autowired注解逻辑,并根据构造参数实例化bean并返回。

       在实例化完成后,执行postProcessMergedBeanDefinition切入点,添加三级缓存,并执行实例化后的切点服务,这一步在AbstractAutowireCapableBeanFactory.populateBean方法中完成。

相关栏目:热点