【源码分析】@Configuration源码分析2

谁借莪１个温暖的怀抱￠ 2023-10-08 17:36 31阅读 0赞

[@Configuration源码分析1][Configuration_1]

[@Configuration源码分析2][Configuration_2]

**使用版本：5.3.22**

## 1.注册ConfigurationClassPostProcessor流程源码解析 ##

下面开始搞@Configuration注解涉及到的ConfigurationClassPostProcessor核心类的注册流程的源码执行过程。

### 1.启动类ConfigurationDemo的main()方法 ###

在main()方法中会调用AnnotationConfigApplicationContext类的构造方法传入配置类ConfigurationAnnotationConfig的Class对象来创建IOC容器。

public static void main(String[] args) {
        
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConfigurationAnnotationConfig.class);
        }

### 2.解析AnnotationConfigApplicationContext类的AnnotationConfigApplicationContext(Class<?>… componentClasses)构造方法 ###

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
        
    		this();
    		register(componentClasses);
    		refresh();
    	}

在上述构造方法中，会通过this()调用AnnotationConfigApplicationContext类的无参构造方法。

### 3.解析AnnotationConfigApplicationContext类的AnnotationConfigApplicationContext()无参构造方法 ###

public AnnotationConfigApplicationContext() {
        
    		StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
    		//表示注解类型的Bean定义信息读取器，主要就是读取通过注解方式进行实例化的Bean的定义信息。
    		this.reader = new AnnotatedBeanDefinitionReader(this);
    		createAnnotatedBeanDefReader.end();
    		//表示类路径下的Bean定义扫描器，主要就是扫描类路径下的Bean定义信息。
    		this.scanner = new ClassPathBeanDefinitionScanner(this);
    	}

在AnnotationConfigApplicationContext类的无参构造方法中，主要的逻辑就是实例化了AnnotatedBeanDefinitionReader类型的reader成员变量和ClassPathBeanDefinitionScanner类型的scanner成员变量。

@Configuration注解涉及到的注册流程源码的执行过程，会执行实例化reader成员变量的代码.

this.scanner = new ClassPathBeanDefinitionScanner(this);

下面在调用：

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
        
    	this(registry, getOrCreateEnvironment(registry));
    }

在上述构造方法中，通过this调用了AnnotatedBeanDefinitionReader类的AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment)构造方法。

### 4.解析 AnnotatedBeanDefinitionReader\#AnnotatedBeanDefinitionReader ###

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
        
    		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    		Assert.notNull(environment, "Environment must not be null");
    		this.registry = registry;
    		this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    	}

在上述构造方法中，最核心的逻辑就是调用了AnnotationConfigUtils工具类的registerAnnotationConfigProcessors()方法，将BeanDefinitionRegistry类型的registry对象传入方法中。

registry对象本质上就是一个AnnotationConfigApplicationContext类对象的实例，这是因为AnnotationConfigApplicationContext类继承了GenericApplicationContext类，而GenericApplicationContext类实现了BeanDefinitionRegistry接口。

如下：

public class AnnotationConfigApplicationContext extends GenericApplicationContext {
        }

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
        }

### 5.解析AnnotationConfigUtils\# registerAnnotationConfigProcessors ###

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
        
    		registerAnnotationConfigProcessors(registry, null);
    	}

在AnnotationConfigUtils类的registerAnnotationConfigProcessors(BeanDefinitionRegistry registry)方法中调用了AnnotationConfigUtils类中的另外一个registerAnnotationConfigProcessors()方法。

**再往下看 registerAnnotationConfigProcessors()方法**

此方法主要是将@Configuration注解涉及到的ConfigurationClassPostProcessor类的Bean定义信息注册到IOC容器中的核心代码。

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
    			BeanDefinitionRegistry registry, @Nullable Object source) {
        
    
    		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    		if (beanFactory != null) {
        
    			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
        
    				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
    			}
    			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
        
    				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
    			}
    		}
    
    		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
    		// 会调用registerPostProcessor()方法注册后置处理器。
    		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);
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    		}
    
    		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
    		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        
    			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
    			def.setSource(source);
    			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    		}
    
    		// 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;
    	}

这里会调用registerPostProcessor()方法注册后置处理器。

