Java實現動態(tài)代理

更新時間：2015年02月28日 14:39:45 投稿：hebedich

本文給大家介紹的是java使用動態(tài)代理類實現動態(tài)代理的方法和示例，這里推薦給大家，有需要的小伙伴參考下吧

Java動態(tài)代理類位于java.lang.reflect包下，一般主要涉及到以下兩個類：
（1）InvocationHandler：該接口中僅定義了一個方法
public object invoke(Object obj,Method method, Object[] args)
在實際使用時，第一個參數obj一般是指代理類，method是被代理的方法，如上例中的request()，args為該方法的參數數組。這個抽象方法在代理類中動態(tài)實現。

（2）Proxy：該類即為動態(tài)代理類，作用類似于上例中的ProxySubject，其中主要包含以下內容protected Proxy(InvocationHandler h)：構造函數，用于給內部的h賦值。
static Class getProxyClass (ClassLoader loader, Class[] interfaces)
獲得一個代理類，其中l(wèi)oader是類裝載器，interfaces是真實類所擁有的全部接口的數組。

        static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)
        返回代理類的一個實例，返回后的代理類可以當作被代理類使    用(可使用被代理類的在Subject接口中聲明過的方法)

        所謂Dynamic Proxy是這樣一種class：它是在運行時生成的class，在生成它時你必須     提供一組interface給它，然后該class就宣稱它實現了這些 interface。你當然可以把    該class的實例當作這些interface中的任何一個來用。當然，這個Dynamic Proxy其實   就是一個   Proxy，它不會替你作實質性的工作，在生成它的實例時你必須提供一個handler，由它    接管實際的工作。

在使用動態(tài)代理類時，我們必須實現InvocationHandler接口：
    參見程序 Subject.java
    參見程序 RealSubject.java
    參見程序 DynamicSubject.java
    參見程序 Client.java

復制代碼代碼如下:

package com.langsin.dynamicproxy;

//抽象角色(之前是抽象類，此處應改為接口)： 

public interface Subject

{

    abstract public void request();

}

復制代碼代碼如下:

package com.langsin.dynamicproxy;

//具體角色

public class RealSubject implements Subject

{

    public RealSubject()

    {

    }

    public void request()

    {

        System.out.println("From real subject.");

    }

}

復制代碼代碼如下:

package com.langsin.dynamicproxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

//代理處理器 

/**

 * 該代理類的內部屬性為Object類，實際使用時通過該類的構造函數DynamicSubject(Object obj)對其賦值；

 * 此外，在該類還實現了invoke方法，該方法中的 method.invoke(sub,args);

 * 其實就是調用被代理對象的將要被執(zhí)行的方法，方法參數sub是實際的被代理對象，

 * args為執(zhí)行被代理對象相應操作所需的參數。

 * 通過動態(tài)代理類，我們可以在調用之前或之后執(zhí)行一些相關操作

 */

public class DynamicSubject implements InvocationHandler

{

    private Object sub;

    public DynamicSubject()

    {

    }

    public DynamicSubject(Object obj)

    {

        sub = obj;

    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

    {

        System.out.println("before calling " + method);

        method.invoke(sub, args);

        System.out.println("after calling " + method);

        return null;

    }

}

復制代碼代碼如下:

package com.langsin.dynamicproxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Proxy;

//客戶端

public class Client

{

    static public void main(String[] args) throws Throwable

    {

        RealSubject rs = new RealSubject(); // 在這里指定被代理類

        InvocationHandler ds = new DynamicSubject(rs);

        Class<?> cls = rs.getClass();

        // 以下是一次性生成代理

        Subject subject = (Subject) Proxy.newProxyInstance(

        cls.getClassLoader(), cls.getInterfaces(), ds);

        subject.request();

    }

}

實例2：

復制代碼代碼如下:

package com.langsin.dynamicproxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.List;

import java.util.Vector;

public class VectorProxy implements InvocationHandler

{

    private Object proxyobj;

    public VectorProxy(Object obj){

        proxyobj = obj;

    }

    public static Object factory(Object obj){

        Class<?> cls = obj.getClass();

        return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), new VectorProxy(obj));

    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{

        System.out.println("before calling " + method);

        if (args != null){

            for (int i = 0; i < args.length; i++){

                System.out.println(args[i] + "");

            }

        }

        Object object = method.invoke(proxyobj, args);

        System.out.println("after calling " + method);

        return object;

    }

    @SuppressWarnings("unchecked")

    public static void main(String[] args){

        List<String> v = (List<String>) factory(new Vector<String>(10));

        v.add("New");

        v.add("York");

        System.out.println(v);

        v.remove(0);

        System.out.println(v);

    }

}

實例3、

復制代碼代碼如下:

package com.langsin.dynamicproxy;

public interface Foo{

    void doAction();

}

package com.langsin.dynamicproxy;

public class FooImpl implements Foo{

    public FooImpl(){

    }

    public void doAction(){

        System.out.println("in FooImp1.doAction()");

    }

}

package com.langsin.dynamicproxy;

public class FooImpl2 implements Foo{

    public FooImpl2(){

    }

    public void doAction(){

        System.out.println("in FooImp2.doAction()");

    }

}

package com.langsin.dynamicproxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

public class CommonInvocationHandler implements InvocationHandler{

    // 動態(tài)執(zhí)行對象，需要回調的對象

    private Object target;

    // 支持構造子注射

    public CommonInvocationHandler(){

    }

    // 支持構造子注射

    public CommonInvocationHandler(Object target){

        setTarget(target);

    }

    /**

     * 

     * 采用setter方法注射

     * 

     * @param target

     * 

     */

    public void setTarget(Object target){

        this.target = target;

    }

    /**

     * 

     * 調用proxy中指定的方法method，并傳入參數列表args

     * 

     * @param proxy

     *            代理類的類型，例如定義對應method的代理接口

     * 

     * @param method

     *            被代理的方法

     * 

     * @param args

     *            調用被代理方法的參數

     * 

     * @return

     * 

     * @throws java.lang.Throwable

     * 

     */

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{

        return method.invoke(target, args);

    }

}

package com.langsin.dynamicproxy;

import java.lang.reflect.Proxy;

public class Demo{

    public static void main(String[] args){

        // 1.通用的動態(tài)代理實現

        CommonInvocationHandler handler = new CommonInvocationHandler();

        Foo f;

        // 2.接口實現1

        handler.setTarget(new FooImpl());

        // 方法參數說明：代理類、代理類實現的接口列表、代理類的處理器

        // 關聯(lián)代理類、代理類中接口方法、處理器，當代理類中接口方法被調用時，會自動分發(fā)到處理器的invoke方法

        // 如果代理類沒有實現指定接口列表，會拋出非法參數異常

        f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),

        new Class[] { Foo.class },

        handler);

        f.doAction();

        // 3.接口實現2

        handler.setTarget(new FooImpl2());

        f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),

        new Class[] { Foo.class },

        handler);

        f.doAction();

    }

}