ConfigurableBeanFactory

ConfigurableBeanFactory :关系如下

在上面这样的一个关系图中可以先看下SingletonBeanRegistry的源代码:

package org.springframework.beans.factory.config;

public interface SingletonBeanRegistry {

    //在容器中创建一个指定的单利bean的类
    void registerSingleton(String beanName, Object singletonObject);

//返回一个单利类
    Object getSingleton(String beanName);

    //判断容器红是否错在这个单例的bean
    boolean containsSingleton(String beanName);
//返回这个单例bean的所有名字
    String[] getSingletonNames();

    //统计单例Bean的个数
    int getSingletonCount();

    Object getSingletonMutex();

}

这个接口的方法:主要单例bean的注册,生成实例,以及统计单例bean

ConfigurableBeanFactory :源代码
/*
 * Copyright 2002-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.beans.factory.config;

import java.beans.PropertyEditor;
import java.security.AccessControlContext;

import org.springframework.beans.PropertyEditorRegistrar;
import org.springframework.beans.PropertyEditorRegistry;
import org.springframework.beans.TypeConverter;
import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.HierarchicalBeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.core.convert.ConversionService;
import org.springframework.util.StringValueResolver;

/**
 * Configuration interface to be implemented by most bean factories. Provides
 * facilities to configure a bean factory, in addition to the bean factory
 * client methods in the {@link org.springframework.beans.factory.BeanFactory}
 * interface.
 *
 * <p>This bean factory interface is not meant to be used in normal application
 * code: Stick to {@link org.springframework.beans.factory.BeanFactory} or
 * {@link org.springframework.beans.factory.ListableBeanFactory} for typical
 * needs. This extended interface is just meant to allow for framework-internal
 * plug‘n‘play and for special access to bean factory configuration methods.
 *
 * @author Juergen Hoeller
 * @since 03.11.2003
 * @see org.springframework.beans.factory.BeanFactory
 * @see org.springframework.beans.factory.ListableBeanFactory
 * @see ConfigurableListableBeanFactory
 */
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

    /**
     * Scope identifier for the standard singleton scope: "singleton".
     * Custom scopes can be added via {@code registerScope}.
     * @see #registerScope
     */

    String SCOPE_SINGLETON = "singleton";

    /**
     * Scope identifier for the standard prototype scope: "prototype".
     * Custom scopes can be added via {@code registerScope}.
     * @see #registerScope
     */
    String SCOPE_PROTOTYPE = "prototype";

    /**
     * Set the parent of this bean factory.
     * <p>Note that the parent cannot be changed: It should only be set outside
     * a constructor if it isn‘t available at the time of factory instantiation.
     * @param parentBeanFactory the parent BeanFactory
     * @throws IllegalStateException if this factory is already associated with
     * a parent BeanFactory
     * @see #getParentBeanFactory()
     */
     //搭配父接口HierarchicalBeanFactory 中得getParentBeanFactory()
    void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

    /**
     * Set the class loader to use for loading bean classes.
     * Default is the thread context class loader.
     * <p>Note that this class loader will only apply to bean definitions
     * that do not carry a resolved bean class yet. This is the case as of
     * Spring 2.0 by default: Bean definitions only carry bean class names,
     * to be resolved once the factory processes the bean definition.
     * @param beanClassLoader the class loader to use,
     * or {@code null} to suggest the default class loader
     */
     //设置bean的类加载器
    void setBeanClassLoader(ClassLoader beanClassLoader);

    /**
     * Return this factory‘s class loader for loading bean classes.
     */
     //返回类的加载器
    ClassLoader getBeanClassLoader();

    /**
     * Specify a temporary ClassLoader to use for type matching purposes.
     * Default is none, simply using the standard bean ClassLoader.
     * <p>A temporary ClassLoader is usually just specified if
     * <i>load-time weaving</i> is involved, to make sure that actual bean
     * classes are loaded as lazily as possible. The temporary loader is
     * then removed once the BeanFactory completes its bootstrap phase.
     * @since 2.5
     */
     //设置一个零时的类加载器
    void setTempClassLoader(ClassLoader tempClassLoader);

    /**
     * Return the temporary ClassLoader to use for type matching purposes,
     * if any.
     * @since 2.5
     */
     //返回一个零时的类加载器
    ClassLoader getTempClassLoader();

    /**
     * Set whether to cache bean metadata such as given bean definitions
     * (in merged fashion) and resolved bean classes. Default is on.
     * <p>Turn this flag off to enable hot-refreshing of bean definition objects
     * and in particular bean classes. If this flag is off, any creation of a bean
     * instance will re-query the bean class loader for newly resolved classes.
     */
     //设置是否缓存源,false石化,从新从类加载器加载
    void setCacheBeanMetadata(boolean cacheBeanMetadata);

    /**
     * Return whether to cache bean metadata such as given bean definitions
     * (in merged fashion) and resolved bean classes.
     */
     //是否缓存了definitions
    boolean isCacheBeanMetadata();

    /**
     * Specify the resolution strategy for expressions in bean definition values.
     * <p>There is no expression support active in a BeanFactory by default.
     * An ApplicationContext will typically set a standard expression strategy
     * here, supporting "#{...}" expressions in a Unified EL compatible style.
     * @since 3.0
     */
     //bean的表达式解析
    void setBeanExpressionResolver(BeanExpressionResolver resolver);

    /**
     * Return the resolution strategy for expressions in bean definition values.
     * @since 3.0
     */
     //获取bean的表达式解析
    BeanExpressionResolver getBeanExpressionResolver();

    /**
     * Specify a Spring 3.0 ConversionService to use for converting
     * property values, as an alternative to JavaBeans PropertyEditors.
     * @since 3.0
     */
     //设置一个转换服务
    void setConversionService(ConversionService conversionService);

    /**
     * Return the associated ConversionService, if any.
     * @since 3.0
     */
     //返回一个转换服务
    ConversionService getConversionService();

    /**
     * Add a PropertyEditorRegistrar to be applied to all bean creation processes.
     * <p>Such a registrar creates new PropertyEditor instances and registers them
     * on the given registry, fresh for each bean creation attempt. This avoids
     * the need for synchronization on custom editors; hence, it is generally
     * preferable to use this method instead of {@link #registerCustomEditor}.
     * @param registrar the PropertyEditorRegistrar to register
     */
     //设置属性注册员
    void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

    /**
     * Register the given custom property editor for all properties of the
     * given type. To be invoked during factory configuration.
     * <p>Note that this method will register a shared custom editor instance;
     * access to that instance will be synchronized for thread-safety. It is
     * generally preferable to use {@link #addPropertyEditorRegistrar} instead
     * of this method, to avoid for the need for synchronization on custom editors.
     * @param requiredType type of the property
     * @param propertyEditorClass the {@link PropertyEditor} class to register
     */
     //注册属性编辑器
    void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);

    /**
     * Initialize the given PropertyEditorRegistry with the custom editors
     * that have been registered with this BeanFactory.
     * @param registry the PropertyEditorRegistry to initialize
     */
     //复制属性编辑器
    void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

    /**
     * Set a custom type converter that this BeanFactory should use for converting
     * bean property values, constructor argument values, etc.
     * <p>This will override the default PropertyEditor mechanism and hence make
     * any custom editors or custom editor registrars irrelevant.
     * @see #addPropertyEditorRegistrar
     * @see #registerCustomEditor
     * @since 2.5
     */
     //设置类型转换器
    void setTypeConverter(TypeConverter typeConverter);

    /**
     * Obtain a type converter as used by this BeanFactory. This may be a fresh
     * instance for each call, since TypeConverters are usually <i>not</i> thread-safe.
     * <p>If the default PropertyEditor mechanism is active, the returned
     * TypeConverter will be aware of all custom editors that have been registered.
     * @since 2.5
     */
     //获取类型转换器
    TypeConverter getTypeConverter();

    /**
     * Add a String resolver for embedded values such as annotation attributes.
     * @param valueResolver the String resolver to apply to embedded values
     * @since 3.0
     */
     // 增加一个嵌入式的StringValueResolver
    void addEmbeddedValueResolver(StringValueResolver valueResolver);

    /**
     * Determine whether an embedded value resolver has been registered with this
     * bean factory, to be applied through {@link #resolveEmbeddedValue(String)}.
     * @since 4.3
     */

    boolean hasEmbeddedValueResolver();

    /**
     * Resolve the given embedded value, e.g. an annotation attribute.
     * @param value the value to resolve
     * @return the resolved value (may be the original value as-is)
     * @since 3.0
     */
      //分解指定的嵌入式的值
    String resolveEmbeddedValue(String value);

    /**
     * Add a new BeanPostProcessor that will get applied to beans created
     * by this factory. To be invoked during factory configuration.
     * <p>Note: Post-processors submitted here will be applied in the order of
     * registration; any ordering semantics expressed through implementing the
     * {@link org.springframework.core.Ordered} interface will be ignored. Note
     * that autodetected post-processors (e.g. as beans in an ApplicationContext)
     * will always be applied after programmatically registered ones.
     * @param beanPostProcessor the post-processor to register
     */
     //增加一个BeanPostProcessor的处理器 前后
    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

    /**
     * Return the current number of registered BeanPostProcessors, if any.
     */
    int getBeanPostProcessorCount();

    /**
     * Register the given scope, backed by the given Scope implementation.
     * @param scopeName the scope identifier
     * @param scope the backing Scope implementation
     */
     //注册bean的范围
    void registerScope(String scopeName, Scope scope);

    /**
     * Return the names of all currently registered scopes.
     * <p>This will only return the names of explicitly registered scopes.
     * Built-in scopes such as "singleton" and "prototype" won‘t be exposed.
     * @return the array of scope names, or an empty array if none
     * @see #registerScope
     */
     //获取Bean的范围
    String[] getRegisteredScopeNames();

    /**
     * Return the Scope implementation for the given scope name, if any.
     * <p>This will only return explicitly registered scopes.
     * Built-in scopes such as "singleton" and "prototype" won‘t be exposed.
     * @param scopeName the name of the scope
     * @return the registered Scope implementation, or {@code null} if none
     * @see #registerScope
     */
     //获取注册的范围
    Scope getRegisteredScope(String scopeName);

    /**
     * Provides a security access control context relevant to this factory.
     * @return the applicable AccessControlContext (never {@code null})
     * @since 3.0
     */
     //返回本工厂的一个安全访问上下文
    AccessControlContext getAccessControlContext();

    /**
     * Copy all relevant configuration from the given other factory.
     * <p>Should include all standard configuration settings as well as
     * BeanPostProcessors, Scopes, and factory-specific internal settings.
     * Should not include any metadata of actual bean definitions,
     * such as BeanDefinition objects and bean name aliases.
     * @param otherFactory the other BeanFactory to copy from
     */
     //复制其他工程的属性配置
    void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

    /**
     * Given a bean name, create an alias. We typically use this method to
     * support names that are illegal within XML ids (used for bean names).
     * <p>Typically invoked during factory configuration, but can also be
     * used for runtime registration of aliases. Therefore, a factory
     * implementation should synchronize alias access.
     * @param beanName the canonical name of the target bean
     * @param alias the alias to be registered for the bean
     * @throws BeanDefinitionStoreException if the alias is already in use
     */
     //注册bean起一个别名
    void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;

    /**
     * Resolve all alias target names and aliases registered in this
     * factory, applying the given StringValueResolver to them.
     * <p>The value resolver may for example resolve placeholders
     * in target bean names and even in alias names.
     * @param valueResolver the StringValueResolver to apply
     * @since 2.5
     */
     //根据StringValueResolver来移除bean
    void resolveAliases(StringValueResolver valueResolver);

    /**
     * Return a merged BeanDefinition for the given bean name,
     * merging a child bean definition with its parent if necessary.
     * Considers bean definitions in ancestor factories as well.
     * @param beanName the name of the bean to retrieve the merged definition for
     * @return a (potentially merged) BeanDefinition for the given bean
     * @throws NoSuchBeanDefinitionException if there is no bean definition with the given name
     * @since 2.5
     */
     //返回合并后的Beandefinition
    BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    /**
     * Determine whether the bean with the given name is a FactoryBean.
     * @param name the name of the bean to check
     * @return whether the bean is a FactoryBean
     * ({@code false} means the bean exists but is not a FactoryBean)
     * @throws NoSuchBeanDefinitionException if there is no bean with the given name
     * @since 2.5
     */
     //判断一个bean是否是工厂bean
    boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;

    /**
     * Explicitly control the current in-creation status of the specified bean.
     * For container-internal use only.
     * @param beanName the name of the bean
     * @param inCreation whether the bean is currently in creation
     * @since 3.1
     */
     //设置一个是否真在创建的bean
    void setCurrentlyInCreation(String beanName, boolean inCreation);

    /**
     * Determine whether the specified bean is currently in creation.
     * @param beanName the name of the bean
     * @return whether the bean is currently in creation
     * @since 2.5
     */
     //指定的bean是否创建成功
    boolean isCurrentlyInCreation(String beanName);

    /**
     * Register a dependent bean for the given bean,
     * to be destroyed before the given bean is destroyed.
     * @param beanName the name of the bean
     * @param dependentBeanName the name of the dependent bean
     * @since 2.5
     */
     //注册这个bean的依赖
    void registerDependentBean(String beanName, String dependentBeanName);

    /**
     * Return the names of all beans which depend on the specified bean, if any.
     * @param beanName the name of the bean
     * @return the array of dependent bean names, or an empty array if none
     * @since 2.5
     */
     //获取指定bean依赖的bean
    String[] getDependentBeans(String beanName);

    /**
     * Return the names of all beans that the specified bean depends on, if any.
     * @param beanName the name of the bean
     * @return the array of names of beans which the bean depends on,
     * or an empty array if none
     * @since 2.5
     */
    String[] getDependenciesForBean(String beanName);

    /**
     * Destroy the given bean instance (usually a prototype instance
     * obtained from this factory) according to its bean definition.
     * <p>Any exception that arises during destruction should be caught
     * and logged instead of propagated to the caller of this method.
     * @param beanName the name of the bean definition
     * @param beanInstance the bean instance to destroy
     */
     //销毁指定的bean
    void destroyBean(String beanName, Object beanInstance);

    /**
     * Destroy the specified scoped bean in the current target scope, if any.
     * <p>Any exception that arises during destruction should be caught
     * and logged instead of propagated to the caller of this method.
     * @param beanName the name of the scoped bean
     */
     //销毁指定返回的bean
    void destroyScopedBean(String beanName);

    /**
     * Destroy all singleton beans in this factory, including inner beans that have
     * been registered as disposable. To be called on shutdown of a factory.
     * <p>Any exception that arises during destruction should be caught
     * and logged instead of propagated to the caller of this method.
     */
     //销毁单利的bean
    void destroySingletons();

}

