高级Spring之Bean后处理器

╰+哭是因爲堅強的太久メ 2024-03-27 09:12 42阅读 0赞

常见Bean后处理器的作用：

public static void main(String[] args) {
            // ⬇️GenericApplicationContext 是一个【干净】的容器  干净:没有额外的添加bean工厂处理器,bean处理器,消除一些干拢
            GenericApplicationContext context = new GenericApplicationContext();
    
            // ⬇️用原始方法注册三个 bean
            context.registerBean("bean1", Bean1.class);
            context.registerBean("bean2", Bean2.class);
            context.registerBean("bean3", Bean3.class);
        
        
            // ⬇️初始化容器
            context.refresh(); // 执行beanFactory后处理器, 添加bean后处理器, 初始化所有单例
    
            // ⬇️销毁容器
            context.close();
    
       
        }

Bean1

public class Bean1 {
        private static final Logger log = LoggerFactory.getLogger(Bean1.class);
    
        private Bean2 bean2;
    
        @Autowired
        public void setBean2(Bean2 bean2) {
            log.debug("@Autowired 生效: {}", bean2);
            this.bean2 = bean2;
        }
    
        @Autowired
        private Bean3 bean3;
    
        @Resource
        public void setBean3(Bean3 bean3) {
            log.debug("@Resource 生效: {}", bean3);
            this.bean3 = bean3;
        }
    
        private String home;
    
        @Autowired
        public void setHome(@Value("${JAVA_HOME}") String home) {
            log.debug("@Value 生效: {}", home);
            this.home = home;
        }
    
        @PostConstruct
        public void init() {
            log.debug("@PostConstruct 生效");
        }
    
        @PreDestroy
        public void destroy() {
            log.debug("@PreDestroy 生效");
        }
    
        @Override
        public String toString() {
            return "Bean1{" +
                   "bean2=" + bean2 +
                   ", bean3=" + bean3 +
                   ", home='" + home + '\'' +
                   '}';
        }

输出结果：

![8f43bcdc631d41a786fa562255166322.png][]

可以看出，打印的都是spring的日志信息，Bean1里面的注解打印信息，都没有打印出来，说明没有对其进行解析。

那么，我们将如何让注解解析，并打印信息呢？使用Bean的后处理器来完成。

//注册bean
            context.registerBean(AutowiredAnnotationBeanPostProcessor.class); //解析 @Autowired @Value注解   依赖注入阶段解析

这时候运行，会报错

![ff51ae8a99574c94a90b04106ee66177.png][]

为什么会报错呢？是因为在作值注入，解析字符串的值的时候，还需要一个类去获取getValue里面的值的，默认情况下没有这个功能，所以报错

//默认解析器不能解析值注入
         //获取@Autowired的注入
            context.getDefaultListableBeanFactory().setAutowireCandidateResolver(new    ContextAnnotationAutowireCandidateResolver());

这时候运行，@Autowired和@value注解就被解析，打印信息了

@value 生效：D:\tools\jdk1.8
    @Autowired 生效：com.tangyuan.ao4.Bean2@59d016c9

我们可以看到，bean生命周期的方法没有解析，所以我们要再加Bean后处理器：

context.registerBean(CommonAnnotationBeanPostProcessor.class); // @Resource @PostConstruct @PreDestroy  依赖注入 初始化前 销毁前

**彩蛋：springBoot中的后处理器-----属性绑定**

有一个bean，加了@ConfigurationProperties注解，并且给了一个prefix 前缀，将来会根据前缀配合我们的属性名称，去匹配我们配置文件中的信息，匹配到了就进行绑定

例如：

/*
        java.home=
        java.version=
     */
    @ConfigurationProperties(prefix = "java")
    public class Bean4 {
    
        private String home;
    
        private String version;
    
        public String getHome() {
            return home;
        }
    
        public void setHome(String home) {
            this.home = home;
        }
    
        public String getVersion() {
            return version;
        }
    
        public void setVersion(String version) {
            this.version = version;
        }
    
