521我发誓读完本文，再也不会担心Spring配置类问题了

public class AppConfig {

    @Bean
    public Son son() {
        Son son = new Son();
        System.out.println("son created..." + son.hashCode());
        return son;
    }

    @Bean
    public Parent parent() {
        Son son = son();
        System.out.println("parent created...持有的Son是：" + son.hashCode());
        return new Parent(son);
    }

}

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

    AppConfig appConfig = context.getBean(AppConfig.class);
    System.out.println(appConfig);

    // bean情况
    Son son = context.getBean(Son.class);
    Parent parent = context.getBean(Parent.class);

    System.out.println("容器内的Son实例：" + son.hashCode());
    System.out.println("容器内Person持有的Son实例：" + parent.getSon().hashCode());
    System.out.println(parent.getSon() == son);
}

son created...624271064
son created...564742142
parent created...持有的Son是：564742142
com.yourbatman.fullliteconfig.config.AppConfig@1a38c59b
容器内的Son实例：624271064
容器内Person持有的Son实例：564742142
false

// @Bean
// public Parent parent() {
//     Son son = son();
//     System.out.println("parent created...持有的Son是：" + son.hashCode());
//     return new Parent(son);
// }

@Bean
public Parent parent(Son son){
    System.out.println("parent created...持有的Son是：" + son.hashCode());
    return new Parent(son);
}

son created...624271064
parent created...持有的Son是：624271064
com.yourbatman.fullliteconfig.config.AppConfig@667a738
容器内的Son实例：624271064
容器内Person持有的Son实例：624271064
true

son created...1797712197
parent created...持有的Son是：1797712197
com.yourbatman.fullliteconfig.config.AppConfig$$EnhancerBySpringCGLIB$$8ef51461@be64738
容器内的Son实例：1797712197
容器内Person持有的Son实例：1797712197
true

BeanMethodInterceptor：

@Override
public boolean isMatch(Method candidateMethod) {
	return (candidateMethod.getDeclaringClass() != Object.class &&
			!BeanFactoryAwareMethodInterceptor.isSetBeanFactory(candidateMethod) &&
			BeanAnnotationHelper.isBeanAnnotated(candidateMethod));
}

BeanMethodInterceptor：

// enhancedConfigInstance：被拦截的对象实例，也是代理对象
// beanMethod：parent()方法
// beanMethodArgs：空
// cglibMethodProxy：代理。用于调用其invoke/invokeSuper()来执行对应的方法
@Override
@Nullable
public Object intercept(Object enhancedConfigInstance, 
	Method beanMethod, Object[] beanMethodArgs, MethodProxy cglibMethodProxy) throws Throwable {

	// 通过反射，获取到Bean工厂。也就是$$beanFactory这个属性的值~
	ConfigurableBeanFactory beanFactory = getBeanFactory(enhancedConfigInstance);
	// 拿到Bean的名称
	String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);

	// 判断这个方法是否是Scoped代理对象 很明显本利里是没有标注的 暂先略过
	// 简答的说：parent()方法头上是否标注有@Scoped注解~~~
	if (BeanAnnotationHelper.isScopedProxy(beanMethod)) {
		String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
		if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
			beanName = scopedBeanName;
		}
	}

	// ========下面要处理bean间方法引用的情况了========
	// 首先：检查所请求的Bean是否是FactoryBean。也就是bean名称为`&parent`的Bean是否存在
	// 如果是的话，就创建一个代理子类，拦截它的getObject()方法以返回容器里的实例
	// 这样做保证了方法返回一个FactoryBean和@Bean的语义是效果一样的，确保了不会重复创建多个Bean
	if (factoryContainsBean(beanFactory, BeanFactory.FACTORY_BEAN_PREFIX + beanName) &&
			factoryContainsBean(beanFactory, beanName)) {
		
		// 先得到这个工厂Bean
		Object factoryBean = beanFactory.getBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName);
		if (factoryBean instanceof ScopedProxyFactoryBean) {
			// Scoped proxy factory beans are a special case and should not be further proxied
			// 如果工厂Bean已经是一个Scope代理Bean，则不需要再增强
			// 因为它已经能够满足FactoryBean延迟初始化Bean了~
		}
		
		// 继续增强
		else {
			return enhanceFactoryBean(factoryBean, beanMethod.getReturnType(), beanFactory, beanName);
		}
	}


	// 检查给定的方法是否与当前调用的容器相对应工厂方法。
	// 比较方法名称和参数列表来确定是否是同一个方法
	// 怎么理解这句话，参照下面详解吧
	if (isCurrentlyInvokedFactoryMethod(beanMethod)) {

		// 这是个小细节：若你@Bean返回的是BeanFactoryPostProcessor类型
		// 请你使用static静态方法，否则会打印这句日志的~~~~
		// 因为如果是非静态方法，部分后置处理失效处理不到你，可能对你程序有影像
		// 当然也可能没影响，所以官方也只是建议而已~~~
		if (logger.isInfoEnabled() &&
				BeanFactoryPostProcessor.class.isAssignableFrom(beanMethod.getReturnType())) {
			... // 输出info日志
		}

		// 这表示：当前parent()方法，就是这个被拦截的方法，那就没啥好说的 
		// 相当于在代理代理类里执行了super(xxx);
		// 但是，但是，但是，此时的this依旧是代理类
		return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
	}

	// parent()方法里调用的son()方法会交给这里来执行
	return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);
}

