Springboot中注解@Configuration源码分析

Springboot中注解@Configuration和@Component的区别

1.先说结论，@Configuration注解上面有@Component注解，所以@Component有的功能@Configuration都有。@Configuration生成的bean是一个代理对象，具体@Configuration的实现如何我们现在就打开源码来看看它。

2.博客的代码路径：代码路径

生成的代理类class文件路径：generate-class.zip

你自己执行工程也会在target/classes/generate-class目录下生成代理类class代码

3.@Configuration源码分析

由于@SpringBootApplication注解上有@Configuration，为了代码简单，我们就直接看主类SpringbootconfigurationApplication就可以了。

@Configuration注解的类会进入ConfigurationClassPostProcessor.enhanceConfigurationClasses方法去生成代理类。

	public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
		......
		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
            //configClass就是原始的类
			Class<?> configClass = beanDef.getBeanClass();
            //enhancedClass就是生成的代理类
			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();
	}

生成代理类主要就是enhancer.enhance(configClass, this.beanClassLoader)这句了，下面我们自己去看看

	public Class<?> enhance(Class<?> configClass, @Nullable ClassLoader classLoader) {
		......
        //关键代码也就这一行了，首先创建一个Enhancer对象，然后调用createClass方法
		Class<?> enhancedClass = createClass(newEnhancer(configClass, classLoader));
		......
		return enhancedClass;
	}

	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));
        //设置代理类要重写的方法，对类中@Bean的方法和对实现了BeanFactoryAware接口的setBeanFactory进行重写，也就是代理
		enhancer.setCallbackFilter(CALLBACK_FILTER);
		enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
		return enhancer;
	}

在这里我们还需要Enhancer类中的属性KEY_FACTORY,由于它是静态属性，所以在加载Enhancer类的时候就会执行下面的代码

	//代理类会实现EnhancerKey接口，继承KeyFactory(KEY_FACTORY是代理类的对象)
	private static final EnhancerKey ,KEY_FACTORY =
			(EnhancerKey) KeyFactory.create(EnhancerKey.class, KeyFactory.HASH_ASM_TYPE, null);

这个KEY_FACTORY其实也是一个代理类的实例。我们就先看看它吧，这个主要是生成缓存的key,不感兴趣也可以跳过下面KEY_FACTORY的生成部分

KEY_FACTORY的生成

	public static KeyFactory create(ClassLoader loader, Class keyInterface, KeyFactoryCustomizer customizer,
			List<KeyFactoryCustomizer> next) {
		Generator gen = new Generator();
		gen.setInterface(keyInterface);
		// SPRING PATCH BEGIN
		gen.setContextClass(keyInterface);
		// SPRING PATCH END

		if (customizer != null) {
			gen.addCustomizer(customizer);
		}
		if (next != null && !next.isEmpty()) {
			for (KeyFactoryCustomizer keyFactoryCustomizer : next) {
				gen.addCustomizer(keyFactoryCustomizer);
			}
		}
		gen.setClassLoader(loader);
        //主要是这句,我们继续走进去看看
		return gen.create();
	}

		public KeyFactory create() {
			//这里是设置类名的前缀
			setNamePrefix(keyInterface.getName());
			//继续跟进去
			return (KeyFactory) super.create(keyInterface.getName());
		}

	protected Object create(Object key) {
		try {
            //这里有个二级缓存，首先根据getClassLoader()去找，然后根据ClassLoaderData的lambda表达式GET_KEY去找，这里就是入参key了
			ClassLoader loader = getClassLoader();
			Map<ClassLoader, ClassLoaderData> cache = CACHE;
			ClassLoaderData data = cache.get(loader);
			if (data == null) {
				synchronized (AbstractClassGenerator.class) {
					cache = CACHE;
					data = cache.get(loader);
					if (data == null) {
						Map<ClassLoader, ClassLoaderData> newCache = new WeakHashMap<ClassLoader, ClassLoaderData>(cache);
						data = new ClassLoaderData(loader);
						newCache.put(loader, data);
						CACHE = newCache;
					}
				}
			}
			this.key = key;
            //这里就会生成真正的类，我们走进去
			Object obj = data.get(this, getUseCache());
			if (obj instanceof Class) {
                //在这里生成代理类的对象
				return firstInstance((Class) obj);
			}
			return nextInstance(obj);
		}
		catch (RuntimeException | Error ex) {
			throw ex;
		}
		catch (Exception ex) {
			throw new CodeGenerationException(ex);
		}
	}

