首页手记设计模式--代理模式（JAVA 实现）

设计模式--代理模式（JAVA 实现）

标签：

Java

代理简述：

代理是一个动词，动词之间会有产生关系两者。代理这个词产生关系的两者就是：realSubject(被代理者)，proxySubject（代理者）。举个例子：火车站，与火车站代售点。
火车站可以进行售票工作，而火车站代售点可以实现代售车票。但是代售点还有其他的功能，比如说支持预约。这个是火车站所不具有的功能。
简单理解代理模式就是：代理者代替被代理者去完成一些功能，在完成一些功能之前可以做一些预处理，完成之后可以做一些后置处理。
再看一个程序中的例子：AOP就是建立在代理的思想之上的，AOP面向切面编程，何为切面，就是你程序中的主要逻辑，在这些主要逻辑产生的地方设置切点，在切点的地方设置一个注入一些非主要功能，这个就是面向切面编程。面向切面编程是以动态代理为底层实现的

java代理模式应用

<1.静态代理--继承实现：
java中静态代理的实现方式有两种：一种基于继承思想，一种基于聚合。
首先描述基于继承思想的静态代理：（每段代码下方会有讲解，代码内会有注释）
代码如下：
1.定义一个接口：Moveable

package com.feixun.designerpattern.proxy.static_proxy;

public interface Moveable {
      void move(); //定义抽象方法 move()，表示移动功能
}

2.定义一个被代理类Car类实现这个Moveable接口

package com.feixun.designerpattern.proxy.static_proxy;

import java.util.Random;

public class Car implements Moveable{
       //实现move方法
    @Override
    public void move() {
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3.在定义一个代理类Car2继承自Car

package com.feixun.designerpattern.proxy.static_proxy;

/**
 * @author tao.liu
 * 通过继承实现静态代理 丰富RealSubject的功能，Car2相当于ProxySubject
 *
 */
public class Car2 extends Car{

    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶");
        super.move();
        long endtime = System.currentTimeMillis();
        System.out.println("汽车行驶结束，行驶了"+(endtime-starttime)+" 毫秒");
    }
}

解释：此程序在调用真实被代理类之前，对move花费的时间进行记录。

4.客户端调用

package com.feixun.designerpattern.proxy.static_proxy;

public class Client {
   public static void main(String[] args) {
     /*采用car2继承car 的方式实现代理 
      *随着功能的增加会出现更多的继承才能满足需求
      */
      Moveable moveable = new Car2();
      moveable.move();
   }
}

程序输出结果：

汽车开始行驶
汽车行驶中
汽车行驶结束，行驶了287 毫秒

此种静态代理采用的是代理类（proxySubject）继承被代理类（realSubject）而实现的。
分析弊端：
1.假设现在我需要在汽车运行前后加上日志记录的功能，在这种方式（继承）下，我需要新建一个（Car3继承Car）的代理类完成这件事情。
2.再假设我现在还需要在运行前加上启动汽车的功能，我们需要再建立一个（Car4继承Car）的代理类来完成这个事情。
3.再假设，我需要在汽车运行之前先启动汽车，再进行日志记录，我们需要再建立一个Car5来继承Car3.
综上所述，随着功能的叠加，类的数量也会呈爆炸式增长。
解决这个问题就需要用聚合来实现类的代理

<2.静态代理--聚合实现：
代码如下：
建立move功能定义接口

package com.feixun.designerpattern.proxy.static_proxy;

public interface Moveable {
      void move();
}

建立实现move功能的Car类

package com.feixun.designerpattern.proxy.static_proxy;

import java.util.Random;

public class Car implements Moveable{

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

建立日志代理类CarLogProxy

package com.feixun.designerpattern.proxy.static_proxy;

public class CarLogProxy implements Moveable {
    private Moveable moveable;//将movable 类型的对象聚合进来，其实movable是一个接口，这里用到了多态的概念。

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

    @Override
    public void move() {
        System.out.println("日志开始...");
        moveable.move();
        System.out.println("日志结束...");
    }
}

接着建立行驶时间CarTimeProxy代理类

package com.feixun.designerpattern.proxy.static_proxy;
//CarTimeProxy 为 属于Moveable 的类型对象的代理类
//基于聚合的方式
public class CarTimeProxy implements Moveable{
    private Moveable moveable;//同上所示

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

    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶");
        moveable.move();
        long endtime = System.currentTimeMillis();
        System.out.println("汽车行驶结束，行驶了"+(endtime-starttime)+" 毫秒");
    }
}

测试类

package com.feixun.designerpattern.proxy.static_proxy;

public class Client {
   public static void main(String[] args) {
      Car car1 = new Car();
      CarLogProxy carLogProxy = new CarLogProxy(car1);
      CarTimeProxy carTimeProxy = new CarTimeProxy(carLogProxy);

      carTimeProxy.move();
   }

