DefaultListableBeanFactory

首先是繼承圖

[圖片上傳失敗...(image-5d521d-1558969519678)]

BeanFactory最基礎(chǔ)的bean生產(chǎn)工廠的主要實(shí)現(xiàn)功能

String FACTORY_BEAN_PREFIX = "&";


//根據(jù)name獲取一個(gè)bean對(duì)象
Object getBean(String name) throws BeansException;

//根據(jù)name和requireType指定的類型獲取指定的bean實(shí)例
<T> T getBean(String name, Class<T> requiredType) throws BeansException;

//根據(jù)name和args參數(shù)獲取bean實(shí)例饱亮，注意:args是bean的構(gòu)造器的參數(shù)
Object getBean(String name, Object... args) throws BeansException;

//根據(jù)requireType類型獲取bean猖腕，也可能使用Type的名字獲取bean
<T> T getBean(Class<T> requiredType) throws BeansException;

//根據(jù)類型和構(gòu)造器參數(shù)獲取bean
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

//獲取一個(gè)requireType類型的bean的封裝對(duì)象，可以進(jìn)行后續(xù)復(fù)雜的操作
//如根據(jù)參數(shù)實(shí)例化一個(gè)bean，對(duì)于匹配了多個(gè)bean的情況，可以進(jìn)行stream()
//操作排除NullBean，或者是對(duì)多個(gè)匹配的bean進(jìn)行排序
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);


<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

//檢查工廠是否包含name對(duì)應(yīng)的bean或者有無單例bean
boolean containsBean(String name);

//判斷bean的實(shí)例化模式是否是singleton單例模式
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

//判斷bean的實(shí)例化模式是否是prototype
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

//檢查name對(duì)應(yīng)的bean與typeToMatch對(duì)應(yīng)的類型是否一致
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

//檢查name對(duì)應(yīng)的bean與typeToMatch對(duì)應(yīng)的類型是否一致
boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;


@Nullable
//根據(jù)name查找對(duì)應(yīng)的bean的類型
Class<?> getType(String name) throws NoSuchBeanDefinitionException;


String[] getAliases(String name);//獲取name對(duì)應(yīng)的bean的別名,就是外號(hào)

BeanObjectProvider的一個(gè)實(shí)現(xiàn)類

public <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType) {
    return new BeanObjectProvider<T>() {
        @Override
        public T getObject() throws BeansException {
            T resolved = resolveBean(requiredType, null, false);
            if (resolved == null) {
                throw new NoSuchBeanDefinitionException(requiredType);
            }
            return resolved;
        }
        @Override
        public T getObject(Object... args) throws BeansException {
            T resolved = resolveBean(requiredType, args, false);
            if (resolved == null) {
                throw new NoSuchBeanDefinitionException(requiredType);
            }
            return resolved;
        }
        @Override
        @Nullable
        //當(dāng)無法獲取時(shí)返回null
        public T getIfAvailable() throws BeansException {
            return resolveBean(requiredType, null, false);
        }
        @Override
        @Nullable
        //當(dāng)無法獲取和~~不唯一~~時(shí)返回null
        //不唯一是指 multiple candidates found with none marked as primary
        public T getIfUnique() throws BeansException {
            return resolveBean(requiredType, null, true);
        }
        @Override
        public Stream<T> stream() {
            return Arrays.stream(getBeanNamesForTypedStream(requiredType))
                    .map(name -> (T) getBean(name))
                    .filter(bean -> !(bean instanceof NullBean));
        }
        @Override
        public Stream<T> orderedStream() {
            String[] beanNames = getBeanNamesForTypedStream(requiredType);
            Map<String, T> matchingBeans = new LinkedHashMap<>(beanNames.length);
            for (String beanName : beanNames) {
                Object beanInstance = getBean(beanName);
                if (!(beanInstance instanceof NullBean)) {
                    matchingBeans.put(beanName, (T) beanInstance);
                }
            }
            Stream<T> stream = matchingBeans.values().stream();
            return stream.sorted(adaptOrderComparator(matchingBeans));
        }
    };
}

resolveBean方法有多個(gè)，這里為了節(jié)約篇幅只列舉一個(gè)

功能就是獲取一個(gè)bean的實(shí)例