这就会走到AbstractClassGenerator.ClassLoaderData的get方法

		public Object get(AbstractClassGenerator gen, boolean useCache) {
			if (!useCache) {
				return gen.generate(ClassLoaderData.this);
			}
			else {
                //我们传入的useCache是true，会走这里，再进去
				Object cachedValue = generatedClasses.get(gen);
				return gen.unwrapCachedValue(cachedValue);
			}
		}

现在走到了LoadingCache.get方法

    public V get(K key) {
        	//这里的cacheKey就是org.springframework.cglib.proxy.Enhancer$EnhancerKey
        KK cacheKey = this.keyMapper.apply(key);
        Object v = this.map.get(cacheKey);
        我们这里是第一次创建，所以会走到 this.createEntry(key, cacheKey, v)
        return v != null && !(v instanceof FutureTask) ? v : this.createEntry(key, cacheKey, v);
    }

···

protected V createEntry(final K key, KK cacheKey, Object v) {
    boolean creator = false;
    FutureTask task;
    Object result;
    if (v != null) {
        task = (FutureTask)v;
    } else {
        task = new FutureTask(new Callable<V>() {
            public V call() throws Exception {
                //真正的执行会在这里，这里会是一个单独的线程，LoadingCache.this.loader是在ClassLoaderData的构造方法定义的lambda表达式，我们进去看看
                return LoadingCache.this.loader.apply(key);
            }
        });
        result = this.map.putIfAbsent(cacheKey, task);
        if (result == null) {
            creator = true;
            //在这里开启线程调用
            task.run();
        } else {
            if (!(result instanceof FutureTask)) {
                return result;
            }

            task = (FutureTask)result;
        }
    }

    try {
        //在这里挂起，等待线程返回结果
        result = task.get();
    } catch (InterruptedException var9) {
        throw new IllegalStateException("Interrupted while loading cache item", var9);
    } catch (ExecutionException var10) {
        Throwable cause = var10.getCause();
        if (cause instanceof RuntimeException) {
            throw (RuntimeException)cause;
        }

        throw new IllegalStateException("Unable to load cache item", cause);
    }

    if (creator) {
        //创建成功，就会在这里加入到缓存中
        this.map.put(cacheKey, result);
    }

    return result;
}

			Function<AbstractClassGenerator, Object> load =
					new Function<AbstractClassGenerator, Object>() {
						public Object apply(AbstractClassGenerator gen) {
                            //这里又会回到KeyFactory.Generator这个内部类中，这个方法在它的父类AbstractClassGenerator中，我们走进去
							Class klass = gen.generate(ClassLoaderData.this);
							return gen.wrapCachedClass(klass);
						}
					};

AbstractClassGenerator的generate方法

protected Class generate(ClassLoaderData data) {
			......
		try {
			......
			synchronized (classLoader) {
				//这里生成类的名字
				String name = generateClassName(data.getUniqueNamePredicate());
				data.reserveName(name);
				this.setClassName(name);
			}
			......
			//在这里生成类的byte[]文件,继续走进去
			byte[] b = strategy.generate(this);
            //这个是从字节码中获取类名
            //在工程springbootconfiguration\target\classes\generate-class这个目录下,根据className+".class"就能找到我们生成的class文件(注意将包名的.换成路径分割线)
			String className = ClassNameReader.getClassName(new ClassReader(b));
			ProtectionDomain protectionDomain = getProtectionDomain();
			synchronized (classLoader) { // just in case
				// SPRING PATCH BEGIN
				//将生成的类的文件加载进jvm
				gen = ReflectUtils.defineClass(className, b, classLoader, protectionDomain, contextClass);
				// SPRING PATCH END
			}
			return gen;
		}
		......
	}

