代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。
二 Java 动态代理类Java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类：
（1）
public object invoke(Object obj,Method method, Object[] args)
在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。
（2）
Proxy：该类即为动态代理类，其中主要包含以下内容：
protected Proxy(InvocationHandler h)：构造函数，用于给内部的h赋值。
static Class getProxyClass (ClassLoaderloader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
static Object newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)
所谓DynamicProxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然，这个DynamicProxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。
在使用动态代理类时，我们必须实现InvocationHandler接口
通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口(Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实现了非常灵活的动态代理关系。
动态代理步骤：
1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法
2.创建被代理的类以及接口
3.通过Proxy的静态方法
newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)创建一个代理
4.通过代理调用方法
1、需要动态代理的接口：
package com.ssc.demo.proxy.staticProxy;
public interface Person {
public void findLove();
}
2、需要代理的实际对象
public class Customer implements Person{
@Override
public void findLove(){
System.out.println("高富帅");
System.out.println("身高 180cm");
System.out.println("胸大，6 块腹肌");
}
}
3、调用处理器实现类（像不像AOP）
package com.ssc.demo.proxy.staticProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class JDKMeipo implements InvocationHandler {
//被代理的对象，把引用给保存下来 这个就是我们要代理的真实对象
private Object target;
public Object getInstance(Object target) throws Exception{
this.target = target;
Class clazz = target.getClass();
return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//在代理真实对象前我们可以添加一些自己的操作
before();
//当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
Object obj = method.invoke(this.target,args);
//在代理真实对象后我们可以添加一些自己的操作
after();
return obj;
}
private void before(){
System.out.println("我是媒婆：我要给你找对象，现在已经拿到你的需求");
System.out.println("开始物色");
}
private void after(){
System.out.println("如果合适的话，就准备办事");
}
}
4、测试
public static void main(String[] args) {
try {
Person obj = (Person)new JDKMeipo().getInstance(new Customer());
obj.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
5、输出结果如下：
我们现在来探究一下原理，并模仿 JDK Proxy 自己动手写一个属于自己的动态代理。
我们都知道 JDK Proxy 采用字节重组，重新生的对象来替代原始的对象以达到动态代理
的目的。JDK Proxy 生成对象的步骤如下：
1、拿到被代理对象的引用，并且获取到它的所有的接口，反射获取。
2、JDK Proxy 类重新生成一个新的类、同时新的类要实现被代理类所有实现的所有的接
口。
3、动态生成 Java 代码，把新加的业务逻辑方法由一定的逻辑代码去调用（在代码中体
现）。
4、编译新生成的 Java 代码.class。
5、再重新加载到 JVM 中运行。
以上这个过程就叫字节码重组。JDK 中有一个规范，在 ClassPath 下只要是$开头的 class文件一般都是自动生成的。那么我们有没有办法看到代替后的对象的真容呢？做一个这样测试，我们从内存中的对象字节码通过文件流输出到一个新的 class 文件，然后，利用反编译工具查看 class 的源代码。
public static void main(String[] args) {
try {
Person obj = (Person) new JDKMeipo().getInstance(new Customer());
obj.findLove();
//通过反编译工具可以查看源代码
byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Person.class});
FileOutputStream os = new FileOutputStream("D://test//$Proxy0.class");
os.write(bytes);
os.close();
} catch (Exception e) {
e.printStackTrace();
}
}
运行之后，我们能在 E://盘下找到一个$Proxy0.class 文件。使用 Jad 反编译，得到
$Proxy0.jad 文件，打开可以看到如下内容：
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
import com.ssc.demo.proxy.staticProxy.Person;
import java.lang.reflect.*;
public final class $Proxy0 extends Proxy
implements Person
{
public $Proxy0(InvocationHandler invocationhandler)
{
super(invocationhandler);
}
public final boolean equals(Object obj)
{
try
{
return ((Boolean)super.h.invoke(this, m1, new Object[] {
obj
})).booleanValue();
}
catch(Error _ex) { }
catch(Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
public final void findLove()
{
try
{
super.h.invoke(this, m3, null);
return;
}
catch(Error _ex) { }
catch(Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
public final String toString()
{
try
{
return (String)super.h.invoke(this, m2, null);
}
catch(Error _ex) { }
catch(Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
public final int hashCode()
{
try
{
return ((Integer)super.h.invoke(this, m0, null)).intValue();
}
catch(Error _ex) { }
catch(Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
static
{
try
{
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
Class.forName("java.lang.Object")
});
m3 = Class.forName("com.ssc.demo.proxy.staticProxy.Person").getMethod("findLove", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
}
catch(NoSuchMethodException nosuchmethodexception)
{
throw new NoSuchMethodError(nosuchmethodexception.getMessage());
}
catch(ClassNotFoundException classnotfoundexception)
{
throw new NoClassDefFoundError(classnotfoundexception.getMessage());
}
}
}
我们发现$Proxy0 继承了 Proxy 类，同时还实现了我们的 Person 接口，而且重写了
findLove()等方法。而且在静态块中用反射查找到了目标对象的所有方法，而且保存了所
有方法的引用，在重写的方法用反射调用目标对象的方法。这些代码是哪里来的呢？其实是 JDK 帮我们自动生成的。
======================================================
这就是最终真正的代理类，它继承自Proxy并实现了我们定义的Person接口，也就是说：
Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
这里的person实际是这个类的一个实例，那么我们调用它的：
Person obj = (Person)new JDKMeipo().getInstance(new Customer());
obj.findLove();
对应反编译文件中的代码块
public final void findLove()
{
try
{
super.h.invoke(this, m3, null);
return;
}
catch(Error _ex) { }
catch(Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