// 会调用registerPostProcessor()方法注册后置处理器。
    		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));
    		}

### 6.解析registerPostProcessor方法 ###

private static BeanDefinitionHolder registerPostProcessor(
    			BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
        
    
    		definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    		registry.registerBeanDefinition(beanName, definition);
    		return new BeanDefinitionHolder(definition, beanName);
    	}

代码主要是，调用了registry参数的registerBeanDefinition()方法来注册ConfigurationClassPostProcessor类的Bean定义信息，definition参数本质上就是一个AnnotationConfigApplicationContext类的实例对象。  
最终会调用DefaultListableBeanFactory类的registerBeanDefinition()方法来注册ConfigurationClassPostProcessor类的Bean定义信息。

### 7.解析DefaultListableBeanFactory\#registerBeanDefinition方法 ###

@Override
    	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    			throws BeanDefinitionStoreException {
        
    			this.beanDefinitionMap.put(beanName, beanDefinition);
    			}

主要看这一行代码，Spring的IOC容器中注册类的Bean定义信息，其实就是向beanDefinitionMap对象中添加元素，beanDefinitionMap对象本质上是一个ConcurrentHashMap对象。向beanDefinitionMap对象中添加的元素的Key为Bean的名称，Value为Bean的定义信息。

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

到这@Configuration注解涉及到的ConfigurationClassPostProcessor类的注册过程分析完成了，可以多看几遍理解就好，记住谁也记不住。

## 2.注册ConfigurationAnnotationConfig 源码解析 ##

启动Spring IOC容器时，向IOC容器中注册ConfigurationAnnotationConfig类的Bean定义信息的源码。

### 1.启动类ConfigurationDemo的main()方法 ###

在main()方法中会调用AnnotationConfigApplicationContext类的构造方法传入配置类ConfigurationAnnotationConfig的Class对象来创建IOC容器。

public static void main(String[] args) {
        
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConfigurationAnnotationConfig.class);
        }

### 2.解析AnnotationConfigApplicationContext类的AnnotationConfigApplicationContext(Class<?>… componentClasses)构造方法 ###

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
        
    		this();
    		register(componentClasses);
    		refresh();
    	}

在register(Class<?>… componentClasses)方法中调用了reader的register()方法。

@Override
    	public void register(Class<?>... componentClasses) {
        
    		Assert.notEmpty(componentClasses, "At least one component class must be specified");
    		StartupStep registerComponentClass = this.getApplicationStartup().start("spring.context.component-classes.register")
    				.tag("classes", () -> Arrays.toString(componentClasses));
    		this.reader.register(componentClasses);
    		registerComponentClass.end();
    	}

### 3.解析AnnotatedBeanDefinitionReader \# register ###

public void register(Class<?>... componentClasses) {
        
    		for (Class<?> componentClass : componentClasses) {
        
    			registerBean(componentClass);
    		}
    	}

循环遍历传入的可变参数componentClasses，每次循环时，都会调用registerBean()方法。

### 4.解析AnnotatedBeanDefinitionReader\# doRegisterBean ###

public void registerBean(Class<?> beanClass) {
        
    		doRegisterBean(beanClass, null, null, null, null);
    	}

主要部分会用注释备注：

// 从给定的bean类注册bean，从类声明的注释派生其元数据。
    	private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
    			@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
    			@Nullable BeanDefinitionCustomizer[] customizers) {
        
    
    		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
    		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
        
    			return;
    		}
    
    		abd.setInstanceSupplier(supplier);
    		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
    		abd.setScope(scopeMetadata.getScopeName());
    		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    
    		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
    		if (qualifiers != null) {
        
    			for (Class<? extends Annotation> qualifier : qualifiers) {
        
    				if (Primary.class == qualifier) {
        
    					abd.setPrimary(true);
    				}
    				else if (Lazy.class == qualifier) {
        
    					abd.setLazyInit(true);
    				}
    				else {
        
    					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
    				}
    			}
    		}
    		if (customizers != null) {
        
    			for (BeanDefinitionCustomizer customizer : customizers) {
        
    				customizer.customize(abd);
    			}
    		}
    
    		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    		//主要看这个
    		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    	}

可以看到调用了BeanDefinitionReaderUtils.registerBeanDefinition()

