Spring源码解析,spring源码【nba买球】

作者:计算机教程

Spring源码解析,spring源码

我们先来看类图吧:

除了BeanFactory这一支的接口,AbstractBeanFactory主要实现了AliasRegistry和SingletonBeanRegistry接口.

这边主要提供了这样的三个功能: 别名管理,单例创建与注册,工厂方法FactoryBean支持.

nba买球 1

 

我们来看看这些接口,类的主要职责吧:

BeanFactory Spring IOC容器的根接口

-- HierachicalBeanFactory 实现容器的继承,就是可以有父 BeanFactory

-- -- ConfigureabelBeanFactory 提供factory的配置功能

AliasRegistry 定义bean name的别名管理

-- SimpleAliasRegistry 在实现别名管理接口基础上,添加一个canonicalName查找类真是名称api

SingletonBeanRegistry 提供单例注册,查询服务

-- DefaultSingletonBeanRegistry 实现单例与DisposableBean的生命周期管理(创建,维护,销毁)

-- -- FactoryBeanRegistrySupport 添加工厂方式创建类FactoryBean的支持

-- -- -- AbstractBeanFactory BeanFactory的抽象实现.

 

也就是说这边可以分为这样几类职责:

a, 类别名管理

b, 单例生命周期管理

c, 工厂方法初始化类对应的FactoryBean

d, BeanFactory容器

 

BeanFactory容器的职责(BeanFactory,HierachicalBeanFactory,ConfigureableBeanFactory)在上一篇文章<Spring源码解析

  • BeanFactory接口体系解读>里已经分析过,有兴趣可以看下.

我们今天主要分析其他的三个职责,如下的接口与类(顺便做目录):

  1. AliasRegistry 定义bean name的别名管理

  2. SimpleAliasRegistry 实现别名管理接口

  3. SingletonBeanRegistry 提供单例注册,查询服务

  4. DefaultSingletonBeanRegistry 实现单例与DisposableBean的生命周期管理(创建,维护,销毁)

  5. FactoryBeanRegistrySupport 添加工厂方式创建类FactoryBean的支持

 

 

1. AliasRegistry 定义bean name的别名管理

提供别名的注册,查找,删除,判断定义.

 看个类图就行,不用展开.

nba买球 2

 

 

2. SimpleAliasRegistry 实现别名管理接口

这边除了实现接口定义的api,还添加了两个公共api:

  批量校验别名public void resolveAliases(StringValueResolver valueResolver)和查找别名对应的原始类名public String canonicalName(String name)

 

这边以别名为key缓存数据.

1     /** Map from alias to canonical name */
2     private final Map<String, String> aliasMap = new ConcurrentHashMap<String, String>(16);

 

分析下api实现逻辑吧:

2.1 别名注册 registerAlias(String name, String alias)

nba买球 3

2.2 删除别名public void removeAlias(String alias)

  校验下,如果别名不存在报错:throw new IllegalStateException("No alias '" alias "' registered");

 

2.3 判断别名是否存在

  直接使用ConcurrentHashMap的containsKey

2.4 获取别名public String[] getAliases(String name)

  主要逻辑是加了个锁,然后是递归调用retrieveAliases,查找多层次的别名(就是查找别名的别名这些下去)

2.5 使用StringValueResolver解析类名,别名后,进行循环依赖的校验

  这边使用的是StringValueResolver的接口,具体实现需要靠注入

 

 

3. SingletonBeanRegistry 提供单例注册,查询服务

这边定义的单例注册,有点门道,主要就是相对BeanFactory的api而言有点low,没有做附加的处理.

  注册的时候不管注入afterPropertiesSet的初始化回调.

  查找的时候不管还没初始化的单例不说,还不管别名问题,不管FactoryBean如何区分是获取FactoryBean本身还是getObject初始化的实例.

 

咱们一个个api分析吧.

3.1 注册单例 void registerSingleton(String beanName, Object singletonObject);

  这边的实现不会再调用 初始化回调函数,如InitializingBean 的afterPropertiesSet,所以这边应该接收的是完成初始化的实例

  同理也不会调用销毁的回调,如DisposableBean的destroy

  这跟标准的BeanFactory中注册单例是明显不同的,因为那边是会调用各种回调.

 

