`
adapterofcoms
  • 浏览: 75386 次
  • 性别: Icon_minigender_1
  • 来自: 苏州
社区版块
存档分类
最新评论

Spring IOC BeanFactory ApplicationContext

 
阅读更多



BeanFactoryPostProcessor[e.g: PropertyPlaceholderConfigurer]可以修改BEAN的配置信息而BeanPostProcessor不能
PriorityOrdered

BeanPostProcessor Reference : http://jinnianshilongnian.iteye.com

五、五个接口十个扩展点解析

1InstantiationAwareBeanPostProcessor:实例化Bean后置处理器(继承BeanPostProcessor

postProcessBeforeInstantiation 在实例化目标对象之前执行,可以自定义实例化逻辑,如返回一个代理对象等,3.1处执行;如果此处返回的Bean不为null将中断后续Spring创建Bean的流程,且只执行postProcessAfterInitialization回调方法,如当AbstractAutoProxyCreator的实现者注册了TargetSourceCreator(创建自定义的TargetSource)将改变执行流程,不注册TargetSourceCreator我们默认使用的是SingletonTargetSource(即AOP代理直接保证目标对象),此处我们还可以使用如ThreadLocalTargetSource(线程绑定的Bean)、CommonsPoolTargetSource(实例池的Bean)等等,大家可以去spring官方文档了解TargetSource详情;

postProcessAfterInitialization Bean实例化完毕后执行的后处理操作,所有初始化逻辑、装配逻辑之前执行,如果返回false将阻止其他的InstantiationAwareBeanPostProcessorpostProcessAfterInstantiation的执行,(3.2和(9.1处执行;在此处可以执行一些初始化逻辑或依赖装配逻辑;

postProcessPropertyValues 完成其他定制的一些依赖注入和依赖检查等,如AutowiredAnnotationBeanPostProcessor执行@Autowired注解注入,CommonAnnotationBeanPostProcessor执行@Resource等注解的注入,PersistenceAnnotationBeanPostProcessor执行@ PersistenceContextJPA注解的注入,RequiredAnnotationBeanPostProcessor执行@ Required注解的检查等等,9.3处执行

 

2MergedBeanDefinitionPostProcessor:合并Bean定义后置处理器         (继承BeanPostProcessor

postProcessMergedBeanDefinition执行Bean定义的合并,在7.1处执行,且在实例化完Bean之后执行;

 

3SmartInstantiationAwareBeanPostProcessor:智能实例化Bean后置处理器(继承InstantiationAwareBeanPostProcessor

predictBeanType预测Bean的类型,返回第一个预测成功的Class类型,如果不能预测返回null;当你调用BeanFactory.getType(name)时当通过Bean定义无法得到Bean类型信息时就调用该回调方法来决定类型信息;BeanFactory.isTypeMatch(name, targetType)用于检测给定名字的Bean是否匹配目标类型(如在依赖注入时需要使用);

determineCandidateConstructors检测Bean的构造器,可以检测出多个候选构造器,再有相应的策略决定使用哪一个,如AutowiredAnnotationBeanPostProcessor实现将自动扫描通过@Autowired/@Value注解的构造器从而可以完成构造器注入,请参考【第十二章】零配置 12.2 注解实现Bean依赖注入 ——跟我学spring3 6.2.2.1处执行;

getEarlyBeanReference当正在创建A时,A依赖B,此时通过(8A作为ObjectFactory放入单例工厂中进行early expose,此处B需要引用A,但A正在创建,从单例工厂拿到ObjectFactory(其通过getEarlyBeanReference获取及早暴露Bean),从而允许循环依赖,此时AspectJAwareAdvisorAutoProxyCreator(完成xml风格的AOP配置(<aop:config>)将目标对象(A)包装到AOP代理对象)或AnnotationAwareAspectJAutoProxyCreator(完成@Aspectj注解风格(<aop:aspectj-autoproxy> @Aspect)将目标对象(A)包装到AOP代理对象),其返回值将替代原始的Bean对象,即此时通过early reference能得到正确的代理对象,8.1处实施;如果此处执行了,10.3.3处的AspectJAwareAdvisorAutoProxyCreatorAnnotationAwareAspectJAutoProxyCreatorpostProcessAfterInitialization将不执行,即这两个回调方法是二选一的;

 

4BeanPostProcessorBean后置处理器

postProcessBeforeInitialization实例化、依赖注入完毕,在调用显示的初始化之前完成一些定制的初始化任务,如BeanValidationPostProcessor完成JSR-303 @Valid注解Bean验证,InitDestroyAnnotationBeanPostProcessor完成@PostConstruct注解的初始化方法调用,ApplicationContextAwareProcessor完成一些Aware接口的注入(如EnvironmentAwareResourceLoaderAwareApplicationContextAware),其返回值将替代原始的Bean对象;10.2处执行;

postProcessAfterInitialization实例化、依赖注入、初始化完毕时执行,如AspectJAwareAdvisorAutoProxyCreator(完成xml风格的AOP配置(<aop:config>)的目标对象包装到AOP代理对象)、AnnotationAwareAspectJAutoProxyCreator(完成@Aspectj注解风格(<aop:aspectj-autoproxy> @Aspect)的AOP配置的目标对象包装到AOP代理对象),其返回值将替代原始的Bean对象;10.3.3处执行;此处需要参考getEarlyBeanReference

 

5DestructionAwareBeanPostProcessor:销毁Bean后置处理器(继承BeanPostProcessor

postProcessBeforeDestruction销毁后处理回调方法,该回调只能应用到单例Bean,如InitDestroyAnnotationBeanPostProcessor完成@PreDestroy注解的销毁方法调用;12.1.1处执行。

 

===================================================================

===================================================================

六、内置的一些BeanPostProcessor


 部分内置的BeanPostProcessor

此图只有内置的一部分。

 

1、ApplicationContextAwareProcessor

容器启动时会自动注册。注入那些实现ApplicationContextAwareMessageSourceAwareResourceLoaderAwareEnvironmentAware

EmbeddedValueResolverAwareApplicationEventPublisherAware标识接口的Bean需要的相应实例,在postProcessBeforeInitialization回调方法中进行实施,即10.2处实施

 

2CommonAnnotationBeanPostProcessor

CommonAnnotationBeanPostProcessor继承InitDestroyAnnotationBeanPostProcessor,当在配置文件有<context:annotation-config><context:component-scan>会自动注册。

 

提供对JSR-250规范注解的支持@javax.annotation.Resource@javax.annotation.PostConstruct@javax.annotation.PreDestroy等的支持。

 

2.1、通过@Resource注解进行依赖注入:

    postProcessPropertyValues:通过此回调进行@Resource注解的依赖注入;9.3处实施;

2.2、用于执行@PostConstruct @PreDestroy 注解的初始化和销毁方法的扩展点:

    postProcessBeforeInitialization()将会调用bean@PostConstruct方法;10.2处实施;

    postProcessBeforeDestruction()将会调用单例 Bean@PreDestroy方法(此回调方法会在容器销毁时调用),12.1.1处实施

 

详见【第十二章】零配置 12.2 注解实现Bean依赖注入 ——跟我学spring3JSR-250注解部分。

 

3AutowiredAnnotationBeanPostProcessor

当在配置文件有<context:annotation-config><context:component-scan>会自动注册。

 

提供对JSR-330规范注解的支持和Spring自带注解的支持。

 

3.1Spring自带注解的依赖注入支持,@Autowired@Value

    determineCandidateConstructors :决定候选构造器;详见【12.2中的构造器注入】;6.2.2.1处实施;

postProcessPropertyValues:进行依赖注入;详见【12.2中的字段注入和方法参数注入】;9.3处实施;

3.2、对JSR-330规范注解的依赖注入支持,@Inject

    2.1类似只是查找使用的注解不一样;

 

详见【第十二章】零配置 12.2 注解实现Bean依赖注入 ——跟我学spring3Spring自带依赖注入注解和 JSR-330注解部分。

 

4RequiredAnnotationBeanPostProcessor

当在配置文件有<context:annotation-config><context:component-scan>会自动注册。

 

4.1、提供对@ Required注解的方法进行依赖检查支持:

    postProcessPropertyValues:如果检测到没有进行依赖注入时抛出BeanInitializationException异常;9.3处实施;

 

详见【第十二章】零配置 12.2 注解实现Bean依赖注入 ——跟我学spring3@Required:依赖检查

 

5PersistenceAnnotationBeanPostProcessor

当在配置文件有<context:annotation-config><context:component-scan>会自动注册。

 

5.1、通过对JPA @ javax.persistence.PersistenceUnit@ javax.persistence.PersistenceContext注解进行依赖注入的支持;

    postProcessPropertyValues 根据@PersistenceUnit/@PersistenceContext进行EntityManagerFactoryEntityManager的支持;

 

6AbstractAutoProxyCreator

AspectJAwareAdvisorAutoProxyCreatorAnnotationAwareAspectJAutoProxyCreator都是继承AbstractAutoProxyCreatorAspectJAwareAdvisorAutoProxyCreator提供对(<aop:config>)声明式AOP的支持,AnnotationAwareAspectJAutoProxyCreator提供对(<aop:aspectj-autoproxy>)注解式(@AspectJAOP的支持,因此只需要分析AbstractAutoProxyCreator即可。

 

当使用<aop:config>配置时自动注册AspectJAwareAdvisorAutoProxyCreator,而使用<aop:aspectj-autoproxy>时会自动注册AnnotationAwareAspectJAutoProxyCreator

 

6.1predictBeanType:预测Bean的类型,如果目标对象被AOP代理对象包装,此处将返回AOP代理对象的类型;

Java代码  收藏代码
  1. public Class<?> predictBeanType(Class<?> beanClass, String beanName) {  
  2.         Object cacheKey = getCacheKey(beanClass, beanName);  
  3.         return this.proxyTypes.get(cacheKey); //获取代理对象类型,可能返回null  
  4. }  

6.2postProcessBeforeInstantiation

Java代码  收藏代码
  1. public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {  
  2.     //1、得到一个缓存的唯一key(根据beanClass和beanName生成唯一key)  
  3.     Object cacheKey = getCacheKey(beanClass, beanName);  
  4.     //2、如果当前targetSourcedBeans(通过自定义TargetSourceCreator创建的TargetSource)不包含cacheKey  
  5.     if (!this.targetSourcedBeans.contains(cacheKey)) {  
  6.         //2.1、advisedBeans(已经被增强的Bean,即AOP代理对象)中包含当前cacheKey或nonAdvisedBeans(不应该被增强的Bean)中包含当前cacheKey 返回null,即走Spring默认流程  
  7.         if (this.advisedBeans.contains(cacheKey) || this.nonAdvisedBeans.contains(cacheKey)) {  
  8.             return null;  
  9.         }  
  10.         //2.2、如果是基础设施类(如Advisor、Advice、AopInfrastructureBean的实现)不进行处理  
  11.         //2.2、 shouldSkip 默认false,可以生成子类覆盖,如AspectJAwareAdvisorAutoProxyCreator覆 盖    (if (((AbstractAspectJAdvice) advisor.getAdvice()).getAspectName().equals(beanName)) return true;  即 如果是自己就跳过)  
  12.         if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {  
  13.             this.nonAdvisedBeans.add(cacheKey);//在不能增强的Bean列表缓存当前cacheKey  
  14.             return null;  
  15.         }  
  16.     }  
  17.   
  18.     //3、开始创建AOP代理对象  
  19.     //3.1、配置自定义的TargetSourceCreator进行TargetSource创建  
  20.     TargetSource targetSource = getCustomTargetSource(beanClass, beanName);  
  21.     if (targetSource != null) {  
  22.         //3.2、如果targetSource不为null 添加到targetSourcedBeans缓存,并创建AOP代理对象  
  23.         this.targetSourcedBeans.add(beanName);  
  24.         // specificInterceptors即增强(包括前置增强、后置增强等等)  
  25.         Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);  
  26.         //3.3、创建代理对象  
  27.         Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);  
  28.         //3.4、将代理类型放入proxyTypes从而允许后续的predictBeanType()调用获取  
  29.         this.proxyTypes.put(cacheKey, proxy.getClass());  
  30.         return proxy;  
  31.     }  
  32.     return null;  
  33. }  

  从如上代码可以看出,当我们配置TargetSourceCreator进行自定义TargetSource创建时,会创建代理对象并中断默认Spring创建流程。

 

6.3getEarlyBeanReference

Java代码  收藏代码
  1. //获取early Bean引用(只有单例Bean才能回调该方法)  
  2. public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {  
  3.     Object cacheKey = getCacheKey(bean.getClass(), beanName);  
  4.     //1、将cacheKey添加到earlyProxyReferences缓存,从而避免多次重复创建  
  5.     this.earlyProxyReferences.add(cacheKey);  
  6.     //2、包装目标对象到AOP代理对象(如果需要)  
  7.     return wrapIfNecessary(bean, beanName, cacheKey);  
  8. }  

 

6.4postProcessAfterInitialization

Java代码  收藏代码
  1. public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {  
  2.     if (bean != null) {  
  3.         Object cacheKey = getCacheKey(bean.getClass(), beanName);  
  4.         //1、如果之前调用过getEarlyBeanReference获取包装目标对象到AOP代理对象(如果需要),则不再执行  
  5.         if (!this.earlyProxyReferences.contains(cacheKey)) {  
  6.             //2、包装目标对象到AOP代理对象(如果需要)  
  7.             return wrapIfNecessary(bean, beanName, cacheKey);  
  8.         }  
  9.     }  
  10.     return bean;  
  11. }  

 

Java代码  收藏代码
  1. protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {  
  2.     if (this.targetSourcedBeans.contains(beanName)) {//通过TargetSourceCreator进行自定义TargetSource不需要包装  
  3.         return bean;  
  4.     }  
  5.     if (this.nonAdvisedBeans.contains(cacheKey)) {//不应该被增强对象不需要包装  
  6.         return bean;  
  7.     }  
  8.     if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {//基础设施/应该skip的不需要保证  
  9.         this.nonAdvisedBeans.add(cacheKey);  
  10.         return bean;  
  11.     }  
  12.   
  13.     // 如果有增强就执行包装目标对象到代理对象  
  14.     Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);  
  15.     if (specificInterceptors != DO_NOT_PROXY) {  
  16.         this.advisedBeans.add(cacheKey);//将cacheKey添加到已经被增强列表,防止多次增强  
  17.         Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));//创建代理对象  
  18.         this.proxyTypes.put(cacheKey, proxy.getClass());//缓存代理类型  
  19.         return proxy;  
  20.     }  
  21.     this.nonAdvisedBeans.add(cacheKey);  
  22.     return bean;  
  23. }  

  

从如上流程可以看出 getEarlyBeanReferencepostProcessAfterInitialization是二者选一的,而且单例Bean目标对象只能被增强一次,而原型Bean目标对象可能被包装多次。

 

7BeanValidationPostProcessor

默认不自动注册,Spring3.0开始支持。

 

提供对JSR-303验证规范支持。

 

根据afterInitializationfalse/true决定调用postProcessBeforeInitializationpostProcessAfterInitialization来通过JSR-303规范验证Bean,默认false

 

8MethodValidationPostProcessor

Spring3.1开始支持,且只支持Hibernate Validator 4.2及更高版本,从Spring 3.2起可能将采取自动检测Bean Validation 1.1兼容的提供商且自动注册(Bean Validation 1.1 (JSR-349)正处于草案阶段,它将提供方法级别的验证,提供对方法级别的验证),目前默认不自动注册。

 

Bean Validation 1.1草案请参考http://jcp.org/en/jsr/detail?id=349    http://beanvalidation.org/

 

提供对方法参数/方法返回值的进行验证(即前置条件/后置条件的支持),通过JSR-303注解验证,使用方式如:

public @NotNull Object myValidMethod(@NotNull String arg1, @Max(10) int arg2)

 

默认只对@org.springframework.validation.annotation.Validated注解的Bean进行验证,我们可以修改validatedAnnotationType为其他注解类型来支持其他注解验证。而且目前只支持Hibernate Validator实现,在未来版本可能支持其他实现。

 

有了这东西之后我们就不需要在进行如Assert.assertNotNull()这种前置条件/后置条件的判断了。

 

9ScheduledAnnotationBeanPostProcessor

当配置文件中有<task:annotation-driven>自动注册或@EnableScheduling自动注册。

 

提供对注解@Scheduled任务调度的支持。

 

postProcessAfterInitialization:通过查找Bean对象类上的@Scheduled注解来创建ScheduledMethodRunnable对象并注册任务调度方法(仅返回值为void且方法是无形式参数的才可以)。

 

可参考Spring官方文档的任务调度章节学习@Scheduled注解任务调度。

 

10AsyncAnnotationBeanPostProcessor

当配置文件中有<task:annotation-driven>自动注册或@EnableAsync自动注册。

 

提供对@ AsyncEJB3.1@javax.ejb.Asynchronous注解的异步调用支持。

 

postProcessAfterInitialization:通过ProxyFactory创建目标对象的代理对象,默认使用AsyncAnnotationAdvisor(内部使用AsyncExecutionInterceptor 通过AsyncTaskExecutor(继承TaskExecutor)通过submit提交异步任务)。

 

可参考Spring官方文档的异步调用章节学习@Async注解异步调用。

 

11ServletContextAwareProcessor

在使用Web容器时自动注册。

 

类似于ApplicationContextAwareProcessor,当你的Bean 实现了ServletContextAware/ ServletConfigAware会自动调用回调方法注入ServletContext/ ServletConfig

 

===================================================================

===================================================================

七、BeanPostProcessor如何注册

1ApplicationContextAwareProcessor会在ApplicationContext容器启动时自动注册,而CommonAnnotationBeanPostProcessorAutowiredAnnotationBeanPostProcessor会在当你使用<context:annotation-config><context:component-scan>配置时自动注册。

2只要将BeanPostProcessor注册到容器中,Spring会在启动时自动获取并注册。

 

===================================================================

===================================================================

八、BeanPostProcessor的执行顺序

1、如果使用BeanFactory实现,非ApplicationContext实现,BeanPostProcessor执行顺序就是添加顺序。

 

2、如果使用的是AbstractApplicationContext(实现了ApplicationContext)的实现,则通过如下规则指定顺序。

2.1PriorityOrdered(继承了Ordered),实现了该接口的BeanPostProcessor会在第一个顺序注册,标识高优先级顺序,即比实现Ordered的具有更高的优先级;

2.2Ordered,实现了该接口的BeanPostProcessor会第二个顺序注册;

 

int HIGHEST_PRECEDENCE = Integer.MIN_VALUE;//最高优先级

int LOWEST_PRECEDENCE = Integer.MAX_VALUE;//最低优先级

 

即数字越小优先级越高,数字越大优先级越低,如0(高优先级)——1000(低优先级)

 

2.3、无序的,没有实现Ordered/ PriorityOrdered的会在第三个顺序注册;

2.4、内部Bean后处理器,实现了MergedBeanDefinitionPostProcessor接口的是内部Bean PostProcessor,将在最后且无序注册。

 

 

3、接下来我们看看内置的BeanPostProcessor执行顺序

 

//1注册实现了PriorityOrdered接口的BeanPostProcessor

 

//2注册实现了Ordered接口的BeanPostProcessor

AbstractAutoProxyCreator              实现了Orderedorder = Ordered.LOWEST_PRECEDENCE

MethodValidationPostProcessor          实现了OrderedLOWEST_PRECEDENCE

ScheduledAnnotationBeanPostProcessor   实现了OrderedLOWEST_PRECEDENCE

AsyncAnnotationBeanPostProcessor      实现了Orderedorder = Ordered.LOWEST_PRECEDENCE

 

//3注册无实现任何接口的BeanPostProcessor

BeanValidationPostProcessor            无序

ApplicationContextAwareProcessor       无序

ServletContextAwareProcessor          无序

 

//3 注册实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor,且按照实现了Ordered的顺序进行注册,没有实现Ordered的默认为Ordered.LOWEST_PRECEDENCE

PersistenceAnnotationBeanPostProcessor  实现了PriorityOrderedOrdered.LOWEST_PRECEDENCE - 4

AutowiredAnnotationBeanPostProcessor   实现了PriorityOrderedorder = Ordered.LOWEST_PRECEDENCE - 2

RequiredAnnotationBeanPostProcessor    实现了PriorityOrderedorder = Ordered.LOWEST_PRECEDENCE - 1

CommonAnnotationBeanPostProcessor    实现了PriorityOrderedOrdered.LOWEST_PRECEDENCE

 

从上到下顺序执行,如果order相同则我们应该认为同序(谁先执行不确定,其执行顺序根据注册顺序决定)。

 

===================================================================

===================================================================

九、完成Spring事务处理时自我调用的解决方案及一些实现方式的风险分析

场景请先参考请参考Spring事务处理时自我调用的解决方案及一些实现方式的风险中的3.3、通过BeanPostProcessor 在目标对象中注入代理对象。

 

 

分析:


 

 

问题出现在59处:

 

5、使用步骤1处注册的SingletonFactoryObjectFactory.getObject() 使用AnnotationAwareAspectJAutoProxyCreatorgetEarlyBeanReference获取循环引用Bean),因此此处将返回A目标对象的代理对象;

 

9、此处调用AnnotationAwareAspectJAutoProxyCreatorpostProcessAfterInitialization但发现之前调用过AnnotationAwareAspectJAutoProxyCreatorgetEarlyBeanReference获取代理对象,此处不再创建代理对象,而是直接返回目标对象,因此使用InjectBeanSelfProcessor不能注入代理对象;但此时的Spring容器中的A已经是代理对象了,因此我使用了从上下文重新获取A代理对象的方式注入(context.getBean(beanName))。

 

此处的getEarlyBeanReferencepostProcessAfterInitialization为什么是二者选一的请参考之前介绍的AbstractAutoProxyCreator

 

到此问题我们分析完毕,实际项目中的循环依赖应该尽量避免,这违反了“无环依赖原则”。

 

 

分享到:
评论

相关推荐

    实验一 Springioc基本操作.docx

    SpringIOC是Spring Framework中的核心组件之一,负责管理应用程序中的对象、依赖关系和生命周期。 在 Spring IOC 中,对象的创建和管理是通过 BeanFactory 或 ApplicationContext 实现的。BeanFactory 是 Spring ...

    Spring IoC源码深度剖析开源架构源码2021.pdf

    - `BeanFactory` 是Spring IoC容器的顶层接口,代表了IoC容器的基础原则和能力。其不能被实例化,提供了一套IoC容器必须遵循的基本原则。 - `ApplicationContext` 是在 `BeanFactory` 的基础上,添加了更多功能的...

    spring ioc思维导图源文件

    - **应用上下文(ApplicationContext)**:是BeanFactory的扩展,除了提供BeanFactory的所有功能外,还增加了国际化支持、事件传播、AOP等功能,更适合企业级应用。 **3. Bean的定义与实例化** - **XML配置**:...

    spring ioc

    Spring 还提供了接口如 `ApplicationContext` 和 `BeanFactory` 用于获取和管理 Bean。例如,我们可以这样从容器中获取 Bean: ```java ApplicationContext context = new ClassPathXmlApplicationContext("beans....

    Spring IOC容器实现分析.pdf 下载

    Spring的IOC容器主要由BeanFactory和ApplicationContext两个接口构成。BeanFactory是Spring的基础容器,提供了基本的对象管理功能;ApplicationContext则是在BeanFactory的基础上扩展,增加了更多企业级应用的功能,...

    Spring IOC.pdf

    2. 配置Spring的IoC容器,如创建applicationContext.xml文件,并在其中配置Bean,比如定义一个数据访问对象(DAO)或服务层对象(Service)。 3. 在Java代码中利用Spring的依赖注入特性,例如使用@Autowired注解来...

    Spring IOC源码解读

    Spring的IOC容器主要有两种类型:BeanFactory和ApplicationContext。BeanFactory是最基础的容器,它实现了基本的IOC功能,如加载和管理Bean的定义。BeanDefinition是Spring中用于描述Bean实例的关键数据结构,包含了...

    Spring ioc源码解读

    - **BeanFactory**:这是Spring提供的最基础的IoC容器接口,定义了一些用于获取Bean实例的基础方法。如`getBean`用于获取指定名称的Bean实例;`containsBean`用于检查是否存在指定名称的Bean;`isSingleton`用于判断...

    手写spring ioc(三) 资源org.zip

    在本资源"手写spring ioc(三) 资源org.zip"中,我们主要关注的是如何实现一个简易版的Spring IOC(Inversion of Control)容器,它涵盖了ioc的基本功能,包括解决循环依赖、使用构造器注入以及自动注入等核心特性。...

    Spring IOC:找对象的一次革命(1)

    Spring IoC提供了BeanFactory和ApplicationContext两种容器类型,其中BeanFactory是基础的IoC容器,而ApplicationContext则提供了更多高级功能,如资源加载、事件发布等。 Spring IoC的配置主要通过XML或注解的方式...

    Spring-ioc-jar

    Spring框架的IOC容器是其核心组件,主要由`ApplicationContext`和`BeanFactory`两个接口代表。`BeanFactory`是基础,它负责管理Bean的创建、配置和依赖关系。而`ApplicationContext`则是在`BeanFactory`基础上增加了...

    Spring IOC基础jar包

    它包含了`ApplicationContext`接口,是所有Spring应用的基础。此外,它还支持事件传播、国际化和资源访问。 2. `org.springframework.beans-3.0.6.RELEASE.jar`: 这个jar包是处理Java Bean的核心库,它包含了对Bean...

    Spring的IoC容器初始化源码解析

    在Spring中,IoC容器主要分为两大类:`BeanFactory`和`ApplicationContext`。 ##### 3.1 BeanFactory简介 `BeanFactory`是最基本的IoC容器实现,它主要负责创建和管理bean的生命周期。BeanFactory提供了一系列基础...

    Spring获取ApplicationContext对象工具类的实现方法

    通常我们会在初始化Spring IoC容器时加载配置文件,然后获取到这个容器的实例。但有时候,特别是在多模块项目或者非Web应用中,我们需要一种更加灵活的方式来获取ApplicationContext。 一种常见的做法是实现一个...

    spring ioc以及事物架构图

    2. **创建BeanFactory实例**:接着,创建一个`DefaultListableBeanFactory`实例,它继承自`AbstractAutowireCapableBeanFactory`,是Spring IoC容器的核心实现之一。 ```java DefaultListableBeanFactory factory ...

    简单模拟Spring的beanFactory

    `BeanFactory`是Spring框架中最基础的bean管理容器,它是所有更高级别的容器(如`ApplicationContext`)的基类。它负责实例化、配置、存储和管理bean。在实际的Spring框架中,`BeanFactory`接口提供了许多方法,如`...

    Spring源码分析_Spring_IOC

    总结来说,Spring的IOC容器机制通过`BeanFactory`和`ApplicationContext`接口的实现,提供了强大且灵活的对象管理和依赖注入能力,极大地简化了Java应用的开发和维护过程。通过深入理解IOC容器的创建与初始化流程,...

    spring_ioc spring ioc

    - **BeanFactory与ApplicationContext**:BeanFactory是最基础的IoC容器,提供了最基本的IoC功能,如Bean的定义、配置和管理等。而ApplicationContext则是BeanFactory的扩展,提供了更多企业级服务的支持,如国际化...

    Spring IOC 笔记

    Spring 提供了两种类型的容器:BeanFactory 和 ApplicationContext。BeanFactory 是最基础的容器,它可以加载配置元数据并创建 Bean 实例。ApplicationContext 在 BeanFactory 基础上增加了更多企业级服务,如消息...

Global site tag (gtag.js) - Google Analytics