實作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 = "https://www.cnblogs.com/liyuelian/archive/2023/01/29/monsterService") //將 MonsterService注入到自己的spring容器中
@Scope(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/29/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 = "https://www.cnblogs.com/liyuelian/archive/2023/01/29/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機制關系不大了）
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/542523.html
標籤：其他