1.对父接口中HierarchicalBeanFactory得获取父beanfactory的方法进行补全,set,get方法

2.对类的加载器进行set和get

3.属性的编辑器,类的转换器进行注册

4.2个后处理bean的后处理器的方法

5.2个跟Bean别名相关的方法、1个返回合并后的Bean定义的方法。

6.对指定的Bean 依赖情况进行返回

7.3个销毁bean的方法

8.1个安全访问上下文的方法

时间: 04-26

ConfigurableBeanFactory的相关文章

Spring rabbitMq 中 correlationId或CorrelationIdString 消费者获取为null的问题

问题 在用Spring boot 的 spring-boot-starter-amqp   快速启动 rabbitMq 是遇到了个坑 消费者端获取不到:correlationId或CorrelationIdString 问题产生的原因 correlationId 的在 spring rabbitmq 2.0 以后 byte方式会被放弃,所以 目前 代码中有些地方没有改过来,应该算一个BUG @SuppressWarnings("deprecation") public class De

spring源码阅读之Bean的加载(二)

在正式分析源码之前,先来了解一下SpringBeans里面最核心的两个类  DefaultListableBeanFactory XMLBean继承自 DefaultListableBeanFactory,而 DefaultListableBeanFactory是整个Bean加载的核心部分,是Sprin注册及加载Bean的默认实现,而对于XmlBeanFactory与 DefaultListableBeanFactory不同的地方其实就是在XmlBeanFactory中使用了自定义的XML读取器

