你自我介绍说很懂Spring配置类，那你怎么解释这个现象？

@Configuration
public class AppConfig {

}

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

    AppConfig appConfig = context.getBean(AppConfig.class);

    System.out.println(appConfig.getClass());
    System.out.println(appConfig.getClass().getSuperclass() == AppConfig.class);
    System.out.println(AopUtils.isCglibProxy(appConfig));
}

class com.yourbatman.fullliteconfig.config.AppConfig$$EnhancerBySpringCGLIB$$d38ead10
true
false

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

    AppConfig appConfig = context.getBean(AppConfig.class);

    Field $$beanFactoryField = ReflectionUtils.findField(appConfig.getClass(), "$$beanFactory");
    BeanFactory beanFactory = (BeanFactory) $$beanFactoryField.get(appConfig);

    System.out.println(beanFactory == context.getAutowireCapableBeanFactory());
    System.out.println(beanFactory == context);
    System.out.println(appConfig instanceof BeanFactoryAware);
    System.out.println(appConfig.getClass().getInterfaces()[0]);
}

true
false
true
interface org.springframework.context.annotation.ConfigurationClassEnhancer$EnhancedConfiguration

// @since 3.0
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
		PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
		...
}

ConfigurationClassPostProcessor：

	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		// 生成一个id，放置后面再重复执行
		int registryId = System.identityHashCode(registry);
		// 若重复执行  就抛出异常
		if (this.registriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException("postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
		}
		if (this.factoriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException("postProcessBeanFactory already called on this post-processor against " + registry);
		}

		// 表示此registry里的bd收集动作，已经做了  避免再重复收集此registry
		this.registriesPostProcessed.add(registryId);

		// 根据配置类，收集到所有的bd信息
		// 并且做出mark标注：是Full模式还是Lite模式，和很重要很重要
		processConfigBeanDefinitions(registry);
	}

ConfigurationClassPostProcessor：

	@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);

		// 在执行postProcessBeanDefinitionRegistry方法的时就已经将
		// 这个id添加到registriesPostProcessed集合中了
		// 所以到这里就不会再重复执行配置类的解析了（解析@Import、@Bean等）
		if (!this.registriesPostProcessed.contains(factoryId)) {
			processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
		}

		// 从名字上看，这个方法应该就是为配置类创建代理用的喽
		enhanceConfigurationClasses(beanFactory);
		
		// 添加了一个后置处理器 它是个SmartInstantiationAwareBeanPostProcessor
		// 它不是本文重点，略
		beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
	}

ConfigurationClassPostProcessor：

	public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
		// 最终需要做增强的Bean定义们
		Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
		
		for (String beanName : beanFactory.getBeanDefinitionNames()) {
			BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
			Object configClassAttr = beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE);
		
			... // 省略其它情况以及异常情况的处理代码
			
			// 如果是Full模式，才会放进来
			if (ConfigurationClassUtils.CONFIGURATION_CLASS_FULL.equals(configClassAttr)) {
				configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
			}
		}
		if (configBeanDefs.isEmpty()) {
			// nothing to enhance -> return immediately
			return;
		}

		// ConfigurationClassEnhancer就是对配置类做增强操作的核心类，下面详解
		ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
		// 对每个Full模式的配置类，一个个做enhance()增强处理
		for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
			AbstractBeanDefinition beanDef = entry.getValue();
			
			// 如果代理了@Configuration类，则始终代理目标类
			// 该属性和自动代理时是相关的，具体参见Spring的自动代理章节描述
			beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
			
			// CGLIB是给父类生成子类对象的方式实现代理，所以这里指定“父类”类型
			Class<?> configClass = beanDef.getBeanClass();
			// 做增强处理，返回enhancedClass就是一个增强过的子类
			Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
			// 不相等，证明代理成功，那就把实际类型设置进去
			// 这样后面实例化配置类的实例时，实际实例化的就是增强子类喽
			if (configClass != enhancedClass) {
				beanDef.setBeanClass(enhancedClass);
			}
		}
	}

ConfigurationClassEnhancer：

	public Class<?> enhance(Class<?> configClass, @Nullable ClassLoader classLoader) {
		// 如果已经实现了该接口，证明已经被代理过了，直接返回呗~
		if (EnhancedConfiguration.class.isAssignableFrom(configClass)) {
			return configClass;
		}

		// 若没被代理过。就先调用newEnhancer()方法创建一个增强器Enhancer
		// 然后在使用这个增强器，生成代理类字节码Class对象
		Class<?> enhancedClass = createClass(newEnhancer(configClass, classLoader));
		return enhancedClass;
	}

ConfigurationClassEnhancer：

	private Enhancer newEnhancer(Class<?> configSuperClass, @Nullable ClassLoader classLoader) {
		Enhancer enhancer = new Enhancer();
		// 目标类型：会以这个作为父类型来生成字节码子类
		enhancer.setSuperclass(configSuperClass);
		// 让代理类实现EnhancedConfiguration接口，这个接口继承了BeanFactoryAware接口
		enhancer.setInterfaces(new Class<?>[] {EnhancedConfiguration.class});
		
		// 设置生成的代理类不实现org.springframework.cglib.proxy.Factory接口
		enhancer.setUseFactory(false);
		// 设置代理类名称的生成策略：Spring定义的一个生成策略
		// 你名称中会有“BySpringCGLIB”字样
		enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
		enhancer.setStrategy(new BeanFactoryAwareGeneratorStrategy(classLoader));

		// 设置拦截器/过滤器
		enhancer.setCallbackFilter(CALLBACK_FILTER);
		enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
		return enhancer;
	}


	// 使用增强器生，成代理类的字节码对象
	private Class<?> createClass(Enhancer enhancer) {
		Class<?> subclass = enhancer.createClass();
		Enhancer.registerStaticCallbacks(subclass, CALLBACKS);
		return subclass;
	}

ConfigurationClassEnhancer：

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

BeanFactoryAwareMethodInterceptor：

		// 当执行到setBeanFactory(xxx)方法时匹配成功
		@Override
		public boolean isMatch(Method candidateMethod) {
			return isSetBeanFactory(candidateMethod);
		}
		// 此方法标记为public static 是因为下面这个拦截器也会用到
		public static boolean isSetBeanFactory(Method candidateMethod) {
			return (candidateMethod.getName().equals("setBeanFactory") &&
					candidateMethod.getParameterCount() == 1 &&
					BeanFactory.class == candidateMethod.getParameterTypes()[0] &&
					BeanFactoryAware.class.isAssignableFrom(candidateMethod.getDeclaringClass()));
		}

BeanFactoryAwareMethodInterceptor：

		@Override
		@Nullable
		public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
			
			// 找到本类（代理类）里名为`$$beanFactory`的字段
			// 若没找到直接报错。若找到了此字段，就给此字段赋值
			Field field = ReflectionUtils.findField(obj.getClass(), BEAN_FACTORY_FIELD);
			Assert.state(field != null, "Unable to find generated BeanFactory field");
			field.set(obj, args[0]);

			// 如果用户类（也就是你自己定义的类）自己实现了该接口，那么别担心，也会给你赋值上
			if (BeanFactoryAware.class.isAssignableFrom(ClassUtils.getUserClass(obj.getClass().getSuperclass()))) {
				return proxy.invokeSuper(obj, args);
			}
			return null;
		}