java动态代理及原理

什么是代理？

代理是一种设计模式，简单的说就是为某个对象提供代理，以控制这个对象的访问，在不修改原方法的状况下作方法加强，简单的能够分为两种：

• 静态代理
• 动态代理

静态代理

通常状况下的代理就是有一个接口，接口中定义了一些方法须要被实现，实现了那些方法的类被称为实现类，可是当咱们须要在调用该方法前作一些额外的操做，又不想影响原来的代码，这时候就能够引入一个代理类，让代理类也实现该接口，而后将接口的那个实现类做为成员变量引入代理类中，额外操做时由代理类操做，具体到该方法时则由实现类去操做，下面举个例子；
public interface Calculator {

//须要代理的接口
public int add(int a,int b);
//接口实现类,执行真正的a+b操做
public static class CalculatorImpl implements Calculator{
    @Override
    public int add(int a, int b) {
        System.out.println("doing ");
        return a+b;
    }
}
//静态代理类的实现.代码已经实现好了.
public static class CalculatorProxy implements Calculator{
    private Calculator calculator;
    public CalculatorProxy(Calculator calculator) {
        this.calculator=calculator;
    }
    @Override
    public int add(int a, int b) {
        //执行一些操做
        System.out.println("begin ");
        int result = calculator.add(a, b);
        System.out.println("end ");
        return result;
    }
}

}

Calculator是一个计算器的接口类，定义了一个加法的接口方法，由CalculatorImpl类实现真正的加法操做.如今若是咱们想对这个方法作一层静态的代理，这儿实现了一个简单的代理类实现了计算接口Calculator，构造函数传入的参数是真正的实现类，可是在调用这个代理类的add方法的时候咱们在CalculatorImpl的实现方法执行的先后分别作了一些操做。这样的代理方式就叫作静态代理(这个是别人的例子，只是为了更加形象的展现静态代理，拿代码说话)。

很明显静态代理的缺点,因为咱们须要事先实现代理类,那么每一个方法我都都须要去实现。若是咱们要实现不少的代理类,那么工做量就太大了。动态代理的产生就是这样而来的。

动态代理

使用动态代理可让代理类在程序运行的时候生成代理类，咱们只须要为一类代理写一个具体的实现类就好了，因此实现动态代理要比静态代理简单许多，省了很多重复的工做。在JDK的方案中咱们只须要这样作能够实现动态代理了。
public class ProxyFactory implements InvocationHandler {

private Class<?> target;
private Object real;
//委托类class
public ProxyFactory(Class<?> target){
    this.target=target;
}
//实际执行类bind
public  Object bind(Object real){
    this.real=real;
    //利用JDK提供的Proxy实现动态代理
    return  Proxy.newProxyInstance(target.getClassLoader(),new Class[]{target},this);
}
@Override
public Object invoke(Object o, Method method, Object[] args) throws Throwable {
    //代理环绕
    System.out.println("begin");
    //执行实际的方法
    Object invoke = method.invoke(real, args);
    System.out.println("end");
    return invoke;
}

public static void main(String[] args) {
    Calculator proxy =(Calculator) new ProxyFactory(Calculator.class).bind(new Calculator.CalculatorImpl());
    proxy.add(1,2);
}

}
利用JDK的proxy实现代理动态代理，有几个关键点，一个就是InvocationHandler接口，这个方法中的invoke方法是执行代理时会执行的方法。因此咱们全部代理须要执行的逻辑都会写在这里面,invo参数里面的method可使用java 反射调用真实的实现类的方法，咱们在这个方法周围作一些代理逻辑工做就能够了。上面的代码会把Calculator接口的全部方法所有在程序运行时代理。不用咱们一个个的去写静态代理的方法。

JDK生成的代理类

public final class Calcultor$ProxyCode extends Proxy implements Calculator {

private static Method m1;
private static Method m4;
private static Method m0;
private static Method m3;
private static Method m2;

public Calcultor$ProxyCode(InvocationHandler var1) throws  {
    super(var1);
}

public final boolean equals(Object var1) throws  {
    try {
        return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
    } catch (RuntimeException | Error var3) {
        throw var3;
    } catch (Throwable var4) {
        throw new UndeclaredThrowableException(var4);
    }
}

public final int reduce(int var1, int var2) throws  {
    try {
        return ((Integer)super.h.invoke(this, m4, new Object[]{Integer.valueOf(var1), Integer.valueOf(var2)})).intValue();
    } catch (RuntimeException | Error var4) {
        throw var4;
    } catch (Throwable var5) {
        throw new UndeclaredThrowableException(var5);
    }
}

public final int hashCode() throws  {
    try {
        return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
    } catch (RuntimeException | Error var2) {
        throw var2;
    } catch (Throwable var3) {
        throw new UndeclaredThrowableException(var3);
    }
}

public final int add(int var1, int var2) throws  {
    try {
        return ((Integer)super.h.invoke(this, m3, new Object[]{Integer.valueOf(var1), Integer.valueOf(var2)})).intValue();
    } catch (RuntimeException | Error var4) {
        throw var4;
    } catch (Throwable var5) {
        throw new UndeclaredThrowableException(var5);
    }
}

public final String toString() throws  {
    try {
        return (String)super.h.invoke(this, m2, (Object[])null);
    } catch (RuntimeException | Error var2) {
        throw var2;
    } catch (Throwable var3) {
        throw new UndeclaredThrowableException(var3);
    }
}

static {
    try {
        //static静态块加载每一个方法的Method对象
        m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
        m4 = Class.forName("jdkproxy.Calculator").getMethod("reduce", new Class[]{Integer.TYPE, Integer.TYPE});
        m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        m3 = Class.forName("jdkproxy.Calculator").getMethod("add", new Class[]{Integer.TYPE, Integer.TYPE});
        m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
    } catch (NoSuchMethodException var2) {
        throw new NoSuchMethodError(var2.getMessage());
    } catch (ClassNotFoundException var3) {
        throw new NoClassDefFoundError(var3.getMessage());
    }
}

}