代理机制

静态代理和动态代理

Java动态代理的优势是实现无侵入式的代码扩展，也就是方法的增强；让你可以在不用修改源码的情况下，增强一些方法；在方法的前后你可以做你任何想做的事情（甚至不去执行这个方法就可以）。

1.动态代理是设计模式中的代理模式：

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

2.静态代理

静态代理类：由程序员创建或者由第三方工具生成，再进行编译；在程序运行之前，代理类的.class文件已经存在了。
静态代理类通常只代理一个类。
静态代理事先知道要代理的是什么。

3.动态代理

动态代理类：在程序运行时，通过反射机制动态生成。
动态代理类通常代理接口下的所有类。
动态代理事先不知道要代理的是什么，只有在运行的时候才能确定。
动态代理的调用处理程序必须事先InvocationHandler接口，及使用Proxy类中的newProxyInstance方法动态的创建代理类。
Java动态代理只能代理接口，要代理类需要使用第三方的CLIGB等类库。

简述

利用代理可以在运行时创建一个实现了 一组给定接口的新类。这种功能只有在编译时无法确定需要实现哪个接口时才有必要使用。

为何使用代理

框架的编写者无法知道使用者会编写怎样的类怎样的方法，所以无法用new的方法来创建对象，也无法用对象.方法的方式来直接调用对应的方法，所以需要用反射的机制按照class.forName()这个方式获取类的信息然后在newInstance()进行实例化，拿到类的信息之后用代理机制的invoke来执行类的方法，所以说反射机制和代理机制是相辅相成的，反射来拿到信息，代理来执行方法，实现功能。

何时使用代理

假设有一个表示接口的Class对象(有可能只包含-一个接口)，它的确切类型在编译时无
法知道。要想构造一个实现这些接口的类，就需要使用newInstance方法
或反射找出这个类的构造器。但是，不能实例化一个接口,需要在程序处于运行状态时定义
一个新类。
为了解决这个问题，有些程序将会生成代码;将这些代码放置在一-个文件中; 调用编译
器;然后再加载结果类文件。很自然，这样做的速度会比较慢，并且需要将编译器与程序放
在一起。而代理机制则是一种更好的解决方案。代理类可以在运行时创建全新的类。这样的
代理类能够实现指定的接口。尤其是，它具有下列方法:
●指定接口所需要的全部方法。
●Object类中的全部方法，例如，toString、 equals 等。
然而，不能在运行时定义这些方法的新代码。而是要提供-一个调用处理器(invocation
handler)。调用处理器是实现了InvocationHandler 接口的类对象。在这个接口中只有-一个方法:
0bject invoke(Object proxy, Method method, 0bject[] args)
无论何时调用代理对象的方法，调用处理器的invoke方法都会被调用，并向其传递
Method对象和原始的调用参数。调用处理器必须给出处理调用的方式。

创建代理对象

要想创建一个代理对象，需要使用Proxy类的newProxyInstance方法。这个方法有三个
参数:
●一个类加载器( class loader)。作为Java安全模型的一部分， 对于系统类和从因特网
上下载下来的类，可以使用不同的类加载器。有关类加载器的详细内容将在卷II第9
章中讨论。目前，用null表示使用默认的类加载器。
●一个Class对象数组，每个元素都是需要实现的接口。
●一个调用处理器。
还有两个需要解决的问题。如何定义–个处理器?能够用结果代理对象做些什么?当.
然，这两个问题的答案取决于打算使用代理机制解决什么问题。使用代理可能出于很多原
因，例如:
●路由对远程服务器的方法调用。
●在程序运行期间，将用户接口事件与动作关联起来。
●为调试，跟踪方法调用。
在示例程序中，使用代理和调用处理器跟踪方法调用，并且定义了一个TraceHander包
装器类存储包装的对象。其中的invoke 方法打印出被调用方法的名字和参数，随后用包装好的对象作为隐式参数调用这个方法。

代码示例

Singer类：

public interface Singer {
    void sing();
    void dance();
}

AW类：

public class AW implements Singer{
    String name;

    public AW(String name) {
        this.name = name;
    }

    @java.lang.Override
    public void sing() {
        System.out.println("我正在唱歌");
    }

    @java.lang.Override
    public void dance() {
        System.out.println("我正在跳舞");
    }

}

Test类：

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

public class Test {
    public static void main(String[] args) {

        Singer singer = new AW("张三");
		//创建代理对象，第一个参数是类加载器，第二个参数是类实现的接口，第三个new一个InvocationHandler 接口的实现类的对象把被代理对象传进去
        Object o = Proxy.newProxyInstance(singer.getClass().getClassLoader(), singer.getClass().getInterfaces(),
                new SingerHandler(singer));
        if (o instanceof Singer) {
            Singer s = (Singer) o;
            s.sing();//
            s.dance();//
        }
    }
}
class SingerHandler implements InvocationHandler {
    private Singer singer;

    public SingerHandler(Singer singer) {
        this.singer = singer;
    }
	//每次调用方法的时候会调用invoke方法来代理
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("给点钱");
        //method是把被代理类的方法当做Method的对象传了进来，下一行是调用被代理对象的方法的意思
        return method.invoke(singer, args);
    }
}