   //引入问题:如果现在更多的realsubject 需要事件代理，那么现在需要新建多个代理类吗？类膨胀。
   //动态产生代理，实现对不同类，不同方法的代理。

}

运行结果：

汽车开始行驶
日志开始...
汽车行驶中
日志结束...
汽车行驶结束，行驶了529 毫秒

现在我们这样测试：（请注意如下程序与上方程序的不同点：）

package com.feixun.designerpattern.proxy.static_proxy;

public class Client {
   public static void main(String[] args) {
     //采用聚合的方式实现的代理，代理之间也可以互相调用
      Car car1 = new Car();
      CarTimeProxy carTimeProxy = new CarTimeProxy(car1);
      CarLogProxy carLogProxy = new CarLogProxy(carTimeProxy);

      carLogProxy.move();
   }

   //引入问题，如果现在更多的不同类型的realsubject：比如或火车的，汽车的类 需要被代理，那么现在需要新建多个代理类吗？类膨胀。
   //动态产生代理，实现对不同类，不同方法的代理。

}

运行结果：

日志开始...
汽车开始行驶
汽车行驶中
汽车行驶结束，行驶了649 毫秒
日志结束...

优点：这样的话就可以实现多个代理对象之间的相互调用相互聚合。从而比用继承方式实现的静态代理更优。减少了一个维度。

引入问题，如果现在更多的不同类型的realsubject：比如或火车的，汽车的类需要被代理，那么现在需要新建多个代理类吗？类膨胀问题产生。
动态产生代理，实现对不同类，不同方法的代理。

动态代理

直接上代码：
首先建立定义接口的Moveable:

package com.feixun.designerpattern.proxy.dynamic_proxy;

public interface Moveable {
    void move();
}

接着定义realsubject（被代理类）：泛指所有类型的被代理类。可以是Car,Subway，etc.

package com.feixun.designerpattern.proxy.dynamic_proxy;

import java.util.Random;

public class Car implements Moveable {

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

接着建立实现（implements）InvocationHandler接口的类：
InvocationHandler,中定义了Object invoke(Object proxy, Method method, Object[] args) 方法。参数解释如下图代码中注释

package com.feixun.designerpattern.proxy.dynamic_proxy;

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

public class MyHandler implements InvocationHandler {
    private Object target;//被代理对象

    public MyHandler(Object target) {
        this.target = target;
    }

    /* (non-Javadoc)
     * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
     * proxy--指被代理的对象（感觉java这个参数的名字并不是很好）
     * method--被代理对象的方法
     * args:被代理对象的方法参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) 
            throws Throwable {
        System.out.println("汽车开始运行了...");
        method.invoke(target, args);//运行被代理对象的方法，采用反射的机制。
        System.out.println("汽车运行结束...");
        return null;
    }
}

这一步只是完成了被代理对象方法的扩充，还没有产生真实的代理对象。
再看测试类：

package com.feixun.designerpattern.proxy.dynamic_proxy;

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

public class TestDynamicProxy {
   public static void main(String[] args) {
      Car car = new Car();
      InvocationHandler handler = new MyHandler(car);
      Class<?> cs = car.getClass();
      /*
       * @param ：  classloader 被代理对象的类加载器
       * @param : interfaces 被代理对象实现的接口
       * @param ：  Invocationhandler handler /子类
       */
      Moveable moveable=(Moveable)Proxy.newProxyInstance(cs.getClassLoader(),
              cs.getInterfaces(), handler);//这一步动态生成代理对象 moveable
      moveable.move();
   }
}

运行结果：

汽车开始运行了...
汽车行驶中
汽车运行结束...

可以看出：动态代理解决了对不同委托类产生代理对象的问题，假设现在我有Subway类，我要实现被代理，我只需要Subway实现Moveable，然后在测试类中更改几行代码就好，所以解决了聚合静态代理产生的问题,又将问题复杂度减少了一个维度。
但是jdk动态代理也有问题：委托累想要实现自己的代理类，必须实现接口，如果有类没有实现接口，就不能使用JDK代理。
完

点击查看更多内容