SpringBoot 中BeanDefinition究竟是什么时候转化成Cglib对象的（三）

太过爱你忘了你带给我的痛 2022-12-10 10:20 100阅读 0赞

1、最近在看boot源码，前后读了好几遍，逻辑捋了个大概，细节的问题找的真难  
2、boot装配到BeanDefinition的对象有的是CGlig对象，有的是对象，如下图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1eGllMTM_size_16_color_FFFFFF_t_70_pic_center]  
3、代理对象在调用的时候会走代理类的invoke方法，然后执行被代理对象的方法

在[SpringBoot加载类到DefaultListableBeanFactory.beanDefinitionMap][SpringBoot_DefaultListableBeanFactory.beanDefinitionMap]一文中有个锚点二  
里面有这么一段代码

@Nullable
    	protected final SourceClass doProcessConfigurationClass(
    			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
    			throws IOException {
    
    		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
    			// Recursively process any member (nested) classes first
    			processMemberClasses(configClass, sourceClass, filter);
    		}
    
    		// Process any @PropertySource annotations
    		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");
    			}
    		}
    
    		// Process any @ComponentScan annotations
    		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
    				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    		if (!componentScans.isEmpty() &&
    				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
    			for (AnnotationAttributes componentScan : componentScans) {
    				// The config class is annotated with @ComponentScan -> perform the scan immediately
    				Set<BeanDefinitionHolder> scannedBeanDefinitions =
    						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
    				// Check the set of scanned definitions for any further config classes and parse recursively if needed
    				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
    					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
    					if (bdCand == null) {
    						bdCand = holder.getBeanDefinition();
    					}
    					//这个if里面的判断，埋点就在这里面，接下文
    					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
    						parse(bdCand.getBeanClassName(), holder.getBeanName());
    					}
    				}
    			}
    		}
    										      略
    										      略
    										      略

public static boolean checkConfigurationClassCandidate(
    			BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
    
    		String className = beanDef.getBeanClassName();
    		if (className == null || beanDef.getFactoryMethodName() != null) {
    			return false;
    		}
    
    		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;
    			}
    		}
    
    		//获取这个类的注解，看这个注解的所有属性里面是否有 proxyBeanMethods 值，有的话，则给
    		//添加属性key:CONFIGURATION_CLASS_ATTRIBUTE, value: CONFIGURATION_CLASS_FULL
    		
    		Map<String, Object> config = metadata.getAnnotationAttributes(Configuration.class.getName());
    		if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
    			beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
    		}
    		else if (config != null || isConfigurationCandidate(metadata)) {
    			beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
    		}
    		else {
    			return false;
    		}
    
    		// It's a full or lite configuration candidate... Let's determine the order value, if any.
    		Integer order = getOrder(metadata);
    		if (order != null) {
    			beanDef.setAttribute(ORDER_ATTRIBUTE, order);
    		}
    
    		return true;
    	}

这个**proxyBeanMethods** 又是什么东西呢，看@Configuration源码

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package org.springframework.context.annotation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import org.springframework.core.annotation.AliasFor;
    import org.springframework.stereotype.Component;
    
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Component
    public @interface Configuration {
        @AliasFor(
            annotation = Component.class
        )
        String value() default "";
    	// 这不长得一模一样嘛,看这个字面意思是代理bean方法
        boolean proxyBeanMethods() default true;
    }

只要类的注解是@Configuration，或者配置的注解继承了@Configuration，都会给BeanDefinition添加这个一个属性。

那么这个属性什么时候起作用呢，还是那篇文章，有个锚点三的地方

