@ComponentScan("com.dmz.source.code")
//@Configuration
public class Config{
	@Bean
	public A a(){
	return new A(dmzService());
	}

	@Bean
	public DmzService dmzService(){
		return new DmzService();
	}
}

public class A {
	public A(DmzService dmzService){
		System.out.println("create A by dmzService");
	}
}

@Component
public class DmzService {
	public DmzService(){
		System.out.println("create dmzService");
	}
}

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  int factoryId = System.identityHashCode(beanFactory);
  // 防止重復(fù)處理
  if (this.factoriesPostProcessed.contains(factoryId)) {
    throw new IllegalStateException(
      "postProcessBeanFactory already called on this post-processor against " + beanFactory);
  }
  this.factoriesPostProcessed.add(factoryId);
  // 在執(zhí)行postProcessBeanDefinitionRegistry方法的時(shí)就已經(jīng)將這個(gè)id添加到registriesPostProcessed集合中了
  if (!this.registriesPostProcessed.contains(factoryId)) {
    processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
  }
	// 看起來(lái)這個(gè)方法就是完成了代理
  enhanceConfigurationClasses(beanFactory);
  // 添加了一個(gè)后置處理器
  beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}

public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {		// map中放置的是所有需要被代理的類
		Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
		for (String beanName : beanFactory.getBeanDefinitionNames()) {
			BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
			if (ConfigurationClassUtils.isFullConfigurationClass(beanDef)) {
				// 省略異常跟日志代碼....
        // 這個(gè)代碼的含義就是如果是一個(gè)被@Configuration注解標(biāo)注的類,那么將其放入到configBeanDefs這個(gè)集合中
				configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
			}
		}
    
		if (configBeanDefs.isEmpty()) {
			// nothing to enhance -> return immediately
			return;
		}
		
    // 對(duì)配置類進(jìn)行代理的核心類
		ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
		for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
			AbstractBeanDefinition beanDef = entry.getValue();
			// 對(duì)于配置類永遠(yuǎn)使用cglib代理
			beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
			try {
				// cglib代理是基于類實(shí)現(xiàn)的,所以在這之前要明確代理的類是什么
				Class<?> configClass = beanDef.resolveBeanClass(this.beanClassLoader);
				if (configClass != null) {
          // 通過ConfigurationClassEnhancer獲取到一個(gè)經(jīng)過代理的class
					Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
         // 省略日志....
          
          // 將原有的配置類的bd中的beanClass屬性替換成代理后的class
						beanDef.setBeanClass(enhancedClass);
					}
				}
			}
			catch (Throwable ex) {
				throw new IllegalStateException("Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
			}
		}
	}

public class Target{
  public void f(){
    System.out.println("Target f()");
  }
  public void g(){
    System.out.println("Target g()");
  }
}

public class Interceptor implements MethodInterceptor {
  @Override
  public Object intercept(Object obj, Method method, Object[] args,  MethodProxy proxy) throws Throwable {
    System.out.println("I am intercept begin");
//Note: 此處一定要使用proxy的invokeSuper方法來(lái)調(diào)用目標(biāo)類的方法
    proxy.invokeSuper(obj, args);
    System.out.println("I am intercept end");
    return null;
  }
}

public class Test {
  public static void main(String[] args) {
    // 設(shè)置這個(gè)屬性，將代理類的字節(jié)碼文件生成到F盤的code目錄下
  System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "F:\\code");
    //實(shí)例化一個(gè)增強(qiáng)器，也就是cglib中的一個(gè)class generator
    Enhancer eh = new Enhancer();
    //設(shè)置目標(biāo)類
    eh.setSuperclass(Target.class);
    // 設(shè)置攔截對(duì)象
    eh.setCallback(new Interceptor());
    // 生成代理類并返回一個(gè)實(shí)例
    Target t = (Target) eh.create();
    t.f();
    t.g();
  }
}

// 省略多余的方法，我們就關(guān)注g方法
public class Target$$EnhancerByCGLIB$$788444a0 extends Target implements Factory
{
  
  final void CGLIB$g$0()
  {
   super.g();
  }
  
  // 經(jīng)過代理過的g方法
  public final void g()
  {
  
  // 查看是否有攔截器存在
   MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
   if (tmp4_1 == null)
   {
     CGLIB$BIND_CALLBACKS(this);
     tmp4_1 = this.CGLIB$CALLBACK_0;
   }
   
   // 如果有攔截器的存在的話，直接調(diào)用攔截器的方法
   if (this.CGLIB$CALLBACK_0 != null) {
     tmp4_1.intercept(this, CGLIB$g$0$Method, CGLIB$emptyArgs, CGLIB$g$0$Proxy);
   }
   
   // 如果沒有攔截器，說明不需要代理，直接調(diào)用父類方法，也就是目標(biāo)類的方法
   else{
     super.g();
   }
  }
}

