[TOC]
一、代理模式简介
1.1、代理模式
提供了间接对目标对象进行访问的方式，即通过代理对象访问目标对象。
1.2、代理模式的好处
在实现目标对象功能的基础上，增加额外的功能，扩充目标对象的功能。符合开闭原则：即不改变既有代码的前提下，对功能进行扩展。
例如，需要在所有类的方法执行前后打印日志。
二、JVM 创建对象
对象创建过程
对象创建过程
关于 Class 对象和实例对象
Class 对象：每个类运行时的类型信息由 Class 对象来表示，Class 对象中包含与这个类有关的信息。
实例对象：实例对象是由 Class 对象创建的。
Class 对象和实例对象
Java 程序在开始运行之前并非被完全加载，其各个类都是在必需时才加载的 —— 懒加载
获取 Class 对象的方式
Class.forName(“类的全限定名”)
实例对象.getClass()
类名.class —— 类字面常量
如：
Class clazz = int.class
如果字段被 static final 修饰，称为“编译时常量”。调用该字段时，不会对类进行初始化。
因为这个字段在编译期就把结果放入常量池中了。
三、静态代理
静态代理的逻辑：
静态代理的逻辑
静态代理缺陷
对于每一个目标类都需要写对应的 XXProxy 代理类，如果目标类很多的话，写成百上千个代理类是不切实际的。
四、动态代理
动态代理的思路
动态代理的思路
动态代理的优势
在程序运行时，JVM 才对被代理对象（目标对象）生成代理对象。涉及到反射。
注意，动态代理的时候目标对象必须得实现接口，否则动态代理无法使用，原因很明显，因为代理对象本身不用实现接口，它用到的是目标对象的引用，所以如果目标对象不实现接口的话，根本没法进行代理。
如何从 interface 创建 Class 对象？
JDK 提供：java.lang.reflect.InvocationHandler接口 + java.lang.reflect.Proxy 类
Proxy 类有一个静态方法：
1
| public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)
|
入参是 ClassLoader 类加载器以及一组接口 Class 对象。出参是 Class 类型，也就是一个 Class 对象，实际就是一个代理 Class，通过这个 Class 可以创建对应入参的代理对象。
动态代理的实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
| import java.lang.reflect.*;
public class DynamicProxy {
public static void main(String[] args) throws Throwable {
Class proxyClass = Proxy.getProxyClass(Dog.class.getClassLoader(), Dog.class);
Constructor constructor = proxyClass.getConstructor(InvocationHandler.class);
Dog dog = (Dog)constructor.newInstance(new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
WhiteDog whiteDog = new WhiteDog();
Object result = method.invoke(whiteDog, args);
return result;
}
});
dog.canRun();
dog.canBark();
}
}
import java.lang.reflect.*;
public class DynamicProxy {
public static void main(String[] args) throws Throwable {
WhiteDog target = new WhiteDog();
Dog dog = (Dog) getProxy(target);
dog.canRun();
dog.canBark();
}
private static Object getProxy(final Object target) throws Throwable {
Class proxyClass = Proxy.getProxyClass(Dog.class.getClassLoader(), Dog.class);
Constructor constructor = proxyClass.getConstructor(InvocationHandler.class);
return constructor.newInstance(new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return method.invoke(target, args);
}
});
}
}
|
实际使用的是 Proxy.newProxyInstance()
1
2
3
4
5
6
7
8
9
10
11
12
13
|
private static Object getProxy2(final Object target) throws Throwable{
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return method.invoke(target,args);
}
});
}
|
动态代理逻辑图
动态代理逻辑图
五、Cglib 代理
Cglib 代理的实现
前面说的动态代理需要目标类实现接口，但是如果某个类根本不实现接口怎么办呢？这时候就需要 Cglib 代理了，也称 子类代理。
逻辑是在内存中构建一个子类对象集成目标对象，实现目标对象的功能扩展。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CglibProxy {
public static void main(String[] args) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(BlackDog.class);
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
return methodProxy.invokeSuper(o, objects);
}
});
BlackDog dog = (BlackDog)enhancer.create();
dog.canBark();
dog.canRun();
}
}
|
Cglib 代理总结
在 Spring 的 AOP 编程中: 面向切面编程
如果加入容器的目标对象有实现接口, 用 JDK 的动态代理
如果目标对象没有实现接口,用 Cglib 代理。
六、参考材料
Java 动态代理作用是什么？
Java中三种代理模式
Java中Class对象详解