private <T> T resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) {
    NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args, nonUniqueAsNull);
    if (namedBean != null) {
        return namedBean.getBeanInstance();
    }
    BeanFactory parent = getParentBeanFactory();
    if (parent instanceof DefaultListableBeanFactory) {
        return ((DefaultListableBeanFactory) parent).resolveBean(requiredType, args, nonUniqueAsNull);
    }
    else if (parent != null) {
        ObjectProvider<T> parentProvider = parent.getBeanProvider(requiredType);
        if (args != null) {
            return parentProvider.getObject(args);
        }
        else {
            return (nonUniqueAsNull ? parentProvider.getIfUnique() : parentProvider.getIfAvailable());
        }
    }
    return null;
}

ListableBeanFactory 方法解釋

方法的用途從名字就能看出來成翩，我就不再贅述，只是簡(jiǎn)單的列出方法赦役。

boolean containsBeanDefinition(String beanName);


int getBeanDefinitionCount();


String[] getBeanDefinitionNames();


String[] getBeanNamesForType(ResolvableType type);


String[] getBeanNamesForType(@Nullable Class<?> type);


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


<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;

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


String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);


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


@Nullable
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
        throws NoSuchBeanDefinitionException;

這個(gè)interface的實(shí)現(xiàn)類都會(huì)有自身的bean成員列表麻敌，具體的就有DefaultListableBeanFactory。其中的具體表現(xiàn)為:
/** Map from dependency type to corresponding autowired value. */
private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);

/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

/** Map of singleton and non-singleton bean names, keyed by dependency type. */
private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);

/** Map of singleton-only bean names, keyed by dependency type. */
private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);

/** List of bean definition names, in registration order. */
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

/** List of names of manually registered singletons, in registration order. */
private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

/** Cached array of bean definition names in case of frozen configuration. */
@Nullable
private volatile String[] frozenBeanDefinitionNames;

ListableBeanFactory的方法基本是根據(jù)上面的各種數(shù)據(jù)集實(shí)現(xiàn)的掂摔，目的是加快查詢的速度术羔？

HierarchicalBeanFactory

這個(gè)沒什么太多要講的，就兩個(gè)方法乙漓。自己看英語原文吧级历，開始偷懶。

/**
 * Return the parent bean factory, or {@code null} if there is none.
 */
@Nullable
BeanFactory getParentBeanFactory();

/**
 * Return whether the local bean factory contains a bean of the given name,
 * ignoring beans defined in ancestor contexts.
 * <p>This is an alternative to {@code containsBean}, ignoring a bean
 * of the given name from an ancestor bean factory.
 * @param name the name of the bean to query
 * @return whether a bean with the given name is defined in the local factory
 * @see BeanFactory#containsBean
 */
boolean containsLocalBean(String name);

SingletonBeanRegistry

看名識(shí)意

//注冊(cè)單例bean
void registerSingleton(String beanName, Object singletonObject);


@Nullable
Object getSingleton(String beanName);


boolean containsSingleton(String beanName);

//獲取所有單例bean的名字
String[] getSingletonNames();


int getSingletonCount();

//Return the singleton mutex used by this registry (for external collaborators)能力有限簇秒，你們自已意會(huì)一下吧鱼喉，哈哈秀鞭。
Object getSingletonMutex();

ConfigurableBeanFactory

看名字就知道趋观，這個(gè)接口的方法主要用來對(duì)bean做各種修改扛禽。

//設(shè)置父bean實(shí)例化工廠，get方法在HierarchicalBeanFactory接口中就聲明過了
void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

//設(shè)置bean的類加載器
void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);

//獲取bean的類加載器
@Nullable
ClassLoader getBeanClassLoader();

//
void setTempClassLoader(@Nullable ClassLoader tempClassLoader);

@Nullable
ClassLoader getTempClassLoader();

//設(shè)置是否允許緩存bean的metadata皱坛，默認(rèn)是允許
void setCacheBeanMetadata(boolean cacheBeanMetadata);

//返回是否緩存
boolean isCacheBeanMetadata();

//設(shè)置表達(dá)式解析器编曼，用于解析字符串表達(dá)式
void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);

@Nullable
BeanExpressionResolver getBeanExpressionResolver();

//設(shè)置類型轉(zhuǎn)換器
void setConversionService(@Nullable ConversionService conversionService);

@Nullable
ConversionService getConversionService();

//設(shè)置屬性注冊(cè)(添加/修改)器
void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

//設(shè)置用戶自定義的屬性編輯器(單例共享，線程安全)
void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);

//用已經(jīng)注冊(cè)的編輯器去初始化入?yún)egistry
void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

//設(shè)置一個(gè)類型轉(zhuǎn)換器
void setTypeConverter(TypeConverter typeConverter);

TypeConverter getTypeConverter();