3.2 查找单例 Object getSingleton(String beanName); 

      String[] getSingletonNames();

      int getSingletonCount();

  设计于访问手动注册的单例.

  这边只会查找已经初始化完毕 的单例,有bean definition但没有实例化的这边查找不到.

  这边也不会处理FactoryBean的情况(就是具体获取getObject还是factoryBean本身的区分,&),别名也需要预先转化好了来查.

 

3.3 判断是否保护单例 boolean containsSingleton(String beanName);

  只有单例已经实例化才会返回true,剩下的看3.2 查找单例的说明吧,一样的.

 

 

4. DefaultSingletonBeanRegistry 实现单例与DisposableBean的生命周期管理(创建,维护,销毁)

 在SingletonBeanRegistry注册的基础上,添加单例的共享.

也支持容器关闭时,DisposableBean实例的销毁

 

4.1 这边注册时,通过下面四个变量来维护:

  Map<String, Object> singletonObjects 缓存以bean name为key的单例实例

  Map<String, ObjectFactory> singletonFactories 缓存以bean name 为key的ObjectFactory

  Map<String, Object> earlySingletonObjects 用于解决单例时的循环依赖,这边缓存以bean name为key的预初始化单例

  Set<String> registeredSingletons 已经注册好的单例bean name

  这边singletonObjects和registeredSingletons的数据应该是同步的,只是适用于不同的场景,但他们俩跟singletonFactories 和earlySingletonObjects分别互斥,就是singletonObjects里有了,这两个肯定没有.

  

  同时这边也有inCreationCheckExclusions和singletonsCurrentlyInCreation进行锁控制的概念.

    singletonsCurrentlyInCreation缓存bean正在被初始化,这样就不能再发起初始化;

    inCreationCheckExclusions 直接缓存当前不能加载的bean

  这部分看个例子就,清晰了,初始化前需要先使用beforeSingletonCreation判断

    这边inCreationCheckExclusions不包含beanName才会去判断singletonsCurrentlyInCreation

1     protected void beforeSingletonCreation(String beanName) {
2         if (!this.inCreationCheckExclusions.containsKey(beanName) &&
3                 this.singletonsCurrentlyInCreation.put(beanName, Boolean.TRUE) != null) {
4             throw new BeanCurrentlyInCreationException(beanName);
5         }
6     }

 

4.2 管理bean的依赖问题

  使用如下三个属性进行管理:

  Map<String, Set<String>> containedBeanMap  依赖的bean name为key , 就是依赖类 -> 查找 被依赖的类

  Map<String, Set<String>> dependentBeanMap  依赖的原始bean name为key

  Map<String, Set<String>> dependenciesForBeanMap  被依赖的bean name为key

 

4.3 bean 销毁

  这不过跟初始化类似,自行看代码比较简单.    

 

 

5. FactoryBeanRegistrySupport 添加工厂方式创建类FactoryBean的支持

添加对FactoryBean的支持,就是使用工厂方法初始化类.

这里主要涉及3个新概念:FactoryBean,BeanPostProcessor和AccessController.这三个概念懂了,源码也就分析完了.

 

5.1 FactoryBean,通过T getObject() api提供简单工厂方法,可用用于创建单例,原型模式的实例.主要用于创建过程复杂,xml配置不方便的情况.

  其实这个就是使用spring的接口对简单工厂设计模式做了一个规范,方便大家在spring中配置使用.

  具体直接看<Spring配置bean的方法(工厂方法和Factorybean)>

 

5.2 BeanPostProcessor用于bean 初始化时进行功能增强,类似web开发中的filter.

  这边有两个api:

  postProcessBeforeInitialization 在类初始化前调用,比InitializaingBean 的 setPropertiesSet 和 xml文件中自定义的init-method方法执行都早

  postProcessAfterInitialization 类初始话后调用,在InitializaingBean 的 setPropertiesSet 和 xml文件中自定义的init-method方法之后执行

 