        @Override
        public String toString() {
            return "Bean4{" +
                   "home='" + home + '\'' +
                   ", version='" + version + '\'' +
                   '}';
        }
    }

前缀是java，所以匹配配置信息文件中，以java开头的 java.home，java.version，将值返回给属性名称

所以，我们下面演示spring中的后处理器来解析@ConfigurationProperties注解：

在上面的代码中，对bean4进行注册：

context.registerBean("bean4", Bean4.class);

ConfigurationPropertiesBindingPostProcessor.register(context.getDefaultListableBeanFactory()); 初始化前  @ConfigurationProperties    属性绑定

#### **继续讲bean重要的后处理器------AutowiredAnnotationBeanPostProcessor ，解析 @Autowired @Value注解 ，所以我们在这里对它的运行过程进行分析：** ####

// AutowiredAnnotationBeanPostProcessor 运行分析
    public class DigInAutowired {
        public static void main(String[] args) throws Throwable {
       //创建 beanFactory
            DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        //注册两个单例
            beanFactory.registerSingleton("bean2", new Bean2()); // 缺点：认为bean是成熟的bean,bean工厂不会执行创建过程,依赖注入,初始化
            beanFactory.registerSingleton("bean3", new Bean3());
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver()); // @Value
            beanFactory.addEmbeddedValueResolver(new StandardEnvironment()::resolvePlaceholders); // ${} 的解析器
    
            // 1. 查找哪些属性、方法加了 @Autowired, 这称之为 InjectionMetadata
            //创建后处理器对象
            AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
          //bean后处理器会间接用到beanFactory根据类型找bean
            processor.setBeanFactory(beanFactory);
    
             //实例化bean1
            Bean1 bean1 = new Bean1();
    //        System.out.println(bean1);
    //        processor.postProcessProperties(null, bean1, "bean1"); // 执行依赖注入 @Autowired @Value   参数：是否需要自动装配，被注入的目标，bean的名字
    //        System.out.println(bean1);
    
    //        Method findAutowiringMetadata = AutowiredAnnotationBeanPostProcessor.class.getDeclaredMethod("findAutowiringMetadata", String.class, Class.class, PropertyValues.class);
    //        findAutowiringMetadata.setAccessible(true);
    //        InjectionMetadata metadata = (InjectionMetadata) findAutowiringMetadata.invoke(processor, "bean1", Bean1.class, null);// 获取 Bean1 上加了 @Value @Autowired 的成员变量，方法参数信息
          后处理器的对象，bean的名字，类型，PropertyValue
    //        System.out.println(metadata);
    
            // 2. 调用 InjectionMetadata 来进行依赖注入, 注入时按类型查找值
    //        metadata.inject(bean1, "bean1", null);
    //        System.out.println(bean1);
    
            // 3. 如何按类型查找值
           //获取bean3类中的加了@Autowired注解的成员变量
            Field bean3 = Bean1.class.getDeclaredField("bean3");
          //封装成对象 false---->可选的
            DependencyDescriptor dd1 = new DependencyDescriptor(bean3, false);
           //根据成员变量去找要注入哪里
            Object o = beanFactory.doResolveDependency(dd1, null, null, null);
            System.out.println(o);
    
          //获取bean3类中的加了@Autowired注解的方法
            Method setBean2 = Bean1.class.getDeclaredMethod("setBean2", Bean2.class);
            DependencyDescriptor dd2 =
                    new DependencyDescriptor(new MethodParameter(setBean2, 0), true);
            Object o1 = beanFactory.doResolveDependency(dd2, null, null, null);
            System.out.println(o1);
    
           //获取bean3类中的加了@Autowired注解的参数的值注入方法
            Method setHome = Bean1.class.getDeclaredMethod("setHome", String.class);
            DependencyDescriptor dd3 = new DependencyDescriptor(new MethodParameter(setHome, 0), true);
            Object o2 = beanFactory.doResolveDependency(dd3, null, null, null);
            System.out.println(o2);
    
        }
    
             //Bean3
              @Autowired
              private Bean3 bean3;
    
              @Resource
              public void setBean3(Bean3 bean3) {
               log.debug("@Resource 生效: {}", bean3);
               this.bean3 = bean3;
             }
    
               private String home;
    
               @Autowired
               public void setHome(@Value("${JAVA_HOME}") String home) {
                 log.debug("@Value 生效: {}", home);
                 this.home = home;
             }
    
            @PostConstruct
              public void init() {
              log.debug("@PostConstruct 生效");
          }
       
            @PreDestroy
           public void destroy() {
              log.debug("@PreDestroy 生效");
          }

[8f43bcdc631d41a786fa562255166322.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e6bf30f20cd644c6b79513cb1905dea3.png
[ff51ae8a99574c94a90b04106ee66177.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/044d15e9561840018aaec1def9608a90.png