//設(shè)置annotation 字符串值解析器
void addEmbeddedValueResolver(StringValueResolver valueResolver);

boolean hasEmbeddedValueResolver();

//解析value中字符串中的值
@Nullable
String resolveEmbeddedValue(String value);

//添加一個(gè)新的bean實(shí)例化前置處理器剩辟，會(huì)在bean實(shí)例化之前調(diào)用
void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

int getBeanPostProcessorCount();

//注冊(cè)一個(gè)scope掐场，建立scopeName和scope的一個(gè)映射關(guān)系
void registerScope(String scopeName, Scope scope);

例如
[圖片上傳失敗...(image-50b833-1558969519678)]

//獲取當(dāng)前factory中已經(jīng)注冊(cè)過的所有scope的名字
String[] getRegisteredScopeNames();

//根據(jù)名字找scope
@Nullable
Scope getRegisteredScope(String scopeName);

//返回一個(gè)當(dāng)前factory可安全訪問的context
AccessControlContext getAccessControlContext();

//從otherFactory中復(fù)制所有相關(guān)的屬性到當(dāng)前factory
void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

//注冊(cè)別名
void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;

//處理factory中所有的別名
void resolveAliases(StringValueResolver valueResolver);

//返回一個(gè)merged的bean定義對(duì)象,如果必要，會(huì)merge子類bean定義和其父類的
BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

//判斷name對(duì)應(yīng)的bean是不是factory bean
boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;

//控制beanName對(duì)應(yīng)的bean的創(chuàng)建狀態(tài)
void setCurrentlyInCreation(String beanName, boolean inCreation);

例如[圖片上傳失敗...(image-d7a80b-1558969519678)]

//判斷bean是否在實(shí)例化
boolean isCurrentlyInCreation(String beanName);

//為bean注冊(cè)一個(gè)有依賴關(guān)系的bean
void registerDependentBean(String beanName, String dependentBeanName);

//返回所有和beanName對(duì)應(yīng)的bean有依賴關(guān)系的bean的名字
String[] getDependentBeans(String beanName);

//同上
String[] getDependenciesForBean(String beanName);

//銷毀一個(gè)bean 的實(shí)例對(duì)象贩猎，通常這個(gè)bean是prototype方式創(chuàng)建的
void destroyBean(String beanName, Object beanInstance);

//銷毀當(dāng)前scope中的bean
void destroyScopedBean(String beanName);

//銷毀當(dāng)前factory的所有單例bean
void destroySingletons();

AutowireCapableBeanFactory

//執(zhí)行所有可用的BeanPostProcessor實(shí)例化一個(gè)bean對(duì)象
<T> T createBean(Class<T> beanClass) throws BeansException;

//對(duì)于一個(gè)已經(jīng)實(shí)例化的bean執(zhí)行after-instantiation的回調(diào)方法
void autowireBean(Object existingBean) throws BeansException;

//配置bean的變量值熊户，執(zhí)行factory的各種回調(diào)方法和post processor方法
Object configureBean(Object existingBean, String beanName) throws BeansException;


//-------------------------------------------------------------------------
// Specialized methods for fine-grained control over the bean lifecycle
//-------------------------------------------------------------------------

//autowire方式實(shí)例化bean
Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

//autowire方式實(shí)例化bean
Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

//autowire方式裝載已經(jīng)實(shí)例化的bean的各種屬性
void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
        throws BeansException;

//用beanName對(duì)應(yīng)的beanDefination對(duì)象參數(shù)配置已經(jīng)實(shí)例化的existingBean
void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

//對(duì)已經(jīng)存在的bean執(zhí)行初始化操作
Object initializeBean(Object existingBean, String beanName) throws BeansException;

//對(duì)已存在的bean實(shí)例執(zhí)行PostProcessor方法，在初始化之前
Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
        throws BeansException;

//對(duì)已存在的bean實(shí)例執(zhí)行PostProcessor方法吭服，在初始化之后
Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException;

//銷毀一個(gè)已存在的bean對(duì)象
void destroyBean(Object existingBean);


//-------------------------------------------------------------------------
// Delegate methods for resolving injection points
//-------------------------------------------------------------------------

//getBean(Class)方法的變形
<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;

//根據(jù)此工廠中定義的bean解析指定的依賴項(xiàng)
Object resolveBeanByName(String name, DependencyDescriptor descriptor) throws BeansException;

//
@Nullable
Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;


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

先做到這里吧嚷堡，篇幅太長(zhǎng)看的難受