面试官提问：什么是动态代理？_Java教程

面试官提问：什么是动态代理？

一、介绍

何谓代理?

据史料记载，代理这个词最早出现在代理商这个行业，所谓代理商，简而言之，其实就是帮助企业或者老板打理生意，自己本身不做生产任何商品。

举个例子，我们去火车站买票的时候，人少老板一个人还忙的过来，但是人一多的话，就会非常拥挤，于是就有了各种代售点，我们可以从代售点买车票，从而加快老板的卖票速度。

代售点的出现，可以说，很直观的帮助老板提升了用户购票体验。

站在软件设计的角度，其实效果也是一样的，采用代理模式的编程，能显著的增强原有的功能和简化方法调用方式。

面试官提问：什么是动态代理？

在介绍动态代理之前，我们先来聊解静态代理。

二、静态代理

下面，我们以两数相加为例，实现过程如下!

接口类

public interface Calculator {
/**
* 计算两个数之和
* @param num1
* @param num2
* @return
*/
Integer add(Integer num1, Integer num2);
}

目标对象

public class CalculatorImpl implements Calculator {
@Override
public Integer add(Integer num1, Integer num2) {
Integer result = num1 + num2;
return result;
}
}

代理对象

public class CalculatorProxyImpl implements Calculator {
private Calculator calculator;
@Override
public Integer add(Integer num1, Integer num2) {
//方法调用前，可以添加其他功能....
Integer result = calculator.add(num1, num2);
//方法调用后，可以添加其他功能....
return result;
}
public CalculatorProxyImpl(Calculator calculator) {
this.calculator = calculator;
}
}

测试类

public class CalculatorProxyClient {
public static void main(String[] args) {
//目标对象
Calculator target = new CalculatorImpl();
//代理对象
Calculator proxy = new CalculatorProxyImpl(target);
Integer result = proxy.add(1,2);
System.out.println("相加结果：" + result);
}
}

输出结果

相加结果：3

通过这种代理方式，最大的优点就是：可以在不修改目标对象的前提下，扩展目标对象的功能。

但也有缺点：需要代理对象和目标对象实现一样的接口，因此，当目标对象扩展新的功能时，代理对象也要跟着一起扩展，不易维护!

三、动态代理

动态代理，其实本质也是为了解决上面当目标对象扩展新功能时，代理对象也需要跟着一起扩展的痛点问题而生。

那它是怎么解决的呢?

以 JDK 为例，当需要给某个目标对象添加代理处理的时候，JDK 会在内存中动态的构建代理对象，从而实现对目标对象的代理功能。

下面，我们还是以两数相加为例，介绍具体的玩法!

3.1、JDK 中生成代理对象的玩法

创建接口

public interface JdkCalculator {
/**
* 计算两个数之和
* @param num1
* @param num2
* @return
*/
Integer add(Integer num1, Integer num2);
}

目标对象

public class JdkCalculatorImpl implements JdkCalculator {
@Override
public Integer add(Integer num1, Integer num2) {
Integer result = num1 + num2;
return result;
}
}

动态代理对象

public class JdkProxyFactory {
/**
* 维护一个目标对象
*/
private Object target;
public JdkProxyFactory(Object target) {
this.target = target;
}
public Object getProxyInstance(){
Object proxyClassObj = Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler(){
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("方法调用前，可以添加其他功能....");
// 执行目标对象方法
Object returnValue = method.invoke(target, args);
System.out.println("方法调用后，可以添加其他功能....");
return returnValue;
}
});
return proxyClassObj;
}
}

测试类

public class TestJdkProxy {
public static void main(String[] args) {
//目标对象
JdkCalculator target = new JdkCalculatorImpl();
System.out.println(target.getClass());
//代理对象
JdkCalculator proxyClassObj = (JdkCalculator) new JdkProxyFactory(target).getProxyInstance();
System.out.println(proxyClassObj.getClass());
//执行代理方法
Integer result = proxyClassObj.add(1,2);
System.out.println("相加结果：" + result);
}
}

输出结果

class com.example.java.proxy.jdk1.JdkCalculatorImpl
class com.sun.proxy.$Proxy0
方法调用前，可以添加其他功能....
方法调用后，可以添加其他功能....
相加结果：3

采用 JDK 技术动态创建interface实例的步骤如下：

1. 首先定义一个 InvocationHandler 实例，它负责实现接口的方法调用
2. 通过 Proxy.newProxyInstance() 创建 interface 实例，它需要 3 个参数:
（1）使用的 ClassLoader，通常就是接口类的 ClassLoader
（2）需要实现的接口数组，至少需要传入一个接口进去；
（3）用来处理接口方法调用的 InvocationHandler 实例。
3. 将返回的 Object 强制转型为接口

