Spring Bean後處理器詳細介紹
常見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:\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 生效");
}
到此這篇關於Spring Bean後處理器詳細介紹的文章就介紹到這瞭,更多相關Spring Bean後處理器內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！
推薦閱讀：
- 深入瞭解Spring控制反轉IOC原理
- Spring Bean自動裝配入門到精通
- Java Spring中Bean的作用域及生命周期
- Java基礎之Spring5的核心之一IOC容器
- 淺析Spring 中 Bean 的理解與使用