### 5.解析BeanDefinitionReaderUtils.registerBeanDefinition ###

public static void registerBeanDefinition(
    			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
    			throws BeanDefinitionStoreException {
        
    
    		// Register bean definition under primary name.
    		String beanName = definitionHolder.getBeanName();
    		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
    
    		// Register aliases for bean name, if any.
    		String[] aliases = definitionHolder.getAliases();
    		if (aliases != null) {
        
    			for (String alias : aliases) {
        
    				registry.registerAlias(beanName, alias);
    			}
    		}
    	}

在registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)方法中通过调用registry的registerBeanDefinition()方法来向IOC容器中注册Bean定义信息。

**到这里后面 registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());就跟上面的第7部分一样了，主要就是Spring的IOC容器中注册类的Bean定义信息。**

## 3.实例化流程源码解析 ##

Spring IOC容器在刷新时，会实例化使用@Configuration注解标注的类

### 1.启动类ConfigurationDemo的main()方法 ###

在main()方法中会调用AnnotationConfigApplicationContext类的构造方法传入配置类ConfigurationAnnotationConfig的Class对象来创建IOC容器。

public static void main(String[] args) {
        
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConfigurationAnnotationConfig.class);
        }

### 2.解析AnnotationConfigApplicationContext类的AnnotationConfigApplicationContext(Class<?>… componentClasses)构造方法 ###

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
        
    		this();
    		register(componentClasses);
    		refresh();
    	}

**在register(Class<?>… componentClasses)方法中调用了reader的 refresh() 方法刷新IOC容器。**

### 3.解析AbstractApplicationContext类的refresh()方法 ###

@Override
    public void refresh() throws BeansException, IllegalStateException {
        
    		    // 在上下文中调用注册为bean的工厂处理器。
    			invokeBeanFactoryPostProcessors(beanFactory);
    }

### 4.解析AbstractApplicationContext\#invokeBeanFactoryPostProcessors ###

在invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory)方法中调用了PostProcessorRegistrationDelegate类的invokeBeanFactoryPostProcessors()方法。

//实例化并调用所有注册的BeanFactoryPostProcessor bean
    	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        
    		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
     		...
    		}
    	}

### 5.解析PostProcessorRegistrationDelegate \# invokeBeanFactoryPostProcessors ###

public static void invokeBeanFactoryPostProcessors(
    			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        
    			// 核心代码 这里，主要关注的是标注了@Configuration注解的类的实例化过程，所以，只需要关注invokeBeanFactoryPostProcessors()
    			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
    			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    
    }

在invokeBeanFactoryPostProcessors()方法中会解析标注了@Configuration注解的类中标注了@Bean等注解的方法，生成相应的Bean定义信息注册到IOC容器中。

### 6. 解析PostProcessorRegistrationDelegate \# invokeBeanFactoryPostProcessors （内部方法） ###

private static void invokeBeanFactoryPostProcessors(
    			Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
        
    
    		for (BeanFactoryPostProcessor postProcessor : postProcessors) {
        
    			StartupStep postProcessBeanFactory = beanFactory.getApplicationStartup().start("spring.context.bean-factory.post-process")
    					.tag("postProcessor", postProcessor::toString);
    			postProcessor.postProcessBeanFactory(beanFactory);
    			postProcessBeanFactory.end();
    		}
    	}

在invokeBeanFactoryPostProcessors()方法中，会循环遍历传递进来的所有postProcessors集合，每次循环时，都会使用一个postProcessor对象来接收postProcessors集合中的每一个元素，调用postProcessor对象的postProcessBeanFactory()方法，并传入beanFactory来实例化对象。

### 7.解析ConfigurationClassPostProcessor类中的postProcessBeanFactory ###

@Override
    //通过用CGLIB增强的子类替换Configuration类，准备在运行时为bean请求提供服务的Configuration类。
    	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);
    		}
    		// 核心方法
    		enhanceConfigurationClasses(beanFactory);
    		beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
    	}

再看enhanceConfigurationClasses()方法

### 8.ConfigurationClassPostProcessor \# enhanceConfigurationClasses()方法 ###

