代理模式
- 静态代理：代理和被代理对象在代理之前都是确定的，它们都实现相同的接口或者继承相同的抽象类。
即代理类是在编译时就实现好的。也就是说 Java 编译完成后代理类是一个实际的 class 文件。 - 动态代理：代理类是在运行时生成的。也就是说 Java 编译完之后并没有实际的 class 文件，而是在运行时动态生成的类字节码，并加载到JVM中。
静态代理
代理模式
上图中
- RealSubject 是原对象（此处将原对象称为"委托对象"），Proxy 是代理对象。
- Subject 是委托对象和代理对象都共同实现的接口。
- Request() 是委托对象和代理对象共同拥有的方法。
public class demo {
public static void main(String[] args) {
RealThing realThing=new RealThing();
MyProxy myProxy=new MyProxy(realThing);
myProxy.check();
}
}
interface Thing{
void check();
}
class RealThing implements Thing{
@Override
public void check() {
System.out.println("RealThing is called.");
}
}
class MyProxy implements Thing{
private Thing thing;
public MyProxy(Thing thing) {
this.thing = thing;
}
@Override
public void check() {
System.out.println("Before proxy process");
thing.check();
System.out.println("After proxy process");
}
}
运行结果
Before proxy process
RealThing is called.
After proxy process
动态代理
Overview
前面的静态代理中，我们每次要代理一个新的类，都要一个新的代理类，这样很麻烦。在动态代理中，我们通过动态生成代理类的方法实现代理。
这里主要依靠InvocationHandler和Proxy来实现。
- 委托类和委托对象：委托类是一个类，委托对象是委托类的实例。
- 代理类和代理对象：代理类是一个类，代理对象是代理类的实例。
Achieve
Java实现动态代理的大致步骤如下：
- 定义一个委托类和公共接口。
- 自己定义一个类（调用处理器类，即实现 InvocationHandler 接口），这个类的目的是指定运行时将生成的代理类需要完成的具体任务（包括Preprocess和Postprocess），即代理类调用任何方法都会经过这个调用处理器类（在本文最后一节对此进行解释）。
- 生成代理对象（当然也会生成代理类），需要为他指定
(1)委托对象
(2)实现的一系列接口
(3)调用处理器类的实例。
因此可以看出一个代理对象对应一个委托对象，对应一个调用处理器实例。
Java 实现动态代理主要涉及以下几个类：
-
java.lang.reflect.Proxy: 这是生成代理类的主类，通过 Proxy 类生成的代理类都继承了 Proxy 类，即DynamicProxyClass extends Proxy。 -
java.lang.reflect.InvocationHandler: 这里称其为"调用处理器"，它是一个接口，我们动态生成的代理类需要完成的具体内容需要自己定义一个类，而这个类必须实现 InvocationHandler 接口。
Proxy类的主要方法
//创建代理对象
static Object newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)
这个静态函数的第一个参数是类加载器对象（即哪个类加载器来加载这个代理类到 JVM 的方法区），第二个参数是接口（表明你这个代理类需要实现哪些接口），第三个参数是调用处理器类实例（指定代理类中具体要干什么）。这个函数是 JDK 为了程序员方便创建代理对象而封装的一个函数，因此你调用newProxyInstance()时直接创建了代理对象（略去了创建代理类的代码）。其实他主要完成了以下几个工作：
static Object newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler handler)
{
//1. 根据类加载器和接口创建代理类
Class clazz = Proxy.getProxyClass(loader, interfaces);
//2. 获得代理类的带参数的构造函数
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });
//3. 创建代理对象，并制定调用处理器实例为参数传入
Interface Proxy = (Interface)constructor.newInstance(new Object[] {handler});
}
Proxy 类还有一些静态方法，比如：
-
InvocationHandler getInvocationHandler(Object proxy): 获得代理对象对应的调用处理器对象。 -
Class getProxyClass(ClassLoader loader, Class[] interfaces): 根据类加载器和实现的接口获得代理类。
Proxy 类中有一个映射表，映射关系为：(，可以看出一级key为类加载器，根据这个一级key获得二级映射表，二级key为接口数组，因此可以看出：一个类加载器对象和一个接口数组确定了一个代理类。,( , ) )
我们写一个简单的例子来阐述 Java 实现动态代理的整个过程：
public class DynamicProxyDemo01 {
public static void main(String[] args) {
RealSubject realSubject = new RealSubject(); //1.创建委托对象
ProxyHandler handler = new ProxyHandler(realSubject); //2.创建调用处理器对象
Subject proxySubject = (Subject)Proxy.newProxyInstance(RealSubject.class.getClassLoader(),
RealSubject.class.getInterfaces(), handler); //3.动态生成代理对象
proxySubject.request(); //4.通过代理对象调用方法
}
}
/**
* 接口
*/
interface Subject{
void request();
}
/**
* 委托类
*/
class RealSubject implements Subject{
public void request(){
System.out.println("====RealSubject Request====");
}
}
/**
* 代理类的调用处理器
*/
class ProxyHandler implements InvocationHandler{
private Subject subject;
public ProxyHandler(Subject subject){
this.subject = subject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("====before====");//定义预处理的工作，当然你也可以根据 method 的不同进行不同的预处理工作
Object result = method.invoke(subject, args);
System.out.println("====after====");
return result;
}
}
InvocationHandler 接口中有方法：
invoke(Object proxy, Method method, Object[] args)
这个函数是在代理对象调用任何一个方法时都会调用的，方法不同会导致第二个参数method不同，第一个参数是代理对象（表示哪个代理对象调用了method方法），第二个参数是 Method 对象（表示哪个方法被调用了），第三个参数是指定调用方法的参数。
动态生成的代理类具有几个特点：
- 继承 Proxy 类，并实现了在
Proxy.newProxyInstance()中提供的接口数组。 - public final
- 命名方式为
$ProxyN，其中N会慢慢增加，一开始是$Proxy1，接下来是$Proxy2... - 有一个参数为
InvocationHandler的构造函数。这个从 Proxy.newProxyInstance() 函数内部的clazz.getConstructor(new Class[] { InvocationHandler.class }) 可以看出。
Java 实现动态代理的缺点：因为 Java 的单继承特性（每个代理类都继承了 Proxy 类），只能针对接口创建代理类，不能针对类创建代理类。
不难发现，代理类的实现是有很多共性的（重复代码），动态代理的好处在于避免了这些重复代码，只需要关注操作。
Java 动态代理的内部实现
Java 是怎么保证代理对象调用的任何方法都会调用 InvocationHandler 的 invoke() 方法的？
这就涉及到动态代理的内部实现。假设有一个接口 Subject，且里面有 int request(int i) 方法，则生成的代理类大致如下：
public final class $Proxy1 extends Proxy implements Subject{
private InvocationHandler h;
private $Proxy1(){}
public $Proxy1(InvocationHandler h){
this.h = h;
}
public int request(int i){
Method method = Subject.class.getMethod("request", new Class[]{int.class}); //创建method对象
return (Integer)h.invoke(this, method, new Object[]{new Integer(i)}); //调用了invoke方法
}
}
通过上面的方法就成功调用了 invoke() 方法。
元编程
元编程就是能够操作代码的代码
Java 支持元编程因为反射、动态代理、内省等特性。
PS
JDK的动态代理不能代理一个类，只能代理接口。
而cglib可以做到基于类的动态代理。