DefaultGeneratorStrategy的generate方法

    //真正生成类文件的代码就在这里，这个是通过asm来生成的，具体asm这块就不再往里面看了，关于asm这块是个单独的知识点，不过对我们来说，不看里面细节也不影响我们的分析，我们main方法中有 System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,p);，就会将生成的class文件保存到本地，我们直接看这个就好了，我们当前生成的class文件统一放到了springbootconfiguration\target\classes\generate-class这个目录下
    public byte[] generate(ClassGenerator cg) throws Exception {
        DebuggingClassWriter cw = this.getClassVisitor();
        this.transform(cg).generateClass(cw);
        return this.transform(cw.toByteArray());
    }

下面这个就是我本地生成的class文件反编译后的java代码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.cglib.proxy;

import org.springframework.asm.Type;
import org.springframework.cglib.core.KeyFactory;
import org.springframework.cglib.core.WeakCacheKey;
import org.springframework.cglib.proxy.Enhancer.EnhancerKey;

public class Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f extends KeyFactory implements EnhancerKey {
    private final String FIELD_0;
    private final String[] FIELD_1;
    private final WeakCacheKey FIELD_2;
    private final Type[] FIELD_3;
    private final boolean FIELD_4;
    private final boolean FIELD_5;
    private final Long FIELD_6;

    public Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f() {
    }

    public Object newInstance(String var1, String[] var2, WeakCacheKey var3, Type[] var4, boolean var5, boolean var6, Long var7) {
        return new Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f(var1, var2, var3, var4, var5, var6, var7);
    }

    public Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f(String var1, String[] var2, WeakCacheKey var3, Type[] var4, boolean var5, boolean var6, Long var7) {
        this.FIELD_0 = var1;
        this.FIELD_1 = var2;
        this.FIELD_2 = var3;
        this.FIELD_3 = var4;
        this.FIELD_4 = var5;
        this.FIELD_5 = var6;
        this.FIELD_6 = var7;
    }

    public int hashCode() {
        int var10002 = 1213 * 1209107;
        String var10001 = this.FIELD_0;
        int var10000 = var10002 + (var10001 != null ? var10001.hashCode() : 0);
        String[] var5 = this.FIELD_1;
        if (var5 != null) {
            String[] var1 = var5;

            for(int var2 = 0; var2 < var1.length; ++var2) {
                var10000 = var10000 * 1209107 + (var1[var2] != null ? var1[var2].hashCode() : 0);
            }
        }

        var10002 = var10000 * 1209107;
        WeakCacheKey var6 = this.FIELD_2;
        var10000 = var10002 + (var6 != null ? var6.hashCode() : 0);
        Type[] var7 = this.FIELD_3;
        if (var7 != null) {
            Type[] var3 = var7;

            for(int var4 = 0; var4 < var3.length; ++var4) {
                var10000 = var10000 * 1209107 + (var3[var4] != null ? var3[var4].hashCode() : 0);
            }
        }

        var10002 = ((var10000 * 1209107 + (this.FIELD_4 ^ 1)) * 1209107 + (this.FIELD_5 ^ 1)) * 1209107;
        Long var8 = this.FIELD_6;
        return var10002 + (var8 != null ? var8.hashCode() : 0);
    }

    public boolean equals(Object var1) {
        if (var1 instanceof Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f) {
            String var10000 = this.FIELD_0;
            String var10001 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f)var1).FIELD_0;
            if (var10001 == null) {
                if (var10000 != null) {
                    return false;
                }
            } else if (var10000 == null || !var10000.equals(var10001)) {
                return false;
            }

