Java的动态代理机制详解(附示例代码)

Spring主要有两大思想,一个是IoC,另一个就是AOP。

对于IoC,依赖注入就不用多说了,而对于Spring的核心AOP来说,我们不但要知道怎么通过AOP来满足的我们的功能,我们更需要学习的是其底层是怎么样的一个原理,而AOP的原理就是Java的动态代理机制,所以本篇随笔就是对java的动态机制进行一个回顾。

Spring AOP 内部是使用动态代理模式来实现的。

在Java的动态代理机制中,有两个重要的类或接口,一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class),这一个类和接口是实现我们动态代理所必须用到的。首先我们先来看看java的API帮助文档是怎么样对这两个类进行描述的:

InvocationHandler:

InvocationHandler is the interface implemented by the invocation handler of a proxy instance.

Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the invoke method of its invocation handler.

每一个动态代理类都必须要实现InvocationHandler这个接口,并且每个代理类的实例都关联到了一个handler,当我们通过代理对象调用一个方法的时候,这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法:

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

我们看到这个方法一共接受三个参数,那么这三个参数分别代表什么呢?

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy: 指代我们所代理的那个真实对象;method: 指代的是我们所要调用真实对象的某个方法的Method对象;args: 指代的是调用真实对象某个方法时接受的参数;

接下来我们来看看Proxy这个类:

Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.

Proxy这个类的作用就是用来动态创建一个代理对象的类,它提供了许多的方法,但是我们用的最多的就是 newProxyInstance 这个方法:

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

Returns an instance of a proxy class for the specified interfaces that dispatches method invocations to the specified invocation handler.

返回针对特定接口的代理类实例,并且分发方法调用到特定的Invocation handler。

这个方法的作用就是得到一个动态的代理对象,其接收三个参数,我们来看看这三个参数所代表的含义:

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

loader: 一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载;interfaces: 一个Interface对象的数组,表示的是将要给需要代理的对象提供一组什么接口,如果提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样就能调用这组接口中的方法了;h: 一个InvocationHandler对象,表示的是当这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上;

好了,在介绍完这两个接口(类)以后,我们来通过一个实例来看看我们的动态代理模式是什么样的:

1. 首先,我们创建业务接口 BusinessClassService:

package com.rickie;

public interface BusinessClassService {

void doSomeThing();

}

2. 开发业务类的实现类 BusinessClassServiceImpl:

package com.rickie;

public class BusinessClassServiceImpl implements BusinessClassService {

@Override

public void doSomeThing() {

System.out.println("do something ...");

try {

Thread.currentThread().sleep(1000L);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

3. 开发日志接口MyLogger,以及对应的实现类 MyLoggerImpl(这一步骤不是必须的):

MyLogger.java

package com.rickie;

import java.lang.reflect.Method;

public interface MyLogger {

// 记录进入方法时间

void saveIntoMethodTime(Method method);

// 记录退出方法时间

void saveOutMethodTime(Method method);

}

MyLoggerImpl.java

package com.rickie;

import java.lang.reflect.Method;

public class MyLoggerImpl implements MyLogger {

@Override

public void saveIntoMethodTime(Method method) {

System.out.println("进入" + method.getName() +

"方法时间为:" + System.currentTimeMillis());

}

@Override

public void saveOutMethodTime(Method method) {

System.out.println("退出" + method.getName() +

"方法时间为:" + System.currentTimeMillis());

}

}

4. 定义类 MyLoggerHandler,实现InvocationHandler(这一步非常关键):

package com.rickie;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

/**

* 日志类 Handler

*/

public class MyLoggerHandler implements InvocationHandler {

// 这个是我们要代理的真实对象,Original object

private Object objOriginal;

private MyLogger myLogger = new MyLoggerImpl();

// 构造方法,传入要代理的真实对象,并赋值;

public MyLoggerHandler(Object obj) {

super();

this.objOriginal = obj;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

Object result = null;

// logger - save into method time

myLogger.saveIntoMethodTime(method);

System.out.println("Method: " + method);

// 调用代理类方法

result = method.invoke(this.objOriginal, args);

// logger - save out method time

myLogger.saveOutMethodTime(method);

return result;

}

}

5. 编写MyLoggerTest.java 进行测试:

package com.rickie;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Proxy;

public class MyLoggerTest {

public static void main(String[] args) {

// 业务类 - 要代理的真实对象

BusinessClassService businessClassService = new BusinessClassServiceImpl();

// 我们需要代理哪个真实对象,就将该对象作为构造函数参数传进去

InvocationHandler myLoggerHandler = new MyLoggerHandler(businessClassService);

/**

* 获得代理类对象

* 通过Proxy的newProxyInstance方法来创建我们的代理对象,我们来看看其三个参数:

* 第一个参数 businessClassService.getClass().getClassLoader(),

* 我们这里使用businessClassService 这个类的ClassLoader对象来加载我们的代理对象。

* 第二个参数businessClassService.getClass().getInterfaces(),

* 我们这里为代理对象提供的接口,是真实对象所实现的接口,表示我们要代理的是该真实对象,这样就能调用这组接口中的方法了。

* 第三个参数handler, 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上。

*/

BusinessClassService proxyInstance = (BusinessClassService)Proxy.newProxyInstance(

businessClassService.getClass().getClassLoader(),

businessClassService.getClass().getInterfaces(),

myLoggerHandler

);

System.out.println("Proxy Class: " + proxyInstance.getClass());

System.out.println("Proxy Class.getName(): " + proxyInstance.getClass().getName());

// 执行代理类方法

proxyInstance.doSomeThing();

}

}

Proxy.NewProxyInstance: 该类即为动态代理类;返回代理类的一个实例(instance),返回后的代理类,可以当做被代理类使用。

在代理类实例被调用时,会执行InvocationHandler的invoke() 方法。

使用动态代理是为了更好地扩展,比如在方法之前做什么操作,之后做什么操作,这个时候这些公共的操作就可以统一交给代理类去做。

此时,需要调用实现了 InvocationHandler 类的一个回调方法(Invoke方法)。

执行结果:

Proxy Class: class com.sun.proxy.$Proxy0

Proxy Class.getName(): com.sun.proxy.$Proxy0

进入doSomeThing方法时间为:22

Method: public abstract void com.rickie.BusinessClassService.doSomeThing()

do something ...

退出doSomeThing方法时间为:23

总结一下JDK 动态代理的一般实现步骤:

创建一个实现 InvocationHandler 接口的类 MyLoggerHandler,它必须实现 invoke 方法。创建被代理类 BusinessClassService 以及接口实现类 BusinessClassServiceImpl。调用 Proxy 的静态方法:newProxyInstance,创建一个代理类。通过代理类调用方法。