2. 程式人生 > >AOP的實現原理—反射與動態代理

AOP的實現原理—反射與動態代理

阿新 • • 發佈：2019-02-06

        其實AOP的意思就是面向切面程式設計。OO注重的是我們解決問題的方法(封裝成Method)，而AOP注重的是解決許多問題的方法中的共同點，是對OO思想的一種補充！還是拿人家經常舉的一個例子講解一下吧：比如說，我們現在要開發的一個應用裡面有很多的業務方法，但是，我們現在要對這個方法的執行做全面監控,或部分監控。也許我們就會在要一些方法前去加上一條日誌記錄，我們寫個例子看看我們最簡單的解決方案。

public interface IHello {
     /**
      * 假設這是一個業務方法
      * @param name
      */
     void sayHello(String name);
}

        裡面有一個方法，用於輸入"Hello"加傳進來的姓名。我們去寫個類實現IHello介面： 

public class Hello implements IHello {
    public void sayHello(String name) {
        System.out.println("Hello " + name);
    }
}

        現在我們要為這個業務方法加上日誌記錄的業務，在不改變原始碼的情況下，我們會去怎麼做呢?也許，你會去寫一個類去實現IHello介面，並依賴Hello這個類。程式碼如下： 

public class HelloProxy implements IHello {
     private IHello hello;
     public HelloProxy(IHello hello) {
         this.hello = hello;
     }
     public void sayHello(String name) {
        Logger.logging(Level.DEBUGE, "sayHello method start.");
        hello.sayHello(name);
        Logger.logging(Level.INFO, "sayHello method end!");
     }
}

        其中Logger類程式碼如下:

public class Logger{
    /**
     * 根據等級記錄日誌
     * @param level
     * @param context
     */
    public static void logging(Level level, String context) {
        if (level.equals(Level.INFO)) {
            System.out.println(new Date().toLocaleString() + " " + context);
        }
        if (level.equals(Level.DEBUGE)) {
            System.err.println(new Date() + " " + context);
        }
    }
}

        Level列舉程式碼如下:

public enum Level {
    INFO,DEBUGE;
}

        現在我們去寫個測試類看看，程式碼如下：

public class Test {
    public static void main(String[] args) {
        IHello hello = new HelloProxy(new Hello());
        hello.sayHello("Doublej");
    }
}

        執行以上程式碼我們可以得到下面結果： 

Tue Mar 04 20:57:12 CST 2008 sayHello method start.
Hello Doublej
2008-3-4 20:57:12 sayHello method end!

        從上面的程式碼我們可以看出，hello物件是被HelloProxy這個所謂的代理類所建立的。這樣，如果我們以後要把日誌記錄的功能去掉。那我們只要把得到hello物件的程式碼改成以下：

public class Test {
    public static void main(String[] args) {
        IHello hello = new Hello();
        hello.sayHello("Doublej");
    }
}

        上面的程式碼，可以說是AOP最簡單的實現！

        但是我們會發現一個問題，如果我們像Hello這樣的類很多，那麼，我們是不是要去寫很多個HelloProxy這樣的類呢？沒錯，是的。其實也是一種很麻煩的事。在jdk1.3以後，jdk跟我們提供了一個API,即java.lang.reflect.InvocationHandler的類。 這個類可以讓我們在JVM呼叫某個類的方法時動態的為些方法做些什麼事，讓我們把以上的程式碼改一下來看看效果。同樣，我們寫一個IHello的介面和一個Hello的實現類。在介面中，我們定義兩個方法；程式碼如下 ：

public interface IHello {
    /**
     * 業務處理A方法
     * @param name
     */
    void sayHello(String name);
    /**
     * 業務處理B方法
     * @param name
     */
    void sayGoogBye(String name);
}

        Hello.java程式碼如下： 

