版本：spring-framework-3.0.5.RELEASE

接上篇继续

一、首先看ConfigurableBeanFactory接口

本接口继承了HierarchicalBeanFactory和SingletonBeanRegistry，接口代码如下：

String SCOPE_SINGLETON = "singleton";
String SCOPE_PROTOTYPE = "prototype";

void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

void setBeanClassLoader(ClassLoader beanClassLoader);
ClassLoader getBeanClassLoader();

void setTempClassLoader(ClassLoader tempClassLoader);
ClassLoader getTempClassLoader();

void setCacheBeanMetadata(boolean cacheBeanMetadata);
boolean isCacheBeanMetadata();

void setBeanExpressionResolver(BeanExpressionResolver resolver);
BeanExpressionResolver getBeanExpressionResolver();

void setConversionService(ConversionService conversionService);
ConversionService getConversionService();

void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

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

void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

void setTypeConverter(TypeConverter typeConverter);
TypeConverter getTypeConverter();

void addEmbeddedValueResolver(StringValueResolver valueResolver);
String resolveEmbeddedValue(String value);

void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
int getBeanPostProcessorCount();

void registerScope(String scopeName, Scope scope);
String[] getRegisteredScopeNames();
Scope getRegisteredScope(String scopeName);

AccessControlContext getAccessControlContext();

void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
void resolveAliases(StringValueResolver valueResolver);

BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;

boolean isCurrentlyInCreation(String beanName);

void registerDependentBean(String beanName, String dependentBeanName);

String[] getDependentBeans(String beanName);
String[] getDependenciesForBean(String beanName);

void destroyBean(String beanName, Object beanInstance);
void destroyScopedBean(String beanName);
void destroySingletons();

• 前面两行是定义了spring里bean的两个作用域名称：singleton和prototype，基本两个的区别就是一为单例模式的一个对象，spring对其生命周期负责；二为每次请求都会生成新的对象，spring只负责创建，并不负责其生命周期管理。具体的作用域相关详细分析请查看  spring作用域分析
• 第4行设置ParentBeanFactory
• 第6-19行是标准的Javabean模板的Getter/Setter方法了，分别是对beanClassLoader（类加载器）,tempClassLoader（临时加载器）,cacheBeanMetadata（是否缓存bean的元数据）,BeanExpressionResolver（表达式语言处理器）,conversionService（数据转换服务）的操作
• 第21行为添加bean属性编辑器的管理器
• 第23行注册某个类型requiredType的属性编辑器为propertyEditorClass
• 第25行将所有当前已经注册的属性编辑器类型初始化并注册到输入参数registry中
• 第27-28行是typeConverter的Getter/Setter方法，这个对象是bean属性的转换器，会覆盖propertyEditor机制
• 第30行添加字符串解析器，主要用于嵌入式的属性解析，例如注解中的属性
• 第31行进行字符串属性解析，使用的就是上面添加的字符串解析器
• 第33行注册一个BeanPostProcessor
• 第34行获取已经注册的BeanPostProcessor的数量
• 第36-38行分别为注册bean的作用域，获取所有作用域名称，根据名称获取作用域对象
• 第40行获取安全管理上下文对象
• 第42行从传入的otherFactory中获取所有配置信息（BeanPostProcessors，作用域等），但不包括具体的bean定义信息
• 第44行注册bean别名
• 第45行是使用传入的valueResolver对别名进行处理
• 第47行根据beanName获取bean定义信息对象
• 第49行判断指定name的bean是否为FactoryBean
• 第51行判断指定name的bean是否正在创建中
• 第53行注册dependentBeanName为beanName的依赖bean，在销毁beanName对应的bean之前必须要先销毁dependentBeanName对应的bean
• 第55-56行获取所有依赖于beanName的bean名称，以及获取所有beanName依赖的bean名称。
• 第58行销毁bean实例
• 第59行把bean从其作用域中移除并销毁
• 第60行销毁所有单例bean

二、ConfigurableListableBeanFactory接口

本接口继承了ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory，代码如下：

void ignoreDependencyType(Class type);
void ignoreDependencyInterface(Class ifc);

void registerResolvableDependency(Class dependencyType, Object autowiredValue);

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

BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

void freezeConfiguration();
boolean isConfigurationFrozen();

void preInstantiateSingletons() throws BeansException;

