设计模式（2） 代理模式 静态代理

• 需求：设计一个车类，具有方法run，现需要设计一个方案计算它的前后行驶时间。

• 一般来说该类可以这样写

public class car{
    long start,end;
    private void before(){
        start=System.currentTimeMillis();
        System.out.println("开车前时间:"+start);
    }
    private void after(){
        end=System.currentTimeMillis();
        System.out.println("开车后时间："+end+".\n总耗时："+(end-start)+"毫秒");
    }
    pubic void run(){
        try {
            after();
            System.out.println("正在开车~~~");
            Thread.sleep((int)(Math.random()*100));
            before();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

• 结果为：

开车前时间:1503127134747
正在开车~~~
开车后时间：1503127135124.
总耗时：377毫秒

Process finished with exit code 0

但是为了可以扩展，一般采取写法
Icar.java (汽车接口)

package cn.niriqiang.demo;

/**
 * Created by fengyuwusong on 2017/8/19 14:53.
 */
public interface ICar {
    public void run();
}

CarImpl 汽车实现类

package cn.niriqiang.demo;

/**
 * Created by fengyuwusong on 2017/8/19 14:54.
 */
public class CarImpl implements ICar{
    @Override
    public void run() {
        try {
            System.out.println("正在开车~~~");
            Thread.sleep((int)(Math.random()*1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

CarProxy 汽车计时功能代理

package cn.niriqiang.demo;

/**
 * Created by fengyuwusong on 2017/8/19 14:58.
 */
public class Carproxy implements ICar{
    private ICar car;
    long start,end;
    public Carproxy(ICar car) {
        this.car = car;
    }

    @Override
    public void run() {
        before();
        car.run();
        after();

    }

    private void before(){
        start=System.currentTimeMillis();
        System.out.println("开车前时间:"+start);

    }

    private void after(){
        end=System.currentTimeMillis();
        System.out.println("开车后时间："+end+".\n总耗时："+(end-start)+"毫秒");
    }
}

main 测试方法

package cn.niriqiang.demo;

/**
 * Created by fengyuwusong on 2017/8/19 14:55.
 */
public class main {

    public static void main(String[] args) {
        ICar car=new CarImpl();
        Carproxy carproxy=new Carproxy(car);
        carproxy.run();
    }
}

以上写法即为代理模式的静态代理，这样的好处是加入需求改变，需要在汽车行驶前后添加新功能时，我们可以根据功能给汽车添加新的代理，例如：

CarLogProxy.java 给汽车添加日志功能

package cn.niriqiang.demo;

/**
 * Created by fengyuwusong on 2017/8/19 15:27.
 */
public class CarLogProxy implements ICar{
    ICar car;

    public CarLogProxy(ICar car) {
        this.car = car;
    }


    private void before(){
        System.out.println("开车前日志：xxxxx...");
    }

    private void after(){
        System.out.println("开车后日志：xxxxx...");
    }

    @Override
    public void run() {
        before();
        car.run();
        after();
    }
}

我们给man方法稍作改变即可得到新功能(既添加了计时又添加了日志功能的汽车)

package cn.niriqiang.demo;

/**
 * Created by fengyuwusong on 2017/8/19 14:55.
 */
public class main {

    public static void main(String[] args) {
        ICar car=new CarImpl();
        Carproxy carproxy=new Carproxy(car);
        CarLogProxy carLogProxy=new CarLogProxy(carproxy);
        carLogProxy.run();
    }
}

结果

开车前日志：xxxxx...
开车前时间:1503127842768
正在开车~~~
开车后时间：1503127842835.
总耗时：67毫秒
开车后日志：xxxxx...