Java设计模式-代理模式

代理模式的定义:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。


代理模式顾名思义,有个代理,那这个代理做什么工作呢?我们平时生活中,我们遇到过的代理就是各个品牌的代理,一个产品不能让广大的消费者去工厂去买吧,工厂生产出产品,各个地方有一个代理,代理这个工厂负责个每个商店推销产品。又比如一个歌手有一个助理,很多事情都是助理负责,助理接收到信息,看看是什么信息,自己可以干的就自己完成,就比如歌手的助理收到要去开演唱会的通知,助理不能唱歌啊,这个核心的事情还是得交给老板,助理的作用就是避免自己的老板受到打扰。所以代理是过滤掉一些事情,剩下的核心内容还是由真实的对象来负责。


代理模式存在的意义就是,降低了真实对象和要做事情的耦合性,降低了他们之间的联系,代理类对请求进行过滤,预处理,将请求交给真实对象,或者委派给真实对象。好比消费者不会去工厂去买产品,一个歌手不会每天都会接收到很多没有用的信息。


同样代理模式也符合开闭原则,对修改关闭,对扩展开放。在不改变真实类的情况下,对其类进行扩展。代理类对外提供一系列的接口,用户对其使用不会对原对象产生影响,对原对象有一个良好的封装性。


代理模式分为静态代理和动态代理,还有一种是Cglib代理,这里就不介绍了。

静态代理:

抽象角色:是一个接口,定义了行为,没有具体实现

package demo_staticagent;

public interface AbstractSubject {

    public abstract void sing();
}

代理角色:其中有真实对象的引用,从而对真实对象进行操作,可以对真实对象的操作进行扩展,不会修改原对象。

package demo_staticagent;

public class ProxySubject implements AbstractSubject {
    
    private AbstractSubject abstractSubject;

    public ProxySubject(AbstractSubject abstractSubject) {
        this.abstractSubject = abstractSubject;
    }


    @Override
    public void sing() {
        abstractSubject.sing();
    }
}

真实对象:有对事件的真实操作,最终我们要引用的对象。
package demo_staticagent;

public class RealSubject implements AbstractSubject{

    @Override
    public void sing() {
        System.out.println("真唱");
    }
}

测试类:
package demo_staticagent;

public class Test {

    public static void main(String[] args) {
        RealSubject reaal = new RealSubject();
        ProxySubject proxy = new ProxySubject(reaal);
        proxy.sing();

    }
}

输出:
真唱

从输出结果可以看出,是真唱不是假唱。我们创建了真实对象和代理对象,用代理模式进行调用,通过代理最终我们核心的代码,执行的还是真实角色中的代码。知识对真实角色进行了封装。


动态代理:

动态代理相比于静态代理,动态代理的代理类是在动态生成的,也就是jvm通过反射获取代码生成代理类,所以用户并不能决定代理角色和真实角色之间的联系,而是由程序运行时候决定的。相比于静态代理, 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理,而不用修改每个代理类的函数。


动态代理实现的三步走:

  • 实现InvocationHandler接口,创建自己的调用处理器 。
  • 给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类 。
  • 执行真实角色具体任务。

要想创建处理器必须实现InvocationHandler接口,之后通过类装载器创建代理类。每一个动态代理类都必须要实现InvocationHandler这个接口,并且每个代理类的实例都关联到了一个handler,当我们通过代理对象调用一个方法的时候,这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。


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

proxy:  指代我们所代理的那个真实对象
method:  指代的是我们所要调用真实对象的某个方法的Method对象
args:  指代的是调用真实对象某个方法时接受的参数


我们依旧要创建抽象角色和真实角色类

package demo_proxy;

public interface AbstractSubject {

    public abstract void sing();
}
package demo_proxy;

public class RealSubject implements AbstractSubject{

    @Override
    public void sing() {
        System.out.println("真唱");
    }
}

代理角色:和静态代理相比,静态代理运用对象调用完成代理,而动态代理通过实现InvocationHandler接口,创建了一个调用处理器,其实是通过Java的反射机制完成

package demo_proxy;

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

public class ProxySubject implements InvocationHandler {

    public AbstractSubject abstractSubject;

    public ProxySubject(AbstractSubject abstractSubject) {
        this.abstractSubject = abstractSubject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        method.invoke(abstractSubject, args);
        return null;
    }

}
当我们调用代理类对象的方法时,这个“调用”会转送到invoke方法中,代理类对象作为proxy参数传入,参数method标识了我们具体调用的是代理类的哪个方法,args为这个方法的参数。这样一来,我们对代理类中的所有方法的调用都会变为对invoke的调用,这样我们可以在invoke方法中添加统一的处理逻辑(也可以根据method参数对不同的代理类方法做不同的处理)。

测试类:

package demo_proxy;

import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        /*代理的真实对象*/
        RealSubject real = new RealSubject();
        /*代理哪个对象就把真实对象传进去*/
        ProxySubject proxySubject = new ProxySubject(real);
         /*
         * 通过Proxy的newProxyInstance方法来创建我们的代理对象,我们来看看其三个参数
         * 第一个参数 handler.getClass().getClassLoader() ,我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
         * 第二个参数realSubject.getClass().getInterfaces(),我们这里为代理对象提供的接口是真实对象所实行的接口,表示我要代理的是该真实对象,这样我就能调用这组接口中的方法了
         * 第三个参数handler, 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
         */
        AbstractSubject a = (AbstractSubject) Proxy.newProxyInstance(proxySubject.getClass().getClassLoader, 
                real.getClass().getInterfaced(), proxySubject);
        a.sing();
    }
}
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

loader:  一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载

interfaces:  一个Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口,如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口
              (多态),这样我就能调用这组接口中的方法了

h:  一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上

看上去实现很简单,我们只需要实现接口,调用其中的方法就可以实现动态代理。

通过newProxyInstance方法获取代理类实例,而后我们便可以通过这个代理类实例调用代理类的方法,对代理类的方法的调用实际上都会调用中介类(调用处理器)的invoke方法。


输出:

真唱


参考:

http://www.cnblogs.com/xiaoluo501395377/p/3383130.html

http://www.jb51.net/article/86531.htm


posted @ 2017-11-13 20:59  In_new  阅读(119)  评论(0编辑  收藏  举报