public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
        
     
    		ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
    		for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
        
    			AbstractBeanDefinition beanDef = entry.getValue();
    			beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
    			Class<?> configClass = beanDef.getBeanClass();
    			// 核心代码
    			Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
    			if (configClass != enhancedClass) {
        
    				if (logger.isTraceEnabled()) {
        
    					logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " +
    							"enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
    				}
    				beanDef.setBeanClass(enhancedClass);
    			}
    		}
    		enhanceConfigClasses.tag("classCount", () -> String.valueOf(configBeanDefs.keySet().size())).end();
    	}

在enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory)方法中，主要是使用**ConfigurationClassEnhancer**对象的enhance()方法生成代理类，也就是使用CGLib生成代理类。

### 9.解析ConfigurationClassEnhancer \# enhance ###

public Class<?> enhance(Class<?> configClass, @Nullable ClassLoader classLoader) {
        
    		if (EnhancedConfiguration.class.isAssignableFrom(configClass)) {
        
    			if (logger.isDebugEnabled()) {
        
    			}
    			return configClass;
    		}
    		// 核心代码
    		Class<?> enhancedClass = createClass(newEnhancer(configClass, classLoader));
    		if (logger.isTraceEnabled()) {
        
    			logger.trace(String.format("Successfully enhanced %s; enhanced class name is: %s",
    					configClass.getName(), enhancedClass.getName()));
    		}
    		return enhancedClass;
    	}

可以看到在方法中调用了createClass()方法创建代理类，在这之前先调用newEnhancer()方法实例化Enhancer对象。

### 10.解析ConfigurationClassEnhancer \# newEnhancer ###

private Enhancer newEnhancer(Class<?> configSuperClass, @Nullable ClassLoader classLoader) {
        
    		Enhancer enhancer = new Enhancer();
    		enhancer.setSuperclass(configSuperClass);
    		enhancer.setInterfaces(new Class<?>[] {
        EnhancedConfiguration.class});
    		enhancer.setUseFactory(false);
    		enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
    		enhancer.setStrategy(new BeanFactoryAwareGeneratorStrategy(classLoader));
    		enhancer.setCallbackFilter(CALLBACK_FILTER);
    		enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
    		return enhancer;
    	}

创建一个新的CGLIB Enhancer实例后续会使用Enhancer对象生成代理类。

在newEnhancer()方法中为要生成的代理类设置了父类和接口，由于为要生成的代理类设置的接口为EnhancedConfiguration，同时，EnhancedConfiguration接口继承了BeanFactoryAware接口，所以，在后续生成的代理类中可以调用BeanFactoryAware接口的setBeanFactory(BeanFactory beanFactory)方法获取到beanFactory对象。

### 11.解析ConfigurationClassEnhancer\#createClass ###

private Class<?> createClass(Enhancer enhancer) {
        
    		Class<?> subclass = enhancer.createClass();
    		// Registering callbacks statically (as opposed to thread-local)
    		// is critical for usage in an OSGi environment (SPR-5932)...
    		Enhancer.registerStaticCallbacks(subclass, CALLBACKS);
    		return subclass;
    	}

在createClass(Enhancer enhancer)方法中，主要调用了enhancer对象的createClass()方法来创建代理类，因为使用CGLib创建出来的代理类是目标类的子类，所以，这里创建出来的代理类就是目标类的子类。

### 12.解析CALLBACKS ###

private static final Callback[] CALLBACKS = new Callback[] {
        
    			new BeanMethodInterceptor(),
    			new BeanFactoryAwareMethodInterceptor(),
    			NoOp.INSTANCE
    	};

CALLBACKS是一个Callback类型的数组，数组中的每个元素都是一个Callback类型的对象。

BeanMethodInterceptor类和BeanFactoryAwareMethodInterceptor类也是拦截器类型，是两个内部类。

### 13.解析BeanMethodInterceptor类 ###

BeanMethodInterceptor实现了MethodInterceptor接口和ConditionalCallback接口，主要的作用就是对标注了@Bean的注解的方法进行拦截。

执行intercept(Object enhancedConfigInstance, Method beanMethod, Object\[\] beanMethodArgs, MethodProxy cglibMethodProxy)方法，生成Bean的实例对象。

