DefaultListableBeanFactory
首先是继承图
[图片上传失败...(image-5d521d-1558969519678)]
BeanFactory最基础的bean生产工厂的主要实现功能
String FACTORY_BEAN_PREFIX = "&";
//根据name获取一个bean对象
Object getBean(String name) throws BeansException;
//根据name和requireType指定的类型获取指定的bean实例
T getBean(String name, Class requiredType) throws BeansException;
//根据name和args参数获取bean实例，注意:args是bean的构造器的参数
Object getBean(String name, Object... args) throws BeansException;
//根据requireType类型获取bean，也可能使用Type的名字获取bean
T getBean(Class requiredType) throws BeansException;
//根据类型和构造器参数获取bean
T getBean(Class requiredType, Object... args) throws BeansException;
//获取一个requireType类型的bean的封装对象，可以进行后续复杂的操作
//如根据参数实例化一个bean，对于匹配了多个bean的情况，可以进行stream()
//操作排除NullBean，或者是对多个匹配的bean进行排序
ObjectProvider getBeanProvider(Class requiredType);
ObjectProvider getBeanProvider(ResolvableType requiredType);
//检查工厂是否包含name对应的bean或者有无单例bean
boolean containsBean(String name);
//判断bean的实例化模式是否是singleton单例模式
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
//判断bean的实例化模式是否是prototype
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
//检查name对应的bean与typeToMatch对应的类型是否一致
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
//检查name对应的bean与typeToMatch对应的类型是否一致
boolean isTypeMatch(String name, Class typeToMatch) throws NoSuchBeanDefinitionException;
@Nullable
//根据name查找对应的bean的类型
Class getType(String name) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);//获取name对应的bean的别名,就是外号
BeanObjectProvider的一个实现类
public ObjectProvider getBeanProvider(ResolvableType requiredType) {
return new BeanObjectProvider() {
@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
//当无法获取时返回null
public T getIfAvailable() throws BeansException {
return resolveBean(requiredType, null, false);
}
@Override
@Nullable
//当无法获取和~~不唯一~~时返回null
//不唯一是指 multiple candidates found with none marked as primary
public T getIfUnique() throws BeansException {
return resolveBean(requiredType, null, true);
}
@Override
public Stream stream() {
return Arrays.stream(getBeanNamesForTypedStream(requiredType))
.map(name -> (T) getBean(name))
.filter(bean -> !(bean instanceof NullBean));
}
@Override
public Stream orderedStream() {
String[] beanNames = getBeanNamesForTypedStream(requiredType);
Map matchingBeans = new LinkedHashMap<>(beanNames.length);
for (String beanName : beanNames) {
Object beanInstance = getBean(beanName);
if (!(beanInstance instanceof NullBean)) {
matchingBeans.put(beanName, (T) beanInstance);
}
}
Stream stream = matchingBeans.values().stream();
return stream.sorted(adaptOrderComparator(matchingBeans));
}
};
}
resolveBean方法有多个，这里为了节约篇幅只列举一个
功能就是获取一个bean的实例
private T resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) {
NamedBeanHolder 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 parentProvider = parent.getBeanProvider(requiredType);
if (args != null) {
return parentProvider.getObject(args);
}
else {
return (nonUniqueAsNull ? parentProvider.getIfUnique() : parentProvider.getIfAvailable());
}
}
return null;
}
ListableBeanFactory 方法解释
方法的用途从名字就能看出来，我就不再赘述，只是简单的列出方法。
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);
Map getBeansOfType(@Nullable Class type) throws BeansException;
Map getBeansOfType(@Nullable Class type, boolean includeNonSingletons, boolean allowEagerInit)
throws BeansException;
String[] getBeanNamesForAnnotation(Class annotationType);
Map getBeansWithAnnotation(Class annotationType) throws BeansException;
@Nullable
A findAnnotationOnBean(String beanName, Class annotationType)
throws NoSuchBeanDefinitionException;
这个interface的实现类都会有自身的bean成员列表，具体的就有DefaultListableBeanFactory。其中的具体表现为:
/** Map from dependency type to corresponding autowired value. */
private final Map
/** Map of bean definition objects, keyed by bean name. */
private final Map beanDefinitionMap = new ConcurrentHashMap<>(256);
/** Map of singleton and non-singleton bean names, keyed by dependency type. */
private final Map, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);
/** Map of singleton-only bean names, keyed by dependency type. */
private final Map, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);
/** List of bean definition names, in registration order. */
private volatile List beanDefinitionNames = new ArrayList<>(256);
/** List of names of manually registered singletons, in registration order. */
private volatile Set manualSingletonNames = new LinkedHashSet<>(16);
/** Cached array of bean definition names in case of frozen configuration. */
@Nullable
private volatile String[] frozenBeanDefinitionNames;
ListableBeanFactory的方法基本是根据上面的各种数据集实现的，目的是加快查询的速度？
HierarchicalBeanFactory
这个没什么太多要讲的，就两个方法。自己看英语原文吧，开始偷懒。
/**
* 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.
* 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
看名识意
//注册单例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)能力有限，你们自已意会一下吧，哈哈。
Object getSingletonMutex();
ConfigurableBeanFactory
看名字就知道，这个接口的方法主要用来对bean做各种修改。
//设置父bean实例化工厂，get方法在HierarchicalBeanFactory接口中就声明过了
void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
//设置bean的类加载器
void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);
//获取bean的类加载器
@Nullable
ClassLoader getBeanClassLoader();
//
void setTempClassLoader(@Nullable ClassLoader tempClassLoader);
@Nullable
ClassLoader getTempClassLoader();
//设置是否允许缓存bean的metadata，默认是允许
void setCacheBeanMetadata(boolean cacheBeanMetadata);
//返回是否缓存
boolean isCacheBeanMetadata();
//设置表达式解析器，用于解析字符串表达式
void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
@Nullable
BeanExpressionResolver getBeanExpressionResolver();
//设置类型转换器
void setConversionService(@Nullable ConversionService conversionService);
@Nullable
ConversionService getConversionService();
//设置属性注册(添加/修改)器
void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);
//设置用户自定义的属性编辑器(单例共享，线程安全)
void registerCustomEditor(Class requiredType, Class propertyEditorClass);
//用已经注册的编辑器去初始化入参registry
void copyRegisteredEditorsTo(PropertyEditorRegistry registry);
//设置一个类型转换器
void setTypeConverter(TypeConverter typeConverter);
TypeConverter getTypeConverter();
//设置annotation 字符串值解析器
void addEmbeddedValueResolver(StringValueResolver valueResolver);
boolean hasEmbeddedValueResolver();
//解析value中字符串中的值
@Nullable
String resolveEmbeddedValue(String value);
//添加一个新的bean实例化前置处理器，会在bean实例化之前调用
void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
int getBeanPostProcessorCount();
//注册一个scope，建立scopeName和scope的一个映射关系
void registerScope(String scopeName, Scope scope);
例如
[图片上传失败...(image-50b833-1558969519678)]
//获取当前factory中已经注册过的所有scope的名字
String[] getRegisteredScopeNames();
//根据名字找scope
@Nullable
Scope getRegisteredScope(String scopeName);
//返回一个当前factory可安全访问的context
AccessControlContext getAccessControlContext();
//从otherFactory中复制所有相关的属性到当前factory
void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);
//注册别名
void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
//处理factory中所有的别名
void resolveAliases(StringValueResolver valueResolver);
//返回一个merged的bean定义对象,如果必要，会merge子类bean定义和其父类的
BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
//判断name对应的bean是不是factory bean
boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;
//控制beanName对应的bean的创建状态
void setCurrentlyInCreation(String beanName, boolean inCreation);
例如[图片上传失败...(image-d7a80b-1558969519678)]
//判断bean是否在实例化
boolean isCurrentlyInCreation(String beanName);
//为bean注册一个有依赖关系的bean
void registerDependentBean(String beanName, String dependentBeanName);
//返回所有和beanName对应的bean有依赖关系的bean的名字
String[] getDependentBeans(String beanName);
//同上
String[] getDependenciesForBean(String beanName);
//销毁一个bean 的实例对象，通常这个bean是prototype方式创建的
void destroyBean(String beanName, Object beanInstance);
//销毁当前scope中的bean
void destroyScopedBean(String beanName);
//销毁当前factory的所有单例bean
void destroySingletons();
AutowireCapableBeanFactory
//执行所有可用的BeanPostProcessor实例化一个bean对象
T createBean(Class beanClass) throws BeansException;
//对于一个已经实例化的bean执行after-instantiation的回调方法
void autowireBean(Object existingBean) throws BeansException;
//配置bean的变量值，执行factory的各种回调方法和post processor方法
Object configureBean(Object existingBean, String beanName) throws BeansException;
//-------------------------------------------------------------------------
// Specialized methods for fine-grained control over the bean lifecycle
//-------------------------------------------------------------------------
//autowire方式实例化bean
Object createBean(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
//autowire方式实例化bean
Object autowire(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
//autowire方式装载已经实例化的bean的各种属性
void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
throws BeansException;
//用beanName对应的beanDefination对象参数配置已经实例化的existingBean
void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;
//对已经存在的bean执行初始化操作
Object initializeBean(Object existingBean, String beanName) throws BeansException;
//对已存在的bean实例执行PostProcessor方法，在初始化之前
Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException;
//对已存在的bean实例执行PostProcessor方法，在初始化之后
Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException;
//销毁一个已存在的bean对象
void destroyBean(Object existingBean);
//-------------------------------------------------------------------------
// Delegate methods for resolving injection points
//-------------------------------------------------------------------------
//getBean(Class)方法的变形
NamedBeanHolder resolveNamedBean(Class requiredType) throws BeansException;
//根据此工厂中定义的bean解析指定的依赖项
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 autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;
先做到这里吧，篇幅太长看的难受