JDK动态代理原理

JDK 代理类的生成  通过Proxy类中内部类 ProxyClassFactory生成的代理对象

生成包号，和自增num，每生成一个代理对象就会加 num后缀，直接生成一个字节码数组文件，然后defineClass，生成class对象

newProxyInstance，将InvokeHandle传递到生成的代理对象中

JDK 动态代理类解析：

1. 定义接口：

public interface Star

{

String sing(String name);

String dance(String name);

//接口定义默认方法同样会被代理
public default void run(){
    System.out.println("animal is running");
}
}

1. 实现类：

 

public class LiuDeHua implements Star
{   
    @Override
    public String sing(String name)
    {
         System.out.println("给我一杯忘情水");
        return "唱完" ;
    }
    
    @Override
    public String dance(String name)
    {
        System.out.println("开心的马骝");
        return "跳完" ;
    }
}

• 实现InvocationHandler接口

public class StarProxy implements InvocationHandler
{
    // 目标类，也就是被代理对象
    private Object target;
    
    public void setTarget(Object target)
    {
        this.target = target;
    }

      
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    {

        //注意 方法内 不能调用proxy，
        // 这里可以做增强
        System.out.println("收钱");

//注意 方法内 不能调用proxy，否则会不断调用  System.out.println("收钱");
        //jdk动态代理 是针对对象的代理
        Object result = method.invoke(target, args);
        //method.invoke(null, args); 调用静态方法
        
        return result;
    }
    
    // 生成代理类
    public Object CreatProxyedObj()
    {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }  

}

Proxy.newProxyInstance 传递三个参数，

1：classLoader 可能和接口的类加载器不一样，通常我们就用上下文类加载器。

2：可以针对多个接口进行代理

3：代理对象不是实现，因此需要在 invoke方法中去实现具体的代理逻辑。

生成的代理对象继承proxy类，实现了接口，例如代理对象调用接口 SayHello，

内部其实是调用java.lang.reflect.InvocationHandler#invoke(Object proxy, Method method, Object[] args)方法，返回这个方法的执行的返回值。

  //生成的代理对象

public final class XXX extends Proxy implements XXX  Proxy的子类，实现star接口
   
    public final String SayHello(String paramString)
  {
    try
    {//调用父类中的invoke方法， Object result = method.invoke(target, args); 
 生成的代理对象中有sayHello方法，最终调用invocationHandler的invoke方法。
      return (String)supper.h.invoke(this, m4, new Object[] { paramString });
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }




static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("jiankunking.Subject").getMethod("SayGoodBye", new Class[0]);
      m4 = Class.forName("jiankunking.Subject").getMethod("SayHello", new Class[] { Class.forName("java.lang.String") });
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
1. m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {  
2.                 Class.forName("java.lang.Object")  
3.             });  
4.             m3 = Class.forName("dynamic.proxy.UserService").getMethod("add", new Class[0]);  
5.             m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);  
6.             m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);  

注意：Class.forName（接口或者类）

生成的代理类每次调用接口的时候（包括实现的接口和默认的Object中的接口），都会调用InvocationHandler方法

invoke方法，因此需要注意的是，可以没有具体的被代理对象，但是，invoke 方法返回值必须和生产的代理调用接口的

返回值一致。

一个完整的例子：

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("RealSubject do something");
    }
}
public interface Subject {


    void doSomething();
}
public class JDKDynamicProxy implements InvocationHandler {


    private Object target;


    public JDKDynamicProxy(Object target) {
        this.target = target;
    }


    /**
     * 获取被代理接口实例对象
     * @param
     * @return
     */
    public T getProxy() {
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Do something before");
        Object result = method.invoke(target, args);
        System.out.println("Do something after");
        return result;
    }
}

public class Client {
    public static void main(String[] args) {
        // 保存生成的代理类的字节码文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");


        // jdk动态代理测试
        Subject subject = new JDKDynamicProxy(new RealSubject()).getProxy();
        subject.doSomething();
    }
}
public final class $Proxy0 extends Proxy implements Subject {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;


    public $Proxy0(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 void doSomething() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }


    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);
        }
    }


    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);
        }
    }


    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.lnjecit.proxy.Subject").getMethod("doSomething");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

1、代理类继承了Proxy类并且实现了要代理的接口，由于java不支持多继承，所以JDK动态代理不能代理类

2、重写了equals、hashCode、toString

3、有一个静态代码块，通过反射或者代理类的所有方法

4、通过invoke执行代理类中的目标方法doSomething