public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs,
    					MethodProxy cglibMethodProxy) throws Throwable {
        
      			//如果已经创建了Bean的代理实例对象，则调用父类的方法。
    			if (isCurrentlyInvokedFactoryMethod(beanMethod)) {
        
    				// The factory is calling the bean method in order to instantiate and register the bean
    				// (i.e. via a getBean() call) -> invoke the super implementation of the method to actually
    				// create the bean instance.
    				if (logger.isInfoEnabled() &&
    						BeanFactoryPostProcessor.class.isAssignableFrom(beanMethod.getReturnType())) {
        
    			 
    				return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
    			}
    
    			return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);
    		}

上述代码能够保证在类上添加@Configuration注解后，只会为类生成一个代理对象。也就是说，上述代码的逻辑能够保证标注了@Configuration注解的类生成的代理类是单例模式的。

因为使用CGLib创建出来的代理类是目标类的子类，所以第一次执行上述代码片段时，会调用cglibMethodProxy的invokeSuper()方法执行父类的方法，也就是执行目标类的方法。第二次执行上述代码片段时，会调用resolveBeanReference()方法。

#### resolveBeanReference() ####

private Object resolveBeanReference(Method beanMethod, Object[] beanMethodArgs,
    				ConfigurableBeanFactory beanFactory, String beanName) {
        
     			// 确定指定的bean当前是否正在创建中。
    			boolean alreadyInCreation = beanFactory.isCurrentlyInCreation(beanName);
    			try {
        
    				if (alreadyInCreation) {
        
    					beanFactory.setCurrentlyInCreation(beanName, false);
    				}
    				boolean useArgs = !ObjectUtils.isEmpty(beanMethodArgs);
    				if (useArgs && beanFactory.isSingleton(beanName)) {
        
    					for (Object arg : beanMethodArgs) {
        
    						if (arg == null) {
        
    							useArgs = false;
    							break;
    						}
    					}
    				}
    				//通过beanFactory获取已经初始化好的Bean对象，并将这个已经初始化好的bean对象返回,并不会再进行第二次初始化的操作。
    				Object beanInstance = (useArgs ? beanFactory.getBean(beanName, beanMethodArgs) :
    						beanFactory.getBean(beanName));
    				if (!ClassUtils.isAssignableValue(beanMethod.getReturnType(), beanInstance)) {
        
    					if (beanInstance.equals(null)) {
        
    						beanInstance = null;
    					}
    					else {
        
    						String msg = String.format("@Bean method %s.%s called as bean reference " +
    								"for type [%s] but overridden by non-compatible bean instance of type [%s].",
    								beanMethod.getDeclaringClass().getSimpleName(), beanMethod.getName(),
    								beanMethod.getReturnType().getName(), beanInstance.getClass().getName());
    						try {
        
    							BeanDefinition beanDefinition = beanFactory.getMergedBeanDefinition(beanName);
    							msg += " Overriding bean of same name declared in: " + beanDefinition.getResourceDescription();
    						}
    						catch (NoSuchBeanDefinitionException ex) {
        
    							// Ignore - simply no detailed message then.
    						}
    						throw new IllegalStateException(msg);
    					}
    				}
    				Method currentlyInvoked = SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod();
    				if (currentlyInvoked != null) {
        
    					String outerBeanName = BeanAnnotationHelper.determineBeanNameFor(currentlyInvoked);
    					beanFactory.registerDependentBean(beanName, outerBeanName);
    				}
    				return beanInstance;
    			}
    			finally {
        
    				if (alreadyInCreation) {
        
    					beanFactory.setCurrentlyInCreation(beanName, true);
    				}
    			}
    		}

所以上面代码作用是，在类上添加@Configuration注解后，Spring能够保证为类生成的代理类是单例的。最后把beanInstance 返回出去。

终于梳理了一遍一遍学习一遍进步加油~

[Configuration_1]: https://blog.csdn.net/daohangtaiqian/article/details/128893856?csdn_share_tail=%7B%22type%22:%22blog%22,%22rType%22:%22article%22,%22rId%22:%22128893856%22,%22source%22:%22daohangtaiqian%22%7D
[Configuration_2]: https://blog.csdn.net/daohangtaiqian/article/details/128994089?csdn_share_tail=%7B%22type%22:%22blog%22,%22rType%22:%22article%22,%22rId%22:%22128994089%22,%22source%22:%22daohangtaiqian%22%7D