java 动态代理详解

最新推荐文章于 2025-05-14 16:52:23 发布

原创最新推荐文章于 2025-05-14 16:52:23 发布 · 2.5k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#java #动态代理

java 专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了Java动态代理机制中的核心接口InvocationHandler和Proxy。InvocationHandler接口用于处理代理实例的方法调用，而Proxy接口则用于动态创建代理类。在方法调用时，InvocationHandler的invoke方法会被触发，接收代理对象、方法及参数。通过Proxy的newProxyInstance方法，可以指定ClassLoader、一组接口和InvocationHandler来创建动态代理实例。文章通过示例展示了动态代理的实现步骤，包括定义接口和类，创建动态代理类，以及编写测试代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在java动态代理机制中有两个很重要的接口，一个就是java.lang.reflect.InvocationHandler，另一个就是java.lang.reflect.Proxy。首先介绍下这两个接口的作用和参数。
InvocationHandler API中简介是：
Each proxy instance has an associated invocation handler.When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the {@code invoke} method of its invocation handler.
大概意思是每个动态代理类都要实现InvocationHandler接口，并且关联到一个handler，通过代理对象调用时，这个接口的方法调用就会转接到该handler的invoke方法进行调用。
接下来了解下invoke方法：

public Object invoke(Object proxy, Method method, Object[] args)

共有三个参数，分别介绍下：
1 proxy，该参数是代理的真实对象
2 method，该参数是代理的方法
3 代理方法中接受的参数

然后介绍下Proxy这个接口：
{@code Proxy} provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.
意思是这个接口的作用就是动态来创建一个代理类。主要看看newProxyInstance方法。

 public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces, InvocationHandler h)

第一个参数是真实需要代理对象的ClassLoader
第二个参数是需要代理对象的一组接口。代理之后，我们就可以调用这一组接口中的方法了。
第三个参数是一个InvocationHandler对象，表示关联到那一个handler上。

举例说明java动态代理机制实现：
第一步，定义需要代理的接口和类。

public interface TestInterface {

    public void test1();
    public void test2();
}

public class TestClass implements TestInterface {

    @Override
    public void test1() {
        System.out.println("test1");
    }

    @Override
    public void test2() {
        System.out.println("test2");
    }
}

第二步，定义一个动态代理类

public class TestProxy implements InvocationHandler {

    //真实的对象
    private Object realObject;
    //代理对象
    private Object proxyObject;

    public Object getProxyObject() {
        return proxyObject;
    }




    public TestProxy(Object testObject) {

        this.realObject = testObject;
        //代理对象的实现
        this.proxyObject = (TestInterface) Proxy.newProxyInstance(realObject.getClass().getClassLoader(),
                realObject.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before method"+method);
        method.invoke(realObject,args);
        System.out.println("after method"+method);
        return null;
    }
}

最后一步，写测试函数

public class Test {
    public static void main(String[] args){
        TestInterface realSubject = new TestClass();
        TestProxy proxy = new TestProxy(realSubject);

        TestInterface proxyObject = (TestInterface) proxy.getProxyObject();
        proxyObject.test1();
        proxyObject.test2();
    }
}

实现结果如下：

before methodpublic abstract void TestInterface.test1()
test1
after methodpublic abstract void TestInterface.test1()
before methodpublic abstract void TestInterface.test2()
test2
after methodpublic abstract void TestInterface.test2()