首頁 > 軟體

Spring Bean後處理器詳細介紹

2023-10-31 22:00:20

常見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 + ''' +
               '}';
    }

輸出結果:

可以看出,列印的都是spring的紀錄檔資訊,Bean1裡面的註解列印資訊,都沒有列印出來,說明沒有對其進行解析。

那麼,我們將如何讓註解解析,並列印資訊呢?使用Bean的後處理器來完成。

//註冊bean context.registerBean(AutowiredAnnotationBeanPostProcessor.class); //解析 @Autowired @Value註解 依賴注入階段解析

這時候執行,會報錯

為什麼會報錯呢?是因為在作值注入,解析字串的值的時候,還需要一個類去獲取getValue裡面的值的,預設情況下沒有這個功能,所以報錯

  //預設解析器不能解析值注入
     //獲取@Autowired的注入
        context.getDefaultListableBeanFactory().setAutowireCandidateResolver(new    ContextAnnotationAutowireCandidateResolver());

這時候執行,@Autowired和@value註解就被解析,列印資訊了

@value 生效:D:toolsjdk1.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 生效");
      }

到此這篇關於Spring Bean後處理器詳細介紹的文章就介紹到這了,更多相關Spring Bean後處理器內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com!


IT145.com E-mail:sddin#qq.com