Spring中@Configuration注解修改的类生成代理的原因是什么

今天小编给大家分享一下Spring中@Configuration注解修改的类生成代理的原因是什么的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。

前言

在Spring中只要被@Configuration注解修饰的类，Spring就会为其生成代理对象，至于这样做的主要原因就是为了解决生成对象的单例问题。

说明

实际上作者在ConfigurationClassEnhancer这个类也有注解说明

场景

如果Spring不做处理，下面输出的一定的是false，但是实际上输出的结果是true，那么只有可能是代理类做了特殊处理。

@Configurationpublic class MyConfiguration {    @Bean    public TestA a(){        return new TestA();    }    @Bean    public TestB b(){        TestA a = a();        TestA b = a();        System.out.println(a == b);        return new TestB();    }}

处理分析

生成的代理对象，最终会调用ConfigurationClassEnhancer内部类BeanMethodInterceptor的intercept方法，如果不是当前调用的Bean对象（也就是isCurrentlyInvokedFactoryMethod(beanMethod)返回false），则会调用resolveBeanReference方法。

public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs,                        MethodProxy cglibMethodProxy) throws Throwable {        ConfigurableBeanFactory beanFactory = getBeanFactory(enhancedConfigInstance);        String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);        // Determine whether this bean is a scoped-proxy        if (BeanAnnotationHelper.isScopedProxy(beanMethod)) {                String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);                if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {                        beanName = scopedBeanName;                }        }        // To handle the case of an inter-bean method reference, we must explicitly check the        // container for already cached instances.        // First, check to see if the requested bean is a FactoryBean. If so, create a subclass        // proxy that intercepts calls to getObject() and returns any cached bean instance.        // This ensures that the semantics of calling a FactoryBean from within @Bean methods        // is the same as that of referring to a FactoryBean within XML. See SPR-6602.        if (factoryContainsBean(beanFactory, BeanFactory.FACTORY_BEAN_PREFIX + beanName) &&                        factoryContainsBean(beanFactory, beanName)) {                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                }                else {                        // It is a candidate FactoryBean - go ahead with enhancement                        return enhanceFactoryBean(factoryBean, beanMethod.getReturnType(), beanFactory, beanName);                }        }        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())) {                        logger.info(String.format("@Bean method %s.%s is non-static and returns an object " +                                                        "assignable to Spring's BeanFactoryPostProcessor interface. This will " +                                                        "result in a failure to process annotations such as @Autowired, " +                                                        "@Resource and @PostConstruct within the method's declaring " +                                                        "@Configuration class. Add the 'static' modifier to this method to avoid " +                                                        "these container lifecycle issues; see @Bean javadoc for complete details.",                                        beanMethod.getDeclaringClass().getSimpleName(), beanMethod.getName()));                }                return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);        }        return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);}

此方法会通过getBean来获取对象，这样就可以控制对象的生成了。

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.        boolean alreadyInCreation = beanFactory.isCurrentlyInCreation(beanName);        try {                if (alreadyInCreation) {                        beanFactory.setCurrentlyInCreation(beanName, false);                }                boolean useArgs = !ObjectUtils.isEmpty(beanMethodArgs);                if (useArgs && beanFactory.isSingleton(beanName)) {                        // Stubbed null arguments just for reference purposes,                        // expecting them to be autowired for regular singleton references?                        // A safe assumption since @Bean singleton arguments cannot be optional...                        for (Object arg : beanMethodArgs) {                                if (arg == null) {                                        useArgs = false;                                        break;                                }                        }                }                // 通过getBean就可以控制对象的生成，对象如果生成过，则可以直接从一级缓存中获取                Object beanInstance = (useArgs ? beanFactory.getBean(beanName, beanMethodArgs) :                                beanFactory.getBean(beanName));                if (!ClassUtils.isAssignableValue(beanMethod.getReturnType(), beanInstance)) {                        // Detect package-protected NullBean instance through equals(null) check                        if (beanInstance.equals(null)) {                                if (logger.isDebugEnabled()) {                                        logger.debug(String.format("@Bean method %s.%s called as bean reference " +                                                        "for type [%s] returned null bean; resolving to null value.",                                                        beanMethod.getDeclaringClass().getSimpleName(), beanMethod.getName(),                                                        beanMethod.getReturnType().getName()));                                }                                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);                }        }}

以上就是"Spring中@Configuration注解修改的类生成代理的原因是什么"这篇文章的所有内容，感谢各位的阅读！相信大家阅读完这篇文章都有很大的收获，小编每天都会为大家更新不同的知识，如果还想学习更多的知识，请关注行业资讯频道。