通过 BeanNamesForType 初始化项目的解析类的处理器，装配加载到的类为BeanDefinition
    	public static void invokeBeanFactoryPostProcessors(
    			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    
    		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
    		Set<String> processedBeans = new HashSet<>();
    
    		if (beanFactory instanceof BeanDefinitionRegistry) {
    			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
    			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
    
    			//将beanFaction后置处理器分为 registryProcessors和regularPostProcessors，一下主用registryProcessors
    			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
    				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
    					BeanDefinitionRegistryPostProcessor registryProcessor =
    							(BeanDefinitionRegistryPostProcessor) postProcessor;
    					registryProcessor.postProcessBeanDefinitionRegistry(registry);
    					registryProcessors.add(registryProcessor);
    				}
    				else {
    					regularPostProcessors.add(postProcessor);
    				}
    			}
    
    
    			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
    
    		//获取项目中所有继承BeanDefinitionRegistryPostProcessor的类名
    			String[] postProcessorNames =
    					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    			for (String ppName : postProcessorNames) {
    				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    				//如果匹配则通过类名将类实例化出来,本次加载ConfigurationClassPostProcessor
    					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    					processedBeans.add(ppName);
    				}
    			}
    			sortPostProcessors(currentRegistryProcessors, beanFactory);
    			registryProcessors.addAll(currentRegistryProcessors);
    			//通过ConfigurationClassProcessor后置处理器执行bean初始化注册，锚点1
    			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    			currentRegistryProcessors.clear();
    
    			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
    			//看自己的里面是否有BeanDefinitionRegistryPostProcessor处理，默认空
    			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    			for (String ppName : postProcessorNames) {
    				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
    					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    					processedBeans.add(ppName);
    				}
    			}
    			sortPostProcessors(currentRegistryProcessors, beanFactory);
    			registryProcessors.addAll(currentRegistryProcessors);
    			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    			currentRegistryProcessors.clear();
    
    			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
    			boolean reiterate = true;
    			while (reiterate) {
    				reiterate = false;
    					//看自己的里面是否有BeanDefinitionRegistryPostProcessor处理，默认空
    				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    				for (String ppName : postProcessorNames) {
    					if (!processedBeans.contains(ppName)) {
    						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    						processedBeans.add(ppName);
    						reiterate = true;
    					}
    				}
    				sortPostProcessors(currentRegistryProcessors, beanFactory);
    				registryProcessors.addAll(currentRegistryProcessors);
    				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    				currentRegistryProcessors.clear();
    			}
    
    			//锚点三，
    			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
    			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    		}
    						略
    						略
    		余下代码是spring自己的一些对象的初始化，有兴趣可以跟进

就这个方法进去  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1eGllMTM_size_16_color_FFFFFF_t_70_pic_center 1]  
重点第三个类执行的代码

@Override
    	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    		int factoryId = System.identityHashCode(beanFactory);
    		if (this.factoriesPostProcessed.contains(factoryId)) {
    			throw new IllegalStateException(
    					"postProcessBeanFactory already called on this post-processor against " + beanFactory);
    		}
    		this.factoriesPostProcessed.add(factoryId);
    		if (!this.registriesPostProcessed.contains(factoryId)) {
    			// BeanDefinitionRegistryPostProcessor hook apparently not supported...
    			// Simply call processConfigurationClasses lazily at this point then.
    			processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
    		}
    		//增强ConfigurationClasses，啧啧，增强不就是代理么，就这
    		enhanceConfigurationClasses(beanFactory);
    		beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
    	}

org.springframework.context.annotation.ConfigurationClassPostProcessor\#enhanceConfigurationClasses

public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
    		Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
    		for (String beanName : beanFactory.getBeanDefinitionNames()) {
    			BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
    			//熟悉不熟悉，这个那个key
    			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);
    					}
    				}
    			}
    			//判断这个value是否等于CONFIGURATION_CLASS_FULL，这就说前面给的属性值嘛
    			if (ConfigurationClassUtils.CONFIGURATION_CLASS_FULL.equals(configClassAttr)) {
    				if (!(beanDef instanceof AbstractBeanDefinition)) {
    					throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" +
    							beanName + "' since it is not stored in an AbstractBeanDefinition subclass");
    				}
    				else if (logger.isInfoEnabled() && beanFactory.containsSingleton(beanName)) {
    					logger.info("Cannot enhance @Configuration bean definition '" + beanName +
    							"' since its singleton instance has been created too early. The typical cause " +
    							"is a non-static @Bean method with a BeanDefinitionRegistryPostProcessor " +
    							"return type: Consider declaring such methods as 'static'.");
    				}
    				//符合条件的添加ma'p
    				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();
    			//封装Enhancer 对象，创建CGLIB对象
    			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()));
    				}
    				//将CGLIB对象赋值给BeanDefinition
    				beanDef.setBeanClass(enhancedClass);
    			}
    		}
    	}

结束了，找这个CGLIB生成找了好久，总算搞定

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1eGllMTM_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/61ecbd2a4f63423883a39faa513f80a5.png
[SpringBoot_DefaultListableBeanFactory.beanDefinitionMap]: https://blog.csdn.net/xuxie13/article/details/108790635
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1eGllMTM_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/5750985c0d2b42988cccca96044cd16f.png