JAVA动态代理

1、简单的demo

public interface HelloService {
    /**
     * 目标方法
     */
    public abstract void add(String str);
}
public class HelloServiceImpl implements HelloService {
    /*
     * @see dynamic.proxy.UserService#add()
     */
    public void add(String str) {
        System.out.println("==>"+str);
    }
}
//代理类
public class HelloServiceProxy implements InvocationHandler {
    // 目标对象
    private Object target;

    /**
     * 执行目标对象的方法
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 在目标对象的方法执行之前简单的打印一下
        System.out.println("------------------before------------------");

        // 执行目标对象的方法
        Object result = method.invoke(target, args);

        // 在目标对象的方法执行之后简单的打印一下
        System.out.println("-------------------after------------------");

        return result;
    }

    /**
     * 获取目标对象的代理对象
     * @param target 目标对象
     * @return 代理对象
     */
    public Object getProxy(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                target.getClass().getInterfaces(), this);
    }
}

测试代码

public class Test{
    public static void main(String[] args) {
        HelloService service = new HelloServiceImpl();

        HelloServiceProxy proxy = new HelloServiceProxy();
        //绑定代理对象。
        service = (HelloService) proxy.getProxy(service);
        //这里service经过绑定,就会进入invoke方法里面了。
        service.add("hello");
    }
}

执行结果:
——————before——————
==>hello
——————-after——————

2、代码分析

//Proxy.java
//通过反射 获取代理类HelloServiceImpl的实例
public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);
        //克隆一份被代理目标类所实现所有接口的 Class对象数组  
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
         //拿到代理类的Class 主要的方法
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //拿到代理类的Constructor对象,以便用于构造代理对象 
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            //h为InvocationHandler的实现类HelloServiceProxy
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            ////返回构造的代理类对象,这里留个意,传入的是 实现了InvocationHandler接口的对象 
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

主要是跟getProxyClass0的代码,

//主要通过这两个方法获取HelloServiceImpl的Class对象
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);

return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);

详见:http://blog.youkuaiyun.com/scplove/article/details/52451899

3、实际的调用过程

通过ProxyGeneratorUtils生成HelloServiceImpl的class文件并保持在磁盘上

public class ProxyGeneratorUtils {
    /**
     * 把代理类的字节码写到硬盘上
     */
    public static void writeProxyClassToHardDisk(String path) {

        // 获取代理类的字节码  方法的第二个参数为被代理类所实现的全部接口
        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy11", HelloServiceImpl.class.getInterfaces() );

        FileOutputStream out = null;

        try {
            out = new FileOutputStream( path );
            out.write( classFile );
            out.flush();
        } catch(Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            }
            catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
}

用idea可以查看HelloServiceImpl生成的class文件

public final class $Proxy11 extends Proxy implements HelloService {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy11(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 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 void add(String var1) throws  {
        try {
            //h为HelloServiceProxy的实例 直接调用HelloServiceProxy的invoke方法。
            //在HelloServiceProxy的invoke中,通过反射调用HelloServiceImpl的add方法
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    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", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            //通过反射获取add的Method实例
            m3 = Class.forName("com.company.HelloService").getMethod("add", new Class[]{Class.forName("java.lang.String")});
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

总结:
主要步骤为
1、通过ProxyGenerator.generateProxyClass 获取HelloServiceImpl的class对象并使用反射实例化,还会获得add的Method对象
2、调用HelloServiceImpl通过反射得到的实例的add方法,在add方法中会调用HelloServiceProxy的invoke方法。最终通过反射调用HelloServiceImpl的add方法

### Java 动态代理的实现原理与用法 #### 1. Java 动态代理概述 Java 动态代理是一种在运行时动态生成代理对象的技术,它允许开发者无需提前定义具体的代理类即可完成方法拦截和增强功能。这种机制广泛应用于 AOP(面向切面编程)、事务管理以及日志记录等领域[^2]。 #### 2. 动态代理的核心组件 动态代理主要依赖于 `java.lang.reflect.Proxy` 类和 `InvocationHandler` 接口来实现。以下是其核心组成部分: - **Proxy 类**: 提供了用于创建动态代理实例的方法。 - **InvocationHandler 接口**: 定义了一个处理方法调用的回调接口,通过该接口可以自定义代理行为。 当客户端调用代理对象上的某个方法时,实际执行的是由 InvocationHandler 处理逻辑所指定的操作[^3]。 #### 3. JDK 原生动态代理实现 JDK 动态代理基于反射技术,在运行期间为一组接口动态生成代理类及其实例。具体流程如下: - 创建一个实现了 `InvocationHandler` 接口的对象。 - 使用 `Proxy.newProxyInstance()` 方法传入目标类加载器、目标类实现的一组接口列表以及上述 handler 对象,从而获得代理实例。 下面是一个简单的示例代码展示如何利用 JDK 动态代理实现基本的日志打印功能: ```java import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; // 定义服务接口 interface GreetingService { void sayHello(String name); } // 实现服务接口的具体业务逻辑 class SimpleGreetingServiceImpl implements GreetingService { @Override public void sayHello(String name) { System.out.println("Hello, " + name); } } // 自定义 InvocationHandler 来拦截并扩展方法调用 class LoggingInvocationHandler implements InvocationHandler { private Object target; // 被代理的目标对象 public LoggingInvocationHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("[Before] Executing: " + method.getName()); // 执行原始方法 Object result = method.invoke(target, args); System.out.println("[After] Finished execution."); return result; } } public class JdkDynamicProxyDemo { public static void main(String[] args) { // 初始化真实的服务实现 GreetingService greetingService = new SimpleGreetingServiceImpl(); // 构建带有日志功能的代理对象 GreetingService proxyInstance = (GreetingService) Proxy.newProxyInstance( greetingService.getClass().getClassLoader(), greetingService.getClass().getInterfaces(), new LoggingInvocationHandler(greetingService)); // 测试代理效果 proxyInstance.sayHello("World"); } } ``` 此程序展示了如何通过动态代理增加额外的功能而不修改原有代码结构[^1]。 #### 4. CGLib 动态代理实现 除了 JDK 内置支持外,还可以借助第三方库如 CGLib 进行动态代理操作。CGLib 主要针对那些未继承任何接口或者希望直接操控实体类场景下更为适用。它的内部工作机理涉及字节码层面操作,能够子类化任意非 final 的普通类,并重写其中的方法达到相同目的。 需要注意的是,由于两者设计初衷不同,在性能表现上可能会有所差异;通常情况下,如果仅需对接口做封装,则推荐优先考虑更轻量级也更加直观易懂的 JDK 方案。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值