代理模式（java語言實現）

概念和原理

代理模式的定義：

爲其他對象提供一種代理以控制對這個對象的訪問。在某些情況下，一個對象不適合或者不能直接引用另一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用。

組成：

抽象角色：通過接口或抽象類聲明真實角色實現的業務方法。

代理角色：實現抽象角色，是真實角色的代理，通過真實角色的業務邏輯方法來實現抽象方法，並可以附加自己的操作。

真實角色：實現抽象角色，定義真實角色所要實現的業務邏輯，供代理角色調用。

優點

(1).職責清晰

真實的角色就是實現實際的業務邏輯，不用關心其他非本職責的事務，通過後期的代理完成一件完成事務，附帶的結果就是編程簡潔清晰。

(2).代理對象可以在客戶端和目標對象之間起到中介的作用，這樣起到了中介的作用和保護了目標對象的作用。

(3).高擴展性 模式結構

模式結構

一個是真正的你要訪問的對象(目標類)，一個是代理對象,真正對象與代理 　　對象實現同一個接口,先訪問代理類再訪問真正要訪問的對象。

靜態代理的定義和實現

靜態代理定義： 代理對象和被代理對象在代理之前是確定的。 它們都實現相同的接口或者繼承相同的抽象類。

代碼實現：

UML：

Moveable.java

package com.imooc.proxy;

public interface Moveable {
    void move();
}

Car.java

package com.imooc.proxy;

import java.util.Random;

public class Car implements Moveable {

    @Override
    public void move() {
        //實現開車
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("moving....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

CarTimeProxy.java

package com.imooc.proxy;

public class CarTimeProxy implements Moveable {

    private Moveable m;

    public CarTimeProxy(Moveable m) {
        super();
        this.m = m;
    }


    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("start moving....");
        m.move();
        long endtime = System.currentTimeMillis();
        System.out.println("end moving....  Time consumed:"
                + (endtime - starttime) + "ms !");
    }

}

CarLogProxy.java

package com.imooc.proxy;

public class CarLogProxy implements Moveable {

    private Moveable m;

    public CarLogProxy(Moveable m) {
        super();
        this.m = m;
    }


    @Override
    public void move() {
        System.out.println("start logging....");
        m.move();
        System.out.println("end logging....");
    }

}

Client.java

package com.imooc.proxy;

public class Client {

    /**
     * 測試類
     */
    public static void main(String[] args) {
        Car car = new Car();
        CarLogProxy clp = new CarLogProxy(car);
        CarTimeProxy ctp = new CarTimeProxy(clp);
        ctp.move();
    }

}

動態代理的實現

由於靜態代理中的代理對象和被代理對象在代理之前是確定的。 所以，如果需要爲不同的對象比如火車，自行車，的士 等不同的對象實現 時間代理就需要定義 TrainTimeProxy, BicycleTimeProxy, TexiTimeProxy…. 可以看到僅僅是爲了實現不同類的 TimeProxy 我們就要新建那麼多的類， 簡直爆炸！！！

這個時候我們需要實現一種 TimeProxy 能爲不同的類做代理。 這就用到了動態代理的知識。

代碼實現：

TimeHandler.java

package com.imooc.jdkproxy;

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

public class TimeHandler implements InvocationHandler {

    private Object target;

    public TimeHandler(Object target) {
        super();
        this.target = target;
    }


    /*
     * 參數：
     * proxied Object  被代理對象
     * method  被代理對象的方法
     * args 方法的參數
     *
     * 返回值：
     * Object  方法的返回值
     * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        long startTime = System.currentTimeMillis();
        System.out.println("汽車開始行駛....");
        method.invoke(target);
        long endTime = System.currentTimeMillis();
        System.out.println("汽車結束行駛....  汽車行駛時間："
                + (endTime - startTime) + "毫秒！");
        return null;
    }

}

Test.java

package com.imooc.jdkproxy;

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

import com.imooc.proxy.Car;
import com.imooc.proxy.Moveable;

public class Test {

    /**
     * JDK動態代理測試類
     */
    public static void main(String[] args) {
        Car car = new Car();
        InvocationHandler h = new TimeHandler(car);
        Class<?> cls = car.getClass();
        /**
         * loader  類加載器
         * interfaces  實現接口
         * h InvocationHandler
         */
        Moveable m = (Moveable)Proxy.newProxyInstance(cls.getClassLoader(),
                                                cls.getInterfaces(), h);
        m.move();
    }

}