5.3 AccessController jdk的安全控制,跟spring关联不大,还是度娘吧,不多写了.

  在 Java 中将执行程序分成本地和远程两种,本地代码默认视为可信任的,而远程代码则被看作是不受信的。对于授信的本地代码,可以访问一切本地资源。

  在应用开发中还有一些关于安全的复杂用法,其中最常用到的 API 就是 doPrivileged。doPrivileged 方法能够使一段受信任代码获得更大的权限,甚至比调用它的应用程序还要多,可做到临时访问更多的资源。

所以就出现了spring中的典型代码

 1 if (System.getSecurityManager() != null) {
 2     AccessControlContext acc = getAccessControlContext();
 3     try {
 4         object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
 5             public Object run() throws Exception {
 6                     return factory.getObject();
 7                 }
 8             }, acc);
 9     }
10     catch (PrivilegedActionException pae) {
11         throw pae.getException();
12     }
13 }else {
14     object = factory.getObject();
15 }

 

http://www.bkjia.com/Javabc/1108357.htmlwww.bkjia.comtruehttp://www.bkjia.com/Javabc/1108357.htmlTechArticleSpring源码解析,spring源码 我们先来看类图吧: 除了BeanFactory这一支的接口,AbstractBeanFactory主要实现了AliasRegistry和SingletonBeanRegistry接口. 这边主...

Spring源码解析,spring源码

不知道为什么看着Spring的源码,感触最深的是Spring对概念的抽象,所以我就先学接口了.

 

BeanFactory是Spring IOC实现的基础,这边定义了一系列的接口,我们通过这些接口的学习,可以大致了解BeanFactory体系各接口如何分工合作.

为学习具体实现打下基础.毕竟这边逻辑复杂,涉及的概念很多.

nba买球 4

BeanFactory 是Spring bean容器的根接口.提供获取bean,是否包含bean,是否单例与原型,获取bean类型,bean 别名的api.

-- AutowireCapableBeanFactory 添加集成其他框架功能.如果集成WebWork则可以使用Spring对Actions等进行管理.

-- HierarchicalBeanFactory 提供父容器的访问功能

-- -- ConfigurableBeanFactory 如名,提供factory的配置功能,眼花缭乱好多api

-- -- -- ConfigurableListableBeanFactory 集大成者,提供解析,修改bean定义,并与初始化单例.

-- ListableBeanFactory 提供容器内bean实例的枚举功能.这边不会考虑父容器内的实例.

 

看到这边,我们是不是想起了设计模式原则里的接口隔离原则

 Interface Segregation Principle(ISP):客户端不应该依赖它不需要的接口;类间的依赖关系应该建立在最小的接口上

对这个有兴趣的话,找度娘或者看看这个设计模式六大原则(4):接口隔离原则

 

这边清晰地定义了如下的体系:

  根接口BeanFactory(基础容器)

  第二层: 第三方集成,继承体系,遍历bean

  第三层: 配置功能

  第四层: 配置 迭代

  

接下来具体分析下各个接口吧(顺便做目录):

  1. BeanFactory

  2. AutowireCapableBeanFactory

  3. HierarchicalBeanFactory

  4. ListableBeanFactory

  5. ConfigurableBeanFactory

  6. ConfigableListableBeanFactory

 

1. BeanFactory

BeanFactory是Spring bean容器的根接口.

每个bean都是通过string类型bean name进行标识.这边提供了设计模式单例,原型的替代实现.

  如果bean name配置为单例,应用内只会获取到一个实例.如果配置为原型,那么可以实例化好后填充属性(基于用户的配置).

BeanFactory作为应用集中配置管理的地方,极大简便应用开发,这样开发人员可以集中与业务.

 

BeanFactory需要管理bean的生命周期,比如初始化时需要按顺序实现如下接口:

  1. BeanNameAware's {@code setBeanName}
  2. BeanClassLoaderAware's {@code setBeanClassLoader}
  3. BeanFactoryAware's {@code setBeanFactory}
  4. ResourceLoaderAware's {@code setResourceLoader}仅对application context有效
  5. ApplicationEventPublisherAware's {@code setApplicationEventPublisher}仅对application context有效
  6. MessageSourceAware's {@code setMessageSource}仅对application context有效
  7. ApplicationContextAware's {@code setApplicationContext}仅对application context有效
  8. ServletContextAware's {@code setServletContext}仅对application context有效
  9. {@code postProcessBeforeInitialization} methods of BeanPostProcessors
