看这篇文章之前可以先了解之前的跟踪流程，https://www.jianshu.com/p/4934233f0ead
代码过宽，可以shift + 鼠标滚轮 左右滑动查看
AbstractApplicationContext类refresh()方法中的第三个调用方法prepareBeanFactory()的跟踪。
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
...
// Prepare the bean factory for use in this context.
// 准备在上下文中bean factory的使用
prepareBeanFactory(beanFactory);
···
}
断点进入跟踪。
此方法的实现在AbstractApplicationContext类中。
prepareBeanFactory(零)
/**
* Configure the factory's standard context characteristics,
* such as the context's ClassLoader and post-processors.
*
* 配置工厂的标准上下文特征，比如上下文的ClassLoader和post-processors
*/
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
//告知内部的bean工厂，使用上下文的类加载器
beanFactory.setBeanClassLoader(getClassLoader());
//设置bean表达式解析器，
//StandardBeanExpressionResolver内部expressionParser属性默认SpelExpressionParser类型
//spel = spring el表达式
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
//将ResourceEditorRegistrar实例添加到工厂的propertyEditorRegistrars属性中，
//propertyEditorRegistrars是一个LinkedHashSet，里面的元素将会应用到工厂bean中
//ResourceEditorRegistrar持有上下文和environment的引用
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
// 使用上下文回调配置bean 工厂
//在工厂的beanPostProcessor属性中添加处理器，beanPostProcessor是一个ArrayList
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//在工厂的ignoredDependencyInterfaces属性中添加Aware系列接口，
//ignoredDependencyInterfaces是一个HashSet
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
// 在普通的工厂中，BeanFactory接口并没有按照resolvable类型进行注册
// MessageSource被注册成一个Bean（并被自动注入）
//BeanFactory.class为key，beanFactory为value放入到了beanFactory的resolvableDependencies属性中
//resolvableDependencies是一个ConcurrentHashMap,映射依赖类型和对应的被注入的value
//这样的话BeanFactory/ApplicationContext虽然没有以bean的方式被定义在工厂中，
//但是也能够支持自动注入，因为他处于resolvableDependencies属性中
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
//再将上下文的一些接口与上下文本身做映射，一一放入到resolvableDependencies中
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Detect a LoadTimeWeaver and prepare for weaving, if found.
// 检测LoadTimeWeaver，如果有就准备织入
//1.跟踪进入，浅看下containsBean方法
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
//如果有LoadTimeWeaver，加入bean后处理器
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
// 为匹配类型设置一个临时的ClassLoader
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// Register default environment beans.
// 注册默认的environment beans
// 判断目前这个bean工厂中是否包含指定name的bean，忽略父工厂
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
//虽然XmlWebApplicationContext中持有默认实现的StandardServletEnvironment
//但是没有注册到beanFactory中，通过getEnvironment方法拿到持有的引用
//2.注册environment单例
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
//注册systemProperties单例
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
//注册systemEnvironment单例
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
1.containsBean
跟踪标记为1的方法
此方法的实现在AbstractBeanFactory类中
//1.跟踪看下containsBean方法
beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)
/**
* Does this bean factory contain a bean definition or externally registered singleton
* instance with the given name?
* <p>If the given name is an alias, it will be translated back to the corresponding
* canonical bean name.
* <p>If this factory is hierarchical, will ask any parent factory if the bean cannot
* be found in this factory instance.
* <p>If a bean definition or singleton instance matching the given name is found,
* this method will return {@code true} whether the named bean definition is concrete
* or abstract, lazy or eager, in scope or not. Therefore, note that a {@code true}
* return value from this method does not necessarily indicate that {@link #getBean}
* will be able to obtain an instance for the same name.
*
* bean工厂是否包含一个给定name的bean definition，或者外部被注册的单例bean？
* 如果name是一个别名，会被转换成对应的beanName
* 如果工厂是有层级的，那么当工厂实例中找不到这个bean时，就会去父工厂中查找
* 如果找到匹配name的bean definition或者单例，那么这个方法会返回true
* 不管这个bean definition是具体的还是抽象的，提前加载还是懒加载，是否在范围中。
* 因此，注意从这个方法中返回的true值并不代表从getBean方法中能够获取一个同名称的实例
*/
@Override
public boolean containsBean(String name) {
//1.1对name进行必要的转换
String beanName = transformedBeanName(name);
//singletonObjects或者beanDefinitionMap中已注册beanName则进入条件
//说明该beanName有对应的bean definition，或者单例bean
if (containsSingleton(beanName) || containsBeanDefinition(beanName)) {
//name开头不为&返回true，如果带了&但是是FactoryBean也返回true
//要注意下FactoryBean和BeanFactory的区别，可以看下文参考链接
return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(name));
}
// Not found -> check parent.
// 如果没有找到对应beanName的bean或者bean definition，那么从父工厂查找
BeanFactory parentBeanFactory = getParentBeanFactory();
return (parentBeanFactory != null && parentBeanFactory.containsBean(originalBeanName(name)));
}
1.1 transformedBeanName
跟踪标记为1.1的方法
此方法的实现在AbstractBeanFactory类中
//1.1对name进行必要的转换
String beanName = transformedBeanName(name);
/**
* Return the bean name, stripping out the factory dereference prefix if necessary,
* and resolving aliases to canonical names.
*
* 返回bean name，剥离factory dereference 前缀，并将别名解析为bean name
*/
protected String transformedBeanName(String name) {
//总的来说，如果name代表factory，那么name前就带有&前缀，去掉此前缀
//如果这个name是beanName，则直接返回，如果name是alias，在aliasMap中查找对应的beanName，再返回
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
//先看下transformedBeanName方法的实现
//进入BeanFactoryUtils类中
/**
* Return the actual bean name, stripping out the factory dereference
* prefix (if any, also stripping repeated factory prefixes if found).
*
* 返回真实的beanName，剥离工厂前缀（如果有的话，也剥离重复的工厂前缀）
*/
public static String transformedBeanName(String name) {
Assert.notNull(name, "'name' must not be null");
String beanName = name;
//FACTORY_BEAN_PREFIX常量为：&
while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
}
return beanName;
}
//再进入canonicalName方法查看
//此方法在SimpleAliasRegistry中实现，被默认bean工厂间接继承
/**
* Determine the raw name, resolving aliases to canonical names.
*
* 确定原生的name，将别名解析为BeanName
*/
public String canonicalName(String name) {
String canonicalName = name;
// Handle aliasing...
// 处理别名
String resolvedName;
do {
//拿到canonicalName对应的实际名称
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
//只有当canonicalName在aliasMap中对应的value为null时，才跳出循环
//这时候说明canonicalName已经不作为其他任何BeanName的别名，排除了间接引用
//canonicalName就为真正的beanName
while (resolvedName != null);
return canonicalName;
}
2.registerSingleton
跟踪标记为2的方法
此方法的实现在DefaultListableBeanFactory类中
//2.注册environment单例
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
@Override
public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
//2.1调用父类方法，注册单例
super.registerSingleton(beanName, singletonObject);
//AbstractBeanFactory类中有个集合属性alreadyCreated
//里面保存在至少被创建过一次的beanName
//如果这个集合中存在beanName，那么说明已经进入了bean创建阶段
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
// 无法再修改启动时集合元素（为了稳定迭代）
synchronized (this.beanDefinitionMap) {
//beanName不在beanDefinitionMap中，说明是手动注册
if (!this.beanDefinitionMap.containsKey(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames.size() + 1);
updatedSingletons.addAll(this.manualSingletonNames);
updatedSingletons.add(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// Still in startup registration phase
// 仍然处于启动注册阶段
if (!this.beanDefinitionMap.containsKey(beanName)) {
//属于手动注册情况
//environment属于手动注册单例
this.manualSingletonNames.add(beanName);
}
}
//进入这个方法查看
clearByTypeCache();
}
/**
* Remove any assumptions about by-type mappings.
*
* 删除按照类型映射有关的任何假设
*/
private void clearByTypeCache() {
//allBeanNamesByType是单例和非单例beanName的映射，key是依赖类型
this.allBeanNamesByType.clear();
//仅单例beanName的映射，key是依赖类型
this.singletonBeanNamesByType.clear();
}
2.1 registerSingleton
跟踪标记为2.1的方法
此方法的实现在DefaultSingletonBeanRegistry类中
//2.1调用父类方法，注册单例
super.registerSingleton(beanName, singletonObject);
/**
* Register the given existing object as singleton in the bean registry,
* under the given bean name.
* <p>The given instance is supposed to be fully initialized; the registry
* will not perform any initialization callbacks (in particular, it won't
* call InitializingBean's {@code afterPropertiesSet} method).
* The given instance will not receive any destruction callbacks
* (like DisposableBean's {@code destroy} method) either.
* <p>When running within a full BeanFactory: <b>Register a bean definition
* instead of an existing instance if your bean is supposed to receive
* initialization and/or destruction callbacks.</b>
* <p>Typically invoked during registry configuration, but can also be used
* for runtime registration of singletons. As a consequence, a registry
* implementation should synchronize singleton access; it will have to do
* this anyway if it supports a BeanFactory's lazy initialization of singletons.
*
* 在给定的bean name下，将存在的对象作为单例注册在工厂中
* 给定的实例应该是完全初始化；工厂不执行任何初始化回调（特别是，他不会调用InitializingBean的
* afterPropertiesSet方法）
* 给定的实例也不接收任何销毁回调（像DisposableBean的destroy方法）
* 当在完整的BeanFactory运行时：
* 如果你的bean需要接收初始化或者销毁的回调，注册一个bean definition替代一个存在的实例
* 通常此方法在工厂配置时被调用，也能在运行时单例注册时被调用。
* 作为结果，工厂的实现应该同步单例的访问；如果支持BeanFactory的单例的延迟初始化就不得不这样做
*/
@Override
public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
Object oldObject = this.singletonObjects.get(beanName);
//不能注册两次
if (oldObject != null) {
throw new IllegalStateException("Could not register object [" + singletonObject +
"] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
}
//进入这个方法
addSingleton(beanName, singletonObject);
}
}
/**
* Add the given singleton object to the singleton cache of this factory.
* <p>To be called for eager registration of singletons.
*
* 添加给定单例对象到工厂的单例缓存中
* 用来被提早注册的单例调用
*/
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
//singletonObjects是一个ConcurrentHashMap
//用来缓存单例对象
this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
//singletonFactories是一个HashMap
//里面缓存着单例工厂
this.singletonFactories.remove(beanName);
//早期单例对象
//earlySingletonObjects是一个HashMap
this.earlySingletonObjects.remove(beanName);
//registeredSingletons是一个LinkedHashSet
//被注册单例的集合，以注册的顺序包含着bean name
this.registeredSingletons.add(beanName);
}
}
这样，整个prepareBeanFactory方法也就跟踪完毕了。
接下来跟踪postProcessBeanFactory方法：
https://www.jianshu.com/p/c05aea93b939
参考
BeanFactory和FactoryBean的区别：https://www.cnblogs.com/aspirant/p/9082858.html
总结
- 为工厂设置类的加载器、表达式解析器、属性编辑器注册器等
- 为工厂添加后处理器、要忽略的依赖接口
- 在工厂中注册可解析的依赖
- 在工厂中提前注册一些单例Bean