            String[] var8 = this.FIELD_1;
            String[] var10 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f)var1).FIELD_1;
            if (var10 == null) {
                if (var8 != null) {
                    return false;
                }
            } else {
                label178: {
                    if (var8 != null) {
                        if (var10.length == var8.length) {
                            String[] var2 = var10;
                            String[] var3 = var8;
                            int var4 = 0;

                            while(true) {
                                if (var4 >= var2.length) {
                                    break label178;
                                }

                                var10000 = var2[var4];
                                var10001 = var3[var4];
                                if (var3[var4] == null) {
                                    if (var10000 != null) {
                                        return false;
                                    }
                                } else if (var10000 == null || !var10000.equals(var10001)) {
                                    return false;
                                }

                                ++var4;
                            }
                        }
                    }

                    return false;
                }
            }

            WeakCacheKey var9 = this.FIELD_2;
            WeakCacheKey var13 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f)var1).FIELD_2;
            if (var13 == null) {
                if (var9 != null) {
                    return false;
                }
            } else if (var9 == null || !var9.equals(var13)) {
                return false;
            }

            Type[] var11 = this.FIELD_3;
            Type[] var15 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f)var1).FIELD_3;
            if (var15 == null) {
                if (var11 != null) {
                    return false;
                }
            } else {
                if (var11 == null) {
                    return false;
                }

                if (var15.length != var11.length) {
                    return false;
                }

                Type[] var5 = var15;
                Type[] var6 = var11;

                for(int var7 = 0; var7 < var5.length; ++var7) {
                    Type var12 = var5[var7];
                    Type var16 = var6[var7];
                    if (var6[var7] == null) {
                        if (var12 != null) {
                            return false;
                        }
                    } else if (var12 == null || !var12.equals(var16)) {
                        return false;
                    }
                }
            }

            if (this.FIELD_4 == ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f)var1).FIELD_4 && this.FIELD_5 == ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f)var1).FIELD_5) {
                Long var14 = this.FIELD_6;
                Long var17 = ((Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f)var1).FIELD_6;
                if (var17 == null) {
                    if (var14 == null) {
                        return true;
                    }
                } else if (var14 != null && var14.equals(var17)) {
                    return true;
                }
            }
        }

        return false;
    }

    public String toString() {
        StringBuffer var10000 = new StringBuffer();
        String var10001 = this.FIELD_0;
        var10000 = (var10001 != null ? var10000.append(var10001.toString()) : var10000.append("null")).append(", ");
        String[] var6 = this.FIELD_1;
        if (var6 != null) {
            var10000 = var10000.append("{");
            String[] var1 = var6;

            for(int var2 = 0; var2 < var1.length; ++var2) {
                var10000 = (var1[var2] != null ? var10000.append(var1[var2].toString()) : var10000.append("null")).append(", ");
            }

            var10000.setLength(var10000.length() - 2);
            var10000 = var10000.append("}");
        } else {
            var10000 = var10000.append("null");
        }

        var10000 = var10000.append(", ");
        WeakCacheKey var9 = this.FIELD_2;
        var10000 = (var9 != null ? var10000.append(var9.toString()) : var10000.append("null")).append(", ");
        Type[] var10 = this.FIELD_3;
        if (var10 != null) {
            var10000 = var10000.append("{");
            Type[] var3 = var10;

            for(int var4 = 0; var4 < var3.length; ++var4) {
                var10000 = (var3[var4] != null ? var10000.append(var3[var4].toString()) : var10000.append("null")).append(", ");
            }

            var10000.setLength(var10000.length() - 2);
            var10000 = var10000.append("}");
        } else {
            var10000 = var10000.append("null");
        }

        var10000 = var10000.append(", ").append(this.FIELD_4).append(", ").append(this.FIELD_5).append(", ");
        Long var13 = this.FIELD_6;
        return (var13 != null ? var10000.append(var13.toString()) : var10000.append("null")).toString();
    }
}

生成代理类调用的还是create方法中的代码

	protected Object create(Object key) {
			......
			if (obj instanceof Class) {
                //在这里生成代理类的对象,调用代理类的无参构造方法生成代理类的对象
				return firstInstance((Class) obj);
			}
			return nextInstance(obj);
		}
		catch (RuntimeException | Error ex) {
			throw ex;
		}
		catch (Exception ex) {
			throw new CodeGenerationException(ex);
		}
	}

下面就是我本地生成的KEY_FACTORY对象

下面我们看看生成@Configuration代理类的代码

我们回到ConfigurationClassEnhancer的createClass方法，对这个不感兴趣，也可以跳过这部分，直接看初始化@Configuration代理类部分

	private Class<?> createClass(Enhancer enhancer) {
		//这里直接调用Enhancer的createClass方法，继续走进去
		Class<?> subclass = enhancer.createClass();
		......
	}

