• Spring的后处理器

    目录

    Spring后处理器

    Bean工厂后处理器-BeanFactoryPostProcessor

    修改beanDefinition对象

    添加beanDefiniton对象

    方法一

    方法二

    自定义@Component

    Spring后处理器

    • Spring后处理器是Spring对外开放的重要拓展点（让我们可以用添加自己的逻辑），允许我们介入到Bean的整个实例化流程中来，以达到动态注册BeanDefinition（向BeanDefitionMap中添加BeanDefition对象的过程），动态修改BeanDefition，以及动态修改Bean的作用。Spring主要有两种后处理器
      • BeanFactoryPostprocessor：Bean工厂后处理器，（执行时机）在BeanDefinitionMap填充完毕，Bean实例化之前执行
      • BeanPostProcessor：Bean后处理器，（执行时机）一般在Bean实例化后，填充到单例池singletonObjects之前执行

    Bean工厂后处理器-BeanFactoryPostProcessor

    • BeanFactoryPostProcessor是一个接口规范，实现该接口的类只要交由Spring容器管理（即在配置文件中注册该类称为Bean对象）的话，那么Spring就会回调该接口的方法，用于对BeanDefition注册和修改功能
    • BeanFactoryPostProcessor定义如下 
        1. //
        2. // Source code recreated from a .class file by IntelliJ IDEA
        3. // (powered by FernFlower decompiler)
        4. //
        5.  
        6. package org.springframework.beans.factory.config;
        7.  
        8. import org.springframework.beans.BeansException;
        9.  
        10. @FunctionalInterface
        11. public interface BeanFactoryPostProcessor {
        12.     void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
        13. }
    修改beanDefinition对象

    • 创建一个实现类（修改beanDefinition对象）

        1. package com.example.PostProcessor;
        2.  
        3. import org.springframework.beans.BeansException;
        4. import org.springframework.beans.factory.config.BeanDefinition;
        5. import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
        6. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
        7.  
        8. public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
        9.     @Override
        10.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        11.         System.out.println("beanDefinitionMap填充完毕后会回调该方法");
        12.         // todo 修改Map集合中的BeanDefinition对象
        13.         BeanDefinition userService = beanFactory.getBeanDefinition("userService");
        14.         userService.setBeanClassName("com.example.DAO.Impl.UserDAOImpl");
        15.  
        16.     }
        17. }

    • 测试类

        1. package com.example.Test;
        2.  
        3.  
        4. import org.springframework.context.support.ClassPathXmlApplicationContext;
        5. public class TestApplicationContext {
        6.     public static void main(String[] args)  {
        7.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        8.         System.out.println(context.getBean("userService"));
        9.     }
        10. }

    • 运行结果如下

      • 显然bean对应的类被改变了 
    添加beanDefiniton对象
    方法一
    • 创建一个类（添加beanDefiniton对象） 
        1. package com.example.PostProcessor;
        2.  
        3. import org.springframework.beans.BeansException;
        4. import org.springframework.beans.factory.config.BeanDefinition;
        5. import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
        6. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
        7. import org.springframework.beans.factory.support.DefaultListableBeanFactory;
        8. import org.springframework.beans.factory.support.RootBeanDefinition;
        9.  
        10. public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
        11.     @Override
        12.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        13.         // todo 向Map集合中添加一个BeanDefinition对象，即在配置文件中没有注册
        14.         // 创建一个新的beanDefinition对象
        15.         BeanDefinition beanDefinition = new RootBeanDefinition();
        16.         // 设置bean对应的类
        17.         beanDefinition.setBeanClassName("com.example.DAO.Impl.UserDAOImpl");
        18.         DefaultListableBeanFactory listableBeanFactory = (DefaultListableBeanFactory) beanFactory;
        19.         // 添加该beanDefinition对象
        20.         listableBeanFactory.registerBeanDefinition("UserDAO", beanDefinition);
        21.     }
        22. }

        在配置文件中没有配置UserDAO了

    • 测试类

        1. package com.example.Test;
        2.  
        3.  
        4. import com.example.DAO.Impl.UserDAOImpl;
        5. import org.springframework.context.support.ClassPathXmlApplicationContext;
        6.  
        7. public class TestApplicationContext {
        8.     public static void main(String[] args) {
        9.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        10.         
        11.         System.out.println(context.getBean(UserDAOImpl.class));
        12.     }
        13. }

    • 运行结果

                    beanDefinition对象成功添加

    方法二
    • Spring提供了一个BeanFactoryPostProcessor的子接口BeanDefinitionRegistryPostProcessor专门用于注册BeanDefinition操作 
        1. //
        2. // Source code recreated from a .class file by IntelliJ IDEA
        3. // (powered by FernFlower decompiler)
        4. //
        5.  
        6. package org.springframework.beans.factory.support;
        7.  
        8. import org.springframework.beans.BeansException;
        9. import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
        10.  
        11. public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
        12.     void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
        13. }

    • 创建一个类实现后处理器BeanFactoryPostProcessor的子接口BeanDefinitionRegistryPostProcessor（记得将该类注册到Spring容器中）

        1. package com.example.PostProcessor;
        2.  
        3. import org.springframework.beans.BeansException;
        4. import org.springframework.beans.factory.config.BeanDefinition;
        5. import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
        6. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
        7. import org.springframework.beans.factory.support.BeanDefinitionRegistry;
        8. import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
        9. import org.springframework.beans.factory.support.DefaultListableBeanFactory;
        10. import org.springframework.beans.factory.support.RootBeanDefinition;
        11.  
        12. public class MyBeanFactoryPostProcessor02 implements BeanDefinitionRegistryPostProcessor {
        13.     @Override
        14.     public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        15.         // 注册beanDefinition
        16.         BeanDefinition beanDefinition = new RootBeanDefinition();
        17.         beanDefinition.setBeanClassName("com.example.DAO.Impl.UserDAOImpl");
        18.         registry.registerBeanDefinition("UserDAO", beanDefinition);
        19.     }
        20.     @Override
        21.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        22.  
        23.     }
        24. }

        实现添加beanDefiniton就会简单很多

    • 测试类

        1. package com.example.Test;
        2.  
        3.  
        4. import com.example.DAO.Impl.UserDAOImpl;
        5. import org.springframework.context.support.ClassPathXmlApplicationContext;
        6.  
        7. public class TestApplicationContext {
        8.     public static void main(String[] args) {
        9.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        10.         System.out.println(context.getBean(UserDAOImpl.class));
        11.     }
        12. }

    • 运行结果如下

    完整流程图 

            
     

    自定义@Component
    • 案例
      • 使用Spring的BeanFactoryPostProcessor扩展点完成自定义注解扫描
    • 要求
      • 自定义@MyComponent注解，使用在类上
      • 使用资料中提供好的包扫描工具BaseClassScanUtils完成指定包的类扫描
      • 自定义BeanFactoryPostProcessor完成注解@MyComponent的解析，解析最终被Spring管理
    • 具体代码如下
      • 注解类 
          1. package com.example.Anno;
          2.  
          3. import java.lang.annotation.ElementType;
          4. import java.lang.annotation.Retention;
          5. import java.lang.annotation.RetentionPolicy;
          6. import java.lang.annotation.Target;
          7.  
          8. @Target(ElementType.TYPE) // 设该注解的使用范围
          9. @Retention(RetentionPolicy.RUNTIME) // 设置该注解运行期间可见
          10. public @interface MyComponent {
          11.     String value(); //用于设置注解的值
          12. }

      • 工具类

          1. package com.example.Utils;
          2.  
          3. import com.example.Anno.MyComponent;
          4. import org.springframework.core.io.Resource;
          5. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
          6. import org.springframework.core.io.support.ResourcePatternResolver;
          7. import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
          8. import org.springframework.core.type.classreading.MetadataReader;
          9. import org.springframework.core.type.classreading.MetadataReaderFactory;
          10. import org.springframework.util.ClassUtils;
          11.  
          12. import java.util.HashMap;
          13. import java.util.Map;
          14.  
          15. public class BaseClassScanUtils {
          16.  
          17.     //设置资源规则
          18.     private static final String RESOURCE_PATTERN = "/**/*.class";
          19.  
          20.     public static Map scanMyComponentAnnotation(String basePackage) {
          21.  
          22.         //创建容器存储使用了指定注解的Bean字节码对象
          23.         Map annotationClassMap = new HashMap();
          24.  
          25.         //spring工具类，可以获取指定路径下的全部类
          26.         ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
          27.         try {
          28.             String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
          29.                     ClassUtils.convertClassNameToResourcePath(basePackage) + RESOURCE_PATTERN;
          30.             Resource[] resources = resourcePatternResolver.getResources(pattern);
          31.             //MetadataReader 的工厂类
          32.             MetadataReaderFactory refractory = new CachingMetadataReaderFactory(resourcePatternResolver);
          33.             for (Resource resource : resources) {
          34.                 //用于读取类信息
          35.                 MetadataReader reader = refractory.getMetadataReader(resource);
          36.                 //扫描到的class
          37.                 String classname = reader.getClassMetadata().getClassName();
          38.                 Class clazz = Class.forName(classname);
          39.                 //判断是否属于指定的注解类型
          40.                 if(clazz.isAnnotationPresent(MyComponent.class)){
          41.                     //获得注解对象
          42.                     MyComponent annotation = clazz.getAnnotation(MyComponent.class);
          43.                     //获得属value属性值
          44.                     String beanName = annotation.value();
          45.                     //判断是否为""
          46.                     if(beanName!=null&&!beanName.equals("")){
          47.                         //存储到Map中去
          48.                         annotationClassMap.put(beanName,clazz);
          49.                         continue;
          50.                     }
          51.  
          52.                     //如果没有为"",那就把当前类的类名作为beanName
          53.                     annotationClassMap.put(clazz.getSimpleName(),clazz);
          54.  
          55.                 }
          56.             }
          57.         } catch (Exception exception) {
          58.         }
          59.  
          60.         return annotationClassMap;
          61.     }
          62.  
          63.     public static void main(String[] args) {
          64.         Map stringClassMap = scanMyComponentAnnotation("com.itheima");
          65.         System.out.println(stringClassMap);
          66.     }
          67. }

      • 使用注解来注册为Bean对象的类

          1. package com.example.Beans;
          2.  
          3. import com.example.Anno.MyComponent;
          4.  
          5. @MyComponent("otherBean")
          6. public class otherBeans {
          7. }

          在配置文件中没有配置该类作为bean对象

      • 后工厂处理器类（该类要交给Spring容器管理）

          1. package com.example.PostProcessor;
          2.  
          3.  
          4. import com.example.Utils.BaseClassScanUtils;
          5. import org.springframework.beans.BeansException;
          6. import org.springframework.beans.factory.config.BeanDefinition;
          7. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
          8. import org.springframework.beans.factory.support.BeanDefinitionRegistry;
          9. import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
          10. import org.springframework.beans.factory.support.RootBeanDefinition;
          11.  
          12. import java.util.Map;
          13.  
          14. public class MyComponentBeanFactoryProcessor implements BeanDefinitionRegistryPostProcessor {
          15.     @Override
          16.     public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
          17.         // 通过工具去扫描指定包及其子包下的所有类，收集使用@MyComponent注解的类，放在Map集合中
          18.         Map MyComponentAnnotationMap = BaseClassScanUtils.scanMyComponentAnnotation("com.example");
          19.         // 遍历Map，组装BeanDefinition进行注册
          20.         MyComponentAnnotationMap.forEach((beanName,clazz)->{
          21.             // 获取beanClassName
          22.             String beanClassName = clazz.getName();
          23.             // 创建beanDefinition
          24.             BeanDefinition beanDefinition = new RootBeanDefinition();
          25.             beanDefinition.setBeanClassName(beanClassName);
          26.             // 注册
          27.             registry.registerBeanDefinition(beanName,beanDefinition);
          28.         });
          29.  
          30.     }
          31.  
          32.     @Override
          33.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
          34.  
          35.     }
          36. }

          通过后工厂处理器类来将标记了自己创建的@MyComponent注解的类创建为beanDefinition对象后添加到beanDefinitionMap集合中。

      • 测试类

          1. package com.example.Test;
          2.  
          3.  
          4. import com.example.Beans.otherBeans;
          5. import org.springframework.context.support.ClassPathXmlApplicationContext;
          6.  
          7. public class TestApplicationContext {
          8.     public static void main(String[] args) {
          9.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
          10.         System.out.println(context.getBean(otherBeans.class));
          11.     }
          12. }

      • 运行结果


        •  

        • 运行成功~

    • 使用注解注册bean的原理

      • 最主要是通过Bean工厂后处理器进行实现的，通过工具类获取到添加了注解的类的集合后，在后处理器中，对扫描结果进行遍历，然后生成对对应的beanDefinition对象后，注册到beanDefinitonMap集合后即可。

  • 相关阅读:
    八、线性代数二 ，矩阵的秩
    Vulhub靶场搭建与使用
    iOS开发-Xcode
    数据结构--字符串的模式匹配
    10.01
    net基于asp.net的二手商品的交易系统-二手网站-计算机毕业设计
    电商RN项目秒开优化实践
    Clion~Clion常用配置和插件
    HTA入门基础教程 | VBS脚本的GUI界面 HTA简明教程 ,附带完整历程及界面美化
    多个服务器的用户共享同一个用户目录的做法
  • 原文地址：https://blog.csdn.net/weixin_64939936/article/details/133089906