实战动态代理

代理模式介绍

代理模式有点像老大和小弟，也有点像分销商。主要解决的是问题是为某些资源的访问、对象的类的易用操作上提供方便使用的代理服务。而这种设计思想的模式经常会出现在我们的系统中，或者你用到过的组件中，它们都提供给你一种非常简单易用的方式控制原本你需要编写很多代码的进行使用的服务类。

类似这样的场景可以想到；

1. 你的数据库访问层面经常会提供一个较为基础的应用，以此来减少应用服务扩容时不至于数据库连接数暴增。

2. 使用过的一些中间件例如；RPC框架，在拿到jar包对接口的描述后，中间件会在服务启动的时候生成对应的代理类，当调用接口的时候，实际是通过代理类发出的socket信息进行通过。

3. 另外像我们常用的MyBatis，基本是定义接口但是不需要写实现类，就可以对xml或者自定义注解里的sql语句进行增删改查操作。

动态代理的两种实现方式

一、JDK 动态代理机制

介绍

在 Java 动态代理机制中 InvocationHandler 接口和 Proxy 类是核心。

Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象。

java.lang.reflect.Proxy

这个方法一共有 3 个参数：

1. loader :类加载器，用于加载代理对象。

2. interfaces : 被代理类实现的一些接口；

3. h : 实现了 InvocationHandler 接口的对象；

要实现动态代理的话，还必须需要实现InvocationHandler 来自定义处理逻辑。当我们的动态代理对象调用一个方法时候，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用。

java.lang.reflect.InvocationHandler

invoke() 方法有下面三个参数：

4. proxy :动态生成的代理类

5. method : 与代理类对象调用的方法相对应

6. args : 当前 method 方法的参数

也就是说：你通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。 你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

JDK 动态代理类使用步骤

1. 定义一个接口及其实现类；

2. 自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；

3. 通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象；

简单代码使用示例

1.定义发送短信的接口

public interface SmsService {
    String send(String message);
}

2.实现发送短信的接口

public class SmsServiceImpl implements SmsService {
    @Override
    public String send(String message) {
        System.out.println("来到了SmsServiceImpl：send message"+message);
        return message;
    }
}

3.定义一个 JDK 动态代理类

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

public class DebugInvocationHandler implements InvocationHandler {
    /**
     * 代理类中的真实对象
     */
    private final Object target;

    public DebugInvocationHandler(Object target) {
        this.target = target;
    }

