spring源码笔记
public static void main(String[] args) {
//类注入
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Appconfig.class);
//xml文件注入
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("spring.xml");
IndexServiceImpl indexService = (UserServicUImpl) context.getBean("userService");
}生命周期
UserService.class-->无参构造方法-->对象-->依赖注入-->初始化前->初始化->初始化后->代理对象
创建对象
调用构造方法创建对象，创建一个普通对象
依赖注入
给属性赋值，也是按刚才的逻辑先按照type寻找，在按照参数名寻找
初始化前
调用添加了@PostConstruct方法，也可以实现InitializingBean接口会自动调用afterPropertiesSet方法
初始化
执行构造构造方法推断构造
推断构造
初始化后首先找构造方法（推断构造），如果有多个构造方法，默认用无参的构造方法
如果构造方法是有参的那么spring中会去容器中找一个对应类型的然后传入进来，如果容器中找不到的话会报错。
但是有个问题是spring容器中可能存在多个相同类型的对象（用@Bean注入或者@Component注入）
这种情况下如果是@Component注入的话，会用类名改成小驼峰当做key，如果@Bean注入的话会用方法名改成小驼峰当做key。（不允许重复）
所以说如果类型相同的话，spring会从相同类中找一个跟形参对应的对象。
细节：比如有一个对象你重写了一个有参的构造方法，这是无参的构造方法会被覆盖，所以需要spring正常注入的时候，需要注意可能还需要声明一次无参的构造方法。同时也可以再构造方法之上声明@Autowired，spring就会使用这个构造方法。
初始化后
执行实现了InitializingBean接口类的afterPropertiesSet方法
代理对象
初始化后会进行AOP操作返回代理对象，但是返回的代理对象中的属性不会被进行依赖注入，只有被调用时才会进行依赖注入
默认情况下不实现接口用的是cglib的动态代理，CGLib会生成代理类的父类，去执行代理类的方法时会先执行切面的逻辑，再执行调用被代理类的方法。
实际情况下是在当前类中增加一个被代理类的属性target，然后给代理对象赋值，这个赋值就是之前创建的普通对象（内部属性是有值的），然后调用内部的被代理类的方法。
切面最重要的是方法，单独给代理对象的属性赋值显得没有必要。
spring还会判断是否需要对这个对象进行aop，如果需要aop才生成代理对象
判断方式：切面也是bean，判断UserService是否需要aop，首先把所有的切面bean找出来，遍历切面bean的方法定义的表达式，和创建的类是否匹配，匹配到了就创建代理对象，把代理对象的所有被切的方法遍历出来然后缓存起来，执行的时候直接调用缓存中的方法简单理解为key是class，value是list存了方法
核心概念
Beandefinition
Beandefinition是一个接口
Beandefinition表示Bean定义，BeanDefinition中存在很多属性用来描述Bean的特点
- class，表示Bean类型
- scope表示Bean作用域，单例或原型等
- lazyinit：bean是否为懒加载
- initMethodName：bean初始化加载的方法
- 等
String我们通常通过以下方式定义bean
<bean/>- @Bean
- @component
这样我们称之为生命式定义Bean，他们都会生成Beandefintion
我们还可以编程式定义bean
现在的Benadefintion基本都是AbstractBeanDefinition的子类
beanFactory
beanFactory是一个接口
application就继承了beanFactory
首先，在Java中，接口是可以多继承的，我们发现ApplicationContext继承了ListableBeanFactoryHierarchicalBeanFactory，而ListableBeanFactory和HierarchicalBeanFactory都继承至BeanFactory，所以我们可以认为ApplicationContext继承了BeanFactory，相当于苹果继承水果，宝马继承汽车一样，ApplicationContext也是BeanFactory的一种，拥有BeanFactory支持的所有功能，不过ApplicationContext比BeanFactory更加强大，ApplicationContext还基础了其他接口，也就表示ApplicationContext还拥有其他功能，比如MessageSource表示国际化，ApplicationEventPublisher表示事件发布，EnvironmentCapable表示获取环境变量，等等，关于ApplicationContext后面再详细讨论。在Spring的源码实现中，当我们new一个ApplicationContext时，其底层会new一个BeanFactory出来，当使用ApplicationContext的某些方法时，比如getBean()，底层调用的是BeanFactory的getBean()方法。在Spring源码中，BeanFactory接口存在一个非常重要的实现类是：
DefaultListableBeanFactory，也是非常核心的。具体重要性，随着后续课程会感受更深。
所以，我们可以直接来使用DefaultListableBeanFactory，而不用使用ApplicationContext的某个
实现类，比如：
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
AbstractBeanDefinition beanDefinition =
BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(User.class);
beanFactory.registerBeanDefinition("user", beanDefinition);
System.out.println(beanFactory.getBean("user"));其实AnnotatioonConfigApplicationContext的getBean内部也会去调用DefaultListableBeanFactory然后到父类中去new这样一个类
beanFactory是spring框架的基础设置，它是用于管理bean工厂容器。BeanFactory加载配置文件时不会初始化bean，而是在获取时才回去初始化
上面有分析到，ApplicationContext是个接口，实际上也是一个BeanFactory，不过比BeanFactory
更加强大，比如：
- HierarchicalBeanFactory：拥有获取父BeanFactory的功能
- ListableBeanFactory：拥有获取beanNames的功能
- ResourcePatternResolver：资源加载器，可以一次性获取多个资源（文件资源等等）
- EnvironmentCapable：可以获取运行时环境（没有设置运行时环境功能）
- ApplicationEventPublisher：拥有广播事件的功能（没有添加事件监听器的功能）
- MessageSource：拥有国际化功能
具体的功能演示，后面会有。
我们先来看ApplicationContext两个比较重要的实现类：
- AnnotationConfigApplicationContext
- ClassPathXmlApplicationContext
获取运行时环境
AnnotationConfigApplicationContext context = new
AnnotationConfigApplicationContext(AppConfig.class);
Map<String, Object> systemEnvironment = context.getEnvironment().getSystemEnvironment();
System.out.println(systemEnvironment);
System.out.println("=======");
Map<String, Object> systemProperties = context.getEnvironment().getSystemProperties();
System.out.println(systemProperties);
System.out.println("=======");
MutablePropertySources propertySources = context.getEnvironment().getPropertySources();
System.out.println(propertySources);
System.out.println("=======");
System.out.println(context.getEnvironment().getProperty("NO_PROXY"));
System.out.println(context.getEnvironment().getProperty("sun.jnu.encoding"));
System.out.println(context.getEnvironment().getProperty("zhouyu"));注意，可以利用
@PropertySource("classpath:spring.properties")
类型转换
spring源码中，有可能需要把String转换成其他类型，所以在Spring源码中提供了一些技术来更方便的做对象类型转换。
PropertyEditor
其实这就是JDK中提供的转换工具类
public class StringToUserPropertyEditor extends PropertyEditorSupport implements
PropertyEditor {
@Override
public void setAsText(String text) throws IllegalArgumentException {
User user = new User();
user.setName(text);
this.setValue(user);
}
}使用
tringToUserPropertyEditor propertyEditor = new StringToUserPropertyEditor();
propertyEditor.setAsText("1");
User value = (User) propertyEditor.getValue();
System.out.println(value);如何向Spring中注册PropertyEditor：
@Bean
public CustomEditorConfigurer customEditorConfigurer() {
CustomEditorConfigurer customEditorConfigurer = new CustomEditorConfigurer();
Map<Class<?>, Class<? extends PropertyEditor>> propertyEditorMap = new HashMap<>();
// 表示StringToUserPropertyEditor可以将String转化成User类型，在Spring源码中，如果发现当前
对象是String，而需要的类型是User，就会使用该PropertyEditor来做类型转化
propertyEditorMap.put(User.class, StringToUserPropertyEditor.class);
customEditorConfigurer.setCustomEditors(propertyEditorMap);
return customEditorConfigurer;
}假设现在有如下Bean:
@Component
public class UserService {
@Value("xxx")
private User user;
public void test() {
System.out.println(user);
}
}ConversionService
spring中提供的类型转换服务，它比PropertyEditor更强大
public class StringToUserConverter implements ConditionalGenericConverter {
@Override
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.getType().equals(String.class) &&
targetType.getType().equals(User.class);
}
@Override
public Set<ConvertiblePair> getConvertibleTypes() {
return Collections.singleton(new ConvertiblePair(String.class, User.class));
}
@Override
public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor
targetType) {
User user = new User();
user.setName((String)source);
return user;
}
}DefaultConversionService conversionService = new DefaultConversionService();
conversionService.addConverter(new StringToUserConverter());
User value = conversionService.convert("1", User.class);
System.out.println(value);向spirng中注册
@Bean
public ConversionServiceFactoryBean conversionService() {
ConversionServiceFactoryBean conversionServiceFactoryBean = new
ConversionServiceFactoryBean();
conversionServiceFactoryBean.setConverters(Collections.singleton(new
StringToUserConverter()));
return conversionServiceFactoryBean;
}TypeConverter
整合了PropertyEditor和ConversionService的功能，是spring内部用的
SimpleTypeConverter typeConverter = new SimpleTypeConverter();
typeConverter.registerCustomEditor(User.class, new StringToUserPropertyEditor());
//typeConverter.setConversionService(conversionService);
User value = typeConverter.convertIfNecessary("1", User.class);
System.out.println(value);AbstractBeanFactoryFactory抽象类中调用getBean方法
context.getBean("userServicce",UserService.class);首先会根据bean的名字拿到对象判断是否是对应的类型，如果不是这个类型会调用getTypeConverter进行类型转换
OrderComparator
OrderComparator是Spring提供的比较器，可以根据@Order注解活实现Ordered接口来执行比较，从而可以进行排序。
也可以通过@order注解实现
public class A implements Ordered {
@Override
public int getOrder() {
return 3;
}
@Override
public String toString() {
return this.getClass().getSimpleName();
}
}public class B implements Ordered {
@Override
public int getOrder() {
return 2;
}
@Override
public String toString() {
return this.getClass().getSimpleName();
}
}public class Main {
public static void main(String[] args) {
A a = new A(); // order=3
B b = new B(); // order=2
OrderComparator comparator = new OrderComparator();
System.out.println(comparator.compare(a, b)); // 1
List list = new ArrayList<>();
list.add(a);
list.add(b);
// 按order值升序排序
list.sort(comparator);
System.out.println(list); // B，A
}
}另外，Spring中还提供了一个OrderComparator的子类：
AnnotationAwareOrderComparator，它支持用@Order来指定order值。比如：
@Order(3)
public class A {
@Override
public String toString() {
return this.getClass().getSimpleName();
}
}@Order(2)
public class B {
@Override
public String toString() {
return this.getClass().getSimpleName();
}
}
public class Main {
public static void main(String[] args) {
A a = new A(); // order=3
B b = new B(); // order=2
AnnotationAwareOrderComparator comparator = new AnnotationAwareOrderComparator();
System.out.println(comparator.compare(a, b)); // 1
List list = new ArrayList<>();
list.add(a);
list.add(b);
// 按order值升序排序
list.sort(comparator);
System.out.println(list); // B，A
}
}BeanPostProcessor
BeanPostProcess表示Bena的后置处理器，我们可以定义一个或多个BeanPostProcessor，比如通
过一下代码定义一个BeanPostProcessor：
@Component
public class ZhouyuBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws
BeansException {
if ("userService".equals(beanName)) {
System.out.println("初始化前");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws
BeansException {
if ("userService".equals(beanName)) {
System.out.println("初始化后");
}
return bean;
}
}我们可以在postProcessBeanFactory()方法中对BeanFactory进行加工。
MetadataReader、ClassMetadata、AnnotationMetadata
在Spring中需要去解析类的信息，比如类名、类中的方法、类上的注解，这些都可以称之为类的元数
据，所以Spring中对类的元数据做了抽象，并提供了一些工具类。
MetadataReader表示类的元数据读取器，默认实现类为SimpleMetadataReader
public class Test {
public static void main(String[] args) throws IOException {
SimpleMetadataReaderFactory simpleMetadataReaderFactory = new
SimpleMetadataReaderFactory();
// 构造一个MetadataReader
MetadataReader metadataReader =
simpleMetadataReaderFactory.getMetadataReader("com.zhouyu.service.UserService");
// 得到一个ClassMetadata，并获取了类名
ClassMetadata classMetadata = metadataReader.getClassMetadata();
System.out.println(classMetadata.getClassName());
// 获取一个AnnotationMetadata，并获取类上的注解信息
AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
for (String annotationType : annotationMetadata.getAnnotationTypes()) {
System.out.println(annotationType);
}
}
}需要注意的是，SimpleMetadataReader去解析类时，使用的ASM技术。
为什么要使用ASM技术，Spring启动的时候需要去扫描，如果指定的包路径比较宽泛，那么扫描的
类是非常多的，那如果在Spring启动时就把这些类全部加载进JVM了，这样不太好，所以使用了
ASM技术。
ExcludeFilter和IncludeFilter
这两个Filter是Spring扫描过程中用来过滤的。ExcludeFilter表示排除过滤器，IncludeFilter表示包
含过滤器。
比如以下配置，表示扫描com.zhouyu这个包下面的所有类，但是排除UserService类，也就是就算
它上面有@Component注解也不会成为Bean。
@ComponentScan(value = "com.zhouyu",
excludeFilters = {@ComponentScan.Filter(
type = FilterType.ASSIGNABLE_TYPE,
classes = UserService.class)}.)
public class AppConfig {
}再比如以下配置，就算UserService类上没有@Component注解，它也会被扫描成为一个Bean。
@ComponentScan(value = "com.zhouyu",
includeFilters = {@ComponentScan.Filter(
type = FilterType.ASSIGNABLE_TYPE,
classes = UserService.class)})
public class AppConfig {
}FilterType分为：
- ANNOTATION：表示是否包含某个注解
- ASSIGNABLE_TYPE：表示是否是某个类
- ASPECTJ：表示否是符合某个Aspectj表达式
- REGEX：表示是否符合某个正则表达式
- CUSTOM：自定义
在Spring的扫描逻辑中，默认会添加一个AnnotationTypeFilter给includeFilters，表示默认情况下
Spring扫描过程中会认为类上有@Component注解的就是Bean。
FactoryBean
上面提到可以通过BeanPostPorcessor来干涉Spring创建Bean的过程，但如果我们想一个Bean完完全全让我们来构造也是可以的，比如提供BeanFactory
@Component
public class ZhouyuFactoryBean implements FactoryBean {
@Override
public Object getObject() throws Exception {
UserService userService = new UserService();
return userService;
}
@Override
public Class<?> getObjectType() {
return UserService.class;
}
}
如果@Component的类加了实现了FactoryBean接口，那么获取的就是getObject方法中设置的对象
他和@Bean的区别是ZhouyuFactoryBean这个Bean经过了完整的生命周期
就是工厂bean构建出来的对象不会经过后置处理器之类的
构造方法
this
进构造方法，首先调用了this();
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this();
register(componentClasses);
refresh();
}点开start方法调用了
public AnnotationConfigApplicationContext() {
//先启动
StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
//操作
this.reader = new AnnotatedBeanDefinitionReader(this);
//可以在这一步计算时间默认没有实现
createAnnotatedBeanDefReader.end();
this.scanner = new ClassPathBeanDefinitionScanner(this);
}StartupStep是spring5.3中新添加的接口，默认的实现类是DefaultStartStep，默认没有任何逻辑是一个空实现类
另一个实现类是FlightRecorderStartStep是为了做JFR的，（JDK监控记录的），高版本还有BufferedStartupStep
深度探索JFR - JFR详细介绍与生产问题定位落地 - 1. JFR说明与启动配置 - 知乎 (zhihu.com)
AbstractApplicationContext.referesh
再去看refresh方法，
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
// Invoke factory processors registered as beans in the context.
//在这个方法可能会进行扫描，扫描过程中可能又会扫描出其他的BeanFactoryPostProcessor，那么这些也得在这一步执行
//调用scanner.scan() 进行扫描
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
beanPostProcess.end();
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
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();
contextRefresh.end();
}
}
}invokeBeanFactoryPostProcessors调用了scanner.scan() 进行扫描
ClassPathBeanDefinitionScanner
public int scan(String... basePackages) {//传入扫描路径
int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
doScan(basePackages);
// Register annotation config processors, if necessary.
if (this.includeAnnotationConfig) {
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
}这是doScan真正扫描的定义
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
for (String basePackage : basePackages) {
//包扫描
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
//解析scope中的数据
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
// 获取名字，看看@Component上有没有定义名字，如果没有的话就返回一个默认的名字（根据类名生成）
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
//设置beanDefinition设置一些默认值，比如设置默认不是懒加载的
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
//解析@lazy，@Primary，@DepensOn，@Role，@Description
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
//检查spring容器中是否已经存在该beanName，第二个参数是beanDefinition，如果存在会直接抛异常，如果返回false表示不会重新注册到容器中
//大部分情况下已经有会直接抛异常，但扫描俩次的情况就会直接返回false，底层是判断resoure是否相同，防止beanName重复的情况
if (checkCandidate(beanName, candidate)) {
//将BeanDefinition和beanName封装成一个Holder
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//注册，拿到beanDefinition然后注册到beanDefinitionMap中
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}findCandidateComponents最后会调用scanCandidateComponents根据包路径返回set，包括了做一些表达式匹配之类的工作
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else {
return scanCandidateComponents(basePackage);
}
}scanCandidateComponents方法
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
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();
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
try {
//元数据读取器，获取注解信息，类的信息，底层使用的是ASM技术
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
//判断当前类到底是不是一个需要注入的bean
//，会加一层过滤器，判断是否要排除或者包含当前的bean，@Component或者@Conditional条件注解（为true就加载）
if (isCandidateComponent(metadataReader)) {
//构造beanDefinition
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setSource(resource);
//过滤判断是否是独立的一个类，（需要是顶级类，或者是静态内部类）判断是否是接口，或者是抽象类（抽象类方法上有lookup注解除外）
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 (FileNotFoundException ex) {
if (traceEnabled) {
logger.trace("Ignored non-readable " + resource + ": " + ex.getMessage());
}
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to read candidate component class: " + resource, ex);
}
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
可能会走到的这个方法addCandidateComponentsFromIndex，是一个索引机制用的很少，比如在项目中有非常多的类的时候可以再resource/META-INF文件下定义一个spring.components文件，spring如果检查到这个文件，可以直接根据文件中的内容去扫描bean，而不会进行包扫描操作
private Set<BeanDefinition> addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
Set<String> types = new HashSet<>();
for (TypeFilter filter : this.includeFilters) {
String stereotype = extractStereotype(filter);
if (stereotype == null) {
throw new IllegalArgumentException("Failed to extract stereotype from " + filter);
}
//遍历文件中的内容，
types.addAll(index.getCandidateTypes(basePackage, stereotype));
}
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for (String type : types) {
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(type);
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setSource(metadataReader.getResource());
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Using candidate component class from index: " + type);
}
candidates.add(sbd);
}
else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + type);
}
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because matching an exclude filter: " + type);
}
}
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}ScannedGenericBeanDefinition
@SuppressWarnings("serial")
public class ScannedGenericBeanDefinition extends GenericBeanDefinition implements AnnotatedBeanDefinition {
private final AnnotationMetadata metadata;
/**
* Create a new ScannedGenericBeanDefinition for the class that the
* given MetadataReader describes.
* @param metadataReader the MetadataReader for the scanned target class
*/
public ScannedGenericBeanDefinition(MetadataReader metadataReader) {
Assert.notNull(metadataReader, "MetadataReader must not be null");
this.metadata = metadataReader.getAnnotationMetadata();
//这里只是把className设置到BeanDefinition中
//beanClass是个Object类型的对象，创建的时候才会真正去加载，一开始是类的名字后面可能是类的对象
setBeanClassName(this.metadata.getClassName());
setResource(metadataReader.getResource());
}
@Override
public final AnnotationMetadata getMetadata() {
return this.metadata;
}
@Override
@Nullable
public MethodMetadata getFactoryMethodMetadata() {
return null;
}
}finishBeanFactoryInitialization
其中的finishBeanFactoryInitialization会完成bean工厂的初始化，实例化非懒加载的单例bean
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Register a default embedded value resolver if no BeanFactoryPostProcessor
// (such as a PropertySourcesPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}这个方法的结尾preInstantiateSingletons会去实例化非懒加载的单例bean
DefaultListableBeanFactory.preInstantiateSingletons
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
//根据名字得到BeanDefinition,下面会展开
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//是不是 非抽象的BeanDefinition（在xml注入时用的到，自己不能生成bean，但可以给别的去继承 一般不用），是不是单例，是不是非懒加载
//都满足才会去创建bean
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//判断对象是不是isFactoryBean，如果当前factoryBean没有的话，可能会去父FactoryBean中去寻找(父子bean工厂)
//会进行缓存，之后就能加快判断，容器启动时不会去加载beanFactorygetBean的时候加载
//如果实现的是SmartFactoryBean可以设置一个isEagerInit方法返回true，这样容器启动的时候就会加载
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
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) {
//真正创建bean
getBean(beanName);
}
}
}
else {
//真正创建bean
getBean(beanName);
}
}
}
//所有的非懒加载依赖都创建完了之后，才会执行
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
//从单例池中获取对象
Object singletonInstance = getSingleton(beanName);
//判断是不是实现了SmartInitializingSingleton接口
if (singletonInstance instanceof SmartInitializingSingleton) {
StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
.tag("beanName", beanName);
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
//安全管理器
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
//加载完了之后，调用单例bean的方法，实现了SmartInitializingSingleton会复写这个方法
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
smartInitialize.end();
}
}
}父子bean工厂
AbstractBeanFactory.getMergedLocalBeanDefinition
获取合并的BeanDefinition
为什么要合并呢？，这是因为Spring的BeanDefinition支持继承
在 Spring 中，有一种特殊的 BeanDefinition，叫做子 BeanDefinition，也就是我们在 XML 配置文件中通过 parent 属性指定的那种。这种子 BeanDefinition 可以继承父 BeanDefinition 的配置信息。
合并的过程，就是把子 BeanDefinition 的配置信息和父 BeanDefinition 的配置信息合并起来，形成一个完整的配置信息。合并后的 BeanDefinition 对象包含了 Bean 创建所需要的所有信息，Spring 将使用这个完整的 BeanDefinition 来创建 Bean 实例。
会地柜遍历节点去判断是否有BeanDefinition是抽象的
//合并之后的BeanDefinition，RootBeanDefinition就是跟节点
private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
// Quick check on the concurrent map first, with minimal locking.
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null && !mbd.stale) {
return mbd;
}
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
xml例子
<bean id="parentBean" class="com.example.ParentClass" abstract="true">
<property name="commonProperty" value="commonValue" />
</bean>
<bean id="childBean" parent="parentBean">
<property name="specificProperty" value="specificValue" />
</bean>
在这个例子中，我们定义了两个bean，一个是 parentBean，另一个是 childBean。parentBean 是 abstract 的，表示它不会被实例化，只作为模板使用。childBean 的 parent 属性指向 parentBean，表示它继承了 parentBean 的配置。
parentBean 有一个属性 commonProperty，值为 commonValue。childBean 有一个属性 specificProperty，值为 specificValue。在Spring解析这个配置文件，生成BeanDefinition的时候，childBean 的BeanDefinition会包含两个属性：commonProperty 和 specificProperty，这就是 BeanDefinition 的合并过程。
在Java配置中，我们无法直接模拟XML配置的BeanDefinition合并过程，因为这是Spring XML配置的一项特性，配置类通常会采用Java代码的继承或组合来重用bean定义，不会涉及到配置元数据层面的BeanDefinition合并。XML配置中的BeanDefinition合并特性允许我们定义一个父Bean，然后定义一些子Bean，子Bean可以继承父Bean的一些属性。
这个特性在Java配置中并没有直接的替代品，因为Java配置通常更加依赖实例化过程中的逻辑，而不是元数据（即BeanDefinition）。在Java配置中，我们可以使用继承和组合等普通的Java特性来实现类似的结果，但这不是真正的BeanDefinition合并。因此，当我们从XML配置转换为Java配置时，通常需要手动将共享的属性复制到每个Bean的定义中。
BeanDefinition合并的目的
- 提供完整的BeanDefinition信息：在配置中，我们经常会使用父子BeanDefinition（如通过<bean>标签的parent属性）。子BeanDefinition可能只会定义需要改变或增加的bean属性，而父BeanDefinition则提供共享的默认定义。在这种情况下，合并操作会将父子BeanDefinition的信息合并为一个完整的BeanDefinition，用于接下来的bean创建。
- 优化性能：合并操作的结果通常会被缓存起来，因此在下次获取同样的bean时，可以直接从缓存中获取合并后的BeanDefinition，避免了重复的合并操作，从而提高了性能。
- 解决循环依赖：在处理bean之间的循环依赖时，需要尽早抛出已经处理（例如实例化和属性填充）的bean，这时就需要一个完整的BeanDefinition信息。因此，BeanDefinition的合并在解决循环依赖问题上也有重要作用。
简而言之，BeanDefinition的合并是为了得到一个完整、准确的BeanDefinition，以供Spring IoC容器后续的bean创建和依赖解析使用。
合并之后会生成新的一个BeanDefinition
AbstractBeanFacotry
getBean方法会去创建对象
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
//对字符串进行一些处理，name有可能是&xxx，会解析成xxx，那么有可能传进来的是别名，那么beanName就是id，&xxx可以用来得到FactoryBean中的对象
// 或者将别名转换为beanName，底层可能会去递归获取别名
String beanName = transformedBeanName(name);
Object beanInstance;
// Eagerly check singleton cache for manually registered singletons.
// 直接（不做判断）去单例池中获取这个bean
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//如果sharedInstance是FactoryBean，那么就调用getObject()对象，如果不是FactoryBean对象会报错
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//如果单例池没有需要的对象
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
//判断是否有父beanFactory
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.
//自己没有去父factory里面拿，类似递归调用
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
.tag("beanName", name);
try {
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
//获取合并之后的efinition
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//如果是抽象直接报错
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
//获取@ependOn注解，注解作用如果要创建当前对象先要把注解参数中的那个对象进行创建（类似依赖）可以定义多个
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
//dependsOn表示当前beanName所依赖的，当bean创建之前depensOn所依赖的Bena全部创建好了
for (String dep : dependsOn) {
//beanName是不是被dep依赖了，如果是则出现了循环依赖，抛出错误
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//dep被beanName依赖了，存入dependentBeanMap中，dep为key，beanName为value，会存到一个dependentBeanMap之
//private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
//表示某个bean依赖了哪些bean
registerDependentBean(dep, beanName);
try {
//创建所依赖的bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
if (mbd.isSingleton()) {
//如果是单例的，传入一个lambda表达式，下面会详细讲这个方法
sharedInstance = getSingleton(beanName, () -> {
try {
//创建单例bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
//如果是Fcotrybean需要调用方法获取到真正的bean
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//如果是原型bean
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
//标记为正在创建这个bean
beforePrototypeCreation(beanName);
//直接去创建这个bean
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//创建后移除正在创建的标志
afterPrototypeCreation(beanName);
}
//如果是Fcotrybean需要调用方法获取到真正的bean
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
//处理其他scope的情况，也可能是request或者session
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
}
//调用get返回scope对象，这个scope又俩个实现类RequestScope和sessionScope，可能会返回不同的对象（多态）
//每个类对scope实现不一样，比如session就能保证每个请求是相同的，只有用springmvc之类的框架才会用到
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 {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new ScopeNotActiveException(beanName, scopeName, ex);
}
}
}
catch (BeansException ex) {
beanCreation.tag("exception", ex.getClass().toString());
beanCreation.tag("message", String.valueOf(ex.getMessage()));
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
finally {
beanCreation.end();
}
}
//如果传了类型会检查类型是否和得到bean匹配，不匹配抛异常
return adaptBeanInstance(name, beanInstance, requiredType);
}使用@Bean注解时方法名就是bean的名字，写单个参数时参数是名字，写数组时数组的第一个参数是名字，其他参数都是别名，底层是一个别名aliasMap，key是别名，value是名字，
调用getBean方法有非常多的视线
@Override
public Object getBean(String name) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name);
}
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name, requiredType);
}
@Override
public Object getBean(String name, Object... args) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name, args);
}
@Override
public <T> T getBean(Class<T> requiredType) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(requiredType);
}
@Override
public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(requiredType, args);
}第二个参数为Object的构造方法回去影响最后调用的构造方法，但是要注意如果有默认的构造方法，在spring容器启动的时候对象就可能构造完成了，因此不会调用带参数的构造方法，如果把@Scope设置为prototype就可以看到效果
DefaultSingletonBeanRegistry.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对象
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//在这里执行lambda表达式
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
//添加到单例池
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}AbstractAutowireCapableBeanFactory
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;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
//一开始进BeanDefinition是个字符串，这里判断是否已经被加载了，如果没有加载就去加载那个类，可以自定义这个类加载器
//context.getBeanFactory().setBeanClassLoader(),默认情况下是当前线程对应的类加载器
//线程类加载器为null的情况下，获取加载ClassUtils类的类加载器，就是就是看这个jar包是被谁加载的，但一般是获取不到的最终会获取系统类加载器
//最后用类加载器加载出类对象（里面还会做一些解析xml中class=""里面表达式的操作），然后真正设置class对象
//默认BeanPostProcessor是针对所有bean的传入的是object对象，InstantiationAwareBeanPostProcessors是实例化前，传入的是class对象
//这里会判断有没有实现InstantiationAwareBeanPostProcessors接口然后调用初始化方法，遍历所有这个接口的实现类直到调用到有返回值的为止
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
//马上就要实例化bean了确保beanClass被加载了
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//实例化前
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
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);
}
} docreatebean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
//有可能在本bean创建之前，就有其他bean吧当前bean给创建出来了，比如依赖注入
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//创建bean实例，推断构造方法
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//调用MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition() (如果有的话)
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
//这部分解决了循环依赖
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");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//属性填充 调用实例化后 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation
populateBean(beanName, mbd, instanceWrapper);
//初始化 看看有没有实现BeanNameAware方法，如果有的话调用对应的方法，调用初始化前后的方法
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) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
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);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
//销毁bean，执行销毁相关逻辑，除了直接实现销毁对象的方法，close方法或者shutdown方法也会被自动调用，只销毁单例bean（不管有没有定义方法）
//将依赖自己的bena销毁
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
populateBean方法主要完成的是属性赋值和其前后俩部
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
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;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
//如果实现了接口调用postProcessAfterInstantiation
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
//会根据是byType还是ByName注入来找寻对应的set ClassName的方法进行调用，默认是no，
//@Bean(Autowire.BY_TYPE)
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
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) {
//将如果有的话BeanDefinition的PropertyValues直接赋值（可能是外部传进来的值），没有的话在生成默认值
pvs = mbd.getPropertyValues();
}
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
//这里会调用AutowiredAnnotationBeanPostProcessor的postprocessProperties方法
PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = bp.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);
}
//如果当前Bean中的BeanDefinition中设置了PropertyValues，那么最终是PropertyValues的值，覆盖掉@Autowired
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
依赖注入
spring分为三种注入方式，构造，方法，字段注入
AbstractAutowireCapableBeanFactory
autowireByName方法
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
//拿到当前Bean中能自行自动注入的属性名，具体下面展开
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
//便遍历每个属性名，并去获取bean对象，并舍之道pvs当中
for (String propertyName : propertyNames) {
if (containsBean(propertyName)) {
Object bean = getBean(propertyName);
pvs.add(propertyName, bean);
//记录一下propertyName对应的Bean被beanName依赖了
registerDependentBean(propertyName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Added autowiring by name from bean name '" + beanName +
"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
"' by name: no matching bean found");
}
}
}
}unsatisfiedNonSimpleProperties
//bw中包含了生成好的实例对象
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
Set<String> result = new TreeSet<>();
PropertyValues pvs = mbd.getPropertyValues();
//属性描述器
PropertyDescriptor[] pds = bw.getPropertyDescriptors();
//什么样的属性能进行自动注入？
//1.该属性有set方法。2.没有在ignoredDependencyTypes中,3属性类型不能是简单类型（数字字符串Class，URI，Date之类）
//只有是由set开头的方法都能被解析出来，这里还会把Object.getClass方法解析出来。
for (PropertyDescriptor pd : pds) {
//过滤
if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
//去掉简单类型数字字符串Class，URI，Date之类，但是@Autowired没有这个判断所以可以注入di
!BeanUtils.isSimpleProperty(pd.getPropertyType())) {
result.add(pd.getName());
}
}
//最终set方法不会返回
return StringUtils.toStringArray(result);
}@Autowired注解
AutowiredAnnotationBeanPostProcessor下的
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
metadata.checkConfigMembers(beanDefinition);
}查找添加了@Autowired注解的地方
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
// Fall back to class name as cache key, for backwards compatibility with custom callers.
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// Quick check on the concurrent map first, with minimal locking.
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
metadata.clear(pvs);
}
//解析注入点并缓存
metadata = buildAutowiringMetadata(clazz);
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}寻找注入点
private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
//如果一个Bean的类型是String，Number等。。。那么则根本不需要进行依赖注入
if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
return InjectionMetadata.EMPTY;
}
List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
Class<?> targetClass = clazz;
do {
final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
//遍历targetClass中的所有Field
ReflectionUtils.doWithLocalFields(targetClass, field -> {
//field上是否存在@Autowired，@value，@Inject中的其中一个（遍历类上的所有注解）拿到其中一个
MergedAnnotation<?> ann = findAutowiredAnnotation(field);
if (ann != null) {
//静态域不是注入点，不会进行自动注入（static属性是不会进行赋值的）
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static fields: " + field);
}
return;
}
//构造注入点，获取@Autowired的required属性（默认是true，表示希望spring一定要给这个属性赋值）
boolean required = determineRequiredStatus(ann);
//将注入点添加到这个集合中
currElements.add(new AutowiredFieldElement(field, required));
}
});
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
//判断方法是不是桥接方法（asm技术拿到的字节码，可能会在实现接口后生成多个带注解的方法），把桥接方法给过滤掉
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
if (Modifier.isStatic(method.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static methods: " + method);
}
return;
}
if (method.getParameterCount() == 0) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation should only be used on methods with parameters: " +
method);
}
}
boolean required = determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
//即便是没有参数的对象加上@Autowired后spring也会进行调用
//遍历方法，把方法上加了注解的全部获取
currElements.add(new AutowiredMethodElement(method, required, pd));
}
});
//将注入点全都添加到集合中
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
}//遍历父类
while (targetClass != null && targetClass != Object.class);
//汇聚所有注入点返回一个对象
return InjectionMetadata.forElements(elements, clazz);
}静态变量/类变量不是对象的属性,而是一个类的属性,spring则是基于对象层面上的依赖注入.
而使用静态变量/类变量扩大了静态方法的使用范围.静态方法在spring是不推荐使用的.依赖注入的主要目的,是让容器去产生一个对象的实例,然后在整个生命周期中使用他们,同时也让testing工作更加容易.
一旦你使用静态方法,就不再需要去产生这个类的实例,这会让testing变得更加困难,同时你也不能为一个给定的类,依靠注入方式去产生多个具有不同的依赖环境的实例.这种static field是隐含共享的,并且是一种global全局状态,spring同样不推荐这样去做.
AutowiredAnnotationBeanPostProcessor
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
//找注入点
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;
}findAutowiringMetadata
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
// Fall back to class name as cache key, for backwards compatibility with custom callers.
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// Quick check on the concurrent map first, with minimal locking.
//这里已经能从缓存中拿到了
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
metadata.clear(pvs);
}
metadata = buildAutowiringMetadata(clazz);
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}inject方法
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
//如果pvs中已经有当前注入点的值了，则跳过注入（比如getBean的时候手动赋值，那就不会执行）
if (checkPropertySkipping(pvs)) {
return;
}
Method method = (Method) this.member;
Object[] arguments;
if (this.cached) {
try {
arguments = resolveCachedArguments(beanName);
}
catch (NoSuchBeanDefinitionException ex) {
// Unexpected removal of target bean for cached argument -> re-resolve
arguments = resolveMethodArguments(method, bean, beanName);
}
}
else {
//根据方法的信息去找值，遍历每个方法参数找到bean对象
arguments = resolveMethodArguments(method, bean, beanName);
}
if (arguments != null) {
try {
ReflectionUtils.makeAccessible(method);
method.invoke(bean, arguments);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}resolveMethodArguments解析方法参数
@Nullable
private Object[] resolveMethodArguments(Method method, Object bean, @Nullable String beanName) {
int argumentCount = method.getParameterCount();
Object[] arguments = new Object[argumentCount];
DependencyDescriptor[] descriptors = new DependencyDescriptor[argumentCount];
Set<String> autowiredBeans = new LinkedHashSet<>(argumentCount);
Assert.state(beanFactory != null, "No BeanFactory available");
TypeConverter typeConverter = beanFactory.getTypeConverter();
//遍历每个方法参数，找到匹配的bean对象
for (int i = 0; i < arguments.length; i++) {
MethodParameter methodParam = new MethodParameter(method, i);
DependencyDescriptor currDesc = new DependencyDescriptor(methodParam, this.required);
currDesc.setContainingClass(bean.getClass());
descriptors[i] = currDesc;
try {
Object arg = beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);
if (arg == null && !this.required) {
arguments = null;
break;
}
//将参数放到这个数组中
arguments[i] = arg;
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(methodParam), ex);
}
}
synchronized (this) {
if (!this.cached) {
if (arguments != null) {
DependencyDescriptor[] cachedMethodArguments = Arrays.copyOf(descriptors, arguments.length);
registerDependentBeans(beanName, autowiredBeans);
if (autowiredBeans.size() == argumentCount) {
Iterator<String> it = autowiredBeans.iterator();
Class<?>[] paramTypes = method.getParameterTypes();
for (int i = 0; i < paramTypes.length; i++) {
String autowiredBeanName = it.next();
if (beanFactory.containsBean(autowiredBeanName) &&
beanFactory.isTypeMatch(autowiredBeanName, paramTypes[i])) {
cachedMethodArguments[i] = new ShortcutDependencyDescriptor(
descriptors[i], autowiredBeanName, paramTypes[i]);
}
}
}
this.cachedMethodArguments = cachedMethodArguments;
}
else {
this.cachedMethodArguments = null;
}
this.cached = true;
}
}
return arguments;
}DefaultListableBeanFactory
@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
//用来获取方法入参名字
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
//所需类型是OPtional
if (Optional.class == descriptor.getDependencyType()) {
return createOptionalDependency(descriptor, requestingBeanName);
}
//需要类型是objectFactory或ObjectProvider
else if (ObjectFactory.class == descriptor.getDependencyType() ||
ObjectProvider.class == descriptor.getDependencyType()) {
return new DependencyObjectProvider(descriptor, requestingBeanName);
}
else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
}
else {
//在属性或set方法上用了@lazy注解，那么构造一个代理对象并返回，真正使用代理对象时才进行类型筛选Bean
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
if (result == null) {
//descriptor表示某个属性或某个set方法
//requestingBeanName表示正在进行依赖注入的Bean
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
}真正的去找bean
@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
//如果当前的descriptor之前做过依赖注入了，则可以直接取shortcut了，相当于缓存
Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
return shortcut;
}
Class<?> type = descriptor.getDependencyType();
//获取@value所指定的值
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
if (value instanceof String) {
//占位符填充(${}) ,注入环境变量，包括操作系统重的环境变量以及Environment和运行时设置的环境变量
String strVal = resolveEmbeddedValue((String) value);
BeanDefinition bd = (beanName != null && containsBean(beanName) ?
getMergedBeanDefinition(beanName) : null);
//解析spring表达式（#{可以写bean名字}）
value = evaluateBeanDefinitionString(strVal, bd);
}
//将value转化为descriptor所对应的类型（spring中有类型转换器，如果类型转换器匹配到了就能转换对应的类型）
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
try {
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()));
}
}
//如果descriptor所对应的类型是数组，map这些，就将descriptor对应类型所匹配的所有bean方法，不用进一步做筛选了
Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
return multipleBeans;
}
//找到所有Bean，key是beanName，value可能是bean对象，有可能是beanClass
// 比如如果你是map，直接把工厂中所有（类型一样）的对象进行注入，如果写的是泛型就找不到会报错，写Object就是所有的bean
//如果已经创建好了这个对象就拿出来，如果没有创建好只存Class
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
//如果必填抛异常
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null;
}
String autowiredBeanName;
Object instanceCandidate;
if (matchingBeans.size() > 1) {
//根据类型找到了多个Bean，进一步筛选出某一个 @Primary-->优先级最高-->name
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
if (autowiredBeanName == null) {
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
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).
return null;
}
}
instanceCandidate = matchingBeans.get(autowiredBeanName);
}
else {
// We have exactly one match.
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
//记录匹配过的beanName
if (autowiredBeanNames != null) {
autowiredBeanNames.add(autowiredBeanName);
}
//有可能筛选出来的是某个bean的类型（如果是没初始化的class），此处就进行实例化
if (instanceCandidate instanceof Class) {
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
Object result = instanceCandidate;
//spring源码中对返回null的Bean做了特殊处理
if (result instanceof NullBean) {
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
result = null;
}
if (!ClassUtils.isAssignableValue(type, result)) {
throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
}
//返回要注入的class
return result;
}
finally {
ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
}
}@Nullable
protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) {
Class<?> requiredType = descriptor.getDependencyType();
//candidates表示根据类型所找到的多个Bean，判断这些Bean中是否有一个是@primary的（@primary可以设置bean的优先级，但只能写在类上面）
String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
if (primaryCandidate != null) {
return primaryCandidate;
}
//取优先级最高的Bean
String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
if (priorityCandidate != null) {
return priorityCandidate;
}
// Fallback
//匹配descriptor的名字，要么是字段名字，要么是set方法入参名字
for (Map.Entry<String, Object> entry : candidates.entrySet()) {
String candidateName = entry.getKey();
Object beanInstance = entry.getValue();
//如果是spring自己的byType, descriptor.getDependecyName()将返回为空，只有是@Autowired才会返回方法属性名或方法参数名
if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
//获得属性和方法参数的名字
matchesBeanName(candidateName, descriptor.getDependencyName())) {
return candidateName;
}
}
return null;
}
protected Map<String, Object> findAutowireCandidates(
@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
//从BeanFactory中找出和requiredType所匹配的beanName，这些bean不一定已经实例化
String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this, requiredType, true, descriptor.isEager());
Map<String, Object> result = CollectionUtils.newLinkedHashMap(candidateNames.length);
//根据类型从resolvableDependencies中匹配Bean，resolvableDependencies中存放的是类型Bean对象，比如BeanFactory.class
//resolvableDependencies在spring初始化的时候会存特定类型的bean对象
for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
Class<?> autowiringType = classObjectEntry.getKey();
if (autowiringType.isAssignableFrom(requiredType)) {
Object autowiringValue = classObjectEntry.getValue();
autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
if (requiredType.isInstance(autowiringValue)) {
//加入到结果中
result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
break;
}
}
}
for (String candidate : candidateNames) {
//如果不是自己，则判断candidate到底能不能用来进行自动注入（优先匹配其他bean）
if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
//为空要么是真的没有匹配的，要么是匹配的自己（匹配自己的情况不会加入这个result中所以还是空）
if (result.isEmpty()) {
boolean multiple = indicatesMultipleBeans(requiredType);
// Consider fallback matches if the first pass failed to find anything...
DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
for (String candidate : candidateNames) {
if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
//匹配的是自己，被自己添加到result中
if (result.isEmpty() && !multiple) {
// Consider self references as a final pass...
// but in the case of a dependency collection, not the very same bean itself.
for (String candidate : candidateNames) {
if (isSelfReference(beanName, candidate) &&
(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
//这个是控制@bean中autowireCandidate 表示是否可以用来进行依赖注入（父类这个注解也是生效的）
//有可能类型符合@Qualifer不符合
isAutowireCandidate(candidate, fallbackDescriptor)) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
}
}
return result;
}根据类型获取bean名称
private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
List<String> result = new ArrayList<>();
// Check all bean definitions.
//遍历所有的BeanDefinition
for (String beanName : this.beanDefinitionNames) {
// Only consider bean as eligible if the bean name is not defined as alias for some other bean.
if (!isAlias(beanName)) {
try {
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// Only check bean definition if it is complete.
// 一般情况下allowEagerInit都是true，而且不是抽象类，所以基本都能进入这个方法
if (!mbd.isAbstract() && (allowEagerInit ||
(mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&
!requiresEagerInitForType(mbd.getFactoryBeanName()))) {
boolean isFactoryBean = isFactoryBean(beanName, mbd);
BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
boolean matchFound = false;
boolean allowFactoryBeanInit = (allowEagerInit || containsSingleton(beanName));
boolean isNonLazyDecorated = (dbd != null && !mbd.isLazyInit());
//当前BeanDefinition不是FactoryBean，就是普通Bean
if (!isFactoryBean) {
// 在筛选Bean时，如果仅仅包括单例，但是beanName对应的又不是单例，则忽略
if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) {
// 不管如何都会进入这个方法,有可能bean会带&符号开头会进行处理，这里判断是否匹配，如果是FactoryBean会做特殊判断
matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
}
}
else {
if (includeNonSingletons || isNonLazyDecorated ||
(allowFactoryBeanInit && isSingleton(beanName, mbd, dbd))) {
matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
}
if (!matchFound) {
// In case of FactoryBean, try to match FactoryBean instance itself next.
beanName = FACTORY_BEAN_PREFIX + beanName;
if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) {
matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
}
}
}
if (matchFound) {
result.add(beanName);
}
}
}
catch (CannotLoadBeanClassException | BeanDefinitionStoreException ex) {
if (allowEagerInit) {
throw ex;
}
// Probably a placeholder: let's ignore it for type matching purposes.
LogMessage message = (ex instanceof CannotLoadBeanClassException ?
LogMessage.format("Ignoring bean class loading failure for bean '%s'", beanName) :
LogMessage.format("Ignoring unresolvable metadata in bean definition '%s'", beanName));
logger.trace(message, ex);
// Register exception, in case the bean was accidentally unresolvable.
onSuppressedException(ex);
}
catch (NoSuchBeanDefinitionException ex) {
// Bean definition got removed while we were iterating -> ignore.
}
}
}
// Check manually registered singletons too.
for (String beanName : this.manualSingletonNames) {
try {
// In case of FactoryBean, match object created by FactoryBean.
if (isFactoryBean(beanName)) {
if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) {
result.add(beanName);
// Match found for this bean: do not match FactoryBean itself anymore.
continue;
}
// In case of FactoryBean, try to match FactoryBean itself next.
beanName = FACTORY_BEAN_PREFIX + beanName;
}
// Match raw bean instance (might be raw FactoryBean).
if (isTypeMatch(beanName, type)) {
result.add(beanName);
}
}
catch (NoSuchBeanDefinitionException ex) {
// Shouldn't happen - probably a result of circular reference resolution...
logger.trace(LogMessage.format(
"Failed to check manually registered singleton with name '%s'", beanName), ex);
}
}
return StringUtils.toStringArray(result);
}