Enhancer中会继续调到createHelper方法

	private Object createHelper() {
		preValidate();
		//这就是根据上面生成代理类的对象生成key，根据这个key在缓存中查找
		Object key = KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null,
				ReflectUtils.getNames(interfaces),
				filter == ALL_ZERO ? null : new WeakCacheKey<CallbackFilter>(filter),
				callbackTypes,
				useFactory,
				interceptDuringConstruction,
				serialVersionUID);
		this.currentKey = key;
		Object result = super.create(key);
		return result;
	}

后面很多代码都和上面KEY_FACTORY的生成是一样的,主要是这里会对方法进行一些过滤

生成代理类的时候具体要ConfigurationClassEnhancer.CALLBACK_FILTER确定代理方法的生成器

CALLBACK_FILTER中根据CALLBACKS来进行过滤，由于BeanMethodInterceptor，BeanFactoryAwareMethodInterceptor都是实现了MethodInterceptor, ConditionalCallback这两个接口，CALLBACK_FILTER中就会直接使用ConditionalCallback.isMatch去判断，其他的都会由NoOp.INSTANCE来处理。

BeanMethodInterceptor方法会过滤出来有@注解的方法，BeanFactoryAwareMethodInterceptor会过滤出来BeanFactoryAware.setBeanFactory方法

具体方法的生成器是在CallbackInfo中定义的

    static {
        CALLBACKS = new CallbackInfo[]{new CallbackInfo(NoOp.class, NoOpGenerator.INSTANCE), new CallbackInfo(MethodInterceptor.class, MethodInterceptorGenerator.INSTANCE), new CallbackInfo(InvocationHandler.class, InvocationHandlerGenerator.INSTANCE), new CallbackInfo(LazyLoader.class, LazyLoaderGenerator.INSTANCE), new CallbackInfo(Dispatcher.class, DispatcherGenerator.INSTANCE), new CallbackInfo(FixedValue.class, FixedValueGenerator.INSTANCE), new CallbackInfo(ProxyRefDispatcher.class, DispatcherGenerator.PROXY_REF_INSTANCE)};
    }

BeanMethodInterceptor，BeanFactoryAwareMethodInterceptor这两个过滤器实现了MethodInterceptor接口，所以它们的方法生成器都是 MethodInterceptorGenerator.INSTANCE(会处理@注解的方法，BeanFactoryAwareMethodInterceptor会过滤出来BeanFactoryAware.setBeanFactory方法)

其他的都是由NoOp.INSTANCE来处理，方法生成器就是NoOpGenerator.INSTANCE(这个方法实际不会去生成字节码，所以直接上这些方法还是调用父类的方法)

最终生成的字节码是这个样子的

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.example.springbootconfiguration;

import com.example.springbootconfiguration.entity.Home;
import com.example.springbootconfiguration.entity.User;
import java.lang.reflect.Method;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.cglib.core.ReflectUtils;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.cglib.proxy.NoOp;
import org.springframework.context.annotation.ConfigurationClassEnhancer.EnhancedConfiguration;