    /**
     *
     * @param proxy jdk创建的代理对象，无需复制
     * @param method 目标类中的方法
     * @param args 目标类中方法的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("来到了代理类DebugInvocationHandler");
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object result = method.invoke(target, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return result;
    }
}

4.获取代理对象的工厂类

import java.lang.reflect.Proxy;

public class JdkProxyFactory {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 目标类的类加载
                target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                new DebugInvocationHandler(target)   // 代理对象对应的自定义 InvocationHandler
        );
    }
}

测试

代码

    @Test
    public void jdkProxy(){
        SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
        smsService.send("穗爷来也");
    }

结果

来到了代理类DebugInvocationHandler
before method send
来到了SmsServiceImpl：send message穗爷来也
after method send

二、CGLIB 动态代理机制

介绍

JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。

为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。

CGLIB[3](Code Generation Library)是一个基于ASM[4]的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB[5]， 例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心。

你需要自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法。

net.sf.cglib.proxy.MethodInterceptor

1. obj :被代理的对象（需要增强的对象）

2. method :被拦截的方法（需要增强的方法）

3. args :方法入参

4. methodProxy :用于调用原始方法

你可以通过 Enhancer类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法。

CGLIB 动态代理类使用步骤

1. 定义一个类；

2. 自定义 MethodInterceptor 并重写 intercept 方法，intercept用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；

3. 通过 Enhancer 类的 create()创建代理类；

简单实用示例

不同于 JDK 动态代理不需要额外的依赖。CGLIB[6](Code Generation Library) 实际是属于一个开源项目，如果你要使用它的话，需要手动添加相关依赖。

         <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

1.实现一个使用发送邮箱的类

public class EMailService {
    public String send(String message){
        System.out.println("send message:"+message);
        return message;
    }
}

2.自定义 MethodInterceptor（方法拦截器）

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

import java.lang.reflect.Method;

public class DebugMethodInterceptor implements MethodInterceptor {
    /**
     *
     * @param obj 被代理的对象（需要增强的对象）
     * @param method 被拦截的方法（需要增强的方法）
     * @param args 方法入参
     * @param proxy 用于调用原始方法
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("来到了代理类DebugMethodInterceptor");
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object object = proxy.invokeSuper(obj, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return object;
    }
}

3.获取代理类工厂

public class CglibProxyFactory {
    public static Object getProxy(Class<?> clazz) {
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加裁器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new DebugMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}

测试

代码

    @Test
    public void CglibProxy(){
        EMailService aliSmsService = (EMailService) CglibProxyFactory.getProxy(EMailService.class);
        aliSmsService.send("穗爷来也");
    }

结果

来到了代理类DebugMethodInterceptor
before method send
send message:穗爷来也
after method send

JDK 动态代理和 CGLIB 动态代理对比

1. JDK 动态代理只能只能代理实现了接口的类，而 CGLIB 可以代理未实现任何接口的类。 另外， CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。

2. 就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

常见八股文

请简述Java代理模式的作用和优缺点？

Java代理模式的作用是允许你提供一个代理对象来控制对另一个对象的访问，以便你可以在访问对象之前或之后添加额外的处理逻辑。代理对象充当原始对象的代表，它可以隐藏原始对象的复杂性和实现细节，从而使客户端代码与原始对象解耦。

优点包括

• 代理模式可以实现对象的延迟加载和按需加载，提高程序的运行效率。

• 代理模式可以实现对原始对象的访问控制，可以控制客户端对原始对象的访问权限和访问方式，提高系统的安全性。

• 代理模式可以实现对象的装饰和扩展，通过代理对象对原始对象进行包装和增强，可以为原始对象添加额外的功能和处理逻辑

缺点包括：

• 代理模式会导致系统中出现过多的代理类，增加系统的复杂性和维护成本。

• 代理模式需要为每个原始对象编写一个代理类，如果系统中需要代理的类很多，会导致代码冗余和可读性差的问题。

• 代理模式可能会影响程序的运行效率，因为代理对象需要额外的时间和空间来创建和维护。

Java代理模式有哪些常见的实现方式？

Java代理模式有多种实现方式，其中比较常见的包括静态代理和动态代理。

静态代理

是指在代码中显式地定义代理类，代理类负责将请求转发给原始对象，并在请求前后进行额外的处理。静态代理需要为每个原始对象编写一个代理类，因此在需要代理的类较多时会导致代码冗余和维护成本高的问题。

动态代理

是指在运行时生成代理对象，无需显式定义代理类，可以在不修改原始对象代码的情况下实现代理功能。Java提供了动态代理的支持，通过使用Java反射机制和InvocationHandler接口，可以在运行时动态地生成代理对象，并将请求转发给原始对象。

请举例说明Java代理模式的使用场景？

Java代理模式适用于以下场景：

1. 远程代理：将对象在不同的地址空间中进行传输，可以通过代理对象实现远程调用，避免了直接访问远程对象的复杂性和风险。

2. 虚拟代理：将一些开销较大的

延伸：

什么是反射？

Java的反射是指在程序运行时动态地获取一个类的信息，包括类的属性、方法、构造函数等，并且可以在运行时调用这些属性、方法、构造函数，甚至可以创建新的对象实例。通过Java的反射机制，我们可以在不知道类名的情况下获取一个类的信息并进行操作，这样就使得程序具有更高的灵活性和扩展性。反射机制常用于框架开发、插件开发、动态代理等方面。