public class Main {
	public static void main(String[] args) {
		System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "F:\\code");
		//實(shí)例化一個(gè)增強(qiáng)器，也就是cglib中的一個(gè)class generator
		Enhancer eh = new Enhancer();
		//設(shè)置目標(biāo)類
		eh.setSuperclass(Target.class);
		// 設(shè)置攔截對(duì)象
		eh.setCallbacks(new Callback[]{new Interceptor(), NoOp.INSTANCE});
		eh.setCallbackFilter(new CallbackFilter() {
			@Override
			public int accept(Method method) {
				if(method.getName().equals("g"))
       // 這里返回的是上面定義的callback數(shù)組的下標(biāo)，0就是我們的Interceptor對(duì)象，1是內(nèi)置的NoOp對(duì)象，代表不做任何操作
				return 0;
				else return 1;
			}
		});
		// 生成代理類并返回一個(gè)實(shí)例
		Target t = (Target) eh.create();
		t.f();
		t.g();
	}
}

public Class<?> enhance(Class<?> configClass, @Nullable ClassLoader classLoader) {
  // 如果已經(jīng)實(shí)現(xiàn)了EnhancedConfiguration接口，說明被代理過了，直接返回
  if (EnhancedConfiguration.class.isAssignableFrom(configClass)) {
    return configClass;
  }
  // 否則調(diào)用newEnhancer方法先創(chuàng)建一個(gè)增強(qiáng)器，然后直接使用這個(gè)增強(qiáng)器生成代理類的字節(jié)碼對(duì)象
  Class<?> enhancedClass = createClass(newEnhancer(configClass, classLoader));
  if (logger.isDebugEnabled()) {
    logger.debug(String.format("Successfully enhanced %s; enhanced class name is: %s",
                 configClass.getName(), enhancedClass.getName()));
  }
  return enhancedClass;
}

private Enhancer newEnhancer(Class<?> configSuperClass, @Nullable ClassLoader classLoader) {
  Enhancer enhancer = new Enhancer();
  // 設(shè)置目標(biāo)類
  enhancer.setSuperclass(configSuperClass);
  // 讓代理類實(shí)現(xiàn)EnhancedConfiguration接口，這個(gè)接口繼承了BeanFactoryAware接口
  // 主要兩個(gè)作用：1.起到標(biāo)記作用，如果實(shí)現(xiàn)了，代表已經(jīng)被代理過了
  // 2.代理類需要訪問BeanFactory，所有實(shí)現(xiàn)了BeanFactoryAware接口
  enhancer.setInterfaces(new Class<?>[] {EnhancedConfiguration.class});
  // 設(shè)置生成的代理類不實(shí)現(xiàn)factory接口
  enhancer.setUseFactory(false);
  // 設(shè)置代理類名稱的生成策略
  enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
  // 代理類中引入一個(gè)BeanFactory字段
  enhancer.setStrategy(new BeanFactoryAwareGeneratorStrategy(classLoader));
  // 設(shè)置過濾器，CALLBACK_FILTER中也同時(shí)設(shè)置了攔截器
  enhancer.setCallbackFilter(CALLBACK_FILTER);
  enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
  return enhancer;
}

// 使用增強(qiáng)器生成代理類的字節(jié)碼對(duì)象
private Class<?> createClass(Enhancer enhancer) {
  Class<?> subclass = enhancer.createClass();
  Enhancer.registerStaticCallbacks(subclass, CALLBACKS);
  return subclass;
}

// 聲明的三個(gè)攔截器
private static final Callback[] CALLBACKS = new Callback[] {
  new BeanMethodInterceptor(),
  new BeanFactoryAwareMethodInterceptor(),
  NoOp.INSTANCE
};

private static class BeanFactoryAwareMethodInterceptor implements MethodInterceptor, ConditionalCallback {

		@Override
		@Nullable
		public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
			// 在生成代理類的字節(jié)碼時(shí)，使用了BeanFactoryAwareGeneratorStrategy策略
			// 這個(gè)策略會(huì)在代理類中添加一個(gè)字段，BEAN_FACTORY_FIELD = "$$beanFactory"
			Field field = ReflectionUtils.findField(obj.getClass(), BEAN_FACTORY_FIELD);
			Assert.state(field != null, "Unable to find generated BeanFactory field");
			// 此時(shí)調(diào)用的方法是setBeanFactory方法，
			// 直接通過反射將beanFactory賦值給BEAN_FACTORY_FIELD字段
			field.set(obj, args[0]);