@Configuration
public class AppConfig {

    @Bean
    public Son son() {
        Son son = new Son();
        System.out.println("son created..." + son.hashCode());
        return son;
    }

    @Bean
    public Parent parent() {
        notBeanMethod();
        Son son = son();
        System.out.println("parent created...持有的Son是：" + son.hashCode());
        return new Parent(son);
    }

    public void notBeanMethod(){
        System.out.println("notBeanMethod invoked by 【" + this + "】");
    }

}

son created...347978868
notBeanMethod invoked by 【com.yourbatman.fullliteconfig.config.AppConfig$$EnhancerBySpringCGLIB$$ec611337@12591ac8】
parent created...持有的Son是：347978868
com.yourbatman.fullliteconfig.config.AppConfig$$EnhancerBySpringCGLIB$$ec611337@12591ac8
容器内的Son实例：347978868
容器内Person持有的Son实例：347978868
true

son created...624271064
notBeanMethod invoked by 【com.yourbatman.fullliteconfig.config.AppConfig@21a947fe】
son created...90205195
parent created...持有的Son是：90205195
com.yourbatman.fullliteconfig.config.AppConfig@21a947fe
容器内的Son实例：624271064
容器内Person持有的Son实例：90205195
false

ConfigurationClassEnhancer：

// 创建一个子类代理，拦截对getObject()的调用，委托给当前的BeanFactory
// 而不是创建一个新的实例。这些代理仅在调用FactoryBean时创建
// factoryBean：从容器内拿出来的那个已经存在的工厂Bean实例（是工厂Bean实例）
// exposedType：@Bean标注的方法的返回值类型
private Object enhanceFactoryBean(Object factoryBean, Class<?> exposedType,
		ConfigurableBeanFactory beanFactory, String beanName) {

	try {
		// 看看Spring容器内已经存在的这个工厂Bean的情况，看看是否有final
		Class<?> clazz = factoryBean.getClass();
		boolean finalClass = Modifier.isFinal(clazz.getModifiers());
		boolean finalMethod = Modifier.isFinal(clazz.getMethod("getObject").getModifiers());
		
		// 类和方法其中有一个是final，那就只能看看能不能走接口代理喽
		if (finalClass || finalMethod) {
			// @Bean标注的方法返回值若是接口类型 尝试走基于接口的JDK动态代理
			if (exposedType.isInterface()) {
				// 基于JDK的动态代理
				return createInterfaceProxyForFactoryBean(factoryBean, exposedType, beanFactory, beanName);
			} else {
				// 类或方法存在final情况，但是呢返回类型又不是
				return factoryBean;
			}
		}
	}
	catch (NoSuchMethodException ex) {
		// 没有getObject()方法  很明显，一般不会走到这里
	}
	
	// 到这，说明以上条件不满足：存在final且还不是接口类型
	// 类和方法都不是final，生成一个CGLIB的动态代理
	return createCglibProxyForFactoryBean(factoryBean, beanFactory, beanName);
}

public class SonFactoryBean implements FactoryBean<Son> {
    @Override
    public Son getObject() throws Exception {
        return new Son();
    }

    @Override
    public Class<?> getObjectType() {
        return Son.class;
    }
}

@Configuration
public class AppConfig {

    @Bean
    public FactoryBean<Son> son() {
        SonFactoryBean sonFactoryBean = new SonFactoryBean();
        System.out.println("我使用@Bean定义sonFactoryBean：" + sonFactoryBean.hashCode());
        System.out.println("我使用@Bean定义sonFactoryBean identityHashCode：" + System.identityHashCode(sonFactoryBean));
        return sonFactoryBean;
    }