• 第1行忽略指定类型的自动装配，默认为空
• 第2行忽略指定接口的自动装配，默认只忽略BeanFactoryAware接口
• 第4行这个还没有弄清楚，弄清楚了再补上……
• 第6行判断bean的依赖是否自动装配
• 第9行根据beanname获取bean的定义信息对象
• 第11行第锁住所有bean定义信息，锁住后将不允许对其修改
• 第12行判断bean定义对象是否被锁住
• 最后一行是确保对所有非延迟加载的单例bean进行初始化，也就是说在这里会对所有没有初始化的非延迟加载单例bean进行初始化。

三、ApplicationContext接口

本接口继承了ListableBeanFactory, HierarchicalBeanFactory,MessageSource, ApplicationEventPublisher, ResourcePatternResolver，其中ListableBeanFactory是bean相关的列表功能，HierarchicalBeanFactory代表了它本身有层级支持，MessageSource代表了spring的国际化信息支撑，ApplicationEventPublisher代表了spring的事件处理支撑，ResourcePatternResolver则是资源处理相关的支撑。接口代码如下：

String getId();

String getDisplayName();

long getStartupDate();

ApplicationContext getParent();

AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

• 这个代码就很简单了，基本上的功能都是在几个父接口里，特殊的地方就是多几个属性id，displayName，startupDate，parentApplicationContext，autowireCapableBeanFactory的get或set方法

这里简单说下ApplicationContext虽然它是BeanFactory的子接口，但是可以认为它不是一个BeanFactory，ApplicationContext对象里面包含了一个BeanFactory对象，相关bean基本功能是调用了其内部的一个BeanFactory对象来实现的，而不是自己进行的实现，它对BeanFactory进行了一定的封装扩展，另外国际化支持，事件监听等都集成在了里面。

评论 (2)     查看全文    

版本：spring-framework-3.0.5.RELEASE

Spring的最核心的部分就是BeanFactory了，当然我们现在很少直接使用这个类而是通过ApplicationContext来使用了，本篇我们就对BeanFactory接口的核心方法、BeanFactory的子接口及其实现类以及ApplicationContext相关做一个详细的分析和了解。关于实现代码牵扯到的东西太多了，这里只分析接口的功能及继承关系，暂时不做实现类的分析。

一、我们首先看下BeanFactory接口的代码：

public interface BeanFactory {
    String FACTORY_BEAN_PREFIX = "&";

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

    boolean containsBean(String name);
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, Class targetType) throws NoSuchBeanDefinitionException;

    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    String[] getAliases(String name);
}

1. 首先第2行是一个字符串常量，值为"&"，这个是用在FactoryBean那部分，假如有一个FactoryBean的name=foo，则使用name=&foo去取bean对象的时候取到的就是foo的工厂而不是foo本身。
2. 第4行根据bean的name去查找bean，在当前BeanFactory查找不到的时候会去查找parent的BeanFactory，返回为一个Object对象需用户自行转换其原本的类型。
3. 第5行也是根据name查找bean，但是多了一个参数requiredType，查找bean并要求结果符合这个类型，如果requiredType为null，则同上个方法一样只根据name查找，另外这里使用了泛型，返回对象类型会直接是requiredType。
4. 第6行是根据requiredType查找bean，查找一个符合这个类型的bean，同样返回类型为requiredType。
5. 第7行根据name查找bean，同时有一个参数组args，这个主要是用来给给工厂类创建bean对象的时候调用的，所以如果args不为空则意味着这里查找的是一个prototype的bean。
6. 第9-12行分别是几个判断方法：判断是否存在bean；是否是单例bean；是否是prototype的bean,bean是否符合类型requiredType。
7. 第13行是根据bean的name获取bean的类型。
8. 最后是根据bean的name获取指向该bean的所有别名，如果输入的name本身就是别名，那返回的将包括bean的最初name，并且这个name在返回的数组中第一个元素。
    

二、现在我们看下BeanFactory的子接口

BeanFactory一共有3个子接口一个实现类，其中实现类SimpleJndiBeanFactory主要是jndi相关，我们这里暂不讨论，下面看3个接口

2.1、HierarchicalBeanFactory接口：主要定义BeanFactory的分层的支撑，所谓分层也就是parentBeanFactory概念

2.1.1、首先看下代码：

public interface HierarchicalBeanFactory extends BeanFactory {
    BeanFactory getParentBeanFactory();
    boolean containsLocalBean(String name);
}

1. getParentBeanFactory()方法获取parentBeanFactory；
2. containsLocalBean()则类似containsBean()只不过这个方法只在当前BeanFactory查找bean，如果没有不再去parent里查找了。
    

2.1.2、这个接口有两个子接口：ApplicationContext和ConfigurableBeanFactory，关于这两个子接口下面独立做分析，因为他们已经不只是HierarchicalBeanFactory的子接口了。