			// Does the actual (non-CGLIB) superclass implement BeanFactoryAware?
			// If so, call its setBeanFactory() method. If not, just exit.
			// 如果目標(biāo)配置類直接實(shí)現(xiàn)了BeanFactoryAware接口，那么直接調(diào)用目標(biāo)類的setBeanFactory方法
			if (BeanFactoryAware.class.isAssignableFrom(ClassUtils.getUserClass(obj.getClass().getSuperclass()))) {
				return proxy.invokeSuper(obj, args);
			}
			return null;
		}

		@Override
		// 在調(diào)用setBeanFactory方法時(shí)才會(huì)攔截
		// 從前文我們知道，代理類是實(shí)現(xiàn)了實(shí)現(xiàn)EnhancedConfiguration接口的，
		// 這就意味著它也實(shí)現(xiàn)了BeanFactoryAware接口，那么在創(chuàng)建配置類時(shí)，
		// setBeanFactory方法就會(huì)被調(diào)用，之后會(huì)就進(jìn)入到這個(gè)攔截器的intercept方法邏輯中
		public boolean isMatch(Method candidateMethod) {
			return isSetBeanFactory(candidateMethod);
		}

		public static boolean isSetBeanFactory(Method candidateMethod) {
			return (candidateMethod.getName().equals("setBeanFactory") &&
					candidateMethod.getParameterCount() == 1 &&
					BeanFactory.class == candidateMethod.getParameterTypes()[0] &&
					BeanFactoryAware.class.isAssignableFrom(candidateMethod.getDeclaringClass()));
		}
	}

public boolean isMatch(Method candidateMethod) {
  // 第一個(gè)條件，不能是Object，這個(gè)必定是滿足的
  // 第二個(gè)條件，不能是setBeanFactory方法，顯而易見的嘛，我們要攔截的方法實(shí)際只應(yīng)該是添加了@Bean注解的方法
  // 第三個(gè)條件，添加了@Bean注解
  return (candidateMethod.getDeclaringClass() != Object.class &&
      !BeanFactoryAwareMethodInterceptor.isSetBeanFactory(candidateMethod) &&
      BeanAnnotationHelper.isBeanAnnotated(candidateMethod));
}