    @Bean
    public Parent parent(Son son) throws Exception {
        // 根据前面所学，sonFactoryBean肯定是去容器拿
        FactoryBean<Son> sonFactoryBean = son();
        System.out.println("parent流程使用的sonFactoryBean：" + sonFactoryBean.hashCode());
        System.out.println("parent流程使用的sonFactoryBean identityHashCode：" + System.identityHashCode(sonFactoryBean));
        System.out.println("parent流程使用的sonFactoryBean：" + sonFactoryBean.getClass());
        // 虽然sonFactoryBean是从容器拿的，但是getObject()你可不能保证每次都返回单例哦~
        Son sonFromFactory1 = sonFactoryBean.getObject();
        Son sonFromFactory2 = sonFactoryBean.getObject();
        System.out.println("parent流程使用的sonFromFactory1：" + sonFromFactory1.hashCode());
        System.out.println("parent流程使用的sonFromFactory1：" + sonFromFactory2.hashCode());
        System.out.println("parent流程使用的son和容器内的son是否相等：" + (son == sonFromFactory1));

        return new Parent(sonFromFactory1);
    }

}

@Bean
public static void main(String[] args) {
    ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

    SonFactoryBean sonFactoryBean = context.getBean("&son", SonFactoryBean.class);
    System.out.println("Spring容器内的SonFactoryBean：" + sonFactoryBean.hashCode());
    System.out.println("Spring容器内的SonFactoryBean：" + System.identityHashCode(sonFactoryBean));
    System.out.println("Spring容器内的SonFactoryBean：" + sonFactoryBean.getClass());

    System.out.println("Spring容器内的Son：" + context.getBean("son").hashCode());
}

我使用@Bean定义sonFactoryBean：313540687
我使用@Bean定义sonFactoryBean identityHashCode：313540687

parent流程使用的sonFactoryBean：313540687
parent流程使用的sonFactoryBean identityHashCode：70807318
parent流程使用的sonFactoryBean：class com.yourbatman.fullliteconfig.config.SonFactoryBean$$EnhancerBySpringCGLIB$$1ccec41d
parent流程使用的sonFromFactory1：910091170
parent流程使用的sonFromFactory1：910091170
parent流程使用的son和容器内的son是否相等：true

Spring容器内的SonFactoryBean：313540687
Spring容器内的SonFactoryBean：313540687
Spring容器内的SonFactoryBean：class com.yourbatman.fullliteconfig.config.SonFactoryBean
Spring容器内的Son：910091170

// 这两种方式向容器扔bd or singleton bean都行  我就选择第二种喽
// 注意：此处放进去的是BeanFactory工厂，名称是son哦~~~  不要写成了&son
@Component
public class SonBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // registry.registerBeanDefinition("son", BeanDefinitionBuilder.rootBeanDefinition(SonFactoryBean.class).getBeanDefinition());
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        SonFactoryBean sonFactoryBean = new SonFactoryBean();
        System.out.println("初始化时，注册进容器的sonFactoryBean：" + sonFactoryBean);
        beanFactory.registerSingleton("son", sonFactoryBean);
    }
}

初始化时最早进容器的sonFactoryBean：2027775614
初始化时最早进容器的sonFactoryBean identityHashCode：2027775614

parent流程使用的sonFactoryBean：2027775614
parent流程使用的sonFactoryBean identityHashCode：1183888521
parent流程使用的sonFactoryBean：class com.yourbatman.fullliteconfig.config.SonFactoryBean$$EnhancerBySpringCGLIB$$1ccec41d
parent流程使用的sonFromFactory1：2041605291
parent流程使用的sonFromFactory1：2041605291
parent流程使用的son和容器内的son是否相等：true

Spring容器内的SonFactoryBean：2027775614
Spring容器内的SonFactoryBean：2027775614
Spring容器内的SonFactoryBean：class com.yourbatman.fullliteconfig.config.SonFactoryBean
Spring容器内的Son：2041605291

我使用@Bean定义sonFactoryBean：477289012
我使用@Bean定义sonFactoryBean identityHashCode：477289012

我使用@Bean定义sonFactoryBean：2008966511
我使用@Bean定义sonFactoryBean identityHashCode：2008966511
parent流程使用的sonFactoryBean：2008966511
parent流程使用的sonFactoryBean identityHashCode：2008966511
parent流程使用的sonFactoryBean：class com.yourbatman.fullliteconfig.config.SonFactoryBean
parent流程使用的sonFromFactory1：433874882
parent流程使用的sonFromFactory1：572191680
parent流程使用的son和容器内的son是否相等：false

Spring容器内的SonFactoryBean：477289012
Spring容器内的SonFactoryBean：477289012
Spring容器内的SonFactoryBean：class com.yourbatman.fullliteconfig.config.SonFactoryBean
Spring容器内的Son：211968962