實現Spring底層機制-03
7.實現任務階段5
7.1分析
階段5目標：bean後置處理器的實現
7.2程式碼實現
新增：
1.建立 InitializingBean 介面，實現該介面的 Bean 需要實現 Bean 的初始化方法
bean後置處理器的兩個方法，呼叫時機分別在 Bean 初始化方法的前後。因此要實現bean後置處理器，首先要實現 Bean 的初始化方法。
可以參考原生 Spring 規範來定義這個介面
package com.li.spring.processor;
/**
* @author 李
* @version 1.0
* 說明：
* 1.根據 spring 原生機制定義了一個介面
* 2.該介面有一個方法 afterPropertiesSet()，
* 3.afterPropertiesSet() 在 bean的 setter方法後執行，相當於原生的spring的 bean初始化方法
* 4.當一個Bean實現了這個介面後，就要實現afterPropertiesSet()，即 bean的初始化方法
*/
public interface InitializingBean {
void afterPropertiesSet() throws Exception;
}
2.為了測試，在MonsterService中實現該介面，並實現該方法，作為MonsterService的初始化方法
注：其他註解及自動裝配的實現詳見上一篇
package com.li.spring.component;
import com.li.spring.annotation.AutoWired;
import com.li.spring.annotation.Component;
import com.li.spring.annotation.Scope;
import com.li.spring.processor.InitializingBean;
/**
* @author 李
* @version 1.0
* MonsterService 是一個 Service
* 1.如果指定了value，那麼在注入spring容器時，以你指定的為準
* 2.如果沒有指定value，則使用類名（首字母小寫）作為預設名
*/
@Component//(value = "monsterService") //將 MonsterService注入到自己的spring容器中
@Scope(value = "prototype")
public class MonsterService implements InitializingBean {
//使用自定義註解修飾屬性，表示該屬性透過容器完成依賴注入
// （說明：按照名字進行組裝）
@AutoWired(required = true)
private MonsterDao monsterDao;
public void m1() {
monsterDao.hi();
}
/**
* 1.afterPropertiesSet()就是在bean的setter方法執行完畢之後，被spring容器呼叫
* 2.即 bean的初始化方法
*
* @throws Exception
*/
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("MonsterService 初始化方法被呼叫");
}
}
3.修改MySpringApplicationContext.java，新增邏輯：在建立後bean例項後，判斷是否需要進行初始化。
容器中常用的一個方法是，根據該類是否實現了某個介面，來判斷該類是否要執行某個業務邏輯。這個介面被稱為標記介面。
部分程式碼：
//完成createBean(BeanDefinition)方法
public Object createBean(BeanDefinition beanDefinition) {
//得到Bean的class物件
Class clazz = beanDefinition.getClazz();
try {
//反射建立bean例項
Object instance = clazz.getDeclaredConstructor().newInstance();
//todo 這裡要加入依賴注入的業務邏輯
//1.遍歷當前要建立物件的所有屬性欄位
for (Field declaredField : clazz.getDeclaredFields()) {
//2.判斷欄位是否有AutoWired註解
if (declaredField.isAnnotationPresent(AutoWired.class)) {
//判斷是否需要自動裝配
AutoWired autoWiredAnnotation =
declaredField.getAnnotation(AutoWired.class);
if (autoWiredAnnotation.required()) {
//3.得到欄位的名稱
String name = declaredField.getName();
//4.透過getBean()方法獲取要組裝的物件
//如果name對應的物件時單例的，就到單例池去獲取，如果是多例的，就反射建立並返回
Object bean = getBean(name);
//5.進行組裝
//暴破
declaredField.setAccessible(true);
declaredField.set(instance, bean);
}
}
}
System.out.println("======已建立好例項=====" + instance);
//todo 判斷是否要執行bean的初始化方法
// 1.判斷當前建立的 bean物件是否實現了 InitializingBean
// 2.instanceof 表示判斷物件的執行型別 是不是 某個型別或某個型別的子型別
if (instance instanceof InitializingBean) {
//3.將instance轉成介面型別，呼叫初始化方法
try {
((InitializingBean) instance).afterPropertiesSet();
} catch (Exception e) {
e.printStackTrace();
}
}
return instance;
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
//如果反射物件失敗
return null;
}
4.測試類
//...
public class AppMain {
public static void main(String[] args) {
MySpringApplicationContext ioc =
new MySpringApplicationContext(MySpringConfig.class);
MonsterService monsterService = (MonsterService) ioc.getBean("monsterService");
}
}
測試結果：MonsterService的初始化方法成功被呼叫。
5.建立 BeanPostProcessor 介面
package com.li.spring.processor;
/**
* @author 李
* @version 1.0
* 說明：
* 1.此介面參考原生Spring容器定義
* 2.該介面有兩個方法 postProcessBeforeInitialization和 postProcessAfterInitialization
* 3.這兩個方法會對spring容器的所有bean生效（切面程式設計）
*/
public interface BeanPostProcessor {
/**
* postProcessBeforeInitialization方法在bean的初始化方法前 呼叫
*
* @param bean
* @param beanName
* @return
*/
default Object postProcessBeforeInitialization(Object bean, String beanName) {
return bean;
}
/**
* postProcessAfterInitialization方法在bean的初始化方法後 呼叫
*
* @param bean
* @param beanName
* @return
*/
default Object postProcessAfterInitialization(Object bean, String beanName) {
return bean;
}
}
6.為了測試，自定義MyBeanPostProcessor實現上述介面。
package com.li.spring.component;
import com.li.spring.annotation.Component;
import com.li.spring.processor.BeanPostProcessor;
/**
* @author 李
* @version 1.0
* 1.這是我們自己的一個後置處理器，它實現了我們自定義的 BeanPostProcessor
* 2.透過重寫 BeanPostProcessor的方法實現相應業務
* 3.仍然將 MyBeanPostProcessor 看做一個Bean物件，使用Component註解，注入到spring容器中。
*/
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
System.out.println("後置處理器MyBeanPostProcessor的 Before()方法被呼叫，bean型別="
+ bean.getClass() + "，bean的名字=" + beanName);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
System.out.println("後置處理器MyBeanPostProcessor的 After()方法被呼叫，bean型別="
+ bean.getClass() + "，bean的名字=" + beanName);
return bean;
}
}
7.修改 MySpringApplicationContext.java（模擬原生的ioc）
後置處理器和普通bean的建立順序問題：
因為後置處理器要對容器中的所有bean物件都生效。因此後置處理器的bean物件的建立，要比普通的bean物件建立的時機靠前。
為了解決這個問題，我們將後置處理器物件的反射建立，提前到掃描包的時候完成（因為ioc容器初始化時，掃描工作要比反射物件的工作靠前）。
在原生的spring容器中，對後置處理器還是走的getBean，createBean方法。但如果這樣做，需要在singletonObjects中加入相應業務邏輯，這裡為了方便，我們簡化處理了
然後將建立的後置處理器物件放到一個單獨的集合來呼叫。
部分程式碼：
//該方法完成對指定包的掃描，並將Bean資訊封裝到BeanDefinition物件，再放入map中
public void beanDefinitionByScan(Class configClass) {
//步驟一：獲取要掃描的包
//...
//步驟二：得到要掃描的包下的所有資源（類.class）
//...
//步驟三：獲取全類名反射物件，並放入容器中
//...
//判斷該類是否有特定註解
if (clazz.isAnnotationPresent(Component.class)) {
//如果該類使用了 @Component ,說明是spring bean
System.out.println("是一個spring bean=" + clazz + " 類名=" + className);
//--------------------新增程式碼------------------------
/*
為了方便，如果發現是一個後置處理器，將其放入到ArrayList集合中
1.在原生的spring容器中，對後置處理器還是走的getBean，createBean方法
2.如果這樣做，需要在singletonObjects中加入相應業務邏輯
3.這裡為了方便，我們簡化處理
*/
//判斷當前class有沒有實現介面
//注意這裡我們不能透過 instanceof 判斷 class是否實現了 BeanPostProcessor
//因為clazz不是一個例項物件，而是一個Class物件，需要如下判斷：
if (BeanPostProcessor.class.isAssignableFrom(clazz)) {
BeanPostProcessor beanPostProcessor =
(BeanPostProcessor)clazz.newInstance();
//放入ArrayList集合中
beanPostProcessorList.add(beanPostProcessor);
continue;//簡化處理，不再將後置處理器的bean資訊放到beanDefinition物件中
}
//--------------------新增程式碼------------------------
//得到 BeanName-key
//...
//將 Bean資訊封裝到 BeanDefinition物件-value
//...
//將beanDefinition物件放入Map中
//...
} else {
//如果沒有使用，則說明不是spring bean
System.out.println("不是一個 spring bean=" + clazz + " 類名=" + className);
}
} catch (Exception e) {
e.printStackTrace();
}
}
System.out.println("===========================");
}}}
//完成createBean(BeanDefinition)方法
public Object createBean(String beanName, BeanDefinition beanDefinition) {
//得到Bean的class物件
Class clazz = beanDefinition.getClazz();
try {
//反射建立bean例項
Object instance = clazz.getDeclaredConstructor().newInstance();
// 這裡要加入依賴注入的業務邏輯
//...
System.out.println("======已建立好例項=====" + instance);
//--------------------新增程式碼start------------------------
//在bean的初始化方法前呼叫後置處理器的before方法
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
//在後置處理器的before方法，可以對容器的bean進行處理
// 然後返回處理後的bean例項。相當於做了前置處理
Object current = beanPostProcessor.
postProcessBeforeInitialization(instance, beanName);
//如果current為null，就不對instance做處理
if (current != null) {
instance = current;
}
}
//--------------------新增程式碼end------------------------
//判斷是否要執行bean的初始化方法
// 1.判斷當前建立的 bean物件是否實現了 InitializingBean
// 2.instanceof 表示判斷物件的執行型別 是不是 某個型別或某個型別的子型別
if (instance instanceof InitializingBean) {
//3.將instance轉成介面型別，呼叫初始化方法
try {
((InitializingBean) instance).afterPropertiesSet();
} catch (Exception e) {
e.printStackTrace();
}
}
//--------------------新增程式碼start------------------------
// 在bean的初始化方法後呼叫後置處理器的 after方法
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
//在後置處理器的 after方法，可以對容器的 bean進行處理
// 然後返回處理後的bean例項。相當於做了後置處理
Object current = beanPostProcessor.
postProcessAfterInitialization(instance, beanName);
if (current != null) {
instance = current;
}
}
//--------------------新增程式碼end------------------------
return instance;
} catch (InstantiationException e) {
//...
}
//如果反射物件失敗
return null;
}
8.測試類
//...
public class AppMain {
public static void main(String[] args) {
MySpringApplicationContext ioc =
new MySpringApplicationContext(MySpringConfig.class);
MonsterService monsterService = (MonsterService) ioc.getBean("monsterService");
monsterService.m1();
}
}
測試結果：成功在所有bean物件的初始化方法前後，呼叫後置處理器的方法（無論bean物件有無初始化方法）
後置處理器是對容器的所有bean生效，因此相當於可以對多個物件程式設計，即切面程式設計。日誌，身份，許可權，事務……都可以在後置處理器進行處理。
8.實現任務階段6
8.1分析
階段6目標：實現自己的AOP機制
在原生的Spring中，如果我們同時配置了後置處理器和切面類，並在後置處理器的兩個方法中輸出bean的執行型別。你會發現，在後置處理器的before...()方法輸出bean的型別時，bean物件還是原生型別；但在後置處理器的after...()方法輸出時，bean物件已經被封裝成了代理物件。
當然，變化的只是aop的目標方法對應的bean物件
因此，我們需要編寫方法，在後置處理器的after方法中，將原生的bean物件封裝成代理物件並返回。在代理物件中切入要執行的前置/返回/異常/最終通知等。
8.2程式碼實現
1.為了測試，建立介面和實現類，模擬aop的需求
（1）SmartAnimal 介面
package com.li.spring.component;
/**
* @author 李
* @version 1.0
*/
public interface SmartAnimal {
public float getSum(float i, float j);
public float getSub(float i, float j);
}
（2）SmartDog 實現類
package com.li.spring.component;
import com.li.spring.annotation.Component;
/**
* @author 李
* @version 1.0
*/
@Component(value = "smartDog")
public class SmartDog implements SmartAnimal {
@Override
public float getSum(float i, float j) {
float res = i + j;
System.out.println("SmartDog-getSum()-res=" + res);
return res;
}
@Override
public float getSub(float i, float j) {
float res = i - j;
System.out.println("SmartDog-getSub()-res=" + res);
return res;
}
}
2.模擬切面類
原生的切面類有@Aspect，@Before，@AfterReturning，@AfterThrowing，@After等註解。
這裡為了簡化，先將SmartAnimalAspect 當做一個“切面類”來使用，後面再分析如何做得更加靈活
package com.li.spring.component;
/**
* @author 李
* @version 1.0
* 先將SmartAnimalAspect 當做一個切面類來使用
* 後面再分析如何做得更加靈活
*/
public class SmartAnimalAspect {
public static void showBeginLog() {
System.out.println("前置通知...");
}
public static void showSuccessLog() {
System.out.println("返回通知...");
}
}
3.修改配置的後置處理器 MyBeanPostProcessor
在實現後置處理器時，呼叫createBean()方法反射bean物件後，會呼叫後置處理器的兩個方法。因此，我們可以在postProcessAfterInitialization()方法中判斷當前bean是否要返回代理物件，並進行處理。
部分程式碼：
package com.li.spring.component;
import com.li.spring.annotation.Component;
import com.li.spring.processor.BeanPostProcessor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @author 李
* @version 1.0
* 這是我們自己的一個後置處理器，它實現了我們自定義的 BeanPostProcessor
*/
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
//...
//...
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
System.out.println("後置處理器MyBeanPostProcessor的 After()方法被呼叫，bean型別="
+ bean.getClass() + "，bean的名字=" + beanName);
//實現aop，返回代理物件，即對bean進行包裝
//先寫死，後面我們可以透過註解的方式更加靈活運用
if ("smartDog".equals(beanName)) {
//使用jdk的動態代理，返回bean的代理物件
Object proxyInstance = Proxy.newProxyInstance(MyBeanPostProcessor.class.getClassLoader(),
bean.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("method=" + method.getName());
Object result = null;
//假設我們要進行前置,返回通知處理的方法是getSum()
//（原生的spring的通知方法是透過註解來獲取的）
//這裡我們後面再透過註解來做得更加靈活
if ("getSum".equals(method.getName())) {
//前置通知
SmartAnimalAspect.showBeginLog();
//目標方法
result = method.invoke(bean, args);
//返回通知
SmartAnimalAspect.showSuccessLog();
} else {
result = method.invoke(bean, args);
}
return result;
}
});
//如果bean需要返回代理物件，這裡就直接return ProxyInstance
return proxyInstance;
}
//如果不需要AOP，直接返回 bean
return bean;
}
}
4.測試類
//...
public class AppMain {
public static void main(String[] args) {
MySpringApplicationContext ioc =
new MySpringApplicationContext(MySpringConfig.class);
SmartAnimal smartDog = (SmartAnimal) ioc.getBean("smartDog");
System.out.println("smartDog型別=" + smartDog.getClass());
smartDog.getSum(100, 20);
}
}
測試結果：成功透過後置處理器的 postProcessAfterInitialization 方法，對bean物件進行包裝返回，同時透過invoke方法，插入前置通知和後置通知的方法。
擴充：如何做得更加靈活？
- 前面我們使用的硬編碼，不靈活，但是aop的核心機制差不多如此。
- 如果要把aop做得更加靈活，需要實現一點其他的邏輯（註解+資料結構map+切入表示式，其實和aop機制關係不大了）