public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs,
								MethodProxy cglibMethodProxy) throws Throwable {
			// 之前不是給BEAN_FACTORY_FIELD這個(gè)字段賦值了BeanFactory嗎，這里就是反射獲取之前賦的值
			ConfigurableBeanFactory beanFactory = getBeanFactory(enhancedConfigInstance);
			// 確定Bean的名稱
			String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);

			// Determine whether this bean is a scoped-proxy
			// 判斷這個(gè)Bean是否是一個(gè)域代理的類
			Scope scope = AnnotatedElementUtils.findMergedAnnotation(beanMethod, Scope.class);
			// 存在@Scope注解，并且開啟了域代理模式
			if (scope != null && scope.proxyMode() != ScopedProxyMode.NO) {
				String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
				// 域代理對(duì)象的目標(biāo)對(duì)象正在被創(chuàng)建,什么時(shí)候會(huì)被創(chuàng)建？當(dāng)然是使用的時(shí)候嘛
				if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
					// 使用的時(shí)候調(diào)用@Bean方法來(lái)創(chuàng)建這個(gè)域代理的目標(biāo)對(duì)象，所以@Bean方法代理的時(shí)候針對(duì)的是域代理的目標(biāo)對(duì)象，目標(biāo)對(duì)象需要通過getBean的方式創(chuàng)建
					beanName = scopedBeanName;
				}
			}

			// 判斷這個(gè)bean是否是一個(gè)factoryBean
			if (factoryContainsBean(beanFactory, BeanFactory.FACTORY_BEAN_PREFIX + beanName) &&
					factoryContainsBean(beanFactory, beanName)) {
				Object factoryBean = beanFactory.getBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName);
				if (factoryBean instanceof ScopedProxyFactoryBean) {
					// ScopedProxyFactoryBean還記得嗎？在進(jìn)行域代理時(shí)使用的就是這個(gè)對(duì)象
					// 對(duì)于這個(gè)FactoryBean我們是不需要進(jìn)行代理的，因?yàn)檫@個(gè)factoryBean的getObject方法
					// 只是為了得到一個(gè)類似于占位符的Bean,這個(gè)Bean只是為了讓依賴它的Bean在創(chuàng)建的過程中不會(huì)報(bào)錯(cuò)
					// 所以對(duì)于這個(gè)FactoryBean我們是不需要進(jìn)行代理的
					// 我們只需要保證這個(gè)FactoryBean所生成的代理對(duì)象的目標(biāo)對(duì)象是通過getBean的方式創(chuàng)建的即可
				} else {
					// 而對(duì)于普通的FactoryBean我們需要代理其getObject方法，確保getObject方法產(chǎn)生的Bean是通過getBean的方式創(chuàng)建的
					// It is a candidate FactoryBean - go ahead with enhancement
					return enhanceFactoryBean(factoryBean, beanMethod.getReturnType(), beanFactory, beanName);
				}
			}
			// 舉個(gè)例子，假設(shè)我們被@Bean標(biāo)注的是A方法，當(dāng)前創(chuàng)建的BeanName也是a，這樣就符合了這個(gè)條件
			// 但是如果是這種請(qǐng)求，a(){b()},a方法中調(diào)用的b方法，那么此時(shí)調(diào)用b方法創(chuàng)建b對(duì)象時(shí)正在執(zhí)行的就是a方法
			// 此時(shí)就不滿足這個(gè)條件，會(huì)調(diào)用這個(gè)resolveBeanReference方法來(lái)解決方法引用
			if (isCurrentlyInvokedFactoryMethod(beanMethod)) {
				// 如果當(dāng)前執(zhí)行的方法就是這個(gè)被攔截的方法，（說明是在創(chuàng)建這個(gè)Bean的過程中）
				// 那么直接執(zhí)行目標(biāo)類中的方法，也就是我們?cè)谂渲妙愔杏聾Bean標(biāo)注的方法
				return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
			}
  // 說明不是在創(chuàng)建中了，而是別的地方直接調(diào)用了這個(gè)方法，這時(shí)候就需要代理了，實(shí)際調(diào)用getBean方法
  return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);

		private Object resolveBeanReference(Method beanMethod, Object[] beanMethodArgs,
											ConfigurableBeanFactory beanFactory, String beanName) {

			// The user (i.e. not the factory) is requesting this bean through a call to
			// the bean method, direct or indirect. The bean may have already been marked
			// as 'in creation' in certain autowiring scenarios; if so, temporarily set
			// the in-creation status to false in order to avoid an exception.
			// 什么時(shí)候會(huì)是alreadyInCreation？就是正在創(chuàng)建中，當(dāng)Spring完成掃描后得到了所有的BeanDefinition
			// 那么之后就會(huì)遍歷所有的BeanDefinition，根據(jù)BeanDefinition一個(gè)個(gè)的創(chuàng)建Bean，在創(chuàng)建Bean前會(huì)將這個(gè)Bean
			// 標(biāo)記為正在創(chuàng)建的，如果是正在創(chuàng)建的Bean,先將其標(biāo)記為非正在創(chuàng)建，也就是這行代碼beanFactory.setCurrentlyInCreation(beanName, false)
			// 這是因?yàn)橹笥謺?huì)調(diào)用getBean方法，如果已經(jīng)被標(biāo)記為創(chuàng)建中了，那么在調(diào)用getBean時(shí)會(huì)報(bào)錯(cuò)
			boolean alreadyInCreation = beanFactory.isCurrentlyInCreation(beanName);
			try {
        // 如果是正在創(chuàng)建的Bean,先將其標(biāo)記為非正在創(chuàng)建，避免后續(xù)調(diào)用getBean時(shí)報(bào)錯(cuò)
				if (alreadyInCreation) {
					beanFactory.setCurrentlyInCreation(beanName, false);
				}
        
        // 在調(diào)用beanMthod的時(shí)候，也就是被@Bean注解標(biāo)注的方法的時(shí)候如果使用了參數(shù)，只要有一個(gè)參數(shù)為null,就直接調(diào)用getBean(beanName),否則帶參數(shù)調(diào)用getBean(beanName,args)，后面通過例子解釋這段代碼
				boolean useArgs = !ObjectUtils.isEmpty(beanMethodArgs);
				if (useArgs && beanFactory.isSingleton(beanName)) {
					for (Object arg : beanMethodArgs) {
						if (arg == null) {
							useArgs = false;
							break;
						}
					}
				}
				Object beanInstance = (useArgs ? beanFactory.getBean(beanName, beanMethodArgs) :
						beanFactory.getBean(beanName));
        // 這里發(fā)現(xiàn)getBean返回的類型不是我們方法返回的類型，這意味著什么呢？
        // 在《你知道Spring是怎么解析配置類的嗎？》我有提到過BeanDefinition的覆蓋
        // 這個(gè)地方說明beanMethod所定義的bd被覆蓋了
				if (!ClassUtils.isAssignableValue(beanMethod.getReturnType(), beanInstance)) {

					if (beanInstance.equals(null)) {
						beanInstance = null;
					} else {
						// 省略日志
						throw new IllegalStateException(msg);
					}
				}
        // 注冊(cè)Bean之間的依賴關(guān)系
        // 這個(gè)method是當(dāng)前執(zhí)行的一個(gè)創(chuàng)建bean的方法
				Method currentlyInvoked = SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod();
        // 不等于null意味著currentlyInvoked這個(gè)方法創(chuàng)建的bean依賴了beanName所代表的Bean
     		// 在開頭的例子中，currentlyInvoked就是a(),beanName就是dmzService,outBeanName就是a
				if (currentlyInvoked != null) {
					String outerBeanName = BeanAnnotationHelper.determineBeanNafanhr(currentlyInvoked);
          // 注冊(cè)的就是a跟dmzService的依賴關(guān)系，注冊(cè)到容器中的dependentBeanMap中
          // key為依賴，value為依賴所在的bean
					beanFactory.registerDependentBean(beanName, outerBeanName);
				}
				return beanInstance;
			} finally {
				if (alreadyInCreation) {
          // 實(shí)際還在創(chuàng)建中，要走完整個(gè)生命周期流程
					beanFactory.setCurrentlyInCreation(beanName, true);
				}
			}
		}