动态代理实际上是 JVM 在运行期动态创建class字节码并加载的过程，它并没有什么黑魔法技术，把上面的动态代理改写为静态实现类大概长这样：

public class JdkCalculatorDynamicProxy implements JdkCalculator {
private InvocationHandler handler;
public JdkCalculatorDynamicProxy(InvocationHandler handler) {
this.handler = handler;
}
public void add(Integer num1, Integer num2) {
handler.invoke(
this,
JdkCalculator.class.getMethod("add", Integer.class, Integer.class),
new Object[] { num1, num2 });
}
}

本质就是 JVM 帮我们自动编写了一个上述类(不需要源码，可以直接生成字节码)。

3.2、cglib 生成代理对象的玩法

除了 jdk 能实现动态的创建代理对象以外，还有一个非常有名的第三方框架：cglib，它也可以做到运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

cglib 特点如下：

cglib 不仅可以代理接口还可以代理类，而 JDK 的动态代理只能代理接口

cglib 是一个强大的高性能的代码生成包，它广泛的被许多 AOP 的框架使用，例如我们所熟知的 Spring AOP，cglib 为他们提供方法的 interception(拦截)。

CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类，速度非常快。

在使用 cglib 之前，我们需要添加依赖包，如果你已经有spring-core的jar包，则无需引入，因为spring中包含了cglib。

cglib
cglib
3.2.5

下面，我们还是以两数相加为例，介绍具体的玩法!

public interface CglibCalculator {
/**
* 计算两个数之和
* @param num1
* @param num2
* @return
*/
Integer add(Integer num1, Integer num2);
}

目标对象

public class CglibCalculatorImpl implements CglibCalculator {
@Override
public Integer add(Integer num1, Integer num2) {
Integer result = num1 + num2;
return result;
}
}

动态代理对象

public class CglibProxyFactory implements MethodInterceptor {
/**
* 维护一个目标对象
*/
private Object target;
public CglibProxyFactory(Object target) {
this.target = target;
}
/**
* 为目标对象生成代理对象
* @return
*/
public Object getProxyInstance() {
//工具类
Enhancer en = new Enhancer();
//设置父类
en.setSuperclass(target.getClass());
//设置回调函数
en.setCallback(this);
//创建子类对象代理
return en.create();
}
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("方法调用前，可以添加其他功能....");
// 执行目标对象方法
Object returnValue = method.invoke(target, args);
System.out.println("方法调用后，可以添加其他功能....");
return returnValue;
}
}

测试类

public class TestCglibProxy {
public static void main(String[] args) {
//目标对象
CglibCalculator target = new CglibCalculatorImpl();
System.out.println(target.getClass());
//代理对象
CglibCalculator proxyClassObj = (CglibCalculator) new CglibProxyFactory(target).getProxyInstance();
System.out.println(proxyClassObj.getClass());
//执行代理方法
Integer result = proxyClassObj.add(1,2);
System.out.println("相加结果：" + result);
}
}

输出结果

class com.example.java.proxy.cglib1.CglibCalculatorImpl
class com.example.java.proxy.cglib1.CglibCalculatorImpl$$EnhancerByCGLIB$$3ceadfe4
方法调用前，可以添加其他功能....
方法调用后，可以添加其他功能....
相加结果：3

将 cglib 生成的代理类改写为静态实现类大概长这样：

public class CglibCalculatorImplByCGLIB extends CglibCalculatorImpl implements Factory {
private static final MethodInterceptor methodInterceptor;
private static final Method method;
public final Integer add(Integer var1, Integer var2) {
return methodInterceptor.intercept(this, method, new Object[]{var1, var2}, methodProxy);
}
//....
}

其中，拦截思路与 JDK 类似，都是通过一个接口方法进行拦截处理!

在上文中咱们还介绍到了，cglib 不仅可以代理接口还可以代理类，下面我们试试代理类。

public class CglibCalculatorClass {
/**
* 计算两个数之和
* @param num1
* @param num2
* @return
*/
public Integer add(Integer num1, Integer num2) {
Integer result = num1 + num2;
return result;
}
}

测试类

public class TestCglibProxyClass {
public static void main(String[] args) {
//目标对象
CglibCalculatorClass target = new CglibCalculatorClass();
System.out.println(target.getClass());
//代理对象
CglibCalculatorClass proxyClassObj = (CglibCalculatorClass) new CglibProxyFactory(target).getProxyInstance();
System.out.println(proxyClassObj.getClass());
//执行代理方法
Integer result = proxyClassObj.add(1,2);
System.out.println("相加结果：" + result);
}
}

输出结果

class com.example.java.proxy.cglib1.CglibCalculatorClass
class com.example.java.proxy.cglib1.CglibCalculatorClass$$EnhancerByCGLIB$$e68ff36c
方法调用前，可以添加其他功能....
方法调用后，可以添加其他功能....
相加结果：3