nba买球,  10. InitializingBean's {@code afterPropertiesSet}
  11. a custom init-method definition xml中配置的init-method
  12. {@code postProcessAfterInitialization} methods of BeanPostProcessors

还有关闭容器的接口:

  1. DisposableBean's {@code destroy}
  2. a custom destroy-method definition xml配置中的destroy-method

 

接口里定义了一个变量String FACTORY_BEAN_PREFIX = "&";

  这是用来区分是获取FactoryBean还是FactoryBean的createBean创建的实例.如果&开始则获取FactoryBean;否则获取createBean创建的实例.

我们来看下定义的方法:

  a, 获取bean,这边可以实现单例,原型

    Object getBean(String name) throws BeansException; 可以用别名查找哦

    <T> T getBean(String name, Class<T> requiredType) throws BeansException;

    <T> T getBean(Class<T> requiredType) throws BeansException; 这边的类型可以是接口或者子类,但不能是null

    Object getBean(String name, Object... args) throws BeansException;

  b, 判断是否包含bean.陷阱出现:这边不管类是否抽象类,懒加载,是否在容器范围内,只要符合都返回true,所以这边true,不一定能从getBean获取实例

    boolean containsBean(String name);

  c, 单例,原型,bean类型的判断

    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;

  d, 获取bean 的类型,别名

    Class<?> getType(String name) throws NoSuchBeanDefinitionException;

    String[] getAliases(String name);

 

2. AutowireCapableBeanFactory

在BeanFactory基础上实现对已存在实例的管理.

可以使用这个接口集成其它框架,捆绑并填充并不由Spring管理生命周期并已存在的实例.像集成WebWork的Actions 和Tapestry Page就很实用.

一般应用开发者不会使用这个接口,所以像ApplicationContext这样的外观实现类不会实现这个接口,如果真手痒痒可以通过ApplicationContext的getAutowireCapableBeanFactory接口获取. 

 

这边定义了5种自动装配策略:不注入AUTOWIRE_NO,使用bean name策略装配AUTOWIRE_BY_NAME,使用类型装配策略AUTOWIRE_BY_TYPE,使用构造器装配策略AUTOWIRE_CONSTRUCTOR,自动装配策略AUTOWIRE_AUTODETECT

  这边的自动策略是先尝试构造器,然后才是byType.这边应该是跟xml配置文件中的装配策略对应.

继续看定义的api:

  a, 创建和填充外部bean实例的典型方法

    <T> T createBean(Class<T> beanClass) throws BeansException;

    void autowireBean(Object existingBean) throws BeansException; // 使用autowireBeanProperties装配属性

    Object configureBean(Object existingBean, String beanName) throws BeansException; // 自动装配属性,填充属性值,使用诸如setBeanName,setBeanFactory这样的工厂回调填充属性,最好还要调用post processor

    Object resolveDependency(DependencyDescriptor descriptor, String beanName) throws BeansException;

  b, 在bean的生命周期进行细粒度控制的专门方法

    Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException; // 会执行bean完整的初始化,包括BeanPostProcessors和initializeBean

    Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck) throws BeansException;

*    *void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

    Object initializeBean(Object existingBean, String beanName) throws BeansException;

    Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException;

    Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException;

    Object resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException;

 

3. HierarchicalBeanFactory

 提供父容器的访问功能.至于父容器的设置,需要找ConfigurableBeanFactory的setParentBeanFactory(接口把设置跟获取给拆开了!).

这边可说的不多,直接上api:

  a, 获取父容器 bean factory

    BeanFactory getParentBeanFactory();

  b, 判断当前容器是否保护bean

    boolean containsLocalBean(String name);

 

4. ListableBeanFactory