@Configuration
@EnableAspectJAutoProxy
public class Config {
  @Bean
  @Scope(value = WebApplicationContext.SCOPE_REQUEST,proxyMode = ScopedProxyMode.TARGET_CLASS)
  public DmzService dmzService() {
    return new DmzService();
  }
}

@RestController
@RequestMapping("/test")
public class Controller {

  DmzService dmzService;

  @Autowired
  public void setDmzService(DmzService dmzService) {
    this.dmzService = dmzService;
  }

  @GetMapping("/get")
  public ResponseEntity<?> get() {
    System.out.println(dmzService);
    return ResponseEntity.ok().build();
  }
}

// 判斷這個(gè)Bean是否是一個(gè)域代理的類
Scope scope = AnnotatedElementUtils.findMergedAnnotation(beanMethod, Scope.class);
// 存在@Scope注解，并且開啟了域代理模式
if (scope != null && scope.proxyMode() != ScopedProxyMode.NO) {
  String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
  // 域代理對(duì)象的目標(biāo)對(duì)象正在被創(chuàng)建,什么時(shí)候會(huì)被創(chuàng)建？當(dāng)然是使用的時(shí)候嘛
  if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
    // 使用的時(shí)候調(diào)用@Bean方法來(lái)創(chuàng)建這個(gè)域代理的目標(biāo)對(duì)象，所以@Bean方法代理的時(shí)候針對(duì)的是域代理的目標(biāo)對(duì)象
    beanName = scopedBeanName;
  }
}

if (alreadyInCreation) {
  beanFactory.setCurrentlyInCreation(beanName, false);
}

@ComponentScan(value = "com.dmz.spring.first")
@Configuration
public class Config {
	@Bean
	public A a(){
		return new A();
	}

	@Bean
	public B b(){
		a();
		return new B();
	}
}

class A{
	B b;

	@Autowired
	public void setB(B b) {
		this.b = b;
	}
}
class B{

}

@Configuration
public class AnotherConfig {
	@Bean
	public DmzService dmzService(IndexService indexService) {
		return new DmzService(indexService);
	}

	@Bean
	public OrderService orderService() {
		DmzService dmzService = dmzService(null);
		return dmzService.createOrder();
	}
}


@Component
public class IndexService {
}

public class DmzService {
	public DmzService(IndexService indexService) {

	}

	public OrderService createOrder() {
		return new OrderService();
	}
}

public class OrderService {
}

@Configuration
public class AnotherConfig {
	
	@Autowired
	ApplicationContext applicationContext;
	
	@Bean
	public DmzService dmzService(IndexService indexService) {
		return new DmzService(indexService);
	}

	@Bean
	public OrderService orderService() {
		DmzService dmzService = (DmzService) applicationContext.getBean("dmzService");
		return dmzService.createOrder();
	}
}

@Configuration
public class AnotherConfig {
	@Bean
	public DmzService dmzService(){
		return new DmzService();
	}

	@Bean
	public OrderService orderService(){
		return new OrderService(dmzService());
	}
}