JDK Proxy的动态代理机制是如何实现的？
- 内容介绍
- 文章标签
- 相关推荐
本文共计2819个文字，预计阅读时间需要12分钟。
JAVA安全|基础篇：反射的应用-动态代理（qq.com）Java反射和动态代理的区别（JDK+Proxy和Cglib），常见面试题（qq.com）反射的正常使用，需要调用类中的方法，需要通过关键字invoke()实现
JAVA安全|基础篇：反射的应用—动态代理 (qq.com)
Java反射和动态代理的区别（JDK Proxy和Cglib，常见面试题 (qq.com)
反射的正常使用
反射要调用类中的方法，需要通过关键方法“invoke()”实现的，方法调用也分为三种：
- 静态（static）方法调用
- 普通方法调用
- 私有方法调用
以下会分别演示，各种调用的实现代码，各种调用的公共代码部分，如下：
// 此段代码为公共代码
interface People {
int parentAge = 18;
public void sayHi(String name);
}
class PeopleImpl implements People {
private String privSex = "男";
public String race = "汉族";
@Override
public void sayHi(String name) {
System.out.println("hello," + name);
}
private void prvSayHi() {
System.out.println("prvSayHi~");
}
public static void getSex() {
System.out.println("18岁");
}
}
静态方法调用
// 核心代码（省略了抛出异常的声明）
public static void main(String[] args) {
Class myClass = Class.forName("example.PeopleImpl");
// 调用静态（static）方法
Method getSex = myClass.getMethod("getSex");
getSex.invoke(myClass);
}
静态方法的调用比较简单，使用 getMethod(xx) 获取到对应的方法，直接使用 invoke(xx)就可以了。
普通方法调用
普通非静态方法调用，需要先获取类示例，通过“newInstance()”方法获取，核心代码如下：
Class myClass = Class.forName("example.PeopleImpl");
Object object = myClass.newInstance();
Method method = myClass.getMethod("sayHi",String.class);
method.invoke(object,"老王");
getMethod 获取方法，可以声明需要传递的参数的类型。
调用私有方法
调用私有方法，必须使用“getDeclaredMethod(xx)”获取本类所有什么的方法，代码如下：
Class myClass = Class.forName("example.PeopleImpl");
Object object = myClass.newInstance();
Method privSayHi = myClass.getDeclaredMethod("privSayHi");
privSayHi.setAccessible(true); // 修改访问限制
privSayHi.invoke(object);
除了“getDeclaredMethod(xx)”可以看出，调用私有方法的关键是设置 setAccessible(true) 属性，修改访问限制，这样设置之后就可以进行调用了。
总结
在反射中核心的方法是newInstance()获取类实例，getMethod(...)获取方法，使用invoke(...)进行方法调用，通过setAccessible修改访问私有变量/方法的限制
获取属性/方法的时候有无“Declared”的区别是，带有 Declared 修饰的方法或属性，可以获取本类的所有方法或属性（private 到 public），但不能获取到父类的任何信息；非 Declared 修饰的方法或属性，只能获取 public 修饰的方法或属性，并可以获取到父类的信息，比如 getMethod(..)和getDeclaredMethod(..)。
代理模式实例
代理模式，属于结构型模式。使用一个类代表另一个类的功能，在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 比如生活中常见的中介与租房，租房者不需要直接与房东交互，房东把房屋租赁交给中介代理。代理模式的目的有：
（1）通过引入代理对象的方式来间接访问目标对象，防止直接访问目标对象给系统带来的不必要复杂性；
（2）通过代理对象对访问进行控制；
代理模式一般会有三个角色：
抽象角色：指代理角色和真实角色对外提供的公共方法，一般为一个接口
真实角色：需要实现抽象角色接口，定义了真实角色所要实现的业务逻辑，以便供代理角色调用。也就是真正的业务逻辑在此。
代理角色：需要实现抽象角色接口，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。将统一的流程控制都放到代理角色中处理！
实例如下：
首先，我们得有一个接口（比如ClothFactory,衣服工厂），有两个类（被代理类，比如NikeClothFactory；代理类，比如ProxyClothFactory）实现了这个接口，想通过代理类的方法调用到被代理类的同名方法，那么代理对象得将被代理对象包装起来。
怎么通过代码实现包装呢？代理对象中应有一个属性为被代理类对象，通过构造器传入，且在代理对象的方法中调用了被代理对象的同名方法，这样就实现了通过代理来调用原始对象。具体代码如下：
//共同接口
interface ClothFactory{
void produceCloth();
}
//被代理类
class NikeClothFactory implements ClothFactory{
@Override
public void produceCloth() {
System.out.println("Nike工厂生产了一批运动服");
}
}
//代理类
class ProxyClothFactory implements ClothFactory{
private ClothFactory factory;//用被代理类对象进行实例化
public ProxyClothFactory(ClothFactory factory) {
this.factory = factory;
}
@Override
public void produceCloth() {
System.out.println("代理工厂做一些准备工作");
factory.produceCloth();
System.out.println("代理工厂做一些后续的收尾工作");
}
}
测试代码：
//测试类
public class StaticProxyTest {
public static void main(String[] args) {
//创建被代理类的对象
ClothFactory nikeClothFactory = new NikeClothFactory();
//创建代理类的对象
ClothFactory proxyClothFactory = new ProxyClothFactory(nikeClothFactory);
//通过代理对象对被代理对象进行访问
proxyClothFactory.produceCloth();
}
}
运行结果：
代理工厂做一些准备工作
Nike工厂生产了一批运动服
代理工厂做一些后续的收尾工作
动态代理是一种方便运行时动态构建代理，动态处理代理方法调用的机制，很多场景都是利用类似机制做到的，比如用来包装RPC调用、面向切面的编程（AOP）。
实现动态代理的方式很多，比如利用JDK自身提供的动态代理，就是主要利用了上面提到的反射机制。还有其他的实现方式，比如利用传说中更高性能的字节码操作机制，类似ASM、cglib（基于ASM）等。
JDK Proxy 动态代理
JDK Proxy 是通过实现 InvocationHandler 接口来实现的，代码如下：
interface Animal {
void eat();
}
class Dog implements Animal {
@Override
public void eat() {
System.out.println("The dog is eating");
}
}
class Cat implements Animal {
@Override
public void eat() {
System.out.println("The cat is eating");
}
}
// JDK 代理类
class AnimalProxy implements InvocationHandler {
private Object target; // 代理对象
public Object getInstance(Object target) {
this.target = target;
// 取得代理对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("调用前");
Object result = method.invoke(target, args); // 方法调用
System.out.println("调用后");
return result;
}
}
public static void main(String[] args) {
// JDK 动态代理调用
AnimalProxy proxy = new AnimalProxy();
Animal dogProxy = (Animal) proxy.getInstance(new Dog());
dogProxy.eat();
}
如上代码，我们实现了通过动态代理，在所有请求之前和之后打印了一个简单的信息。
注意： JDK Proxy 只能代理实现接口的类（即使是extends继承类也是不可以代理的）。
JDK Proxy 为什么只能代理实现接口的类？
这个问题要从动态代理的实现方法 newProxyInstance 源码说起：
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
// 省略其他代码
来看前两个源码参数说明
* @param loader the class loader to define the proxy class
* @param interfaces the list of interfaces for the proxy class to implement
- loader：为类加载器，也就是 target.getClass().getClassLoader()
- interfaces：接口代理类的接口实现列表
所以这个问题的源头，在于 JDK Proxy 的源码设计。如果要执意动态代理，非接口实现类就会报错：
Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to xxx
Cglib 动态代理
JDK 动态代理机制只能代理实现了接口的类，Cglib 是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对 final 修饰的类进行代理。
Cglib 可以通过 Maven 直接进行版本引用，Maven 版本地址：mvnrepository.com/artifact/cglib/cglib
本文使用的是最新版本 3.2.9 的 Cglib，在 pom.xml 添加如下引用：
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.9</version>
</dependency>
Cglib 代码实现，如下：
class Panda {
public void eat() {
System.out.println("The panda is eating");
}
}
class CglibProxy implements MethodInterceptor {
private Object target; // 代理对象
public Object getInstance(Object target) {
this.target = target;
Enhancer enhancer = new Enhancer();
// 设置父类为实例类
enhancer.setSuperclass(this.target.getClass());
// 回调方法
enhancer.setCallback(this);
// 创建代理对象
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("调用前");
Object result = methodProxy.invokeSuper(o, objects); // 执行方法调用
System.out.println("调用后");
return result;
}
}
public static void main(String[] args) {
// CGLIB 动态代理调用
CglibProxy proxy = new CglibProxy();
Panda panda = (Panda)proxy.getInstance(new Panda());
panda.eat();
}
cglib 的调用通过实现 MethodInterceptor 接口的 intercept 方法，调用 invokeSuper 进行动态代理的，可以直接对普通类进行动态代理。
JDK VS. cjlib
JDK动态代理：利用反射机制生成代理类，可以动态指定代理类的目标类，要求实现invovationHandler接口，重写invoke方法进行功能增强，还要求目标类必须实现接口。
Cjlib动态代理：利用ASM开源包，把代理对象的Class文件加载进来，修改其字节码文件生成子类，子类重写目标类的方法，被final修饰的话就不可以，然后在子类采用方法拦截技术拦截父类方法调用，织入逻辑（定义拦截器实现MethodInterceptor接口）
JDK Proxy 的优势：
- 最小化依赖关系，减少依赖意味着简化开发和维护，JDK 本身的支持，更加可靠；
- 平滑进行 JDK 版本升级，而字节码类库通常需要进行更新以保证在新版上能够使用；
Cglib 框架的优势：
- 可调用普通类，不需要实现接口；
- 基于ASM，高性能；
本文共计2819个文字，预计阅读时间需要12分钟。
JAVA安全|基础篇：反射的应用-动态代理（qq.com）Java反射和动态代理的区别（JDK+Proxy和Cglib），常见面试题（qq.com）反射的正常使用，需要调用类中的方法，需要通过关键字invoke()实现
JAVA安全|基础篇：反射的应用—动态代理 (qq.com)
Java反射和动态代理的区别（JDK Proxy和Cglib，常见面试题 (qq.com)
反射的正常使用
反射要调用类中的方法，需要通过关键方法“invoke()”实现的，方法调用也分为三种：
- 静态（static）方法调用
- 普通方法调用
- 私有方法调用
以下会分别演示，各种调用的实现代码，各种调用的公共代码部分，如下：
// 此段代码为公共代码
interface People {
int parentAge = 18;
public void sayHi(String name);
}
class PeopleImpl implements People {
private String privSex = "男";
public String race = "汉族";
@Override
public void sayHi(String name) {
System.out.println("hello," + name);
}
private void prvSayHi() {
System.out.println("prvSayHi~");
}
public static void getSex() {
System.out.println("18岁");
}
}
静态方法调用
// 核心代码（省略了抛出异常的声明）
public static void main(String[] args) {
Class myClass = Class.forName("example.PeopleImpl");
// 调用静态（static）方法
Method getSex = myClass.getMethod("getSex");
getSex.invoke(myClass);
}
静态方法的调用比较简单，使用 getMethod(xx) 获取到对应的方法，直接使用 invoke(xx)就可以了。
普通方法调用
普通非静态方法调用，需要先获取类示例，通过“newInstance()”方法获取，核心代码如下：
Class myClass = Class.forName("example.PeopleImpl");
Object object = myClass.newInstance();
Method method = myClass.getMethod("sayHi",String.class);
method.invoke(object,"老王");
getMethod 获取方法，可以声明需要传递的参数的类型。
调用私有方法
调用私有方法，必须使用“getDeclaredMethod(xx)”获取本类所有什么的方法，代码如下：
Class myClass = Class.forName("example.PeopleImpl");
Object object = myClass.newInstance();
Method privSayHi = myClass.getDeclaredMethod("privSayHi");
privSayHi.setAccessible(true); // 修改访问限制
privSayHi.invoke(object);
除了“getDeclaredMethod(xx)”可以看出，调用私有方法的关键是设置 setAccessible(true) 属性，修改访问限制，这样设置之后就可以进行调用了。
总结
在反射中核心的方法是newInstance()获取类实例，getMethod(...)获取方法，使用invoke(...)进行方法调用，通过setAccessible修改访问私有变量/方法的限制
获取属性/方法的时候有无“Declared”的区别是，带有 Declared 修饰的方法或属性，可以获取本类的所有方法或属性（private 到 public），但不能获取到父类的任何信息；非 Declared 修饰的方法或属性，只能获取 public 修饰的方法或属性，并可以获取到父类的信息，比如 getMethod(..)和getDeclaredMethod(..)。
代理模式实例
代理模式，属于结构型模式。使用一个类代表另一个类的功能，在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 比如生活中常见的中介与租房，租房者不需要直接与房东交互，房东把房屋租赁交给中介代理。代理模式的目的有：
（1）通过引入代理对象的方式来间接访问目标对象，防止直接访问目标对象给系统带来的不必要复杂性；
（2）通过代理对象对访问进行控制；
代理模式一般会有三个角色：
抽象角色：指代理角色和真实角色对外提供的公共方法，一般为一个接口
真实角色：需要实现抽象角色接口，定义了真实角色所要实现的业务逻辑，以便供代理角色调用。也就是真正的业务逻辑在此。
代理角色：需要实现抽象角色接口，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。将统一的流程控制都放到代理角色中处理！
实例如下：
首先，我们得有一个接口（比如ClothFactory,衣服工厂），有两个类（被代理类，比如NikeClothFactory；代理类，比如ProxyClothFactory）实现了这个接口，想通过代理类的方法调用到被代理类的同名方法，那么代理对象得将被代理对象包装起来。
怎么通过代码实现包装呢？代理对象中应有一个属性为被代理类对象，通过构造器传入，且在代理对象的方法中调用了被代理对象的同名方法，这样就实现了通过代理来调用原始对象。具体代码如下：
//共同接口
interface ClothFactory{
void produceCloth();
}
//被代理类
class NikeClothFactory implements ClothFactory{
@Override
public void produceCloth() {
System.out.println("Nike工厂生产了一批运动服");
}
}
//代理类
class ProxyClothFactory implements ClothFactory{
private ClothFactory factory;//用被代理类对象进行实例化
public ProxyClothFactory(ClothFactory factory) {
this.factory = factory;
}
@Override
public void produceCloth() {
System.out.println("代理工厂做一些准备工作");
factory.produceCloth();
System.out.println("代理工厂做一些后续的收尾工作");
}
}
测试代码：
//测试类
public class StaticProxyTest {
public static void main(String[] args) {
//创建被代理类的对象
ClothFactory nikeClothFactory = new NikeClothFactory();
//创建代理类的对象
ClothFactory proxyClothFactory = new ProxyClothFactory(nikeClothFactory);
//通过代理对象对被代理对象进行访问
proxyClothFactory.produceCloth();
}
}
运行结果：
代理工厂做一些准备工作
Nike工厂生产了一批运动服
代理工厂做一些后续的收尾工作
动态代理是一种方便运行时动态构建代理，动态处理代理方法调用的机制，很多场景都是利用类似机制做到的，比如用来包装RPC调用、面向切面的编程（AOP）。
实现动态代理的方式很多，比如利用JDK自身提供的动态代理，就是主要利用了上面提到的反射机制。还有其他的实现方式，比如利用传说中更高性能的字节码操作机制，类似ASM、cglib（基于ASM）等。
JDK Proxy 动态代理
JDK Proxy 是通过实现 InvocationHandler 接口来实现的，代码如下：
interface Animal {
void eat();
}
class Dog implements Animal {
@Override
public void eat() {
System.out.println("The dog is eating");
}
}
class Cat implements Animal {
@Override
public void eat() {
System.out.println("The cat is eating");
}
}
// JDK 代理类
class AnimalProxy implements InvocationHandler {
private Object target; // 代理对象
public Object getInstance(Object target) {
this.target = target;
// 取得代理对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("调用前");
Object result = method.invoke(target, args); // 方法调用
System.out.println("调用后");
return result;
}
}
public static void main(String[] args) {
// JDK 动态代理调用
AnimalProxy proxy = new AnimalProxy();
Animal dogProxy = (Animal) proxy.getInstance(new Dog());
dogProxy.eat();
}
如上代码，我们实现了通过动态代理，在所有请求之前和之后打印了一个简单的信息。
注意： JDK Proxy 只能代理实现接口的类（即使是extends继承类也是不可以代理的）。
JDK Proxy 为什么只能代理实现接口的类？
这个问题要从动态代理的实现方法 newProxyInstance 源码说起：
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
// 省略其他代码
来看前两个源码参数说明
* @param loader the class loader to define the proxy class
* @param interfaces the list of interfaces for the proxy class to implement
- loader：为类加载器，也就是 target.getClass().getClassLoader()
- interfaces：接口代理类的接口实现列表
所以这个问题的源头，在于 JDK Proxy 的源码设计。如果要执意动态代理，非接口实现类就会报错：
Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to xxx
Cglib 动态代理
JDK 动态代理机制只能代理实现了接口的类，Cglib 是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对 final 修饰的类进行代理。
Cglib 可以通过 Maven 直接进行版本引用，Maven 版本地址：mvnrepository.com/artifact/cglib/cglib
本文使用的是最新版本 3.2.9 的 Cglib，在 pom.xml 添加如下引用：
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.9</version>
</dependency>
Cglib 代码实现，如下：
class Panda {
public void eat() {
System.out.println("The panda is eating");
}
}
class CglibProxy implements MethodInterceptor {
private Object target; // 代理对象
public Object getInstance(Object target) {
this.target = target;
Enhancer enhancer = new Enhancer();
// 设置父类为实例类
enhancer.setSuperclass(this.target.getClass());
// 回调方法
enhancer.setCallback(this);
// 创建代理对象
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("调用前");
Object result = methodProxy.invokeSuper(o, objects); // 执行方法调用
System.out.println("调用后");
return result;
}
}
public static void main(String[] args) {
// CGLIB 动态代理调用
CglibProxy proxy = new CglibProxy();
Panda panda = (Panda)proxy.getInstance(new Panda());
panda.eat();
}
cglib 的调用通过实现 MethodInterceptor 接口的 intercept 方法，调用 invokeSuper 进行动态代理的，可以直接对普通类进行动态代理。
JDK VS. cjlib
JDK动态代理：利用反射机制生成代理类，可以动态指定代理类的目标类，要求实现invovationHandler接口，重写invoke方法进行功能增强，还要求目标类必须实现接口。
Cjlib动态代理：利用ASM开源包，把代理对象的Class文件加载进来，修改其字节码文件生成子类，子类重写目标类的方法，被final修饰的话就不可以，然后在子类采用方法拦截技术拦截父类方法调用，织入逻辑（定义拦截器实现MethodInterceptor接口）
JDK Proxy 的优势：
- 最小化依赖关系，减少依赖意味着简化开发和维护，JDK 本身的支持，更加可靠；
- 平滑进行 JDK 版本升级，而字节码类库通常需要进行更新以保证在新版上能够使用；
Cglib 框架的优势：
- 可调用普通类，不需要实现接口；
- 基于ASM，高性能；