获取bean时,Spring 鼓励使用这个接口定义的api. 还有个Beanfactory方便使用.其他的4个接口都是不鼓励使用的.

提供容器中bean迭代的功能,不再需要一个个bean地查找.比如可以一次获取全部的bean(太暴力了),根据类型获取bean.在看SpringMVC时,扫描包路径下的具体实现策略就是使用的这种方式(那边使用的是BeanFactoryUtils封装的api).

 如果同时实现了HierarchicalBeanFactory,返回值不会考虑父类BeanFactory,只考虑当前factory定义的类.当然也可以使用BeanFactoryUtils辅助类来查找祖先工厂中的类. 

 这个接口中的方法只会考虑本factory定义的bean.这些方法会忽略ConfigurableBeanFactory的registerSingleton注册的单例bean(getBeanNamesOfType和getBeansOfType是例外,一样会考虑手动注册的单例).当然BeanFactory的getBean一样可以透明访问这些特殊bean.当然在典型情况下,所有的bean都是由external bean定义,所以应用不需要顾虑这些差别.

注意:getBeanDefinitionCount和containsBeanDefinition的实现方法因为效率比较低,还是少用为好.

继续上api吧

  a, 暴力获取全部bean的属性:

    boolean containsBeanDefinition(String beanName);  //是否包含bean

    int getBeanDefinitionCount(); // 当前factory中定义的bean数量

    String[] getBeanDefinitionNames(); // 获取当前工厂中定义的所有bean 的name

  b, 根据bean 的类型获取bean

    这边的方法仅检查顶级bean.它不会检查嵌套的bean.FactoryBean创建的bean会匹配为FactoryBean而不是原始类型.

    一样不会考虑父factory中的bean,非要用可以通过BeanFactoryUtils中的beanNamesForTypeIncludingAncestors.
    其他方式注册的单例这边会纳入判断.
    这个版本的getBeanNamesForType会匹配所有类型的bean,包括单例,原型,FactoryBean.返回的bean names会根据backend 配置的进行排序.

    String[] getBeanNamesForType(Class<?> type); // 获取给定类型的bean names(包括子类),通过bean 定义或者FactoryBean的getObjectType判断.

    String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);

    <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException; // 如果保护懒加载的类,FactoryBean初始化的类和工厂方法初始化的类会被初始化.就是说执行这个方法会执行对应的初始化.

    <T> Map<String, T> getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit) throws BeansException;

  c, 查找使用注解的类

    Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;

  d, 查找一个类上的注解,如果找不到,父类,接口使用注解也算.

    <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType);

 

5. ConfigurableBeanFactory

定义BeanFactory的配置.

这边定义了太多太多的api,比如类加载器,类型转化,属性编辑器,BeanPostProcessor,作用域,bean定义,处理bean依赖关系,合并其他ConfigurableBeanFactory,bean如何销毁.

 

定义了两个作用域: 单例和原型.可以通过registerScope来添加.

  SCOPE_SINGLETON,SCOPE_PROTOTYPE

这边定义了好多好多的api,所以我们这边只讲业务,具体的api看文末的附录吧:

  a, 父容器设置.而且一旦设置了就不让修改

  b, 类加载器设置与获取.默认使用当前线程中的类加载器

  c, 为了类型匹配,搞个临时类加载器.好在一般情况为null,使用上面定义的标准加载器  

  d, 是否需要缓存bean metadata,比如bean difinition 和 解析好的classes.默认开启缓存

  e, 定义用于解析bean definition的表达式解析器

  f, 类型转化器

  g, 属性编辑器

  h, BeanFactory用来转换bean属性值或者参数值的自定义转换器

  i,string值解析器(想起mvc中的ArgumentResolver了)

  j,大boss BeanPostProcessor用于增强bean初始化功能 

  k,作用域定义

  l,访问权限控制

  m, 合并其他ConfigurableBeanFactory的配置,包括上面说到的BeanPostProcessor,作用域等

  n, bean定义处理

  o, bean创建状态控制.在解决循环依赖时有使用

  p, 处理bean依赖问题

  q, bean生命周期管理-- 销毁bean

 

 

 