004bean作用域

1.Singleton(单例) 2.Prototype(原型)---->每次注入.通过Spring应用上下文获取,都会重新创建    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) 3.Session(会话)---->在Web应用中,为每个会话创建一个bean实例 @Component @Scope(value = WebApplicationContext.SCOPE_SESSION, //在当前会话,此bean为单例,单例在Spring应用上

Red5源代码分析 - 关键类及其初始化过程

原文地址:http://semi-sleep.javaeye.com/blog/348768 Red5如何响应rmpt的请求,中间涉及哪些关键类? 响应请求的流程如下: 1.Red5在启动时会调用RTMPMinaTransport的start()方法,该方法会开启rmtp的socket监听端口(默认是1935),然后使用mina(apache的io操作类库)的api将RTMPMinaIoHandler绑定到该端口. 2.RTMPMinaIoHandler上定义了messageReceived.m

Spring容器中Bean的生命周期

日出日落,春去秋来,花随流水,北雁南飞,世间万物皆有生死轮回.从调用XML中的Bean配置信息,到应用到具体实例中,再到销毁,Bean也有属于它的生命周期. 人类大脑对图像的认知能力永远高于文字,因此,闲言少叙,书归正传,上图先: 步骤很多,切莫惊慌,我们可以把上面的步骤归纳如下: 1-2:创建实例: 现在假设spring就是个容器,而配置文件中配置的bean属性才是我们真正需要的东西.创建实例就是说,我把配置文件中的bean信息取出来化作一个真正的bean并放到容器中. 3-4:注入依赖关系:

spring beans源码解读

spring beans下面有如下源文件包: org.springframework.beans, 包含了操作java bean的接口和类.org.springframework.beans.annotation, 支持包,提供对java 5注解处理bean样式的支持.org.springframework.beans.factory, 实现spring轻量级IoC容器的核心包.org.springframework.beans.factory.access, 定位和获取bean工程的辅助工具类

IOC容器的初始化过程

1.ClassPathXmlApplicationContext类体系结构 左边的黄色部分是ApplicationContext体系继承结构,右边是BeanFactory结构体系,两个体系是典型的模板方法设计模式的使用. 从该继承体系可以看出: (1)BeanFactory是一个bean工厂的最基本定义,里面包含了一个bean工厂的几个最基本方法:getBean(),containsBean()等,是一个很纯粹的bean工厂,不关注资源.资源位置.事件等. ApplicationContext是

Spring4 In [email&#160;protected]单例、多例Bean

Spring In [email protected]单例.多例Bean 代码下载地址:http://download.csdn.net/download/poiuy1991719/9967494 Singleton:单例    @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)@Scope("singleton") Prototype:每次注入都会创建新的   @Scope(ConfigurableBeanFactory.SCOPE_PRO

Spring 之高级装配

[环境与Profile] 暂略 [条件化的bean] 暂略 [处理自动装配歧义性] 暂略 [ bean 的作用域] 在 @Componen . @Bean 下以及 XML 中的声明方式如下所示, @Component("LonelyHeartsClub") @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) // Singleton 作用域是默认的,Prototype 作用域需要特别声明,每次注入都会创建一个新的 Bean 实例 public