Java设计模式之--代理模式学习

1.代理模式定义

　　为其他对象提供一种代理以控制对这个对象的访问。代理对象起到中介服务，可以去掉功能服务和增加额外的服务。

　　其实按照官方的说法可能不太好理解，代理模式就好比我们生活中买票，一般情况下我们都会去火车站（原对象）买票，但是有的情况下可能我们离火车站比较远不方便去，那我们就会去火车票代售点去（我们的代理对象）买，在这里代售处就是对火车站的一个代理，可以实现卖票的功能，同时呢，代售处也有自己的额外的功能，比如火车票代售处买票需要额外的手续费，火车站能提供的所有服务代售处不是全有，比如代售处不能退票、不能购买学生票，从这里可以看出代理实现了原对象的部分功能外，也有自己额外的处理。

2.代理模式实现--静态代理

　　静态代理：代理和被代理的对象在代理之前都是确定的，他们都是实现了相同的接口或者继承了相同的抽象类。

　　举例说明下：汽车有一个move()方法，然后我想通过代理来实现记录汽车运行过程中时间的问题。

　　Moveable.java  //定义一个统一的接口,里面定义了一个汽车行驶move()方法

public interface Moveable {
    void move();

}

　　Car.java(版本一)   //实现了Moveable接口，实现move方法

public class Car implements Moveable {

    public void move() {
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

　　在这里要实现增加记录汽车运行时间问题，我们是不是可以直接修改Car.java的move方法，如下所示：

public class Car implements Moveable {

    public void move() {
        System.out.println("汽车行驶开始");
        long begin = System.currentTimeMillis();
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("汽车行驶了"+(end-begin)+"毫秒");
    }

}

　　这样就实现了记录行驶时间，但是这个得修改Car.java源码，在不修改源码的情况下，怎么做呢，我们就可以通过代理来实现,这里我们将Car.java还原为版本一时候

　　Car2.java //新增Car2，继承了Car

public class Car2 extends Car {

    public void move() {
        System.out.println("汽车行驶开始");
        long begin = System.currentTimeMillis();
        super.move();
        long end = System.currentTimeMillis();
        System.out.println("汽车行驶了"+(end-begin)+"毫秒");
    }

}

 　　Client.java   //测试类，

public class Client {
    public static void main(String[] args) {
//        Car car = new Car();
//        car.move();
        Moveable m = new Car2();
        m.move();
    }

}

　　可以看到运行结果：

汽车行驶开始
汽车行驶中....
汽车行驶了314毫秒

　　这样就通过代理实现了记录时间的问题。在super.move();之前和之后我们可以添加新的服务。

　　上面我们是通过的继承的方式来实现代理，下面我们换一种方式，用聚合的方式来实现代理模式。

　　Car3.java  //新增Car3.java ，采用聚合方式实现

public class Car3 implements Moveable {
    private Car car;
    
    public Car3(Car car){
        this.car = car;
    }

    public void move() {
        System.out.println("汽车行驶开始");
        long begin = System.currentTimeMillis();
        car.move();
        long end = System.currentTimeMillis();
        System.out.println("汽车行驶了"+(end-begin)+"毫秒");
    }

}

　　修改Client.java来测试，

public class Client {
    public static void main(String[] args) {
        //采用聚合方式测试代码
        Car car = new Car();
        Car3 car3 = new Car3(car);
        car3.move();
    }

}

　　通过运行我们可以得到相同的结果，都可以实现相同的功能。

　　但是哪一种方式更好呢，这里我们仅仅是需要增加个记录时间的功能，假如我们需要增加功能有1.时间记录2.日志记录3.权限控制等，可能有的汽车需要先记录时间在记录日志在是权限，即是123方式，可能有的汽车需要321方式，有的汽车只需要1等等，如果我们采用继承的方式的话，每一种方式我们会创建一个新的Java类，这样的话我们的类会无限的庞大，所以推荐使用聚合方式来实现，那聚合方式怎么实现呢，且看下文。

　　CarTimeProxy.java  //时间代理类，完成对记录时间的代理功能

public class CarTimeProxy implements Moveable {
    private Moveable m;
    
    public CarTimeProxy(Moveable m){
        this.m = m;
    }

    public void move() {
        System.out.println("汽车行驶开始");
        long begin = System.currentTimeMillis();
        m.move();
        long end = System.currentTimeMillis();
        System.out.println("汽车行驶了"+(end-begin)+"毫秒");
    }

}

　　CarLogProxy.java  //日志代理类，完成对日志的记录

public class CarLogProxy implements Moveable {
    private Moveable m;
    
    public CarLogProxy(Moveable m){
        this.m = m;
    }

    public void move() {
        System.out.println("汽车日志记录开始");
        m.move();
        System.out.println("汽车日志记录结束");
    }

}

　　修改Client.java来测试，假如我们先记录日志在记录时间

public class Client {
    public static void main(String[] args) {
        Car car = new Car();
        CarTimeProxy time = new CarTimeProxy(car);
        CarLogProxy log = new CarLogProxy(time);
        log.move();
    }

}

　　结果可以看出，先是记录了日志在是时间

汽车日志记录开始
汽车行驶开始
汽车行驶中....
汽车行驶了586毫秒
汽车日志记录结束

　　这里假如我们需要先记录时间在记录日志，我们仅仅是代码顺序切换下就OK了，

public class Client {
    public static void main(String[] args) {
        Car car = new Car();
        CarLogProxy log = new CarLogProxy(car);
        CarTimeProxy time = new CarTimeProxy(log);
        time.move();
    }

}

汽车行驶开始
汽车日志记录开始
汽车行驶中....
汽车日志记录结束
汽车行驶了192毫秒

　　从这里可以看出，聚合的方式比继承更适合代理模式