public class SpringbootconfigurationApplication$$EnhancerBySpringCGLIB$$d37254bc extends SpringbootconfigurationApplication implements EnhancedConfiguration {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private MethodInterceptor CGLIB$CALLBACK_1;
    private NoOp CGLIB$CALLBACK_2;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$getUser$0$Method;
    private static final MethodProxy CGLIB$getUser$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$getHome$1$Method;
    private static final MethodProxy CGLIB$getHome$1$Proxy;
    private static final Method CGLIB$setBeanFactory$6$Method;
    private static final MethodProxy CGLIB$setBeanFactory$6$Proxy;
    public BeanFactory $$beanFactory;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.example.springbootconfiguration.SpringbootconfigurationApplication$$EnhancerBySpringCGLIB$$d37254bc");
        Class var1;
        CGLIB$setBeanFactory$6$Method = ReflectUtils.findMethods(new String[]{"setBeanFactory", "(Lorg/springframework/beans/factory/BeanFactory;)V"}, (var1 = Class.forName("org.springframework.beans.factory.BeanFactoryAware")).getDeclaredMethods())[0];
        CGLIB$setBeanFactory$6$Proxy = MethodProxy.create(var1, var0, "(Lorg/springframework/beans/factory/BeanFactory;)V", "setBeanFactory", "CGLIB$setBeanFactory$6");
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"getUser", "()Lcom/example/springbootconfiguration/entity/User;", "getHome", "()Lcom/example/springbootconfiguration/entity/Home;"}, (var1 = Class.forName("com.example.springbootconfiguration.SpringbootconfigurationApplication")).getDeclaredMethods());
        CGLIB$getUser$0$Method = var10000[0];
        CGLIB$getUser$0$Proxy = MethodProxy.create(var1, var0, "()Lcom/example/springbootconfiguration/entity/User;", "getUser", "CGLIB$getUser$0");
        CGLIB$getHome$1$Method = var10000[1];
        CGLIB$getHome$1$Proxy = MethodProxy.create(var1, var0, "()Lcom/example/springbootconfiguration/entity/Home;", "getHome", "CGLIB$getHome$1");
    }

    final User CGLIB$getUser$0() {
        return super.getUser();
    }

    public final User getUser() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (User)var10000.intercept(this, CGLIB$getUser$0$Method, CGLIB$emptyArgs, CGLIB$getUser$0$Proxy) : super.getUser();
    }

    final Home CGLIB$getHome$1() {
        return super.getHome();
    }

    public final Home getHome() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (Home)var10000.intercept(this, CGLIB$getHome$1$Method, CGLIB$emptyArgs, CGLIB$getHome$1$Proxy) : super.getHome();
    }

    final void CGLIB$setBeanFactory$6(BeanFactory var1) throws BeansException {
        super.setBeanFactory(var1);
    }

    public final void setBeanFactory(BeanFactory var1) throws BeansException {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_1;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_1;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$setBeanFactory$6$Method, new Object[]{var1}, CGLIB$setBeanFactory$6$Proxy);
        } else {
            super.setBeanFactory(var1);
        }
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -964783719:
            if (var10000.equals("getUser()Lcom/example/springbootconfiguration/entity/User;")) {
                return CGLIB$getUser$0$Proxy;
            }
            break;
        case 1508184433:
            if (var10000.equals("getHome()Lcom/example/springbootconfiguration/entity/Home;")) {
                return CGLIB$getHome$1$Proxy;
            }
            break;
        case 2095635076:
            if (var10000.equals("setBeanFactory(Lorg/springframework/beans/factory/BeanFactory;)V")) {
                return CGLIB$setBeanFactory$6$Proxy;
            }
        }

        return null;
    }

    public SpringbootconfigurationApplication$$EnhancerBySpringCGLIB$$d37254bc() {
        CGLIB$BIND_CALLBACKS(this);
    }

    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        SpringbootconfigurationApplication$$EnhancerBySpringCGLIB$$d37254bc var1 = (SpringbootconfigurationApplication$$EnhancerBySpringCGLIB$$d37254bc)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (var10000 == null) {
                    return;
                }
            }

            Callback[] var10001 = (Callback[])var10000;
            var1.CGLIB$CALLBACK_2 = (NoOp)((Callback[])var10000)[2];
            var1.CGLIB$CALLBACK_1 = (MethodInterceptor)var10001[1];
            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)var10001[0];
        }

    }

    static {
        CGLIB$STATICHOOK2();
        CGLIB$STATICHOOK1();
    }

    static void CGLIB$STATICHOOK2() {
    }
}

初始化@Configuration代理类

在上面生成了代理类字节码之后，就会将代理类字节码加载到jvm，生成代理类。

由于代理类中有static 静态代码块，所以这时就会去执行静态代码块(上面153行代码)

CGLIB$STATICHOOK2()的实现在158行，CGLIB$STATICHOOK1()的实现在39行,具体就不仔细看了。

执行完类加载后，会返回到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)...
        //这时会执行到这里，会通过反射调用代理类的CGLIB$SET_STATIC_CALLBACKS(org.springframework.cglib.proxy.Callback[])方法将CALLBACKS设置上去，由于是静态方法，所以不需要实例化对象可以直接调用
		Enhancer.registerStaticCallbacks(subclass, CALLBACKS);
		return subclass;
	}

到这里代理类就基本完成了，后面就是生成bean对象了。

来生成对应bean的时候，会默认无参构造方法。

  public SpringbootconfigurationApplication$$EnhancerBySpringCGLIB$$d37254bc() {
        CGLIB$BIND_CALLBACKS(this);
    }