public class Hello implements IHello {
    public void sayHello(String name) {
        System.out.println("Hello " + name);
    }
    public void sayGoogBye(String name) {
        System.out.println(name+" GoodBye!");
    }
}

        我們一樣的去寫一個代理類。只不過，讓這個類去實現java.lang.reflect.InvocationHandler介面，程式碼如下： 

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynaProxyHello implements InvocationHandler {
    /**
     * 要處理的物件(也就是我們要在方法的前後加上業務邏輯的物件,如例子中的Hello)
     */
    private Object delegate;
    /**
     * 動態生成方法被處理過後的物件 (寫法固定)
     * 
     * @param delegate
     * @param proxy
     * @return
     */
    public Object bind(Object delegate) {
        this.delegate = delegate;
        return Proxy.newProxyInstance(
                this.delegate.getClass().getClassLoader(), this.delegate
                        .getClass().getInterfaces(), this);
    }
    /**
     * 要處理的物件中的每個方法會被此方法送去JVM呼叫,也就是說,要處理的物件的方法只能通過此方法呼叫
     * 此方法是動態的,不是手動呼叫的
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        try {
            //執行原來的方法之前記錄日誌
            Logger.logging(Level.DEBUGE, method.getName() + " Method end .");
            
            //JVM通過這條語句執行原來的方法(反射機制)
            result = method.invoke(this.delegate, args);
            //執行原來的方法之後記錄日誌
            Logger.logging(Level.INFO, method.getName() + " Method Start!");
        } catch (Exception e) {
            e.printStackTrace();
        }
        //返回方法返回值給呼叫者
        return result;
    }
}

        上面類中出現的Logger類和Level列舉還是和上一上例子的實現是一樣的，這裡就不貼出程式碼了。 

public class Test {
    public static void main(String[] args) {
        IHello hello = (IHello)new DynaProxyHello().bind(new Hello());
        hello.sayGoogBye("Double J");
        hello.sayHello("Double J");
    }
}

        執行輸出的結果如下： 

Tue Mar 04 21:24:03 CST 2008 sayGoogBye Method end .
Double J GoodBye!
2008-3-4 21:24:03 sayGoogBye Method Start!
Tue Mar 04 21:24:03 CST 2008 sayHello Method end .
Hello Double J
2008-3-4 21:24:03 sayHello Method Start!

        由於執行緒的關係，第二個方法的開始出現在第一個方法的結束之前。這不是我們所關注的!從上面的例子我們看出，只要你是採用面向介面程式設計，那麼，你的任何物件的方法執行之前要加上記錄日誌的操作都是可以的。他(DynaPoxyHello)自動去代理執行被代理物件(Hello)中的每一個方法，一個java.lang.reflect.InvocationHandler介面就把我們的代理物件和被代理物件解藕了。但是，我們又發現還有一個問題，這個DynaPoxyHello物件只能跟我們去在方法前後加上日誌記錄的操作。我們能不能把DynaPoxyHello物件和日誌操作物件(Logger)解藕呢?

        結果是肯定的，讓我們來分析一下我們的需求。我們要在被代理物件的方法前面或者後面去加上日誌操作程式碼(或者是其它操作的程式碼)，那麼，我們可以抽象出一個介面，這個接口裡就只有兩個方法，一個是在被代理物件要執行方法之前執行的方法，我們取名為start，第二個方法就是在被代理物件執行方法之後執行的方法，我們取名為end 。介面定義如下 ： 

public interface IOperation {
    /**
     * 方法執行之前的操作
     * @param method
     */
    void start(Method method);
    /**
     * 方法執行之後的操作
     * @param method
     */
    void end(Method method);
}

        我們去寫一個實現上面介面的類，我們把它作為真正的操作者，如下面是日誌操作者類，它實現了上面的介面：

