在学习Spring的时候,我们知道Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,依赖注入就不用多说了,而对于Spring的核心AOP来说,我们不但要知道怎么通过AOP来满足的我们的功能,我们更需要学习的是其底层是怎么样的一个原理,而AOP的原理就是java的动态代理机制,所以本篇随笔就是对java的动态机制进行一个回顾。
在java的动态代理机制中,有两个重要的类或接口,一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class),这一个类和接口是实现我们动态代理所必须用到的。首先我们先来看看java的API帮助文档是怎么样对这两个类进行描述的:
InvocationHandler类:
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时,将在调用处理程序上调用此方法。
参数:
proxy
- 在其上调用方法的代理实例
method
- 对应于在代理实例上调用的接口方法的 Method
实例。Method
对象的声明类将是在其中声明方法的接口,该接口可以是代理类赖以继承方法的代理接口的超接口。
args
- 包含传入代理实例上方法调用的参数值的对象数组,如果接口方法不使用参数,则为 null
。基本类型的参数被包装在适当基本包装器类(如 java.lang.Integer
或 java.lang.Boolean
)的实例中。
返回:
从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型,则此方法返回的值一定是相应基本包装对象类的实例;否则,它一定是可分配到声明返回类型的类型。如果此方法返回的值为 null
并且接口方法的返回类型是基本类型,则代理实例上的方法调用将抛出 NullPointerException
。否则,如果此方法返回的值与上述接口方法的声明返回类型不兼容,则代理实例上的方法调用将抛出 ClassCastException
。
抛出:
Throwable
- 从代理实例上的方法调用抛出的异常。该异常的类型必须可以分配到在接口方法的 throws
子句中声明的任一异常类型或未经检查的异常类型 java.lang.RuntimeException
或 java.lang.Error
。如果此方法抛出经过检查的异常,该异常不可分配到在接口方法的 throws
子句中声明的任一异常类型,代理实例的方法调用将抛出包含此方法曾抛出的异常的 UndeclaredThrowableException
。
Proxy类:
所有已实现的接口:
static Object | newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 返回一个指定接口的代理类实例,该接口可以将方法调用指派到指定的调用处理程序。 |
newProxyInstance
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
返回一个指定接口的代理类实例,该接口可以将方法调用指派到指定的调用处理程序。此方法相当于:
Proxy.getProxyClass(loader, interfaces).
getConstructor(new Class[] { InvocationHandler.class }).
newInstance(new Object[] { handler });
Proxy.newProxyInstance
抛出 IllegalArgumentException
,原因与 Proxy.getProxyClass
相同。
参数:
loader
- 定义代理类的类加载器
interfaces
- 代理类要实现的接口列表
h
- 指派方法调用的调用处理程序
返回:
一个带有代理类的指定调用处理程序的代理实例,它由指定的类加载器定义,并实现指定的接口
下面是我的Demo ---------------
我的(Interface)接口类
package com.test;
public interface IPerson {
int add();
String pre();
void show();
}
测试类(Main方法):
package com.test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Dome {
public static void main(String[] args) {
InvocationHandler handler = new InvocationHandler() {
// proxy: 指代我们所代理的那个真实对象
// method: 指代的是我们所要调用真实对象的某个方法的Method对象
// args: 指代的是调用真实对象某个方法时接受的参数
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.getReturnType() == String.class) {
System.out.println(method.getName()); //打印方法名
return "aaa"; //方法返回值
}else if(method.getReturnType() == Integer.class || method.getReturnType() == int.class){
System.out.println(method.getName());
return 1;
}else{
System.out.println(method.getName());
return null;
}
}
};
// ClassLoader: 一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载
// Class[] interfaces: 一个Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口,如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口中的方法了
// InvocationHandler: 一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上
IPerson iPerson = (IPerson) Proxy.newProxyInstance(IPerson.class.getClassLoader(),new Class<?>[]{IPerson.class},handler);
iPerson.add();
iPerson.pre();
iPerson.show();
}
}
调用接口中的三个方法,这也就证明了当我通过代理对象来调用方法的时候,起实际就是委托由其关联到的 handler 对象的invoke方法中来调用,并不是自己来真实调用,而是通过代理的方式来调用的。
这就是我们的java动态代理机制