在CGLIB$BIND_CALLBACKS中主要会设置CGLIB$CALLBACK_x

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
			......
            Callback[] var10001 = (Callback[])var10000;
            var1.CGLIB$CALLBACK_2 = (NoOp)((Callback[])var10000)[2]; //NoOp.INSTANCE
            var1.CGLIB$CALLBACK_1 = (MethodInterceptor)var10001[1];  //new BeanFactoryAwareMethodInterceptor()
            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)var10001[0];  //new BeanMethodInterceptor()
        }

    }

到这里由代理类生成的bean就完成了，下面我们看看方法上@Bean生成的

生成代理类上@bean方法 表示的对象

我们这里由两个@Bean的方法

    @Bean
    public User getUser() {
        return new User();
    }

    @Bean
    public Home getHome() {
        return new Home(getUser());
    }

}

我们先看getUser的执行吧

    public final User getUser() {
        //这里的var10000就是上面的new BeanMethodInterceptor()
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
		//所以这里会调用BeanMethodInterceptor.intercept进行返回
        return var10000 != null ? (User)var10000.intercept(this, CGLIB$getUser$0$Method, CGLIB$emptyArgs, CGLIB$getUser$0$Proxy) : super.getUser();
    }

BeanMethodInterceptor.intercept方法

public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs,
					MethodProxy cglibMethodProxy) throws Throwable {
			......
			//这里的beanMethod就是我们生成代理类的父类的getUser方法，当前beanFactory是正在创建它，所以会进到这个if分支，
			if (isCurrentlyInvokedFactoryMethod(beanMethod)) {
				......
                //这里使用代理类中CGLIB$STATICHOOK1方法生成的代理方法去继续调用，最终会调用代理类的CGLIB$getUser$1方法，继续调用到父类的getUser()方法
               //在这调用过程中也会生成两个快速查找方法的类
               //1.SpringbootconfigurationApplication$$FastClassBySpringCGLIB$$fae3d721.class在我们的原始类中快速查找方法
               //2.SpringbootconfigurationApplication$$EnhancerBySpringCGLIB$$43375915$$FastClassBySpringCGLIB$$c293f4a3在代理类中快速查找方法
				return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
			}

			return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);
		}

下面我们来看看getHome的执行

    public final Home getHome() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (Home)var10000.intercept(this, CGLIB$getHome$1$Method, CGLIB$emptyArgs, CGLIB$getHome$1$Proxy) : super.getHome();
    }

还是调用BeanMethodInterceptor.intercept方法，前面的逻辑是和上面的一样的，也会调用到CGLIB$getHome$0方法，继续调用到父类的getHome();方法，这时由于父类getHome()方法中有调用getUser()方法，我们的代理类已经重写了这个方法，这时又会回到代理类中getUser()继而继续调用BeanMethodInterceptor.intercept方法

		@Override
		@Nullable
		public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs,
					MethodProxy cglibMethodProxy) throws Throwable {
			......
            //由于beanFactory中我们正在创建的是getHome()这个方法，所以这时beanMethod=getUser()不会走到这个if分支
			if (isCurrentlyInvokedFactoryMethod(beanMethod)) {
				......
			}
			//所以会执行到这里
			return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);
		}

		private Object resolveBeanReference(Method beanMethod, Object[] beanMethodArgs,
				ConfigurableBeanFactory beanFactory, String beanName) {
			......
			try {
				......
                //由于之前已经执行过getUser 生成了bean对象，所以这里会从beanFactory中获取到对应的bean对象
				Object beanInstance = (useArgs ? beanFactory.getBean(beanName, beanMethodArgs) :
						beanFactory.getBean(beanName));
                ......
				//后面这就是获取到当前正在创建的bean,添加依赖关系了
				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注解会生成代理类，代理类会继承我的@Configuration注解所在的类，并实现EnhancedConfiguration接口。

会对@Bean，BeanFactoryAware.setBeanFactory(EnhancedConfiguration继承了BeanFactoryAware接口)的方法在代理类中进行重写，并用BeanMethodInterceptor.intercept进行拦截增强，多次调用@Bean的方法实际是返回的同一个对象，第一次调用时会生成对象，之后的调用都是会从beanFactory中获取