6. ConfigableListableBeanFactory

 提供bean definition的解析,注册功能,再对单例来个预加载(解决循环依赖问题). 

貌似我们一般开发就会直接定义这么个接口了事.而不是像Spring这样先根据使用情况细分那么多,到这边再合并

 

  a, 设置忽略的依赖关系,注册找到的特殊依赖

    void ignoreDependencyType(Class<?> type); // 忽略类型

    void ignoreDependencyInterface(Class<?> ifc); // 忽略接口

    void registerResolvableDependency(Class<?> dependencyType, Object autowiredValue);

    boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor) throws NoSuchBeanDefinitionException;

  b, 获取bean定义 (可以访问属性值跟构造方法的参数值)

    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

  c, 锁定配置信息.在调用refresh时会使用到.

    void freezeConfiguration();

    boolean isConfigurationFrozen();

  d, 预加载不是懒加载的单例.用于解决循环依赖问题

    void preInstantiateSingletons() throws BeansException;

 

 

附录--ConfigureableBeanFactory中定义的api:

  a, 父容器设置.而且一旦设置了就不让修改

    void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

  b, 类加载器设置与获取.默认使用当前线程中的类加载器

    void setBeanClassLoader(ClassLoader beanClassLoader);

    ClassLoader getBeanClassLoader();

  c, 为了类型匹配,搞个临时类加载器.好在一般情况为null,使用上面定义的标准加载器  

    void setTempClassLoader(ClassLoader tempClassLoader);

    ClassLoader getTempClassLoader();

  d, 是否需要缓存bean metadata,比如bean difinition 和 解析好的classes.默认开启缓存

    void setCacheBeanMetadata(boolean cacheBeanMetadata);

    boolean isCacheBeanMetadata();

  e, 定义用于解析bean definition的表达式解析器

    void setBeanExpressionResolver(BeanExpressionResolver resolver);

    BeanExpressionResolver getBeanExpressionResolver();

  f, 类型转化器

    void setConversionService(ConversionService conversionService);

    ConversionService getConversionService();

  g, 属性编辑器

    void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

    void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);

    void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

  h, BeanFactory用来转换bean属性值或者参数值的自定义转换器

    void setTypeConverter(TypeConverter typeConverter);

    TypeConverter getTypeConverter();

  i,string值解析器(想起mvc中的ArgumentResolver了)

    void addEmbeddedValueResolver(StringValueResolver valueResolver);

    String resolveEmbeddedValue(String value);

  j,大boss BeanPostProcessor用于增强bean初始化功能

    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

    int getBeanPostProcessorCount();    

  k,作用域定义

    void registerScope(String scopeName, Scope scope);

    String[] getRegisteredScopeNames();

    Scope getRegisteredScope(String scopeName);

  l,访问权限控制

    AccessControlContext getAccessControlContext();

  m, 合并其他ConfigurableBeanFactory的配置,包括上面说到的BeanPostProcessor,作用域等

    void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

  n, bean定义处理

    void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException; // 注册别名

    void resolveAliases(StringValueResolver valueResolver);

    BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; // 合并bean定义,包括父容器的

    boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException; // 是否是FactoryBean类型

  o, bean创建状态控制.在解决循环依赖时有使用

    void setCurrentlyInCreation(String beanName, boolean inCreation);

    boolean isCurrentlyInCreation(String beanName);

  p, 处理bean依赖问题

    void registerDependentBean(String beanName, String dependentBeanName);

    String[] getDependentBeans(String beanName);

    String[] getDependenciesForBean(String beanName);

  q, bean生命周期管理-- 销毁bean

    void destroyBean(String beanName, Object beanInstance);

    void destroyScopedBean(String beanName);

    void destroySingletons();

 

http://www.bkjia.com/Javabc/1108106.htmlwww.bkjia.comtruehttp://www.bkjia.com/Javabc/1108106.htmlTechArticleSpring源码解析,spring源码 不知道为什么看着Spring的源码,感触最深的是Spring对概念的抽象,所以我就先学接口了. BeanFactory是Spring IOC实现的基...

本文由nba买球发布,转载请注明来源

关键词: