关于动态代理Proxy生成的代理类

动态代理Proxy案例

首先，我们需要3个类

• 被实现接口
• 实现接口的类
• 测试类 接口类

public interface IUserDao {

    void save();
}

实现接口的类

public class UserDao implements IUserDao {

    @Override
    public void save()  {
        System.out.println("----已经保存数据!----");
    }
}

测试类

public class ProxyDemo {

    public static void main(String[] args) {
    	//将生成的代理类保存到磁盘上
        System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        // 被代理对象
        IUserDao target = new UserDao();
        // 【原始的类型 class cn.itcast.b_dynamic.UserDao】
        System.out.println(target.getClass());
        // 获取对象的类加载器
        ClassLoader loader = target.getClass().getClassLoader();
        // 给目标对象，创建代理对象
        IUserDao proxyInstance = (IUserDao)Proxy.newProxyInstance(loader, 
                    target.getClass().getInterfaces(),
                    (proxy, method, args1) -> {
                        System.out.println("方法执行前增强");
                        Object result = method.invoke(target, args1);
                        System.out.println("方法执行后增强");
                        return result;
                    });
        // class $Proxy0   内存中动态生成的代理对象
        System.out.println(proxyInstance.getClass());
        
        // 代理对象执行方法
        proxyInstance.save();
    }
}

如何保存生成的代理类

• 双击shift打开idea的全局搜索找到ProxyGenerator这个类
• 然后在当前类中搜索GetBooleanAction
• 复制字符串,添加这行代码到main方法的第一行（不同版本的jdk，字符串可能不同）

System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

代理类的生成

• 获取对象的class对象和实现的接口集合
• 创建一个proxy的对象并对里面的h进行赋值，h类型为InvocationHandler，值为你创建的匿名内部类
• 根据class对象和接口集合，创建出代理对象
• 代理对象继承Proxy实现被代理的对象的接口

代理对象的class文件

• method对象
  • 从父类和接口中实现的方法
• 静态代码块
  • 对method对象赋值
• 重写的方法 idea反编译出来的代理类

package com.sun.proxy;

import com.proxy.IUserDao;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements IUserDao {
    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", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.proxy.IUserDao").getMethod("save");
            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());
        }
    }

    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});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void save() 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);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
}

代理对象的方法执行流程

• 代理对象的任何方法都会执行

//这个执行的方法就是我们传入的InvocationHandler的匿名内部类的方法
super.h.invoke(this, methodObject, args);
// 就是这个方法
(proxy, method, args1) -> {
                        System.out.println("方法执行前增强");
                        Object result = method.invoke(target, args1);
                        System.out.println("方法执行后增强");
                        return result;
                    }
//我们可以通过以下方式来控制那些方法需要增强
(proxy, method, args1) -> {
		if（"save".equal(method.getname())）{
                        System.out.println("方法执行前增强");
                        Object result = method.invoke(target, args1);
                        System.out.println("方法执行后增强");
                        return result;
                    	}
                }

关于动态代理导致的内存溢出

由于动态代理会生成一个代理类的clss对象并保存到元数据区，所以当动态代理类过多时会导致元数据区内存溢出。