public class LoggerOperation implements IOperation {
    public void end(Method method) {
        Logger.logging(Level.DEBUGE, method.getName() + " Method end .");
    }
    public void start(Method method) {
        Logger.logging(Level.INFO, method.getName() + " Method Start!");
    }
}

        然後我們要改一下代理物件DynaProxyHello中的程式碼，如下： 

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynaProxyHello implements InvocationHandler {
    /**
     * 操作者
     */
    private Object proxy;
    /**
     * 要處理的物件(也就是我們要在方法的前後加上業務邏輯的物件,如例子中的Hello)
     */
    private Object delegate;


    /**
     * 動態生成方法被處理過後的物件 (寫法固定)
     * 
     * @param delegate
     * @param proxy
     * @return
     */
    public Object bind(Object delegate,Object proxy) {
       
        this.proxy = proxy;
        this.delegate = delegate;
        return Proxy.newProxyInstance(
                this.delegate.getClass().getClassLoader(), this.delegate
                        .getClass().getInterfaces(), this);
    }
    /**
     * 要處理的物件中的每個方法會被此方法送去JVM呼叫,也就是說,要處理的物件的方法只能通過此方法呼叫
     * 此方法是動態的,不是手動呼叫的
    */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        try {
        //反射得到操作者的例項
            Class clazz = this.proxy.getClass();
            //反射得到操作者的Start方法
            Method start = clazz.getDeclaredMethod("start",new Class[] { Method.class });
            //反射執行start方法
            start.invoke(this.proxy, new Object[] { method });
            //執行要處理物件的原本方法
            result = method.invoke(this.delegate, args);
            //反射得到操作者的end方法
            Method end = clazz.getDeclaredMethod("end",new Class[] { Method.class });
            //反射執行end方法
            end.invoke(this.proxy, new Object[] { method });
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
}

        然後我們把Test.java中的程式碼改一下，測試一下： 

public class Test {
    public static void main(String[] args) {
        IHello hello = (IHello)new DynaProxyHello().bind(new Hello(),new LoggerOperation());
        hello.sayGoogBye("Double J");
        hello.sayHello("Double J");
        
    }
}

         結果還是一樣的吧。如果你想在每個方法之前加上日誌記錄,而不在方法後加上日誌記錄，你就把LoggerOperation類改成如下： 

import java.lang.reflect.Method;
public class LoggerOperation implements IOperation {
    public void end(Method method) {
        //Logger.logging(Level.DEBUGE, method.getName() + " Method end .");
    }
    public void start(Method method) {
        Logger.logging(Level.INFO, method.getName() + " Method Start!");
    }
}

        執行一下，你就會發現，每個方法之後沒有記錄日誌了。 這樣，我們就把代理者和操作者解藕了！

        如果我們不想讓所有方法都被日誌記錄，我們應該怎麼去解藕呢?我的想法是在代理物件的public Object invoke(Object proxy, Method method, Object[] args)方法裡面加上個if()，對傳進來的method的名字進行判斷，判斷的條件存在XML裡面。這樣我們就可以通過配置檔案進行解藕了。如果有興趣的朋友可以把操作者、被代理者都通過配置檔案進行配置，那麼就可以寫一個簡單的Spring AOP框架了。

相關推薦

AOP的實現原理—反射與動態代理

        其實AOP的意思就是面向切面程式設計。OO注重的是我們解決問題的方法(封裝成Method)，而AOP注重的是解決許多問題的方法中的共同點，是對OO思想的一種補充！還是拿人家經常舉的一個

aop 實現原理（jdk動態代理和動態生成class）

java中可以通過jdk提供的 Proxy.newProxyInstance靜態方法來建立動態代理物件,下面先來看看這個方法的實現public static Object newProxyInstance(ClassLoader loader, Class<?>[

java反射與動態代理的理解

system 對象的訪問 讓我 integer 打破 類屬性 全部 列表 ces 一、什麽是反射機制？ 　　反射的官方定義是這樣的：在運行狀態中，對於任意的一個類，都能夠知道這個類的所有屬性和方法，對任意一個對象都能夠通過反射機制調用一個類的任意方法，這種動態獲取類信息及動

基礎 | Java的反射與動態代理

關於「反射」請參看Class類詳解（反射）部分。 動態代理作為Java反射的主要應用之一，其在多種JavaEE框架中均有使用，如Spring框架中AOP的實現原理就是動態代理，面試中提到AOP也必定會問 「談談對動態代理的理解？」 相關問題，在此做一個梳理與總結。 談

反射與動態代理

反射是動態語言的關鍵，動態代理正是通過反射實現     一.靜態代理：    靜態代理是通過構建代理類物件，將被代理類物件以引數的形式傳遞給代理類物件，進而在代理類物件中呼叫被代理類的方法。 程式碼實現如下： 1.建立介面 2.定義

Spring AOP實現原理-動態代理

目錄 代理模式 靜態代理 動態代理 代理模式 我們知道，Spring AOP的主要作用就是不通過修改原始碼的方式、將非核心功能程式碼織入來實現對方法的增強。那麼Spring AOP的底層如何實現對方法的增強？實現的關鍵在於使用了代理模式 代理模式的作用就是為其它物件提供一種代理，以控制

AOP實現原理——動態代理

      前幾天阿里面試問AOP是怎麼實現的,感覺自己當時答的不好,於是回來重新研究了一下,找了下資料,現在來做個分享.       Spring兩大核心IOC與AOP.IOC負責將物件動態的注入到容器,讓容器來管理bean，AOP就是可以讓容器中的物件都享

JAVA語言核心精講5-反射機制與動態代理原理

談談 Java 反射機制，動態代理是基於什麼原理？典型回答反射機制是 Java 語言提供的一種基礎功能，賦予程式在執行時自省（introspect，官方用語）的能力。通過反射我們可以直接操作類或者物件，比如獲取某個物件的類定義，獲取類宣告的屬性和方法，呼叫方法或者構造物件，甚

Java靜態代理與動態代理模式的實現

loader 兩個 如何 圖片 ide 相同 catch 規範 png 前言： 在現實生活中，考慮以下的場景:小王打算要去租房，他相中了一個房子，準備去找房東洽談相關事宜。但是房東他很忙，平時上班沒時間，總沒有時間見面，他也沒辦法。後來，房東想了一個辦法，他找到了一個

淺談java中內置的觀察者模式與動態代理的實現

所有 代理 notify play ani effect 一個 indicate protected 一.關於觀察者模式 1.將觀察者與被觀察者分離開來，當被觀察者發生變化時，將通知所有觀察者，觀察者會根據這些變化做出對應的處理。 2.jdk裏已經提供對應的Observer

AOP與動態代理

什麽 編譯 spec 加載中 cglib 後者 監控 修改 打印 AOP AOP是指在jvm運行時, 動態將代碼切入到指定位置. OOP是一個維度上寫代碼, AOP是把他切開來, 變成立體的. 這樣的好處是: 業務邏輯跟輔助邏輯分離, 例如日誌打印, 性能監控, 安全控制

Java反射機制——動態代理的理解與程式碼體現！

package com.ITcore.cn; /** * @author 維宇——鮀城小帥 * 作於：2018-10-9 * 別代理物件 * */ public interface Father { //購買 public void buy(); }   packa

Java反射機制與動態代理（一）

導讀： 1. 什麼是反射 2. 反射的基本使用 3. 反射的使用例項 一、什麼是反射？   Java反射機制是在執行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個物件，都能夠呼叫它的任意一個方法和屬性；這

Java反射機制與動態代理（二）

導讀： 1. 代理模式 2. 靜態代理 3. 動態代理 4. 小結 一、代理模式 代理模式所涉及的角色有： 抽象主題角色：聲明瞭真實主題和代理主題的共同介面，這樣一來在任何可以使用真實主題的地方都可以使用代理主題。 真實主

java反射機制（2）- 實踐：反射機制+動態代理實現模擬RMI遠端方法呼叫

1 涉及主要知識點   1、RMI(Remote Method Invocation)：遠端方法呼叫是一種計算機之間利用遠端物件互相呼叫實現雙方通訊的一種通訊機制。使用這種機制，某一臺計算機上

反射機制與動態代理

以前學習基礎的時候不知道哪些是重點，也不會注意，自己動手少，用的少，自然也不會知道，就落下了知識點，當被問反射機制起來時，聽過，但怎麼說，到底是怎麼一回事，腦子一片空白，答不上來，也覺得慚愧。 一.什麼是反射機制？ 在執行期中，對於任意一個類，都能夠呼叫某一個類的

AOP靜態代理與動態代理

AOP面相切面程式設計，是作為面向物件的一種補充，用於處理系統中分佈於各個模組的橫切關注點，比如事務管理，日誌，快取，異常等。AOP代理分類靜態代理和動態代理靜態代理靜態代理就是AOP框架會在編譯階段將Aspect植入java位元組碼中，生成AOP代理類，在執行的時候，是直接

Spring--Spring AOP 實現原理與 CGLIB 應用

AOP（Aspect Orient Programming），也就是面向方面程式設計，作為面向物件程式設計的一種補充，專門用於處理系統中分佈於各個模組（不同方法）中的交叉關注點的問題，在 Java EE 應用中，常常通過 AOP 來處理一些具有橫切性質的系統級服務，如

java反射和動態代理實現介面記錄

專案需求：app含有廣告sdk，在上架個別應用市場時會被拒，產品希望在打包時一些渠道包把廣告sdk剝離出來（內心是哭泣的）。方法一：每次打包刪除jar包，刪除與該jar包相關的程式碼類、介面等等~記錄完成，謝謝大家哈哈 開個玩笑，言歸正傳，以上是我一開始的想法，最笨最笨的方法

php用反射API實現了簡單的動態代理

<?php /*2014-03-26 *根據反射API實現了簡單的動態代理，真正操作類是mysql類。但是通過sqlprozy類實現了根據動態傳入引數，代替實際的執行的類。在具體運行當中需要根據實際情況來使用，不要濫用反射，反射的消耗也比較大。 平時一般情況下有兩個方