Java基础学习: JDK动态代理

一、什么是JDK动态代理

JDK动态代理是Java提供的一种动态生成代理类和代理对象的技术。它主要利用Java的反射机制实现，在运行时动态地创建代理类，并为其生成代理对象。JDK动态代理主要用于实现AOP（面向切面编程）等场景，用于在不修改目标类代码的情况下，为目标类添加额外的功能。

二、JDK动态代理的特点

• 基于接口代理：JDK动态代理只能为接口创建代理实例，不能针对类创建代理实例。如果要为类创建代理，可以考虑使用CGLIB等第三方库。
• 运行时生成代理类：JDK动态代理在运行时动态地创建代理类，无需提前编译。
• 代理类和代理对象：JDK动态代理不仅生成代理类，还生成代理对象。代理对象实现了目标接口，并将目标对象作为参数传递给InvocationHandler。

三、JDK动态代理类如何使用

• 定义接口和目标类：首先，你需要定义一个接口和一个实现了该接口的目标类。

public interface MyInterface {  
    void doSomething();  
}  
  
public class MyTarget implements MyInterface {  
    @Override  
    public void doSomething() {  
        System.out.println("Target method executed.");  
    }  
}

• 创建InvocationHandler：实现InvocationHandler接口，并在invoke方法中编写代理逻辑。invoke方法会在调用代理对象的任何方法时被调用。

import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
  
public class MyInvocationHandler implements InvocationHandler {  
    private Object target;  
  
    public MyInvocationHandler(Object target) {  
        this.target = target;  
    }  
  
    @Override  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        System.out.println("Before method execution.");  
        Object result = method.invoke(target, args);  
        System.out.println("After method execution.");  
        return result;  
    }  
}

invoke参数介绍

• Proxy：代理实例，可以通过newProxyInstance创建代理实例。

• Method：需要执行的目标方法。

• args：需要执行目标方法的参数数组。

• 创建代理对象：使用Proxy.newProxyInstance方法创建代理对象。这个方法需要三个参数：类加载器、代理类实现的接口列表和InvocationHandler实例。

import java.lang.reflect.Proxy;  
  
public class Main {  
    public static void main(String[] args) {  
        MyInterface target = new MyTarget();  
        MyInvocationHandler handler = new MyInvocationHandler(target);  
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(  
                target.getClass().getClassLoader(),  
                target.getClass().getInterfaces(),  
                handler  
        );  
        proxy.doSomething(); // 执行代理对象的方法  
    }  
}

执行上述代码，你会看到在调用doSomething方法前后，都输出了日志信息，这就是通过JDK动态代理实现的AOP效果。

需要注意的是，由于JDK动态代理基于接口，因此如果你的目标类没有实现任何接口，那么JDK动态代理将无法使用。在这种情况下，你可以考虑使用CGLIB等第三方库来创建代理。

四、JDK动态代理原理分析

1、创建代理对象

对于匿名类方法中的实例，会在改类型为其生成相应的变量

2、生成代理类

生成的代理对象继承了Proxy类，并实现了UserService接口。

• 接口

public interface UserService {
    void test();
    void getOne();
    void getById();
}

• 接口实现类

import person.xsc.source.read.service.UserService;

public class UserServiceImpl implements UserService {
    @Override
    public void test() {
        System.out.println("hello world");
    }

    @Override
    public void getOne() {

    }

    @Override
    public void getById() {

    }
}

• 生成$proxy0类

import sun.misc.ProxyGenerator;

import java.io.FileOutputStream;
import java.io.IOException;

public class ProxyDemo {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                "$proxy0", userService.getClass().getInterfaces(), 1);
        FileOutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream("D:\\myProject\\spring-yuanma-fenxi\\src\\test\\java\\proxy\\$proxy0.class");
            outputStream.write(proxyClassFile);
            outputStream.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

• 展示$proxy0类

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import person.xsc.source.read.service.UserService;

public class $proxy0 extends Proxy implements UserService {
    private static Method m1;
    private static Method m3;
    private static Method m4;
    private static Method m2;
    private static Method m5;
    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});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

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

    public final void getById() throws  {
        try {
            super.h.invoke(this, m4, (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 void getOne() throws  {
        try {
            super.h.invoke(this, m5, (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);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("person.xsc.source.read.service.UserService").getMethod("test");
            m4 = Class.forName("person.xsc.source.read.service.UserService").getMethod("getById");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m5 = Class.forName("person.xsc.source.read.service.UserService").getMethod("getOne");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}