static 影响 @Bean 与 BeanFactoryPostProcessor 分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.PostConstruct;

@Configuration(proxyBeanMethods = false)
public class StaticConfigurationBean {
    private static final Logger LOG = LoggerFactory.getLogger(StaticConfigurationBean.class);
    
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(StaticConfigurationBean.class);
        context.refresh();
        context.close();
    }

    @Configuration
    public static class Config {
        public Config() {
            LOG.info("Config construct");
        }

        @PostConstruct
        public void init() {
            LOG.info("Config init");
        }
        
        //    @Bean
//    public BeanDefinitionRegistryPostProcessor customPostProcessor() {  //情况一

//        @Bean
//        public static BeanDefinitionRegistryPostProcessor customPostProcessor() {  //情况二

//        @Bean
//        public BeanFactoryPostProcessor customPostProcessor() {  //情况三
            
        @Bean
        public static BeanFactoryPostProcessor customPostProcessor() {  //情况四
            LOG.info("customPostProcessor construct");
            return new BeanDefinitionRegistryPostProcessor() {
                @Override
                public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
                    registry.removeBeanDefinition("c");
                }

                @Override
                public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
                }
            };
        }

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

        @Bean
        public A a() {
            return new A();
        }

        @Bean
        public C c() {
            return new C();
        }

        public static class A {
            public A() {
                LOG.info("A construct a is " + this.hashCode());
            }

            @PostConstruct
            public void init() {
                LOG.info("A init");
            }
        }

        public static class B {
            public B(A a) {
                LOG.info("B construct B.a is " + a.hashCode());
            }

            @PostConstruct
            public void init() {
                LOG.info("B init");
            }
        }

        public static class C {
            public C() {
                LOG.info("C construct");
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class ConstructorResolver {
......
   public BeanWrapper instantiateUsingFactoryMethod(
         String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {

      BeanWrapperImpl bw = new BeanWrapperImpl();
      this.beanFactory.initBeanWrapper(bw);

      Object factoryBean;
      Class<?> factoryClass;
      boolean isStatic;

      String factoryBeanName = mbd.getFactoryBeanName();
      if (factoryBeanName != null) {
          //factoryBeanName 不为null 会先触发factoryBeanName Bean 的创建
         if (factoryBeanName.equals(beanName)) {
            throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                  "factory-bean reference points back to the same bean definition");
         }
         factoryBean = this.beanFactory.getBean(factoryBeanName);
         if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
            throw new ImplicitlyAppearedSingletonException();
         }
         this.beanFactory.registerDependentBean(factoryBeanName, beanName);
         factoryClass = factoryBean.getClass();
         isStatic = false;
      }
      ......
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class ConfigurationClassBeanDefinitionReader {
......

   /**
    * Read the given {@link BeanMethod}, registering bean definitions
    * with the BeanDefinitionRegistry based on its contents.
    */
   @SuppressWarnings("deprecation")  // for RequiredAnnotationBeanPostProcessor.SKIP_REQUIRED_CHECK_ATTRIBUTE
   private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
      ......
          
      if (metadata.isStatic()) {
         // static @Bean method
         if (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
            beanDef.setBeanClass(((StandardAnnotationMetadata) configClass.getMetadata()).getIntrospectedClass());
         }
         else {
            beanDef.setBeanClassName(configClass.getMetadata().getClassName());
         }
         beanDef.setUniqueFactoryMethodName(methodName);
      }
      else {
         // instance @Bean method
         beanDef.setFactoryBeanName(configClass.getBeanName());
         beanDef.setUniqueFactoryMethodName(methodName);
      }
       ......
   }
    ......
}