2.2、ListableBeanFactory接口：主要是获取bean的定义和配置信息相关的支撑接口

2.2.1、代码如下：

public interface ListableBeanFactory extends BeanFactory {
    boolean containsBeanDefinition(String beanName);
    int getBeanDefinitionCount();
    String[] getBeanDefinitionNames();
    String[] getBeanNamesForType(Class type);
    String[] getBeanNamesForType(Class type, boolean includeNonSingletons, boolean allowEagerInit);
    <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;
    <T> Map<String, T> getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
            throws BeansException;
    Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType)
            throws BeansException;
    <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType);
}

• containsBeanDefinition()方法判断是否存在指定beanName的定义信息
• getBeanDefinitionCount()获取bean定义的总数
• getBeanDefinitionNames()获取所有bean定义的name数组
• getBeanNamesForType()获取所有指定类型的bean的name数组
• 第2个getBeanNamesForType()方法多了两个餐厨，可以指定是否单例，是否渴望初始化
• 两个getBeansOfType()和getBeanNamesForType()的参数一样，只不过这个返回的是name为key，bean对象为value的map集合
• getBeansWithAnnotation()方法获取包含指定注解annotationType所有bean的map集合
• 最后findAnnotationOnBean()方法获取指定beanName的指定注解的注解信息对象
   

2.1.2、这个接口有两个子接口：ApplicationContext和ConfigurableListableBeanFactory，关于这两个子接口同样放到下面独立做分析。

注：该接口还有一个静态实现类StaticListableBeanFactory，没发现哪里在使用，代码上也很简单就是把bean的定义放到一个map集合beans里面，实现一个基本的本接口功能，暂不做分析。
 

2.3、AutowireCapableBeanFactory接口：主要是spring的自动装配相关功能支撑接口

2.3.1、代码如下：

public interface AutowireCapableBeanFactory extends BeanFactory {
    int AUTOWIRE_NO = 0;
    int AUTOWIRE_BY_NAME = 1;
    int AUTOWIRE_BY_TYPE = 2;
    int AUTOWIRE_CONSTRUCTOR = 3;
    int AUTOWIRE_AUTODETECT = 4;

    <T> T createBean(Class<T> beanClass) throws BeansException;
    Object createBean(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    Object configureBean(Object existingBean, String beanName) throws BeansException;
    Object initializeBean(Object existingBean, String beanName) throws BeansException;
    Object autowire(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
    void autowireBean(Object existingBean) throws BeansException;
    void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
            throws BeansException;
    void applyBeanPropertyValues(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) throws BeansException;
    Object resolveDependency(DependencyDescriptor descriptor, String beanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException;
}

这个接口的主要实现代码都在AbstractAutowireCapableBeanFactory类中，暂时也没有发现其他地方用到这个接口，查看这些方法的实现可以去看这个类。

• 首先是5个常量代表自动装配的类型：不自动装配、按name、按类型、根据自省完全自动装配（不推荐，已在3.0中过时）。
• 两个创建Bean的方法，一个是根据类型，另外一个多了两个参数自动装配类型和是否检查依赖
• configureBean()是一个用来主动的配置装配的，就是在需要的时候把existingBean自动装配给beanName对应的bean
• initializeBean()是bean的初始化方法在这里主要调用了几个工厂级回调（BeanNameAware、BeanClassLoaderAware和BeanFactoryAware），并处理了所有BeanPostProcessor的两个调用
• autowire()方法创建一个类型为beanClass的bean对象，并根据自动装配类型autowireMode进行自动装配，dependencyCheck则代表是否做依赖检查
• autowireBean()方法暂时没有很清楚，只知道和普通的按name按类型装配不同，和注解相关，以后分析清楚了再补充。
• autowireBeanProperties方法()和上面的方法类似，只不过省略了bean创建的步骤，直接穿入一个bean对象进行自动装配
• applyBeanPropertyValues()应用bean定义中明确定义的属性值，区别于autowireBeanProperties（会装配所有属性）。
• applyBeanPostProcessorsBeforeInitialization()和applyBeanPostProcessorsAfterInitialization()两个方法处理BeanPostProcessor的两种回调，上面的initializeBean()方法的实现中就是调用这两个
• 两个resolveDependency()方法也没有搞清楚，是跟bean的依赖相关的，以后清楚了再补充。

2.3.2、这个接口的继承结构也很清晰，一个子接口ConfigurableListableBeanFactory，一个实现类AbstractAutowireCapableBeanFactory。

下一篇：ConfigurableBeanFactory、ConfigurableListableBeanFactory、ApplicationContext

评论 (1)     查看全文