一些重要类或者接口
BeanFactory
Spring顶层核心接口,使用了简单工厂模式,负责生产bean
Bean工厂实现应该尽可能支持标准Bean生命周期接口。整套初始化方法及其标准顺序为：
1 BeanNameAware的名字
2 BeanClassLoaderware的setBeanClassLoader
3 BeanFactoryAware的setBeanFactory
4 EnvironmentAware的setEnvironment
5 EmbeddedValueResolverAware的setEmbeddedValueResolver
6 ResourceLoaderWare的setResourceLoader（仅在应用程序上下文中运行时适用）
7 ApplicationEventPublisherAware的setApplicationEventPublisher（仅在应用程序上下文中运行时适用）
8 MessageSourceAware的setMessageSource（仅在应用程序上下文中运行时适用）
9 ApplicationContextAware的setApplicationContext（仅在应用程序上下文中运行时适用）
10 ServletContextAware的setServletContext（仅在web应用程序上下文中运行时适用）
11 BeanPostProcessor的后处理预初始化方法
12 初始化Bean的AfterPropertieSet
13 自定义init方法定义
14 BeanPostProcessor的后处理后初始化方法
关闭bean工厂时，应用以下生命周期方法：
销毁前的后处理销毁Warebean后处理器的销毁方法
可处置豆的破坏
自定义销毁方法定义
BeanDefinition
Spring顶层核心接口,封装了生产Bean的一切原料
BeanDefinition描述一个bean实例，该实例具有属性值、构造函数参数值以及由具体实现提供的进一步信息。
BeanDefinitionReader
用于bean定义读取器的简单接口。使用资源和字符串位置参数指定加载方法。具体的bean定义读者当然可以添加额外的
加载和注册bean定义的方法，特定于他们的bean定义格式。注意，bean定义读取器不必实现这个界面。它只作为bean定义的建议希望遵循标准命名约定的读取器。
实例化:在堆中开闭一块内存空间,属性都是默认值
初始化:给属性完成赋值操作
BeanFactory
用于访问SpringBean容器的根接口。这是bean容器的基本客户端视图；其他接口，如{@link ListableBeanFactory}和{@link org.springframework.beans.factory.config.ConfigurableBeanFactory}可用于特定用途。
PlaceholderConfigureSupport
用于解析bean定义属性值中占位符的属性资源配置器的抽象基类。实现<em>从属性文件或其他{@linkplain org.springframework.core.env.PropertySource PropertySource}将<em>值拉入bean定义。
BeanPostProcessor
工厂钩子，允许自定义修改新bean实例-例如，检查标记接口或使用代理包装bean。
通常，通过标记接口或类似接口填充bean的后处理器将在初始化之前实现后处理，而使用代理包装bean的后处理器通常会在初始化之后实现后处理。
登记
ApplicationContext可以在其bean定义中自动检测BeanPostProcessor bean，并将这些后处理器应用于随后创建的任何bean。普通BeanFactory允许对后处理器进行编程注册，将其应用于通过bean工厂创建的所有bean。
订购
在ApplicationContext中自动检测到的BeanPostProcessor bean将根据org.springframework.core.PriorityOrdered和org.springframework.core.ordered语义进行排序。相反，以编程方式向BeanFactory注册的BeanPostProcessorbean将按注册顺序应用；对于以编程方式注册的后处理器，通过实现PriorityOrdered或Ordered接口表达的任何排序语义都将被忽略。此外，BeanPostProcessor bean不考虑@Order注释。
在任何bean初始化回调（如InitializingBean的afterPropertiesSet或自定义init方法）之前，将此BeanPostProcessor应用于给定的新bean实例。bean将已经被属性值填充。返回的bean实例可能是原始实例的包装器。
postProcessBeforeInitialization(方法1)
在任何bean初始化回调（如InitializingBean的AfterPropertieSet或自定义init方法）之后，将此BeanPostProcessor应用于给定的新bean实例。bean将已经被属性值填充。返回的bean实例可能是原始实例的包装器。
对于FactoryBean，将为FactoryBean实例和FactoryBean创建的对象调用此回调（从Spring 2.0开始）。后处理器可以决定是应用于FactoryBean还是已创建的对象，还是通过FactoryBean检查的相应bean实例应用于两者。
与所有其他BeanPostProcessor回调不同，实例化WareBeanPostProcessor.postProcessBeforeInstantiation方法触发短路后，也将调用此回调。
postProcessAfterInitialization(方法2)
BeanPostProcessor的实现类之一
createProxy return proxyFactory.getProxy(getProxyClassLoader()); -> createAopProxy的return getAopProxyFactory().createAopProxy(this)的createAopProxy(this) -> interface AopProxyFactory的createAopProxy -> DefaultAopProxyFactory
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
//返回cglib动态代理
return new ObjenesisCglibAopProxy(config);
}
else {
//返回jdk动态代理
return new JdkDynamicAopProxy(config);
}
}
Environment
在容器启动之前提前把属性值加到Environment 接口里面
介绍
接口，表示当前应用程序运行的环境。为应用程序环境的两个关键方面建模：概要文件和属性。与属性访问相关的方法通过PropertyResolver超级接口公开。
概要文件是一个命名的、逻辑的bean定义组，只有在给定概要文件处于活动状态时，才会向容器注册。bean可以被分配给一个概要文件，不管是用XML定义的还是通过注释定义的；有关语法详细信息，请参见SpringBeans 3.1模式或@Profile注释。与概要文件相关的环境对象的作用是确定哪些概要文件（如果有）当前处于活动状态，以及默认情况下哪些概要文件（如果有）应处于活动状态。
属性在几乎所有的应用程序中都扮演着重要的角色，并且可能来自各种来源：属性文件、JVM系统属性、系统环境变量、JNDI、servlet上下文参数、特殊属性对象、映射等等。与属性相关的环境对象的作用是为用户提供一个方便的服务界面，用于配置属性源和解析属性。
ApplicationContext中管理的bean可以注册为环境感知或@Inject环境，以便直接查询配置文件状态或解析属性。
但是，在大多数情况下，应用程序级bean不需要直接与环境交互，而是可能需要将${…}属性值替换为属性占位符配置器，如PropertySourcesPlaceholderConfigurer，它本身是环境感知的，从Spring 3.1开始，在使用<context:property placeholder/>时默认注册。
环境对象的配置必须通过ConfigurableEnvironment接口完成，该接口由所有AbstractApplicationContext子类getEnvironment（）方法返回。请参阅ConfigurableEnvironment Javadoc，了解演示在应用程序上下文刷新（）之前操作属性源的用法示例。
1.public class StandardEnvironment extends AbstractEnvironment
适用于“标准”（即非web）应用程序的环境实现。
除了ConfigurableEnvironment的常规功能（如属性解析和与概要文件相关的操作）外，此实现还配置了两个默认属性源，将按以下顺序进行搜索：
系统属性
系统环境变量
也就是说，如果键“xyz”既存在于JVM系统属性中，也存在于当前进程的环境变量集中，那么系统属性中的键“xyz”的值将从对environment.getProperty（“xyz”）的调用返回。默认情况下选择此顺序是因为系统属性是每个JVM的，而环境变量在给定系统上的许多JVM中可能是相同的。赋予系统属性优先级允许在每个JVM的基础上重写环境变量。
可以删除、重新排序或替换这些默认属性源；并且可以使用getPropertySources（）中提供的MutablePropertySources实例添加其他属性源。有关用法示例，请参阅ConfigurableEnvironment Javadoc。
请参阅SystemEnvironmentPropertySource javadoc，以了解在不允许在变量名中使用句点字符的shell环境（例如Bash）中对属性名进行特殊处理的详细信息
三级缓存介绍
/*
//单例对象的缓存：bean名到bean实例。(一级缓存)
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
//早期单例对象的缓存：bean名到bean实例。(二级缓存)
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
//单例工厂缓存：将bean名称转换为ObjectFactory。(三级缓存)
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
循环依赖需要三级缓存
三级缓存参考资料
https://blog.csdn.net/u012098021/article/details/107352463
*/
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
/*
将给定的单例对象添加到此工厂的单例缓存。
被要求立即登记单身人士。
参数：
beanName–bean的名称
singleton对象–singleton对象*/
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
13,
SpringIOC的源码深入学习
- 类加载成Bean大致可以分为两大步
- 将类解析成Bean定义
- 将Bean定义创建成一个成熟的Bean
new AnnotationConfigApplicationContext(xxxxx.class)
/**
* 创建一个新的AnnotationConfigApplicationContext，从给定的组件类派生bean定义，并自 * 动刷新上下文@param * componentClasses一个或多个组件类&mdash；例
* 如，{@link Configuration@Configuration}类
*/
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
//调用构造函数
this();
//注册配置类(将配置类注册成了bean定义,并且保存到BeanDefinitionMap中,后面要去解析他)
register(componentClasses);
//上面两个步骤我们的配置类还没有真正解析成bean定义
//IOC容器刷新接口
refresh();
}
AnnotationConfigApplicationContext#this():构造方法
//构造函数 - this()
//该类的继承结构
public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry
//该类的构造方法
public AnnotationConfigApplicationContext() {
//创建一个读取注解的Bean定义读取器,完成了Spring内部BeanDefinition的注册(主要是后置处理器,为后续读取类的中@Component注解做准备);将后置处理器(例如ConfigurationClassPostProcessor:用来解析配置类)注册成bean定义放到BeanDefinitionMap
//仅仅是读取到了配置类,并没有解析配置类,没有把配置类中的component,import解析成bean定义,解析成BeanDefinition是在BeanFactoryPostProcessor后置处理器中进行解析的
this.reader = new AnnotatedBeanDefinitionReader(this);
/**
* 创建BeanDefinition扫描器
* 可以用来扫描包或者类,继而转换为BeadDefinition
* spring默认的扫描包不是这个scanner对象,而是自己new的一个 * ClassPathBeanDefinitionscanner
* Spring在执行后置处理器ConfigurationClassPostProcessor时,去扫描包时会new一个ClassPathBeanDefinitionScanner
* 这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scanner方法
*/
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
调用子类的构造方法一定会先调用父类的构造方法#GenericApplicationContext
//当调用子类的构造函数一定会先调用父类的构造函数,拿到bean工厂
public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
/**
* 调用父类的构造函数,为ApplicationContext spring上下文对象初始化beanFactory
* 为啥是DefaultListableBeanFactory?我们去看BeanFactory接口的时候发现 * DefaultListableBeanFactory是最底层的实现,功能是最安全的,看下图的继承结构
* DefaultListableBeanFactory实现了BeanDefinitionRegister接口,拥有了注册 * BeanDefinition的能力,所以注册bean定义也是有这个类来负责的
*/
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
AnnotationConfigApplicationContext#this()#new AnnotatedBeanDefinitionReader(this):创建一个读取注解的Bean定义读取器并且将创世纪的类注册到BeanDefinitionMap中
/**
* 为给定注册表创建新的AnnotatedBeanDefinitionReader。
* 如果注册表支持环境，例如是ApplicationContext，则环境将被继承，否则将创建并使用新的 * StandardEnvironment。
*/
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
this(registry, getOrCreateEnvironment(registry));
}
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
//把ApplicationContext对象赋值给BeanDefinitionRegistry
this.registry = registry;
//用户处理条件注解@Conditional os.name
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
//注册一些内置的后置处理器
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
registerAnnotationConfigProcessors(registry, null);
}
#registerAnnotationConfigProcessors():具体注册内置后置处理器的方法
/**
* 在给定注册表中注册所有相关的后置处理器。
* 参数：
* 注册表–要操作的注册表
* source–触发此注册的配置源元素（已提取）。可能为空。
* 返回：
* 一组BeanDefinitionHolders，包含此调用实际注册的所有bean定义
*
*/
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
//注册了实现Order接口的排序器
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
//设置@Autowired的候选解析器:ContextAnnotationAutowireCandidateResolver
//如果字段上带有@Lazy注解,表示进行懒加载,Spring不会立即创建注入属性的实例,而是生成代理对象
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
//为我们的容器中注册了解析我们配置类的后置处理器:ConfigurationClassPostProcessor
//key为org.springframework.context.annotation.internalConfigurationAnnotationProcessor
//value为ConfigurationClassPostProcessor对应的BeanDefinition
//在这里会new一个ConfigurationClassParser用来解析@Configuration的配置类,还会解析@ComponentScan,@ComponentScans注解扫描的包以及解析@Import等注解
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
//为我们的容器中注册了解析我们处理@Autowired注解的处理器:AutowiredAnnotationBeanPostProcessor
//名字叫org.springframework.context.annotation.internalAutowiredAnnotationProcessor
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
......
......
......
......
return beanDefs;
}
#registerPostProcessor():
private static BeanDefinitionHolder registerPostProcessor(
BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(beanName, definition);
return new BeanDefinitionHolder(definition, beanName);
}
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
//都是进行这个if
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
}
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
//已经存在一个相同的beanName
if (existingDefinition != null) {
//默认为true:是否允许存在两个相同的beanName
if (!isAllowBeanDefinitionOverriding()) {
//抛异常
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
......
......
......
......
//不走上面的if则进行覆盖,保留最新的
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
//private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
//保存已经被创建过的beanName,如果这个集合不为空则进入if,否则进入else
if (hasBeanCreationStarted()) {
//加锁
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
//更新beanDefinitionNames
this.beanDefinitionNames = updatedDefinitions;
//
removeManualSingletonName(beanName);
}
}
else {
//放到beanDefinitionMap里面
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
AnnotationConfigApplicationContext#this()#new ClassPathBeanDefinitionScanner(this):创建BeanDefinition扫描器
- 可以用来扫描包或者类,继而转换为BeanDefinition放到BeanDefinitionMap中
#AnnotationConfigApplicationContext#scan(String... basePackages):扫描包或者类
@Override
public void scan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
this.scanner.scan(basePackages);
}
/**
* 在指定的基本包中执行扫描，返回注册的bean定义。此方法不注册配置处理器，而是将其留给调用者。
*
*/
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
//创建bean定义的holder对象用于保存扫描后生成的bean定义对象
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
//循环包路径集合
for (String basePackage : basePackages) {
//找到候选的Compentes
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
//遍历
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
//设置bean的作用域
candidate.setScope(scopeMetadata.getScopeName());
//生成beanName
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
AnnotationBeanNameGenerator#generateBeanName
@Override
public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
if (definition instanceof AnnotatedBeanDefinition) {
String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
if (StringUtils.hasText(beanName)) {
// Explicit bean name found.
return beanName;
}
}
// Fallback: generate a unique default bean name.
return buildDefaultBeanName(definition, registry);
}
@Nullable
protected String determineBeanNameFromAnnotation(AnnotatedBeanDefinition annotatedDef) {
AnnotationMetadata amd = annotatedDef.getMetadata();
//类上注解
Set<String> types = amd.getAnnotationTypes();
String beanName = null;
for (String type : types) {
//注解里的属性
AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(amd, type);
//检查给定的注释是否是允许通过其注释{@code value（）}建议组件名称的原型。
if (attributes != null && isStereotypeWithNameValue(type, amd.getMetaAnnotationTypes(type), attributes)) {
//Configuration中的value属性可以作为beanName
Object value = attributes.get("value");
if (value instanceof String) {
String strVal = (String) value;
if (StringUtils.hasLength(strVal)) {
if (beanName != null && !strVal.equals(beanName)) {
throw new IllegalStateException("Stereotype annotations suggest inconsistent " +
"component names: '" + beanName + "' versus '" + strVal + "'");
}
beanName = strVal;
}
}
}
}
return beanName;
}
AnnotationConfigApplicationContext#register():将配置类注册成bean定义
//reader:在this()方法中创建的Bean定义读取器,调用这个AnnotatedBeanDefinitionReader的register()方法,将配置类(componentClasses)注册到BeanDefinitionMap中
//到这一步,配置类有了,解析配置类的处理器也有了=>可以去准备解析配置类(会在refresh()#invokeBeanFactoryPostProcessors)
//配置类就是传进去的类.class,一般类上会有@Configuration注解
@Override
public void register(Class<?>... componentClasses) {
Assert.notEmpty(componentClasses, "At least one component class must be specified");
this.reader.register(componentClasses);
}
//注册一个或多个要处理的组件类。注册调用是幂等的；多次添加同一组件类不会产生额外的效果。
//参数：ComponentClass–一个或多个组件类，例如@Configuration Class
public void register(Class<?>... componentClasses) {
for (Class<?> componentClass : componentClasses) {
registerBean(componentClass);
}
}
//从给定的bean类中注册一个bean，从类声明的注释中派生其元数据。
//参数：bean类–bean的类
public void registerBean(Class<?> beanClass) {
doRegisterBean(beanClass, null, null, null, null);
}
private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
@Nullable BeanDefinitionCustomizer[] customizers) {
//存储@Configuration注解注释的类
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
//判断是否需要跳过注解,spring中有一个@Confition注解,当不满足条件时,这个bean就不会被解析
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(supplier);
//解析bean的作用域,如果没有设置的话,默认为单例
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
//或者beanName
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
//解析通用注解,填充到AnnotatedGenericBeanDefinition,解析的注解为Lazy,Primary,DependsOn,Qualifier
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
if (customizers != null) {
for (BeanDefinitionCustomizer customizer : customizers) {
customizer.customize(abd);
}
}
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
//注册,最终会调用DefaultListableBeanFactory中的registerBeanDefinition方法去注册
//DefaultListableBeanFactory维护着一系列信息,比如beanDefinitionNames,beanDefinitionMap
//beanDefinitionNames是一个List<String>,用来保存beanName
//beanDefinitionMap是一个Map,用来保存beanName和beanDefinition
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
BeanDefinitionReaderUtils#registerBeanDefinition
//向给定的bean工厂注册给定的bean定义。
//参数：definitionHolder–bean定义，包括名称和别名注册表–要注册的bean工厂
//抛出：BeanDefinitionStoreException–如果注册失败
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// 注册别名 Map<alias, name> aliasMap维护别名和beanName的一个联系
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
//DefaultListableBeanFactory#registerBeanDefinition()
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
//是不是设置了不允许相同名称Bean定义(默认允许存在相同的)
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
//权限大的优先存在,就不会被覆盖
else if (existingDefinition.getRole() < beanDefinition.getRole()) {
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
//注册到beanDefinitionMap中
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
removeManualSingletonName(beanName);
}
}
else {
// Still in startup registration phase
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
AnnotationConfigApplicationContext#refresh():IOC容器刷新接口
//非常重要的方法,执行刷新操作
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 1,准备刷新上下文环境
prepareRefresh();
// 2,获取告诉子类初始化Bean工厂 不同工厂不同实现
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 3,对Bean工厂进行填充属性
prepareBeanFactory(beanFactory);
try {
//六个子类去实现接口
// 允许在上下文子类中对bean工厂进行后处理。
postProcessBeanFactory(beanFactory);
//调用实现了BeanDefinitionRegistryPostProcessor接口(注册Bean定义)和BeanFactoryPostProcessor接口(修改Bean定义)这两个接口的bean定义,而ConfigurationClassPostProcessor实现了两个接口所以当调用invokeBeanFactoryPostProcessors(beanFactory)方法时也会调用ConfigurationClassPostProcessor.
// 调用我们的bean工厂的后置处理器.1,会在此将class扫描成beanDefinition,将配置类中的@ComponentScan解析出来,以及扫描包下的包含@Component,@bean,@service的类解析出来注册到BeanDefinitionMap,
//在这个方法里面执行了BeanFactoryPostPricessor方法,在BeanFactoryPostPricessor方法里面解析了ConfigurationClassPostProcessor,通过ConfigurationClassPostProcessor解析了注解的类为bean定义注册到BeanDefinitionMap,
//ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor接口和BeanFactoryPostProcessor接口ConfigurationClassPostProcessor解析配置类,调用了ConfigurationClassPostProcessor的后置处理器,解析了配置类;在这里只会实例化bean工厂的后置处理器(BeanFactoryPostProcessor)
invokeBeanFactoryPostProcessors(beanFactory);
// 注册我们Bean的后置处理器
registerBeanPostProcessors(beanFactory);
// 初始化国际资源处理器
initMessageSource();
// 创建事件多播器
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// 实例化我们所有的单例bean
finishBeanFactoryInitialization(beanFactory);
// 最后容器刷新,发布刷新事件(SpringCloud也是从这里启动的)
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
invokeBeanFactoryPostProcessors(beanFactory);
- 调用我们的bean工厂的后置处理器BeanFactoryPostProcessor接口和BeanDefinitionRegistryPostProcessor接口,但是要注意BeanDefinitionRegistryPostProcessor实现了BeanFactoryPostProcessor
- BeanFactory的后置处理器(BeanFactoryPostProcessor):生产bean之前调用的,主要针对我们的Bean定义做一些修改或者注册
两个后置处理器接口的介绍
public interface BeanFactoryPostProcessor {
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}
//如果是BeanDefinitionRegistryPostProcessor的是实现类,则需要实现上面两个方法
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}
invokeBeanFactoryPostProcessors
- 进入该方法前BeanDefinitionMap中的BeanDefinition,注意:只有key为internalConfigurationAnnotationProcessor的这个BeanDefinition实现了BeanFactoryPostProcessor,所以在这里之会调用这个和自定义的(如果存在的话)
//在this()方法中将这些后置处理器放到了BeadDefinitonMap中,在进入该方法之前,创世纪的类(用于解析各种注解的类)已经被放到了beadDefinitonMap
//在这个方法里面去调用所有实现了BeanPostProcessor接口(修改Bean定义)和BeanDefinitonRegistryPostProcessor接口(注册Bean定义)的bean定义,而只有ConfigurationClassPostProcessor实现了这个接口,也就意味着会调用这个方法从而去解析我们的配置类中的@Bean,@import
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
/**获取两处存储BeanFactoryPostProcessor的对象,传入供接下来调用
1,当前bean工厂
2,和我们自己调用addBeanFactoryPostProcessor的自定义BeanFactoryPostProcessor
getBeanFactoryPostProcessors()参数:就是我们在代码中通过下列代码添加的自定义后置处理器
添加的自定义bean工厂后置处理器代码实例:
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
context.addBeanFactoryPostProcessor();:**/
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
......
......
......
......
}
#invokeBeanFactoryPostProcessors()
/**该方法有两大步骤
* 调用实现了BeanDefinitionRegistryPostProcessor接口的bean定义,要注意,因为BeanDefinitionRegistryPostProcessor实现了BeanFactoryPostProcessor接口,所以BeanDefinitionRegistryPostProcessor的子类会同时实现两个接口,拥有两个接口的特有方法
* 调用实现了BeanFactoryPostProcessor接口的bean定义
**/
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// 调用BeanDefinitionRegistryPostProcessor的后置处理器
//保存已处理的后置处理器,防止重复调用
Set<String> processedBeans = new HashSet<>();
//判断我们的beanFactory是否实现了BeanDefinitionRegistry(实现了该结构就有注册和获取bean定义的能力);此时的BeanDefinitionRegistry还是之前this()方法中加载父类时创建的:
// this.beanFactory = new DefaultListableBeanFactory();
if (beanFactory instanceof BeanDefinitionRegistry) {
//强行把我们的bean工厂转为BeanDefinitionRegistry,因为待会需要注册Bean定义
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
//保存BeanFactoryPostProcessor类型的后置处理器,BeanFactoryPostProcessor提供修改
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
//保存BeanDefinitionRegistryPostProcessor类型的后置处理器
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
//循环我们传递进来的beanFactoryPostProcessors
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
//判断我们的后置处理器是不是BeanDefinitionRegistryPostProcessor
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { //进行强制转化
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
//调用自定义BeanDefinitionRegistryPostProcessor的处理器的后置方法
registryProcessor.postProcessBeanDefinitionRegistry(registry);
//添加到我们用于保存BeanDefinitionRegistryPostProcessor的集合中
registryProcessors.add(registryProcessor);
}
else {
//如果没有实现BeanDefinitionRegistryPostProcessor接口,那么他就是
//BeanFactoryPostProcessor,加到对应的集合中
regularPostProcessors.add(postProcessor);
}
}
//定义一个集合用于保存当前准备创建的BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
//在实现了BeanDefinitionRegistryPostProcessor接口的bean定义中优先获取实现了PriorityOrdered接口的,然后是实现了Order接口的,再后来是上面两个接口都没有实现的bean定义
//第一步:去容器(beanDefinitionNames)中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称;
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
//循环筛选出来的匹配BeanDefinitionRegistryPostProcessor的类型名称
for (String ppName : postProcessorNames) {
//判断是否实现了PriorityOrdered接口,首先调用内置实现了PriorityOrdered接口的bean定义,ConfigurationClassPostProcessor实现了PriorityOrdered接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//显示的调用getBean()方式创建该对象然后加入到currentRegistryProcessors集合中
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//同时也加入到processedBeans集合中:为了保证在本地被调用的,在下次不被调用
processedBeans.add(ppName);
}
}
//对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//把当前BeanDefinitionRegistryPostProcessor的加入到总集合
registryProcessors.addAll(currentRegistryProcessors);
/** 这一步特别关键,在这里解析配置类
* 在这里典型的BeanDefinitionRegistryPostProcessors就是 * ConfigurationClassPostProcessor,用于进行bean定义的加载,比如我们的包扫 * 描,@import 等等...如果我们自定义了类实现了BeanDefinitionRegistryPostProcessor通过@Component注解,在这步之前BeadDefinitionMap没有我们自定义的类,只有这步之后,通过解析后才会有我们的BeanDefinition
* 如果定义类实现了BeanDefinitionRegistryPostProcessors这个接口调用的方法只是postProcessBeanDefinitionRegistry,并没有调用postProcessBeanFactory()
*/
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//调用完之后马上clear掉
currentRegistryProcessors.clear();
// 去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称(内置 // 的上面注册的)
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); //循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称
for (String ppName : postProcessorNames) {
//表示没有被处理过,且实现了Ordered接口的
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
// 显示的调用getBean方式创建该对象然后加入到 currentRegistryProcessors集合中去
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//同时加入到processedBeans集合中去
processedBeans.add(ppName);
}
}
//排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//保存到registryProcessors中
registryProcessors.addAll(currentRegistryProcessors);
//调用它的后置后置方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//调用完之后,马上clear
currentRegistryProcessors.clear();
// 调用没有实现任何优先级接口的BeanDefinitionRegistryPostProcessor
//定义一个重复处理的开关变量 默认值为true
boolean reiterate = true;
//第一次可以进来
while (reiterate) {
//进入循环马上把开关变量给改为false
reiterate = false;
//去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
//循环上一步获取的BeanDefinitionRegistryPostProcessor的bean的处理器名称
for (String ppName : postProcessorNames) {
//没有被处理过的会被执行
if (!processedBeans.contains(ppName)) {
//调用getBean方法并且添加到currentRegistryProcessors中
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//添加到processedBeans集合中去
processedBeans.add(ppName);
//再次设置为true
reiterate = true;
}
}
//排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//加入到registryProcessors方法中
registryProcessors.addAll(currentRegistryProcessors);
//调用它的后置处理方法:BeanDefinitionRegistryPostProcessor接口的方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//clear
currentRegistryProcessors.clear();
}
//ConfigurationClassPostProcessor(或者其他的bean定义)实现了两个接口Bean工厂的后置处理器和Bean定义注册的后置处理器
//registryProcessors集合中保存的是所有实现了BeanDefinitionRegistryPostProcessor的bean定义,又因为BeanDefinitionRegistryPostProcessor实现了BeanFactoryPostProsessor,如果有一个bean定义同时实现了两种接口
//调用这个BeanFactoryPostProsessor的postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
//调用自定义的BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
/**
* BeanDefinitionRegistryPostProcessor:调用过程可以看下面的图
* 其中ConfigurationClassPostProcessor会有会有执行点:
* 1,既实现了BeanDefinitionRegistryPostProcessor又实现了PriorityOedered
解析配置类
* 2,实现了两个接口Bean工厂的后置处理器和Bean定义注册的后置处理器
*/
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
#invokeBeanDefinitionRegistryPostProcessors():ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry
private static void invokeBeanDefinitionRegistryPostProcessors(
Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
//获取容器中的ConfigurationClassPostProcessor的后置处理器,进行bean定义扫描
for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
postProcessor.postProcessBeanDefinitionRegistry(registry);
}
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
int registryId = System.identityHashCode(registry);
this.registriesPostProcessed.add(registryId);
//真正的解析我们的bean定义
processConfigBeanDefinitions(registry);
}
#processConfigBeanDefinitions(registry);
/**
* 在BeanDefinitonMap中拿到我们的配置类,解析我们的配置类
*/
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
//获取IOC容器中目前所有Bean定义的名称
String[] candidateNames = registry.getBeanDefinitionNames();
//循环我们的上一步的所有Bean定义信息
for (String beanName : candidateNames) {
//通过bean的名称来获取我们的bean定义对象
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
//判断组件是否已经被作为一个配置类处理过(带了@Configuration的就是一个完整的配置类,带了@Component就是一个不完整的配置类)
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
//判断正在进行解析的类是不是完全的配置类,还是一个非正式的配置类
//只要配置类上带了@Configuration,或者方法上带了@Bean,或者带了@Component,@Import注解,都会去当作配置类进行解析
//判断组件是否为候选的配置类，如果是则加入待处理集合
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
//满足条件就加入到候选的配置类集合中
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// 如果没有找到配置类,直接返回,对我们的配置类排序
if (configCandidates.isEmpty()) {
return;
}
// Sort by previously determined @Order value, if applicable
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
//创建我们通过@CompentScan导入进来的bean name的生成器
//创建我们通过@Import导入进来的bean的名称
SingletonBeanRegistry sbr = null;
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
if (generator != null) {
//设置@CompentScan导入进来的bean的名称生成器
this.componentScanBeanNameGenerator = generator;
//设置@Import导入进来的bean的名称生成器
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
// 创建一个配置类解析器对象
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
//用于保存我们的配置类BeanDefinitionHolder放入上面筛选出来的配置类
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
//用于保存我们的已经解析的配置类,长度默认为解析出来默认的配置类的集合长度
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
//do while会进行一次解析
do {
//真正的解析我们的配置类
parser.parse(candidates);
parser.validate();
//解析出来的配置类
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// Read the model and create bean definitions based on its content
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
//此处才把@Bean的方法和@Import注册到BeanDefinitonMap中
this.reader.loadBeanDefinitions(configClasses);
//加入到已经解析的集合中
alreadyParsed.addAll(configClasses);
candidates.clear();
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
// Clear cache in externally provided MetadataReaderFactory; this is a no-op
// for a shared cache since it'll be cleared by the ApplicationContext.
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}
#parse()
public void parse(Set<BeanDefinitionHolder> configCandidates) {
//循环配置类
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
//真正的解析我们的Bean定义:通过注解元数据解析
if (bd instanceof AnnotatedBeanDefinition) {
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
// 处理我们延迟的DeferredImportSelectors,我们SpringBoot就是通过这部进行加载Spring.factories
this.deferredImportSelectorHandler.process();
}
#parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
//第一步:把我们的配置类源信息和beanName包装成一个ConfugurationClass对象
processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
}
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
//判断配置类是否有@Configuration注解,有的话根据条件判断是否成立
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
//获取我们的配置类对象
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
if (existingClass != null) {
//传入进来的配置类是通过其他配置类的Import导入进来的
if (configClass.isImported()) {
if (existingClass.isImported()) {
//需要合并配置
existingClass.mergeImportedBy(configClass);
}
// 如果通过@Import导入一个已存在的配置类是不允许的,会忽略
return;
}
else {
// Explicit bean definition found, probably replacing an import.
// Let's remove the old one and go with the new one.
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
}
// Recursively process the configuration class and its superclass hierarchy.
SourceClass sourceClass = asSourceClass(configClass, filter);
//真正的进行配置类的解析(递归处理配置类和其所有的父类
do {
//解析我们的配置类
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
#doProcessConfigurationClass()
@Nullable
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {
//判断配置类上的注解是否包含@Component注解,如果包含则递归获取内部类进行处理
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
processMemberClasses(configClass, sourceClass, filter);
}
// 处理我们的@PropertySource注解
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
else {
logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
//解析我们的@ComponentScan注解,从我们的配置类上解析@ComponentScan的对象集合属性
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
//循环解析 我们解析出来的AnnotationAttributes
for (AnnotationAttributes componentScan : componentScans) {
// 把我们扫描出来的类变为bean定义的集合,真正的解析
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// 循环处理我们包扫描出来的bean定义
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
//判断当前扫描出来的bean定义是不是一个配置类,若是的话一直进行递归解析
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// Process any @ImportResource annotations
AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// 处理配置类中的所有标注了@Bean注解的方法,并封装成BeanMethod添加到配置类的实例ConfigurationClass中
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
processInterfaces(configClass, sourceClass);
// 如果有父类,则返回父类
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") &&
!this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// Superclass found, return its annotation metadata and recurse
return sourceClass.getSuperClass();
}
}
// 没有父类,返回null
return null;
}
//检查给定的bean定义是否是配置类（或在配置/组件类中声明的嵌套组件类，也要自动注册）的候选项，并相应地标记它。
//参数：
//beanDef–要检查的bean定义
//metadataReaderFactory–调用者正在使用的当前工厂
public static boolean checkConfigurationClassCandidate(
BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
//获取组件的全限定类名
String className = beanDef.getBeanClassName();
if (className == null || beanDef.getFactoryMethodName() != null) {
return false;
}
// 下面这一大段代码都是在获取组件类的元数据信息AnnotationMetadata，这里不详细介绍
AnnotationMetadata metadata;
if (beanDef instanceof AnnotatedBeanDefinition &&
className.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName())) {
// Can reuse the pre-parsed metadata from the given BeanDefinition...
metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();
}
else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDef).hasBeanClass()) {
// Check already loaded Class if present...
// since we possibly can't even load the class file for this Class.
Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
if (BeanFactoryPostProcessor.class.isAssignableFrom(beanClass) ||
BeanPostProcessor.class.isAssignableFrom(beanClass) ||
AopInfrastructureBean.class.isAssignableFrom(beanClass) ||
EventListenerFactory.class.isAssignableFrom(beanClass)) {
return false;
}
metadata = AnnotationMetadata.introspect(beanClass);
}
else {
try {
MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
metadata = metadataReader.getAnnotationMetadata();
}
catch (IOException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Could not find class file for introspecting configuration annotations: " +
className, ex);
}
return false;
}
}
//获取组件类的@Configuration注解属性,如果组件类上不存在@Configuration注解,则返回fasle
//如果存在config为{proxyBeanMethods ->true;value -> ""}
//存在且proxyBeanMethods属性值为true则为full
Map<String, Object> config = metadata.getAnnotationAttributes(Configuration.class.getName());
//如果存在,并且proxyBeanMethods属性的值为空,则标注当前类为full,既需要代理增强,为一个代理类
if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
}
//存在且proxyBeanMethods属性值为false
//不存在Configuration注解但是方法上的注解有@Bean类上有 Component,ComponentScan,Import,ImportResource
else if (config != null || isConfigurationCandidate(metadata)) {
beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
}
else {
return false;
}
// 获取配置类的排序顺序,设置到组件定义属性中
Integer order = getOrder(metadata);
if (order != null) {
beanDef.setAttribute(ORDER_ATTRIBUTE, order);
}
return true;
}
public static boolean isConfigurationCandidate(AnnotationMetadata metadata) {
// 如果配置类为一个接口，则不处理
if (metadata.isInterface()) {
return false;
}
/*
* 判断配置类是否存在（@Component，ComponentScan，@Import，ImportResource）注解
* 如果存在上述任意一个注解，则返回true
*/
for (String indicator : candidateIndicators) {
if (metadata.isAnnotated(indicator)) {
return true;
}
}
// 如果上述四个注解都不存在，则判断配置类中是否存在被@Bean标注的方法
return hasBeanMethods(metadata);
}
#parse()
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
//这里new了一个ClassPathBeanDefinitionScanner,可以利用这个进行扫描其他包
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
//为我们的扫描器设置beanName的生成器对象
Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
BeanUtils.instantiateClass(generatorClass));
//解析@Scope的proxyMode属性,该属性可以将Bean创建jdk代理或者cglib代理
ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
scanner.setScopedProxyMode(scopedProxyMode);
}
else {
Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
}
scanner.setResourcePattern(componentScan.getString("resourcePattern"));
//获取设置的TypeFilter,设置CompentScan对象的includeFilters包含的属性
for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addIncludeFilter(typeFilter);
}
}
//获取设置的TypeFilter,设置CompentScan对象的excludeFilters包含的属性
for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addExcludeFilter(typeFilter);
}
}
//是否为懒加载,此懒加载为ComponentScan延迟加载所有的类
boolean lazyInit = componentScan.getBoolean("lazyInit");
if (lazyInit) {
scanner.getBeanDefinitionDefaults().setLazyInit(true);
}
//包路径
Set<String> basePackages = new LinkedHashSet<>();
String[] basePackagesArray = componentScan.getStringArray("basePackages");
for (String pkg : basePackagesArray) {
String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
Collections.addAll(basePackages, tokenized);
}
for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
if (basePackages.isEmpty()) {
basePackages.add(ClassUtils.getPackageName(declaringClass));
}
scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
@Override
protected boolean matchClassName(String className) {
return declaringClass.equals(className);
}
});
//真正的进行扫描解析
return scanner.doScan(StringUtils.toStringArray(basePackages));
}
#doScan(String… basePackages)
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
//创建bean定义的holder对象,用于保存扫描后生成的bean定义对象
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
//循环我们的包路径集合
for (String basePackage : basePackages) {
//找到候选的Components
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
//循环处理候选的Components
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
//设置我们的beanName
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
//这是默认配置 autowire-candidate
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
//获取@Lazy,@DependsOn等注解到的数据设置到BeanDefinition中
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
//把我们解析出来的组件bean定义注册到我们的IOC容器中(容器中没有才注册)
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
/**详细的介绍搜BeanDefinitionReaderUtils.registerBeanDefinition(
* protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
}
*/
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else {
return scanCandidateComponents(basePackage);
}
}
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
//把我们的包路径转为资源路径 cn/tulingxueyuan/MainConfig
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
//扫描指定包路径下面的所有.class文件
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
//resources集合
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
//是否可读
if (resource.isReadable()) {
try {
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
//是不是候选的组件,可能会通过@Component中的某些属性直接排除某些注解
// 这一部分的逻辑可参考https://blog.csdn.net/qq_44447372/article/details/124105108
if (isCandidateComponent(metadataReader)) {
//包装成一个ScannedGenericBeanDefinition
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
//设置class资源
sbd.setResource(resource);
sbd.setSource(resource);
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Identified candidate component class: " + resource);
}
//加入到集合中
candidates.add(sbd);
}
else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + resource);
}
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not matching any filter: " + resource);
}
}
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to read candidate component class: " + resource, ex);
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not readable: " + resource);
}
}
}
}
catch (IOException ex) {
throw ne BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
#ConfigurationClassBeanDefinitionReader.loadBeanDefinitions方法分析
public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
// 可跟踪记录的条件评估者，也就是解析@Conditon注解的作用，并且可以记录满足@Condition和不满足@Condition的原因
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
for (ConfigurationClass configClass : configurationModel) {
// 从配置类中加载组件定义信息
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
}
private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
// 处理配置类上的@Condition注解
if (trackedConditionEvaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
this.registry.removeBeanDefinition(beanName);
}
this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
return;
}
// 判断当前配置类是否是通过@Import注解导入的
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
// 获取配置类中的所有@Bean注解标注的方法
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
// 从@Bean标注的方法加载组件定义信息
loadBeanDefinitionsForBeanMethod(beanMethod);
}
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
#ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsForBeanMethod()
private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
// 获取配置类信息
ConfigurationClass configClass = beanMethod.getConfigurationClass();
// 获取目标类的元数据
MethodMetadata metadata = beanMethod.getMetadata();
// 获取方法名
String methodName = metadata.getMethodName();
// 处理方法上的@Conditional注解
if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
configClass.skippedBeanMethods.add(methodName);
return;
}
if (configClass.skippedBeanMethods.contains(methodName)) {
return;
}
// 获取方法上@Bean注解的属性信息
AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
Assert.state(bean != null, "No @Bean annotation attributes");
// 处理@Bean注解的name属性，如果此属性为空，则组件的名称为方法名
List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
// 获取第一个别名,没有别名就用方法名
String beanName = (!names.isEmpty() ? names.remove(0) : methodName);
// 注册别名 beanName----别名
for (String alias : names) {
//注册剩下的别名 放到别名Map中 ，key 是别名 value 是名称
this.registry.registerAlias(beanName, alias);
}
// 封装为 ConfigurationClassBeanDefinition，表示是来自配置类里的bean定义
ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);
// 设置 来源的 类
beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));
// 如果@Bean方法为静态方法
if (metadata.isStatic()) {
// static @Bean method
if (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
beanDef.setBeanClass(((StandardAnnotationMetadata) configClass.getMetadata()).getIntrospectedClass());
}
else {
beanDef.setBeanClassName(configClass.getMetadata().getClassName());
}
//设置工厂方法的名字，也就是方法名
beanDef.setUniqueFactoryMethodName(methodName);
}
// 如果@Bean方法为实例方法
else {
beanDef.setFactoryBeanName(configClass.getBeanName());
beanDef.setUniqueFactoryMethodName(methodName);
}
// 设置自定装配模式默认是构造器
beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.
SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);
//处理通用注解，注解里可能还有自动装配注解等
AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
/*
处理@Bean方法上的公共注解(@Lazy,@Primary,@DependsOn,@Role,@Description)
这里稍微解释一下这几个注解
@Lazy：组件是否为懒加载，组件的创建可以在项目启动Spring容器刷新的时候创建，也可以在第一次获取组件的时候(BeanFactory.getBean)创建。后者则为懒加载
@Primary：如果一个接口在容器中有多个实现类的时候，在使用@Autowired依赖注入的时候优先使用被@Primary注解标注的实现类
@DependsOn：创建此组件时依赖的其他组件，在创建此组件时，先创建完成依赖的其他组件
@Role：组件的角色，Spring框架底层使用。开发者一般不用
@Description：可以为组件定义添加描述，相当于一个描述信息，仅此而已
*/
AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
// 解析 @Bean.autowire 自动装配
Autowire autowire = bean.getEnum("autowire");
if (autowire.isAutowire()) {
//如果是自动装配，也就是BY_NAME 或者 BY_TYPE，再设置了一次自动装配模式
beanDef.setAutowireMode(autowire.value());
}
// 解析 @Bean.autowireCandidate 自动装配候选，默认是true
boolean autowireCandidate = bean.getBoolean("autowireCandidate");
if (!autowireCandidate) {
beanDef.setAutowireCandidate(false);
}
// 获取初始化 方法的名称
String initMethodName = bean.getString("initMethod");
if (StringUtils.hasText(initMethodName)) {
beanDef.setInitMethodName(initMethodName);
}
//获取销毁 方法的名称
String destroyMethodName = bean.getString("destroyMethod");
beanDef.setDestroyMethodName(destroyMethodName);
// 默认是 不创建代理
ScopedProxyMode proxyMode = ScopedProxyMode.NO;
// 解析 @Scope 注解
AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
// 如果 不是 Null 则代表了设置了 @Scope 的范围
if (attributes != null) {
beanDef.setScope(attributes.getString("value"));
proxyMode = attributes.getEnum("proxyMode");
// 如果是默认的 则设置为 不进行代理
if (proxyMode == ScopedProxyMode.DEFAULT) {
proxyMode = ScopedProxyMode.NO;
}
}
// Replace the original bean definition with the target one, if necessary
BeanDefinition beanDefToRegister = beanDef;
if (proxyMode != ScopedProxyMode.NO) {
BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
new BeanDefinitionHolder(beanDef, beanName), this.registry,
proxyMode == ScopedProxyMode.TARGET_CLASS);
beanDefToRegister = new ConfigurationClassBeanDefinition(
(RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata);
}
// 去注册
this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}
配置类创建AOP:invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
- //调用这个BeanFactoryPostProsessor的postProcessBeanFactory方法
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
if (!this.registriesPostProcessed.contains(factoryId)) {
processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
}
//使用cglib对配置类进行代理,因为@Bean方法要进行创建Bean的实例
enhanceConfigurationClasses(beanFactory);
beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}
public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
for (String beanName : beanFactory.getBeanDefinitionNames()) {
BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
//只有full版配置类才会创建cglib代理,虽然我们在执行配置类的时候不标注@Configuraion也行,所以加不加注解的区别就在这里
//当在配置类中的一个@Bean使用方法的方式引用另外一个@Bean如果不加注解就会重复加载Bean,如果加了@Configuraion,则会在这里创建cglib代理,当调用@Bean方法时会先去检测容器中是否存在
Object configClassAttr = beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE);
MethodMetadata methodMetadata = null;
if (beanDef instanceof AnnotatedBeanDefinition) {
methodMetadata = ((AnnotatedBeanDefinition) beanDef).getFactoryMethodMetadata();
}
if ((configClassAttr != null || methodMetadata != null) && beanDef instanceof AbstractBeanDefinition) {
// Configuration class (full or lite) or a configuration-derived @Bean method
// -> resolve bean class at this point...
AbstractBeanDefinition abd = (AbstractBeanDefinition) beanDef;
if (!abd.hasBeanClass()) {
try {
abd.resolveBeanClass(this.beanClassLoader);
}
catch (Throwable ex) {
throw new IllegalStateException(
"Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
}
}
}
//full版配置类
if (ConfigurationClassUtils.CONFIGURATION_CLASS_FULL.equals(configClassAttr)) {
configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
}
}
if (configBeanDefs.isEmpty()) {
// nothing to enhance -> return immediately
return;
}
//创建代理配置类
ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
AbstractBeanDefinition beanDef = entry.getValue();
// If a @Configuration class gets proxied, always proxy the target class
beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
// Set enhanced subclass of the user-specified bean class
Class<?> configClass = beanDef.getBeanClass();
Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
if (configClass != enhancedClass) {
if (logger.isTraceEnabled()) {
logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " +
"enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
}
//将BeanDefinition的BeanClass设为代理类
beanDef.setBeanClass(enhancedClass);
}
}
}
class ConfigurationClassEnhancer {
// The callbacks to use. Note that these callbacks must be stateless.
private static final Callback[] CALLBACKS = new Callback[] {
//调用配置类的动态代理的某个方法时BeanMethodInterceptor会进行拦截,先去IOC容器中找
//具体使用可查看AOP章节
new BeanMethodInterceptor(),
new BeanFactoryAwareMethodInterceptor(),
NoOp.INSTANCE
};
}
配置类如下
package com.nieyp.config2;
import com.nieyp.been.Car;
import com.nieyp.been.Person1;
import com.nieyp.been.Student;
import org.springframework.context.annotation.*;
/**
* @author nieyapeng
* @create 2022-03-20-11:11
*/
@Configuration
public class MainConfigOfAutowired {
@Bean
public Car car(){
return new Car("123","123");
}
@Bean
public Person1 person1(){
Car car = car();
Person1 person = new Person1(car);
person.setCar(car);
return person;
}
}
- 创建car实例的时候,调用配置类里面car()方法的时候,进到MethodIntercept里面,进行拦截,因为此时car实例还没有所以不会从IOC容器中取,而是走原逻辑,new一个返回
- 创建person1实例的时候,调用配置类里面person1方法的时候,进到MethodIntercept里面,进行拦截,里面用到了car(),调用car()方法是仍会进到这个里面
BeanMethodInterceptor#intercept()
public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs,
MethodProxy cglibMethodProxy) throws Throwable {
ConfigurableBeanFactory beanFactory = getBeanFactory(enhancedConfigInstance);
String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);
// Determine whether this bean is a scoped-proxy
if (BeanAnnotationHelper.isScopedProxy(beanMethod)) {
String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
beanName = scopedBeanName;
}
}
private boolean factoryContainsBean(ConfigurableBeanFactory beanFactory, String beanName) {
return (beanFactory.containsBean(beanName) && !beanFactory.isCurrentlyInCreation(beanName));
}
@Override
public boolean containsBean(String name) {
//得到真实beanName
String beanName = transformedBeanName(name);
//一级缓存中是否存在(第一次调用car() 返回false ).beanDefinitionMap中是否存在(true)
if (containsSingleton(beanName) || containsBeanDefinition(beanName)) {
// !(name不等于null并且以&开头 name= &car)为false
//是否是FactoryBean
return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(name));
}
}
// car():第一个条件返回false
// car():第二个条件返回false
//第二次通过person1()方法进来的car()方法仍不会走这个if
if (factoryContainsBean(beanFactory, BeanFactory.FACTORY_BEAN_PREFIX + beanName) &&
factoryContainsBean(beanFactory, beanName)) {
Object factoryBean = beanFactory.getBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName);
if (factoryBean instanceof ScopedProxyFactoryBean) {
}
else {
return enhanceFactoryBean(factoryBean, beanMethod.getReturnType(), beanFactory, beanName);
}
}
//检查给定方法是否对应于容器当前调用的工厂方法。比较方法名和参数类型只是为了解决协变返回类型的潜在问题（目前只知道发生在Groovy类上）
if (isCurrentlyInvokedFactoryMethod(beanMethod)) {
//car()走到这个方法里面
//person1()方法也会走到这个地方,但是当调用里面的car()方法是就会走一个新逻辑
return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
}
//第二次通过person1()方法进来的car()方法会走这个
return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);
}
//此时 beanName是car
private Object resolveBeanReference(Method beanMethod, Object[] beanMethodArgs,
ConfigurableBeanFactory beanFactory, String beanName) {
// 是否是正在创建,返回false
boolean alreadyInCreation = beanFactory.isCurrentlyInCreation(beanName);
try {
if (alreadyInCreation) {
beanFactory.setCurrentlyInCreation(beanName, false);
}
//走创建过程,因此从IOC容器中拿
Object beanInstance = (useArgs ? beanFactory.getBean(beanName, beanMethodArgs) :
beanFactory.getBean(beanName));
if (!ClassUtils.isAssignableValue(beanMethod.getReturnType(), beanInstance)) {
// Detect package-protected NullBean instance through equals(null) check
if (beanInstance.equals(null)) {
if (logger.isDebugEnabled()) {
logger.debug(String.format("@Bean method %s.%s called as bean reference " +
"for type [%s] returned null bean; resolving to null value.",
beanMethod.getDeclaringClass().getSimpleName(), beanMethod.getName(),
beanMethod.getReturnType().getName()));
}
beanInstance = null;
}
else {
String msg = String.format("@Bean method %s.%s called as bean reference " +
"for type [%s] but overridden by non-compatible bean instance of type [%s].",
beanMethod.getDeclaringClass().getSimpleName(), beanMethod.getName(),
beanMethod.getReturnType().getName(), beanInstance.getClass().getName());
try {
BeanDefinition beanDefinition = beanFactory.getMergedBeanDefinition(beanName);
msg += " Overriding bean of same name declared in: " + beanDefinition.getResourceDescription();
}
catch (NoSuchBeanDefinitionException ex) {
// Ignore - simply no detailed message then.
}
throw new IllegalStateException(msg);
}
}
Method currentlyInvoked = SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod();
if (currentlyInvoked != null) {
String outerBeanName = BeanAnnotationHelper.determineBeanNameFor(currentlyInvoked);
// beanName:car
// outerBeanName:person1
//放到dependentBeanMap:依赖bean名称之间的映射：bean名称到一组依赖bean名称
beanFactory.registerDependentBean(beanName, outerBeanName);
}
return beanInstance;
}
finally {
if (alreadyInCreation) {
beanFactory.setCurrentlyInCreation(beanName, true);
}
}
}
finishBeanFactoryInitialization(beanFactory)
- Bean的后置处理器(BeanPostProcessor):开始生产Bean的时候才会开始调用,主要针对我们的Bean的创建过程做一些扩展
- 实例化我们所有的单例bean
11.inishBeanFactoryInitialization(beanFactory):初始化所有剩下的单实例Bean
1,beanFactory.preInstantiateSingletons();初始化剩下的单实例bean
1)获取容器中的所所有的bean,依次进行初始化和创建对象
2)获取Bean的定义信息;RootBeanDefinition
3)判断:!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()
1)判断是否是FactroyBean,是否实现FactoryBean接口的Bean
2)不是工厂Bean,利用getBean(beanName):创建对象
0,getBean(beanName);
1,doGetBean(name, null, null, false);
2,先获取缓存中保存的单实例Bean.如果能获取到说明这个Bean之前被创建过(所有创建过的单实 例bean都会被缓存起来)
3,缓存中获取不到,开始Bean的创建对象流程;(跟SpringMvc整合之后,有一些父子容器)
4,标记当前bean已经被创建
5,获取Bean的定义信息
6,获取当前Bean依赖的其他Bean;如果有先把依赖的Bean创建出来
7,启动单实例bean的创建过程
1)createBean(eanName, mbd, args)
2)Object bean = resolveBeforeInstantiation(beanName, mbdToUse);让 BeanPostProcessors先拦截返回代理对象，而不是目标bean实例。
InstantiationAwareBeanPostProcessor:提前执行
先触发:postProcessBeforeInstantiation
如果有返回值,触发postProcessAfterInstantiation
3)如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象,
4)Object beanInstance = doCreateBean(beanName, mbdToUse, args);
1)创建bean实例instanceWrapper = createBeanInstance(beanName, mbd, args);
利用工厂方法或者对象的构造器创建出Bean实例
2)applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
调用MergedBeanDefinitionPostProcessor的 bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
3)属性赋值populateBean(beanName, mbd, instanceWrapper);
1)拿到InstantiationAwareBeanPostProcessor后置处理器;
postProcessAfterInstantiation
2)拿到InstantiationAwareBeanPostProcessor后置处理器;
postProcessProperties
3)应用Bean属性的值,为属性利用setter方法等进行赋值 applyPropertyValues(beanName, mbd, bw, pvs);
4)bean的初始化 initializeBean(beanName, exposedObject, mbd);
1)执行Aware接口的方法 invokeAwareMethods(beanName, bean);执行Aware接 口的方法
BeanNameAware,BeanClassLoaderAware,BeanFactoryAware
2)执行后置处理器初始化之前的方法 applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
BeanPostProcessor.postProcessBeforeInitialization(所有Bean的后置处理器的 该方法)
3)执行初始化方法: invokeInitMethods(beanName, wrappedBean, mbd);
1)bean instanceof InitializingBean:执行接口规定的初始化
2)是否自定义初始化方法:String initMethodName = mbd.getInitMethodName();
4)执行后置处理器初始化之后 applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
BeanPostProcessor.postProcessAfterInitialization(所有Bean的后置处理器的 该方法)
5)注册Bean的销毁方法,容器关闭后调用 registerDisposableBeanIfNecessary(beanName, bean, mbd);
5)将创建的Bean缓存
==所有的bean都创建完成之后=
检查所有的Bean是否是SmartInitializingSingleton的
如果是调用smartSingleton.afterSingletonsInstantiated();
https://blog.csdn.net/chuxue1989/article/details/114322633
https://blog.csdn.net/weixin_42446078/article/details/106182212
AnnotationConfigApplicationContext#refresh()#finishBeanFactoryInitialization()
//完成此上下文bean工厂的初始化，初始化所有剩余的单例bean。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//冻结所有的bean定义,说明注册的bean定义将不被修改或者进一步的处理
//如果我们后续要做一些修改bean定义的操作,可以拿出这里面的属性判断一下,为true说明正在生产
beanFactory.freezeConfiguration();
// 实例化剩余的单实例bean
beanFactory.preInstantiateSingletons();
}
//冻结所有的bean定义,bean工厂是不是生产bean看这个属性就可以看出来.将configurationFrozen设为true:要开始生产bean了,不要去修改了
//假如说要做一些修改bean定义的操作,可以拿出这个属性来判断一下,如果为true说明正在生产,那么不能修改bean定义
@Override
public void freezeConfiguration() {
this.configurationFrozen = true;
//frozenBeanDefinitionNames:冻结配置时缓存的bean定义名称数组
this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
}
// 实例化剩余的单实例bean
@Override
public void preInstantiateSingletons() throws BeansException {
//获取我们容器中所有bean定义的名称
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
//循环我们所有的bean定义名称,为什么循环这个???因为所有的bean定义的类型是不一样的,比如通过@ComponentScan扫描的是一个类型,通过@Bean扫描的是一个类型,类型不一样所以说要根据名字进行循环
// 触发所有非惰性单例bean的初始化。。。
for (String beanName : beanNames) {
//因为bean定义的类型不一样所以要合并我们的bean定义,转换为统一的RootBeanDefinition,方便后续判断
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//根据bean定义判断:只有当不是抽象的&&是单例的&&不是懒加载的才能生产
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//是不是工厂bean
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
//非工厂bean就是普通的bean
else {
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
isFactoryBean(String name)
//是否是工厂bean
@Override
public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
String beanName = transformedBeanName(name);
Object beanInstance = getSingleton(beanName, false);
if (beanInstance != null) {
//判断当前的bean定义是否实现了FactoryBean接口
return (beanInstance instanceof FactoryBean);
}
// No singleton instance found -> check bean definition.
if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
// No bean definition found in this factory -> delegate to parent.
return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
}
return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
}
getBean(String name)
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
//getBean的具体实现
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//这里传入进来的name可能是别名,也有可能是工厂bean的name,所以在这里需要得到真实的name
final String beanName = transformedBeanName(name);
Object bean;
// 尝试去缓存中获取对象
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// spring只能解决单例对象的setter注入的循环依赖,不能解决构造器注入
//bean是不是一个多例bean,是否设置了@Scope("Prototype"),如果是一个多例的bean并且正在创建就会抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 若存在父工厂,且当前的bean工厂不存在当前的bean定义,那么bean定义存在于父工厂
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
//方法参数typeCheckOnly 默认为false,是用来判断调用#getBean(...)方法时,是否为仅仅进行类型检查
//如果不是仅仅做类型检查,而是创建Bean对象,则需要调用#markBeanAsCreated(beanName)
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
//从容器中获取beanName相应的GenericBeanDefinition对象,并将其转为RootBeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查当前创建的bean定义是不是抽象的bean定义
checkMergedBeanDefinition(mbd, beanName, args);
// 保证当前bean所依赖的bean的初始化:优先解析另外一个bean bean1依赖bean2如果想让bean2在bean1前面加载的时候可以使用dependsOn
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
//beanName是当前正在创建的bean,dep是正在创建的bean依赖的bean的名称
// //若给定的依赖bean已经注册为依赖给定的bean即循环依赖的情况,抛出BeanCreateException异常
if (isDependent(beanName, dep)) {
throw new BeanCreationException();
}
//保存的是beanName之间的映射关系:依赖BeanName--->BeanName的集合
registerDependentBean(dep, beanName);
try {
//优先加载依赖的bean
getBean(dep);
}
}
}
// 创建单例bean
if (mbd.isSingleton()) {
//getSingleton主要是用来把当前bean标记为正在创建,然后通过lambda函数 //调用创建bean的逻辑
//把beanNmae和一个singletonFactor传入一个回调对象用于回调
sharedInstance = getSingleton(beanName, () -> {
try {
//进入创建bean的逻辑
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
//创建bean的过程中发生异常,需要销毁关于当前bean的所有信息
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
//进入创建bean的逻辑
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
//返回指定的原型bean当前是否正在创建中（在当前线程内）
protected boolean isPrototypeCurrentlyInCreation(String beanName) {
Object curVal = this.prototypesCurrentlyInCreation.get();
return (curVal != null &&
(curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
}
//标记为正在创建
protected void markBeanAsCreated(String beanName) {
//如果这个之前没有被标记为正在创建
if (!this.alreadyCreated.contains(beanName)) {
//全局加锁
synchronized (this.mergedBeanDefinitions) {
//再次检查一次DCL双检查模式
if (!this.alreadyCreated.contains(beanName)) {
//从mergedBeanDefinition中删除beanName,并在下次访问时重新创建它
clearMergedBeanDefinition(beanName);
//添加到已创建的bean集合中
this.alreadyCreated.add(beanName);
}
}
}
}
protected void clearMergedBeanDefinition(String beanName) {
//从mergedBeanDefinitions集合中取得该bean定义
RootBeanDefinition bd = this.mergedBeanDefinitions.get(beanName);
if (bd != null) {
//确定是否需要重新合并定义,设为true
bd.stale = true;
}
}
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
//返回合并的RootBeanDefinition，如果指定的bean对应于子bean定义，则遍历父bean定义
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
//在clearMergedBeanDefinition(String beanName)方法中已经将stale设为true
if (mbd != null && !mbd.stale) {
return mbd;
}
//默认情况下,都会走这个方法
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
getSingleton()
//这也是解决循环依赖的一个关键点
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
//加锁
synchronized (this.singletonObjects) {
//尝试从单例缓存中池中获取对象
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
//标记当前的bean马上就要被创建了
//singletonsCurrentlyInCreation在这里会把beanName加入进来,若第二次循环依赖(构造 器注入会抛出异常)
beforeSingletonCreation(beanName);
boolean newSingleton = false;
//suppressedExceptions:抑制异常列表，可用于关联相关原因
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//这个过程其实是调用lambda表达式中的createBean()方法
singletonObject = singletonFactory.getObject();
//bean被完整的创建成功,将newSingleton设为true后续利用这个标记把它加入到三级缓存中
newSingleton = true;
}
finally {
//如果没有异常,则将集合设为null
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//创建过程中出现异常则singletonsCurrentlyInCreation移除这个bean定义
afterSingletonCreation(beanName);
}
if (newSingleton) {
//加入缓存
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
//beforeSingletonCreation方法把当前bean标记为正在创建
protected void beforeSingletonCreation(String beanName) {
//如果singletonsCurrentlyInCreation没有添加成功(加到singletonsCurrentlyInCreation里面就意味着当前这个bean正在创建)
//inCreationCheckExclusions:当前从创建中检查中排除的bean的名称
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
//没添加成功抛出异常
throw new BeanCurrentlyInCreationException(beanName);
}
}
#createBean()
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
//确保此时的bean已经被解析
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
/**
* 验证和准备覆盖方法(仅在XML方式中)
* lookup-method和repalce-method
* 这两个配置存放在BeanDefinition中的methodOverrides(仅在XML方式中)
* 在Xml方式总bean实例化的过程中如果检测到存在MethodOverrides,则会动态的为
* 当前bean生成一个代理并使用对象的拦截器为bean做增加处理
* 具体的分析实现我们后续分析
*/
try {
mbdToUse.prepareMethodOverrides();
}
try {
// 让BeanPostProcessors有机会返回代理，而不是目标bean实例。
//第1个bean后置处理器来进行后置处理生成对象,一般情况下在此处不会生成代理对象
//为什么不能生成代理对象,不管是我们的jdk代理或者cglib代理都不会在此处进行处理,因为我们的真实的对象没有生成,所以在这里不会生成代理对象,那么在这一步是我们AOP和事务的关键,因为这会解析我们的aop切面信息进行缓存
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
//如果接收到了Bean.说明自己自己创建了bean直接return(利用这个后置处理器可以阻止bean的创建)
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
//该步骤是我们真正创建我们的bean的实例对象的过程
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
#resolveBeforeInstantiation()方法
/**
*在实例化后处理器之前应用，解析指定bean是否有实例化前快捷方式。该方法也是第一次调用bean后置处理器
*/
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// 判断容器中是否有InstantiationAwareBeanPostProcessors
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { //获取当前bean的class对象
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
//后置处理器的第一次调用,总共有九处需要调用,事务在这里不会被调用,aop的才会被调用,为啥aop在这里调用,因为在此处需要解析出对应的切面报错到缓存中.
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
//调用所有BeanPostProcessor中的postProcessAfterInitialization
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
#applyBeanPostProcessorsBeforeInstantiation():真正调用第一个后置处理器的方法
@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
//获取容器中所有的后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//判断后置处理器是不是InstantiationAwareBeanPostProcessor类型
if (bp instanceof InstantiationAwareBeanPostProcessor) {
//将我们的BeanPostProcessor强制转为InstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
/**
* 我们AOP @EnableAspectJAutoProxy为我们容器中导入了AnnotationAwareAspectJAutoProxyCreator
* 我们事务注解 @EnableAspectJAutoProxy为我们容器中导入了InfrastructureAdvisorAutoProxyCreator
* 都是实现了我们的BeanPostProcessor接 * 口,InstantiationAwareBeanPostProcessor 进行后置处理解析切面
*
*/
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
#doCreateBean():真正创建我们的bean的实例对象的过程;做了实例化,填充属性,初始化三个操作
/**
* 实际创建指定的bean。此时已经进行了创建前处理，例如检查{@code postprocessabefore * instantiation}回调。区分默认bean实例化、使用工厂方法和自动连接构造函数。
* 在这个方法里边调用了实例化,填充属性,初始化
*/
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// BeanWrapper是对Bean的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，获取被包装bean的属性描述器，由于BeanWrapper接口是PropertyAccessor的子接口，因此其也可以设置以及访问被包装对象的属性值。BeanWrapper大部分情况下是在spring ioc内部进行使用，通过BeanWrapper,spring ioc容器可以用统一的方式来访问bean的属性。用户很少需要直接使用BeanWrapper进行编程。
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
//从没有完成的FactoryBean中国移除
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//创建bean实例化,使用合适的实例化策略来创建新的实例:工厂方法,钩子方法
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//从beanWrapper中获取我们的早期对象:用了装饰器的模式将bean的很多信息都封装到了instanceWrapper里面
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
//
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//进行后置处理@Autowired,@value的注解的预解析
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
//缓存单例到三级缓存中,以防循环依赖
//判断是否早期引用的Bean.如果是,则允许提前暴漏引用
//判断是否能够早期暴漏对象的条件:单例;循环依赖,正在创建的Bean
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
//上述条件满足,允许中期暴漏对象
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//把我们的早期对象包装成一个SingletonFactory对象,该对象提供了一个
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//属性赋值,给我们的属性进行赋值(也会调用后置处理器)
populateBean(beanName, mbd, instanceWrapper);
//进行对象初始化操作(在这里可能生成代理对象)
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
//早期对象暴漏
if (earlySingletonExposure) {
//allowEarlyReference:是否应创建早期引用
//去缓存中获取到我们的对象,由于传递的allowEarlyReference时false
//正常普通的bean(不存在循环依赖的bean),创建的过程中
Object earlySingletonReference = getSingleton(beanName, false);
//能够获取到
if (earlySingletonReference != null) {
//经过后置处理的bean和早期的bean引用还相等的话(表示当前的bean)
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
//处理依赖的bean
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
}
}
}
// Register bean as disposable.
try {
//注册销毁的bean的销毁接口
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
#populateBean
//给我们的对象BeanWrapper赋值
//属性填充主要对自动注入的处理,我们大致可以把它分为三类
// 1.autowireByName:通过名字对属性填充
// 2.autowireByType:通过类型对属性填充
// 3.@Autowired:通过bean的后置处理器AutowiredAnnotationBeanPostProcessor对@Autowired注解属性填充
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
//若bw为null,则说明对象没有实例化
if (bw == null) {
//进入if说明对象有属性,bw为空不能为他设置属性,那就在下面就执行
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
//是否持有InstantiationAwareBeanPostProcessor
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//获取容器中的所有的BeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//判断我们的后置处理器是不是InstantiationAwareBeanPostProcessor
if (bp instanceof InstantiationAwareBeanPostProcessor) {
//进行强制转换
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//若存在后置处理器给我们的属性赋值了,那么返回false
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
//获得mbd的自动装配模式
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
//如果自动装配模式为 按名称自动装配bean属性或者按类型自动装配bean属性
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 根据属性名进行注入
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
//通过bw的PropertyDescriptpr属性名,查找出对应的Bean对象,待其添加到newPvs中
autowireByName(beanName, mbd, bw, newPvs);
}
// 根据属性类型进行注入
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
//通过bw的PropertyDescriptpr属类型,查找出对应的Bean对象,待其添加到newPvs中
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
//通过遍历找到AutowiredAnnotationBeanPostProcessor执行postProcessProperties()方法来实现对@Autowired注解进行注入
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
// 上面只会把属性所对应的object保存到pvs中,并没有给属性赋值
//这里会调用类的set方法给属性赋值
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
#AutowiredAnnotationBeanPostProcessor执行postProcessProperties()
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
//从缓存中取出这个bean对应的依赖注入的元信息
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
//进行属性注入
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
InjectionMetadata#inject()：遍历需要注入的所有属性elementsToIterate，一个一个属性注入
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Collection<InjectedElement> checkedElements = this.checkedElements;
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
for (InjectedElement element : elementsToIterate) {
if (logger.isTraceEnabled()) {
logger.trace("Processing injected element of bean '" + beanName + "': " + element);
}
element.inject(target, beanName, pvs);
}
}
}
AutowiredAnnotationBeanPostProcessor#inject()：调用beanFactory.resolveDependency()方法找出所要注入的候选bean然后通过反射给属性赋值
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Field field = (Field) this.member;
Object value;
//如果有,从缓存中获取
if (this.cached) {
// 如果 cachedFieldValue instanceof DependencyDescriptor。则调用 resolveDependency 方法重新加载。
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
else {
// 否则调用了 resolveDependency 方法。这个在前篇讲过，在 populateBean 方法中按照类型注入的时候就是通过此方法，
// 也就是说明了 @Autowired 和 @Inject默认是 按照类型注入的
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
Assert.state(beanFactory != null, "No BeanFactory available");
//转换器使用的bean工厂的转化器
TypeConverter typeConverter = beanFactory.getTypeConverter();
try {
// 获取依赖的value值的工作 最终还是委托给beanFactory.resolveDependency()去完成的
// 这个接口方法由AutowireCapableBeanFactory提供，它提供了从bean工厂里获取依赖值的能力
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
synchronized (this) {
//如果没有则开始缓存
if (!this.cached) {
// 可以看到value！=null并且required=true才会进行缓存的处理
if (value != null || this.required) {
// 这里先缓存一下 desc，如果下面 autowiredBeanNames.size() > 1。则在上面从缓存中获取的时候会重新获取。
this.cachedFieldValue = desc;
//注册依赖bean
registerDependentBeans(beanName, autowiredBeanNames);
// autowiredBeanNames里可能会有别名的名称,所以size可能大于1
if (autowiredBeanNames.size() == 1) {
// beanFactory.isTypeMatch挺重要的,因为@Autowired是按照类型注入的
String autowiredBeanName = autowiredBeanNames.iterator().next();
if (beanFactory.containsBean(autowiredBeanName) &&
beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
this.cachedFieldValue = new ShortcutDependencyDescriptor(
desc, autowiredBeanName, field.getType());
}
}
}
else {
this.cachedFieldValue = null;
}
this.cached = true;
}
}
}
if (value != null) {
//通过反射,给属性赋值
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
}
DefaultListableBeanFactory#resolveDependency()：根据注入属性的类型descriptor.getDependencyType()，去找合适的对象。
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
//获取工厂的参数名发现器，设置到descriptor中。使得descriptor初始化基础方法参数的参数名发现。此时，该方法实际上
// 并没有尝试检索参数名称；它仅允许发现再应用程序调用getDependencyName时发生
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
//如果descriptor的依赖类型为Optional类
if (Optional.class == descriptor.getDependencyType()) {
//创建Optional类型的符合descriptor要求的候选Bean对象
return createOptionalDependency(descriptor, requestingBeanName);
}
// 是对象工厂类型或者对象提供者
else if (ObjectFactory.class == descriptor.getDependencyType() ||
ObjectProvider.class == descriptor.getDependencyType()) {
//DependencyObjectProvider:依赖对象提供者,用于延迟解析依赖项
//新建一个DependencyObjectProvider的实例
return new DependencyObjectProvider(descriptor, requestingBeanName);
}
// javaxInjectProviderClass有可能导致空指针，不过一般情况下，我们引用Spirng包的时候都有引入该类以防止空旨在
//如果依赖类型是javax.inject.Provider类。
else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
//Jse330Provider:javax.inject.Provider实现类.与DependencyObjectProvoid作用一样，也是用于延迟解析依赖
// 项，但它是使用javax.inject.Provider作为依赖 对象，以减少与Springd耦合
//新建一个专门用于构建javax.inject.Provider对象的工厂来构建创建Jse330Provider对象
return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
}
else {
//尝试获取延迟加载代理对象
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
//如果result为null，即表示现在需要得到候选Bean对象
if (result == null) {
//解析出与descriptor所包装的对象匹配的候选Bean对象
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
//将与descriptor所包装的对象匹配的候选Bean对象【result】返回出去
return result;
}
}
#doResolveDependency
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
//设置新得当前切入点对象，得到旧的当前切入点对象
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
/**
* 1，考虑一些预先解决的信息尝试调用该工厂解决这种依赖关系的快捷方式来获取beanName对应的bean对象,默认返回null
*/
Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
return shortcut;
}
//获取descriptor的依赖类型
Class<?> type = descriptor.getDependencyType();
/**
* 2，尝试使用descriptor的默认值作为最近候选Bean对象
*/
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
//如果默认值不为null
if (value != null) {
//如果value是String类型
if (value instanceof String) {
//解析嵌套的值(如果value是表达式会解析出该表达式的值)
String strVal = resolveEmbeddedValue((String) value);
//获取beanName的合并后RootBeanDefinition
BeanDefinition bd = (beanName != null && containsBean(beanName) ?
getMergedBeanDefinition(beanName) : null);
//评估bd中包含的value,如果strVal是可解析表达式，会对其进行解析.
value = evaluateBeanDefinitionString(strVal, bd);
}
//如果没有传入typeConverter,则引用工厂的类型转换器
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
try {
//将value转换为type的实例对象
return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
}
//捕捉 不支持操作异常
catch (UnsupportedOperationException ex) {
// A custom TypeConverter which does not support TypeDescriptor resolution...
return (descriptor.getField() != null ?
converter.convertIfNecessary(value, type, descriptor.getField()) :
converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
}
}
/**
* 3，针对desciptor所包装的对象类型是[stream,数组,Collection类型且对象类型是接口,Map]
* 的情况，进行解析与依赖类型匹配的 候选Bean对象，并将其封装成相应的依赖类型对象
*/
Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
//如果multpleBeans不为null
if (multipleBeans != null) {
//将multipleBeans返回出去
return multipleBeans;
}
/**
* 4，查找与type匹配的候选bean对象,构建成Map，key=bean名,val=Bean对象
*/
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
//如果没有候选bean对象
if (matchingBeans.isEmpty()) {
//如果descriptor需要注入
if (isRequired(descriptor)) {
//抛出NoSuchBeanDefinitionException或BeanNotOfRequiredTypeException以解决不可 解决的依赖关系
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
//返回null，表示么有找到候选Bean对象
return null;
}
//定义用于存储唯一的候选Bean名变量
String autowiredBeanName;
//定义用于存储唯一的候选Bean对象变量
Object instanceCandidate;
//如果候选Bean对象Map不止有一个
if (matchingBeans.size() > 1) {
//确定candidates中可以自动注入的最佳候选Bean名称
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
//如果autowiredBeanName为null
if (autowiredBeanName == null) {
//descriptor需要注入 或者 type不是数组/集合类型
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
//让descriptor尝试选择其中一个实例，默认实现是抛出NoUniqueBeanDefinitionException.
return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
}
else {
// In case of an optional Collection/Map, silently ignore a non-unique case:
// possibly it was meant to be an empty collection of multiple regular beans
// (before 4.3 in particular when we didn't even look for collection beans).
// 如果是可选的Collection/Map,则静默忽略一个非唯一情况：
// 可能是多个常规bean的空集合
// (尤其是在4.3之前，设置在我们没有寻找collection bean的时候 )
return null;
}
}
//获取autowiredBeanName对应的候选Bean对象
instanceCandidate = matchingBeans.get(autowiredBeanName);
}
else {
// We have exactly one match.
//这个时候matchingBeans不会没有元素的，因为前面已经检查了
//获取machingBeans唯一的元素
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
//让autowireBeanName引用该元素的候选bean名
autowiredBeanName = entry.getKey();
//让instanceCandidate引用该元素的候选bean对象
instanceCandidate = entry.getValue();
}
//如果候选bean名不为null，
if (autowiredBeanNames != null) {
//将autowiredBeanName添加到autowiredBeanNames中，又添加一次
autowiredBeanNames.add(autowiredBeanName);
}
//如果instanceCandidate是Class实例
if (instanceCandidate instanceof Class) {
//让instanceCandidate引用 descriptor对autowiredBeanName解析为该工厂的Bean实例
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
//定义一个result变量，用于存储最佳候选Bean对象
Object result = instanceCandidate;
//如果reuslt是NullBean的实例
if (result instanceof NullBean) {
//如果descriptor需要注入
if (isRequired(descriptor)) {
//抛出NoSuchBeanDefinitionException或BeanNotOfRequiredTypeException以解决不可 解决的依赖关系
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
//返回null，表示找不到最佳候选Bean对象
result = null;
}
//如果result不是type的实例
if (!ClassUtils.isAssignableValue(type, result)) {
//抛出Bean不是必需类型异常
throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
}
//返回最佳候选Bean对象【result】
return result;
}
finally {
//设置上一个切入点对象
ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
}
}
#resolveCandidate:
public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
throws BeansException {
return beanFactory.getBean(beanName);
}
上面我们分析过，通过autowireByName，autowireByType注入时都会把找到的属性和对象放入到pvs的propertyValueList，所以此处applyPropertyValues()方法是对里面的属性进行赋值操作的
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
// 为空，直接返回
if (pvs.isEmpty()) {
return;
}
// 如果有安全管理器，且bw是BeanWrapperImpl的实例
if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
// 设置bw的安全上下文为工厂的访问控制上下文
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
//MutablePropertyValues：PropertyValues接口的默认实现。允许对属性进行简单操作，并提供构造函数来支持从映射 进行深度复制和构造
MutablePropertyValues mpvs = null;
// 原始属性列表
List<PropertyValue> original;
// 如果pvs是MutablePropertyValues
if (pvs instanceof MutablePropertyValues) {
// 类型强制转换
mpvs = (MutablePropertyValues) pvs;
//isConverted:返回该holder是否只包含转换后的值(true),或者是否仍然需要转换这些值
//如果mpvs只包含转换后的值
if (mpvs.isConverted()) {
// Shortcut: use the pre-converted values as-is.
try {
// 已完成，直接返回
bw.setPropertyValues(mpvs);
return;
}
catch (BeansException ex) {
//捕捉Bean异常，重新抛出Bean创佳异常：错误设置属性值。
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
// 获取mpvs的PropertyValue列表
original = mpvs.getPropertyValueList();
}
else {
//获取pvs的PropertyValue对象数组，并将其转换成列表
original = Arrays.asList(pvs.getPropertyValues());
}
// 获取用户自定义类型转换器
TypeConverter converter = getCustomTypeConverter();
// 如果转换器为空，则直接把包装类赋值给converter
if (converter == null) {
converter = bw;
}
//BeanDefinitionValueResolver:在bean工厂实现中使用Helper类，它将beanDefinition对象中包含的值解析为应用于 目标bean实例的实际值
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
// Create a deep copy, resolving any references for values.
// 创建一个深拷贝，解析任何值引用
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
//是否还需要解析标记
boolean resolveNecessary = false;
// 遍历属性，将属性转换为对应类的对应属性的类型
for (PropertyValue pv : original) {
// 如果该属性已经解析过
if (pv.isConverted()) {
//将pv添加到deepCopy中
deepCopy.add(pv);
}
// 如果属性没有被解析过
else {
// 获取属性的名字
String propertyName = pv.getName();
// 获取未经类型转换的值
Object originalValue = pv.getValue();
//AutowiredPropertyMarker.INSTANCE：自动生成标记的规范实例
if (originalValue == AutowiredPropertyMarker.INSTANCE) {
//获取propertyName在bw中的setter方法
Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
//如果setter方法为null
if (writeMethod == null) {
//抛出非法参数异常：自动装配标记属性没有写方法。
throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
}
//将writerMethod封装到DependencyDescriptor对象
originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
}
//交由valueResolver根据pv解析出originalValue所封装的对象
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
//默认转换后的值是刚解析出来的值
Object convertedValue = resolvedValue;
//可转换标记: propertyName是否bw中的可写属性 && prepertyName不是表示索引属性或嵌套属性（如果propertyName中有'.'||'['就认为是索引属性或嵌套属性）
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
//如果可转换
if (convertible) {
//将resolvedValue转换为指定的目标属性对象
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
// Possibly store converted value in merged bean definition,
// in order to avoid re-conversion for every created bean instance.
// 可以将转换后的值存储合并后BeanDefinition中，以避免对每个创建的Bean实例进行重新转换
//如果resolvedValue与originalValue是同一个对象
if (resolvedValue == originalValue) {
//如果可转换
if (convertible) {
//将convertedValue设置到pv中
pv.setConvertedValue(convertedValue);
}
//将pv添加到deepCopy中
deepCopy.add(pv);
}
//TypedStringValue:类型字符串的Holder,这个holder将只存储字符串值和目标类型。实际得转换将由Bean工厂执行
//如果可转换 && originalValue是TypedStringValue的实例 && orginalValue不是标记为动态【即不是一个表达式】&&
// convertedValue不是Collection对象 或 数组
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
//将convertedValue设置到pv中
pv.setConvertedValue(convertedValue);
//将pv添加到deepCopy中
deepCopy.add(pv);
}
else {
//标记还需要解析
resolveNecessary = true;
//根据pv,convertedValue构建PropertyValue对象，并添加到deepCopy中
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
//mpvs不为null && 已经不需要解析
if (mpvs != null && !resolveNecessary) {
//将此holder标记为只包含转换后的值
mpvs.setConverted();
}
// Set our (possibly massaged) deep copy.
try {
//按原样使用deepCopy构造一个新的MutablePropertyValues对象然后设置到bw中以对bw的属性值更新
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
#initializeBean()
/**
* 初始化给定的bean实例，应用工厂回调、init方法和bean后处理器<p> 对于传统定义的bean， * 从{@link#createBean}调用；对于现有bean实例，从{@link#initializeBean}调用。
*/
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
//如果我们的bean实现了XXXAware接口进行方法的回调
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean =
// 调用我们的bean的后置处理器postProcessorsBeforeIninialzation方法.如果我们的bean实现了除了invokeAwareMethods(beanName, bean);方法中的三个aware接口外,其余的aware会在这个方法里面调用,同样也会调用@PostConstruct标注的方法
applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//调用初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//调用我们bean的后置处理器的PostProcessorsAfterInitialization方法,在这里会创建AOP的动态代理
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
#invokeAwareMethods():初始化bean之前调用实现了xxxAware接口的方法
//只会执行三个aware,更多的aware会在bean的后置处理器调用(ApplicationContextAwareProcessor)
private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
//我们的bean实现了BeanNameAware
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
//我们的bean实现了BeanClassLoaderAware
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
//我们的bean实现了BeanFactoryAware
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
/** 现在让一个bean有机会做出反应，它的所有属性都设置好了，并且有机会知道它所拥有的bean工厂（这个对象）。
* 这意味着检查bean是否实现了InitializingBean或定义了自定义init方法，如果实现了，则调用必要的回调。
*/
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
//判断我们的容器中是否实现了InitializingBean接口,如果实现了这个接口
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((InitializingBean) bean).afterPropertiesSet();
return null;
}, getAccessControlContext());
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
//回调InitializingBean的afterPropertiesSer()方法
((InitializingBean) bean).afterPropertiesSet();
}
}
//调用initMethod(使用@Bean注解的时候可以指定initMethod)
if (mbd != null && bean.getClass() != NullBean.class) {
//我们的beanclass中是否有自己定义的init方法
String initMethodName = mbd.getInitMethodName();
//判断自定义的init方法名称不叫afterPropertiesSet
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
//调用自己的初始化方法
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
Person bean = (Person) context.getBean("person");
@Override
public Object getBean(String name) throws BeansException {
//Spring上下文不生产bean,只是去通过BeanFactory去生产bean,而BeanFactory在new Spring上下文的时候已经被注册过了
assertBeanFactoryActive();
//调用getBean(name)如果三级缓存中有则从三级缓存中拿到bean,如果没有则创建bean,所以说#getBean(name)方法既可以获取bean,也可以生产bean
return getBeanFactory().getBean(name);
}
#addSingleton()
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
//加入到单例缓存池中
this.singletonObjects.put(beanName, singletonObject);
//从三级缓存中移除(针对的不是处理循环依赖的)
this.singletonFactories.remove(beanName);
//从二级缓存中移除(循环依赖的时候,早期对象存在于二级缓存)
this.earlySingletonObjects.remove(beanName);
//用来记录保存已经处理的bean
this.registeredSingletons.add(beanName);
}
}
有关面试题
FactoryBean和BeanFactory的区别
- BeanFactory:Spring顶层的核心接口,使用了简单工厂模式,负责生产Bean
- FactoryBean:如果一个实体类没有实现FactoryBean接口,将实体类注入到IOC容器当中
如果实现了这个接口,IOC容器会调用重写getObject()方法中,该方法的返回值就是调用getBean方法的返回值;
如果想得到原本的返回值;
- 作用:集成mybatis的时候,dao是一个接口, 希望把接口对应的动态代理给注册到IOC容器当中,通过这 种方式,可以返回动态代理
请介绍BeanFactoryPostProcessor在Spring中的用途
-
解析配置类
-
BeanFactoryPostProcessor调用过程源码深度剖析(对BeanDefinition做一些修改或者注册)
-
配置类的解析过程源码深度剖析(配置类的解析是靠BeanFactoryPostProcessor这个扩展点来完成的)
Spring Bean的生命周期
- 实例化Bean对象，这个时候Bean的对象是非常低级的，基本不能够被我们使用，因为连最基本的属性都没
有设置，可以理解为连Autowired注解都是没有解析的; - 填充属性，当做完这一步, Bean对象基本是完整的了，可以理解为Autowired注解已经解析完毕,依赖注入
完成了; - 如果Bean实现了BeanNameAware接口，则调用setBeanName方法;
- 如果Bean实现了BeanClassLoaderAware接口，则调用setBeanClassLoader方法;
- 如果Bean实现了BeanFactoryAware接口，则调用setBeanFactory方法;
- 调用BeanPostProcessor的postProcessBeforelnitialization方法;
- 如果Bean实现了IitializingBean接口，调用afterPropertiesSet方法;
- 如果Bean定义了init-method方法,则调用Bean的nit-method方法;
- 调用BeanPostProcessor的postProcessfterlnitialization方法;当进行到这一步, Bean已经被准备就绪了,
一直停留在应用的上下文中，直到被销毁; - 如果应用的上下文被销毁了，如果Bean实现了DisposableBean接口，则调用destroy方法, 如果Bean定义了destory-method声明了销毁方法也会被调用。
3042
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
