sping ioc 源码分析（一）-- register(componentClasses) 方法
2024-09-07 21:41:43
一.测试环境的搭建：
public class Apple {
}
@Component
public class MyComponet {
}
public class MyCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
return metadata.isAnnotated("org.springframework.context.annotation.Configuration");
}
}
@Configuration
@Import(Apple.class)
public class MyConfig {
@Bean
public Student student(){
return new Student();
}
}
public class Student {
}
@Configuration
@ComponentScan("com.yang.xiao.hui.ioc")
@Conditional(MyCondition.class)
public class App
{
public static void main( String[] args )
{
ApplicationContext ctx = new AnnotationConfigApplicationContext(App.class);
}
}
//主要分析的是@import,@Componet@Bean @componentScan的方式向spring容器中注入bean的方式：
一个类变成bean的简单过程：
debug调试:
在创建一个类时，会先初始化其父类：GenericApplicationContext 断点在该类的构造器中：
父类创建的过程中，new 了一个beanFactory,而这个就是我们侠义上的ioc容器了，我们的bean定义信息和单例bean都是存在这里的：我们看看该类：
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable { @Nullable
private static Class<?> javaxInjectProviderClass; static {
try {
javaxInjectProviderClass =
ClassUtils.forName("javax.inject.Provider", DefaultListableBeanFactory.class.getClassLoader());
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - Provider interface simply not supported then.
javaxInjectProviderClass = null;
}
} /** Map from serialized id to factory instance. */
private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
new ConcurrentHashMap<>(8); /** Optional id for this factory, for serialization purposes. */
@Nullable
private String serializationId; /** Whether to allow re-registration of a different definition with the same name. */
private boolean allowBeanDefinitionOverriding = true; /** Whether to allow eager class loading even for lazy-init beans. */
private boolean allowEagerClassLoading = true; /** Optional OrderComparator for dependency Lists and arrays. */
@Nullable
private Comparator<Object> dependencyComparator; /** Resolver to use for checking if a bean definition is an autowire candidate. */
private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver(); /** Map from dependency type to corresponding autowired value. */
private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16); /** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256); //这里存储了bean的名称和其定义信息 /** Map of singleton and non-singleton bean names, keyed by dependency type. */
private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64); //bean的类型和对应的beanName,一个bean是可以有别名的 /** Map of singleton-only bean names, keyed by dependency type. */
private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64); /** List of bean definition names, in registration order. */
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);//以list集合的方式，存储了所有的beanName /** List of names of manually registered singletons, in registration order. */
private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16); //手动注册的单列的bean /** Cached array of bean definition names in case of frozen configuration. */
@Nullable
private volatile String[] frozenBeanDefinitionNames; /** Whether bean definition metadata may be cached for all beans. */
private volatile boolean configurationFrozen = false;
//。。。。。。。。。。。。。。。。。。。。省略部分代码。。。。。。。。。。。。。。。。。。
}
由继承体系可知：DefaultListableBeanFactory 继承了DefaultSingletonBeanRegistry，因此我们看看这个类
小结：我们的bean定义信息和bean对象最终都会存到DefaultListableBeanFactory类对应的属性中：Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256) 和private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
我们继续debug调试：
//主要看看this.reader = new AnnotatedBeanDefinitionReader(this);
//该对象底层给beanFactory添加了几个核心的后置处理器
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) { DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry); //获取beanFactory
if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE); //设置一个用于排序的比较器
}
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver()); //设置一个用于解析@lazy @qualifier注解的解析器
}
} Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8); if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
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)) {
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class); //设置一个用于解析@autowired注解的后置处理器
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); //设置一个用于解析@preDestory 和@postConstruct注解的后置处理器
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
} // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition();
try {
def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
AnnotationConfigUtils.class.getClassLoader()));
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
}
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
} if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class); //事件相关的后置处理器
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
} if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class); //事件工厂
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
} return beanDefs;
}
//本次我们主要分析的方法： register(componentClasses);
<T> void doRegisterBean(Class<T> beanClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) { AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass); //创建beanDefinition
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) { //这里是处理Condition注解，如果条件匹配就跳过，后续会分析
return;
} abd.setInstanceSupplier(instanceSupplier);//设置实例工厂，这里为null
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd); //获取@scope注解的元信息，这个在aop源码博客有分析过
abd.setScope(scopeMetadata.getScopeName());
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry)); AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); //这里是处理bean的一些公共注解：@Lazy，@Primary，@DependsOn，@Role，@Description
if (qualifiers != null) {//这里为null
for (Class<? extends Annotation> qualifier : qualifiers) { //处理@Lazy，@Primary，@qualifier
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
for (BeanDefinitionCustomizer customizer : definitionCustomizers) { //这里也为null
customizer.customize(abd); //允许我们对bean的定义信息做一些修改
} BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName); //装饰一下beanDefinition
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); //处理bean的@Scope注解
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);//向DefaultListableBeanFactory中注册beanDefinition,后面会跟进
}
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException { BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);//判断是否已经存在对应的beanDifinition了
if (existingDefinition != null) {
if (!isAllowBeanDefinitionOverriding()) { //如果已经存在，并且不允许覆盖就抛异常
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
else if (existingDefinition.getRole() < beanDefinition.getRole()) { //角色升级，我们自己定义的bean,role就是application,spring自己的bean,角色就是role_support或者ROLE_INFRASTRUCTURE
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (logger.isInfoEnabled()) {
logger.info("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
existingDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(existingDefinition)) {//如果跟之前的不一样，就打印一下日志
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
this.beanDefinitionMap.put(beanName, beanDefinition); //将bean的定义信息存到map集合中
}
else {
if (hasBeanCreationStarted()) { //如果存在bean的创建已经开始
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);//将bean的定义信息存到map集合中
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);//将bean的定义信息存到map集合中
this.beanDefinitionNames.add(beanName);
removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
} if (existingDefinition != null || containsSingleton(beanName)) { //bean的实例已经创建
resetBeanDefinition(beanName); //重新设置bean的定义信息
}
}
接下来，我们回去看看condition注解的解析逻辑：
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) { //先判断有没conditional注解，我们在本次的测试中，添加了@Conditional(MyCondition.class)
return false;
}
if (phase == null) { //ConfigurationPhase phase 是一个枚举，用于判断condition生效的阶段
if (metadata instanceof AnnotationMetadata &&
ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) { //如果被Conditonal标注的类是一个是一个配置类
return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION); //再次递归调用本方法，此时枚举就有值了
}
return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
}
List<Condition> conditions = new ArrayList<>();
for (String[] conditionClasses : getConditionClasses(metadata)) { //获取所有的Conditional注解的属性值，业绩是Condition.class的实现类类名
for (String conditionClass : conditionClasses) {
Condition condition = getCondition(conditionClass, this.context.getClassLoader());//反射创建Conditon.class的实例
conditions.add(condition);
}
}
AnnotationAwareOrderComparator.sort(conditions); //排序
for (Condition condition : conditions) {
ConfigurationPhase requiredPhase = null;
if (condition instanceof ConfigurationCondition) {
requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
}
//如果requiredPhase 为null,或者枚举值一致才会去匹配条件，如果条件匹配不上，就要跳过该bean,这个bean就不会加入到spring容器中
if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
return true;
}
}
return false;
}
//小结： register(componentClasses); 方法的作用就是将主启动类的bean的定义信息注册到容器
最新文章
- eclipse中ctrl+h默认打开是JavaSearch,怎么设置成默认打开是FileSearch
- Python爬虫学习（6）: 爬取MM图片
- JDBC基础与连接sql2012
- FILEtoJPG-神秘文件 -更新（软件BUG及建议可以在这里反馈）
- CentOS上安装FastDFS分布式文件系统
- scala中的implict
- HDU2586 How far away ？(LCA模板题)
- 分析器错误（在浏览器中查看.aspx）
- php artisan 命令报错，什么命令都是这个错误，cmd下运行也不行，又没看到语法错误
- linux workqueue的名字长度小问题
- php替换文件指定行的内容
- NOI-OJ 2.2 ID:6261 汉诺塔
- MT【254】值域包含值域
- 用python实现单向链表
- Html链接标签：
- 源码管理工具Git-客户端GitBash常用命令
- OSINT系列:威胁信息挖掘ThreatMiner
- Json字符串转DataTable
- oplog
- 转 代码修改buildoption