Java动态代理

　　在学习《Java编程思想》的时候看到了动态代理，觉得很有意思，现在来做一下总结。

一、代理模式的定义

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

二、优点

　　(1).职责清晰真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件完成事务，附带的结果就是编程简洁清晰。

　　(2).代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了的作用和保护了目标对象的作用。

　　(3).高扩展性

三、模式结构

　　一个是真正的你要访问的对象(目标类)，一个是代理对象,真正对象与代理对象实现同一个接口,先访问代理类再访问真正要访问的对象。

四、UML示意图

 

 　我们来看一个普通代理实现的例子：

//客户端接口
interface Interface {

    void doSomething();

    void somethingElse(String arg);
}

//客户端实现类，就是执行业务逻辑的类
class RealObject implements Interface {

    @Override
    public void doSomething() {
        // TODO Auto-generated method stub
        System.out.println("doSomething");
    }

    @Override
    public void somethingElse(String arg) {
        // TODO Auto-generated method stub
        System.out.println("somethingElse" + arg);
    }

}

//代理类
class SimpleProxy implements Interface {

    private Interface proxied;

    public SimpleProxy(Interface proxied) {
        // TODO Auto-generated constructor stub
        this.proxied = proxied;
    }

    @Override
    public void doSomething() {
        // TODO Auto-generated method stub
        System.out.println("SimpleProxy doSomething");
        proxied.doSomething();
    }

    @Override
    public void somethingElse(String arg) {
        // TODO Auto-generated method stub
        System.out.println("SimpleProxy somethingElse "+arg);
        proxied.somethingElse(arg);
    }

}

public  class SimpleProxyDemo{
    
    public static void consumer(Interface iface){
        iface.doSomething();
        iface.somethingElse("hello world");
    }
    
    public static void main(String[] args){
        consumer(new RealObject());
        System.out.println("/*****************************/");
        consumer(new SimpleProxy(new RealObject()));
    }
}

 运行结果如下：

doSomething
somethingElsehello world
/*****************************/
SimpleProxy doSomething
doSomething
SimpleProxy somethingElse hello world
somethingElsehello world

五、Java动态代理

　　Java的动态代理比代理的思想更向前迈进了一步，因为它可以动态地创建代理并动态地处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器上，它的工作揭示调用的类型并确定相应的对策。 

接下来我们来看一下Java动态代理的例子：

 interface Interface {

    void doSomething();

    void somethingElse(String arg);
}

class RealObject implements Interface {

    @Override
    public void doSomething() {
        // TODO Auto-generated method stub
        System.out.println("doSomething");
    }

    @Override
    public void somethingElse(String arg) {
        // TODO Auto-generated method stub
        System.out.println("somethingElse" + arg);
    }

}

//动态代理类
class DynamicProxyHandler implements InvocationHandler{

    private Object proxied;
    
    public DynamicProxyHandler(Object proxied) {
        // TODO Auto-generated constructor stub
        this.proxied = proxied;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("****proxy: " + proxy.getClass()+
                ", method: "+method+ ", args: "+ args);
        
        if(args != null){
            for (Object arg : args) {
                System.out.println("  "+ arg);
            }
        }
        
        return method.invoke(proxied, args);
    }
}

class SimpleDynamicProxy{
    
    public static void consumer(Interface iface){
        iface.doSomething();
        iface.somethingElse("hello world");
    }
    
    public static void main(String[] args){
        RealObject real = new RealObject();
        consumer(real);
        
        System.out.println("/*******************************/");
        
        Interface proxy = (Interface)Proxy.newProxyInstance(
                Interface.class.getClassLoader(), 
                new Class[]{Interface.class},
                new DynamicProxyHandler(real));
        
        consumer(proxy);
        
    }
    
}

运行结果如下：

doSomething
somethingElsehello world
/*******************************/
****proxy: class com.sun.proxy.$Proxy0, method: public abstract void Interface.doSomething(), args: null
doSomething
****proxy: class com.sun.proxy.$Proxy0, method: public abstract void Interface.somethingElse(java.lang.String), args: [Ljava.lang.Object;@756095fc
  hello world
somethingElsehello world

 　　通过调用静态方法Proxy.newProxyInstance()可以创建动态代理。这个方法需要得到一个类加载器（你通常可以从已经被加载的对象中获取其类加载器，然后传递给它），一个你希望该代理实现的接口列表（不是类或者抽象类），以及InvocationHandler接口的一个实现。动态代理可以将所有调用重定向到调用处理器，因此通常会向调用处理器的构造器传递一个“实际”对象的引用，从而使得调用处理器执行其中介任务时，可以将请求转发。

 　　invoke()方法传递进来了代理对象，以防你需要区分请求的来源，但是在许多情况下，你并不关心这一点。然而，在invoke()内部，在代理上调用方法时需要格外小心，因为接口的调用将被重定向为对代理对象的调用。

　　通常，你会执行被代理的操作，然后使用Method.invoke()将请求转发给 被代理对象，并传入必需的参数。这初看起来可能有些受限，就像你只能执行泛化操作一样。但是，你可以通过传递其他的参数，来过滤某些方法的调用。