Java动态代理

        在Java中，动态代理是一种在运行时动态生成代理类的技术，它能够在不修改原始类的情况下，为原始类的方法调用提供额外的控制或增强。主要有两种实现方式：基于 JDK 的动态代理和基于 CGLIB 的动态代理。它们的区别主要在于实现原理和适用场景。

一、JDK 动态代理

        JDK 动态代理通过反射机制来创建代理对象和代理方法。它要求目标类必须实现至少一个接口，然后通过 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来生成代理对象。

        假设有一个接口 UserService 和其实现类 UserServiceImpl：

public interface UserService {
    void getUser(String name);
}

public class UserServiceImpl implements UserService {
    @Override
    public void getUser(String name) {
        System.out.println("用户: " + name);
    }
}

        使用 JDK 动态代理，可以动态生成一个实现了 UserService 接口的代理类： 

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JDKDynamicProxyExample {

    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        
        // 创建代理对象
        UserService proxy = (UserService) Proxy.newProxyInstance(
            UserService.class.getClassLoader(),
            new Class[] { UserService.class },
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("调用实际方法之前 " + method.getName());
                    Object result = method.invoke(userService, args); // 调用实际对象的方法
                    System.out.println("调用实际方法之后 " + method.getName());
                    return result;
                }
            }
        );
        
        // 使用代理对象调用方法
        proxy.getUser("张三");
    }
}

        在上面例子中，通过 Proxy.newProxyInstance() 方法创建了一个 UserService 接口的代理对象，实现了在方法调用前后输出日志的功能。 

二、CGLIB 动态代理

        CGLIB（Code Generation Library）动态代理则是通过继承目标类，并生成目标类的子类来实现代理。它不要求目标类实现接口，因此可以代理没有接口的类。

        假设有一个没有实现接口的类 UserService：

public class UserService {
    public void getUser(String name) {
        System.out.println("用户: " + name);
    }
}

        使用 CGLIB 动态代理，可以动态生成一个 UserService 的子类作为代理类：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CGLIBDynamicProxyExample {

    public static void main(String[] args) {
        UserService userService = new UserService();
        
        // 创建 Enhancer 对象
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                System.out.println("调用目标类方法之前 " + method.getName());
                Object result = proxy.invokeSuper(obj, args); // 调用目标类的方法
                System.out.println("调用目标类方法之后 " + method.getName());
                return result;
            }
        });
        
        // 创建代理对象
        UserService proxy = (UserService) enhancer.create();
        
        // 使用代理对象调用方法
        proxy.getUser("李四");
    }
}

         在上面例子中，通过 Enhancer 类来生成 UserService 的子类代理对象，并在方法调用前后输出日志。

三、区别总结

1. 实现原理：

• JDK 动态代理是基于接口的代理，通过 Proxy 类和 InvocationHandler 接口实现，要求目标类必须实现接口。
• CGLIB 动态代理是基于继承的代理，通过继承目标类并生成目标类的子类实现，可以代理没有实现接口的类。

1. 性能：

• JDK 动态代理在创建代理对象时比较高效，但在调用时由于使用反射，可能会稍慢。
• CGLIB 动态代理在创建代理对象时较慢，但在调用时由于是通过方法绑定到子类上，调用速度比 JDK 动态代理快。

1. 适用场景：

• JDK 动态代理适合对实现了接口的类进行代理。
• CGLIB 动态代理适合对没有实现接口的类进行代理，也可以用于增强实现了接口的类。