利用反射手寫代碼實現spring AOP

前言：上一篇博客自己動手編寫spring IOC源碼受到了大家的熱情關注，在這里博客十分感謝。特別是給博主留言建議的@瑪麗的竹子等等。本篇博客我們繼續，還是在原有的基礎上進行改造。下面請先欣賞一下博主畫的一張aop簡圖（沒有藝術天分，畫的不好莫見怪）

解析：往往在我們的系統的多個核心流程中會有一部分與之關系不大的相同的橫切流程，例如權限認證，事務管理。因此我們一般會抽象出這些相同的比較次要的交給spring aop的Handler來統一處理這些橫切流程也就是上圖中綠色部分。接下來我們看一下本例結構圖：

解析：1，我們的Hostess對象是Master接口的實現，主要實現了WalkDog()和shopping()兩個方法，而WalkDog()方法則是調用的是Dog接口的實現類的bark()方法。

2，我們整個程序的入口Client調用的Hostess對象的兩個核心方法，HumanHandler處理的Hostess對象的橫切流程。

public class Client {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); 
        
        Master master = (Master)context.getBean("humanProxy");
        
        System.out.println("");
        System.out.println("");
        System.out.println("");
        System.out.println("");
        
        master.shopping();
        master.WalkDog();
        
    }
}

package human;

import dog.Dog;

public class Hostess implements Master {
    
    private Dog dog;
    
    public void setDog(Dog dog) {
        this.dog = dog;
    }
    
    @Override
    public void WalkDog() {

        dog.bark();
    }
    
    @Override
    public void shopping(){
        System.out.println("瘋狂購物中");
    }

}

解析：通過以上代碼我們不難發現我們的程序只是調用核心業務，而往往核心業務的周圍有很多繁瑣的相對於比較次要的橫切業務。利用本例中遛狗，購物之前，我們需要再家做一些前提准備。例如：整理一下着裝，鎖上房門等等，回家之后有需要換鞋之類的。因此我們還需要一個handler來處理這些業務。

package aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class HumanHandler implements InvocationHandler {

    private Object target;// 目標是不固定
    
    public void setTarget(Object target) {
        this.target = target;
    }

    /*
     * return 返回是原來目標方法所返回的內容 method 就是要執行的方法
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        before();
        // 具體的業務邏輯代碼
        Object returnValue = method.invoke(target, args);

        after();
        return returnValue;
    }

    private void before() {
        // 前置任務
        System.out.println("[代理執行前置任務]整理着裝");
        System.out.println("[代理執行前置任務]帶上鑰匙");
        System.out.println("");
        System.out.println("[核心業務開始]*****************");
    }

    private void after() {
        // 后置任務
        System.out.println("[核心業務結束]*****************");
        System.out.println("");
        System.out.println("[代理執行后置任務]開門");
        System.out.println("[代理執行后置任務]換鞋");
    }

}

解析：有了handler我們還需要一個代理工廠

package org.springframework.aop.framework;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;


public class ProxyFactoryBean {

    private Object target;
    
    private InvocationHandler handler;
    
    public ProxyFactoryBean(Object target,InvocationHandler handler){
        this.target = target;
        this.handler = handler;
    }
    
    //返回本類的一個實例
    public Object getProxyBean() throws IllegalArgumentException, InstantiationException, IllegalAccessException, ClassNotFoundException{
        Object obj = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                handler);
        return obj;
    }
}

接下來我們來看一下本例的具體配置

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean id="hostess" class="human.Hostess" scope="prototype">
        <property name="dog" ref="dog1"></property>
    </bean>
    
    <bean id="dog1" class="dog.Taidi" scope="prototype"></bean>
    
    <bean id="dog2" class="dog.Labuladuo" scope="prototype"></bean>
    
    <bean id="humanHandler" class="aop.HumanHandler">
        <property name="target" ref="hostess"></property>
    </bean>
    
    <bean id="humanProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="handlerName" ref="humanHandler"></property>
        <property name="target" ref="hostess"></property>
    </bean>


</beans>

最后一步也是關鍵，本類中使用到的實例需要我們通過讀取上面這份配置文件然后通過反射構造出來。

package aop;

import java.io.File;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.springframework.aop.framework.ProxyFactoryBean;

public class ClassPathXmlApplicationContext implements ApplicationContext {

    private String fileName;
    
    public ClassPathXmlApplicationContext(String fileName){
        this.fileName = fileName;
    }
    
    @Override
    public Object getBean(String beanid) {
        
        System.out.println("傳遞過來的ID:"+beanid);
        
        //獲取本類的當前目錄
        String currentPath = this.getClass().getResource("").getPath().toString();
        SAXReader reader = new SAXReader();//DOM4J解釋器
        Document doc = null;//xml文檔本身
        Object obj = null;//目標表創建出來的實例
        try {
            doc = reader.read(  new File(currentPath+fileName)  );
            String xpath = "/beans/bean[@id='"+beanid+"']";
            Element beanNode = (Element) doc.selectSingleNode(xpath);
            String className = beanNode.attributeValue("class");
            

            if ("org.springframework.aop.framework.ProxyFactoryBean".equals(className)){
                
                
                Element interceptorNamesNode =
                        (Element) beanNode.selectSingleNode("property[@name='handlerName']");
                
                String handlerName_value = interceptorNamesNode.attributeValue("ref");

                Element targetNode = (Element) beanNode.selectSingleNode("property[@name='target']");
                String targetName_value = targetNode.attributeValue("ref");
                
                return forProxyFactoryBean(targetName_value,handlerName_value);
            }
            
            obj = Class.forName(className).newInstance();
            
            
            //查找下一代
            Element propertyNode = (Element) beanNode.selectSingleNode("property");
            if (propertyNode!=null){
                //注入
                //System.out.println("發現property節點，准備注入");
                //需要注入的屬性名
                String propertyName = propertyNode.attributeValue("name");
                //System.out.println("需要注入的屬性："+propertyName);
                
                //注入方法
                String executeMethod = "set"+(propertyName.substring(0, 1)).toUpperCase()+propertyName.substring(1,propertyName.length());
                //System.out.println("需要執行注入方法："+executeMethod);
                
                //需要注入的對象實例
                String di_object_name = propertyNode.attributeValue("ref");
                //System.out.println("注入的對象是："+di_object_name);
                
                //定義我們的需要注入的對象實例[遞歸算法：1.層級是不知道多少層的  2.自己調用自己  3.最后1層會自己結束]
                Object di_object = getBean(di_object_name);
                //System.out.println("xxx:"+di_object);
                
                //Method method = obj.getClass().getMethod(executeMethod,di_object.getClass().getInterfaces());// new Method(executeMethod);
                Method []methods = obj.getClass().getMethods();
                
                for (Method m : methods) {
                    if(executeMethod.equals(m.getName())  ) {
                        m.invoke(obj, di_object);
                        break;
                    }
                }
                
            }
            else{
                System.out.println("沒有屬性，結束即可");
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        System.out.println("返回實例："+obj);
        return obj;
    }

    
    public Object forProxyFactoryBean(String targetName_value,String handlerName_value) throws Exception{
        System.out.println("目標對象"+targetName_value);
        
        Object target = getBean(targetName_value);
        
        System.out.println("代理對象"+handlerName_value);
        
        InvocationHandler handler = (InvocationHandler) getBean(handlerName_value);
        
        return new ProxyFactoryBean(target,handler).getProxyBean();
    }
}

下面是運行結果

總結：1 spring aop將我們的系統分為兩部分，一核心業務，二橫切業務。我們的只需關注核心業務，橫切業務統一交給代理去處理。

2 本例依舊是利用反射調用橫切方法實現aop，還是那句話，我們自己寫的自然是漏洞百出，只是為了說明問題。作為一個開源的框架，如果對spring源碼感興趣的朋友可以自行查看。

另：博主的個人博客也在努力搭建中，歡迎與各位學習交流，謝謝！個人博客地址:http://www.singletonh.top/