1.前言
之前对动态代理的技术只是表面上理解,没有形成一个体系,这里总结一下,整个动态代理的实现以及实现原理,以表述的更清楚一些。
2.动态代理的实现应用到的技术
1、动态编译技术,可以使用Java自带的JavaCompiler类,也可以使用CGLIB、ASM等字节码增强技术,Java的动态代理包括Spring的内部实现貌似用的都是这个
2、反射,包括对于类.class和getClass()方法的理解,Method类、Constructor类的理解
3、IO流,主要就是字符输出流FileWriter
4、对于ClassLoader的理解
3.动态代理示例
接口类:
1 2 3 4 |
|
接口实现类:
1 2 3 4 5 6 7 8 9 10 |
|
代理处理类MyInvocationHandler.java
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 |
|
测试类:
1 2 3 4 5 6 7 8 9 10 11 12 |
|
输出:
1 2 3 4 5 6 |
|
用起来是很简单,其实这里基本上就是AOP的一个简单实现了,目的是在目标对象的方法执行之前和执行之后进行了增强。
Spring的AOP实现其实也是用了Proxy和InvocationHandler这两个东西的。
4.动态代理原理
下面我们从jdk实现的源代码的层面分析一下,动态代理产生的整个过程。
上面的程序的入口,便是代理处理类MyInvocationHandler中的getProxy()方法。
1 2 3 4 5 |
|
Proxy.newProxyInstance() 方法,最终将返回一个实现了指定接口的类的实例,
其三个参数分别是:ClassLoader,指定的接口及我们自己定义的InvocationHandler类。我摘几条关键的代码出来,看看这个代理类的实例对象到底是怎么生成的。
4.1 Proxy.newProxyInstance的源码(JDK1.6):
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 |
|
4.2 我们再去看getProxyClass0()方法的源码:
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
private
static
Class getProxyClass0(ClassLoader loader, Class... interfaces) {
.........省略一些代码
// 如果目标类实现的接口数大于65535个则抛出异常(我XX)
if
(interfaces.length >
65535
) {
throw
new
IllegalArgumentException(
"interface limit exceeded"
);
}
//声明代理对象的Class对象
Class proxyClass =
null
;
String[] interfaceNames =
new
String[interfaces.length];
Set interfaceSet =
new
HashSet();
// 遍历目标类所实现的接口
for
(
int
i =
0
; i < interfaces.length; i++) {
// 拿到目标类实现的接口的名称
String interfaceName = interfaces[i].getName();
Class interfaceClass =
null
;
try
{
// 加载目标类实现的接口到内存中
interfaceClass = Class.forName(interfaceName,
false
, loader);
}
catch
(ClassNotFoundException e) {
}
if
(interfaceClass != interfaces[i]) {
throw
new
IllegalArgumentException(
interfaces[i] +
" is not visible from class loader"
);
}
/*
* JDK里规定了:动态代理 只能针对接口生成代理,不能只针对某一个类生成代理
这也算是一个缺点吧,如果需要对一个类生成代理则可用第三方库
*/
if
(!interfaceClass.isInterface()) {
throw
new
IllegalArgumentException(
interfaceClass.getName() +
" is not an interface"
);
}
// 把目标类实现的接口代表的Class对象放到Set中
interfaceSet.add(interfaceClass);
interfaceNames[i] = interfaceName;
}
// 把目标类实现的接口名称作为缓存(Map)中的key
Object key = Arrays.asList(interfaceNames);
Map cache;
synchronized
(loaderToCache) {
// 从缓存中获取cache
cache = (Map) loaderToCache.get(loader);
if
(cache ==
null
) {
// 如果获取不到,则新建地个HashMap实例
cache =
new
HashMap();
loaderToCache.put(loader, cache);
}
}
synchronized
(cache) {
do
{
//根据接口的名称从缓存中获取对象
Object value = cache.get(key);
if
(value
instanceof
Reference) {
proxyClass = (Class) ((Reference) value).get();
}
if
(proxyClass !=
null
) {
// 如果代理对象的Class实例已经存在,则直接返回
return
proxyClass;
}
else
if
(value == pendingGenerationMarker) {
// proxy class being generated: wait for it
try
{
cache.wait();
}
catch
(InterruptedException e) {
}
continue
;
}
else
{
cache.put(key, pendingGenerationMarker);
break
;
}
}
while
(
true
);
}
....................省略代码
try
{
// 这里就是动态生成代理对象的最关键的地方:利用ProxyGenerator为我们生成了最终代理类的字节码文件
byte
[] proxyClassFile =ProxyGenerator.generateProxyClass(proxyName,Interfaces);
try
{
// 根据代理类的字节码生成代理类的实例
proxyClass = defineClass0(loader, proxyName,
proxyClassFile,
0
, proxyClassFile.length);
}
catch
(ClassFormatError e) {
throw
new
IllegalArgumentException(e.toString());
}
}
proxyClasses.put(proxyClass,
null
);
}
finally
{
return
proxyClass;
}
4.3 其中ProxyGenerator.generateProxyClass()的方法是最终生成代理类的字节码.
ProxyGenerator是sun.misc包中的类,它没有开源,不过我们可以根据它将生成的代理类的字节码保存在本地上,然后反编译查看生成的代理类。
具体请参照地址:http://blog.csdn.net/mhmyqn/article/details/48474815
4.4 反编译生成的$Proxy0.class代理类文件
下面从网上copy的一个代理类的反编译文件,对比可以看一下:
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
package
com.sun.proxy;
import
com.mikan.proxy.HelloWorld;
import
java.lang.reflect.InvocationHandler;
import
java.lang.reflect.Method;
import
java.lang.reflect.Proxy;
import
java.lang.reflect.UndeclaredThrowableException;
public
final
class
$Proxy0
extends
Proxy
implements
HelloWorld {
private
static
Method m1;
private
static
Method m3;
private
static
Method m0;
private
static
Method m2;
//这个就是 上面newInstance()方法中传入的代理实现类MyInvocationHandler,而这个类在代理类中的变量名为this.h
public
$Proxy0(InvocationHandler paramInvocationHandler) {
super
(paramInvocationHandler);
}
public
final
boolean
equals(Object paramObject) {
try
{
return
((Boolean)
this
.h.invoke(
this
, m1,
new
Object[] { paramObject })).booleanValue();
}
catch
(Error|RuntimeException localError) {
throw
localError;
}
catch
(Throwable localThrowable) {
throw
new
UndeclaredThrowableException(localThrowable);
}
}
//重点就是这里,代理类的
public
final
void
sayHello(String paramString) {
try
{
//见上面构造方法,this.h 就代表MyInvocationHandler类,所以执行的就是我们代理实现类中的invoke方法。
this
.h.invoke(
this
, m3,
new
Object[] { paramString });
return
;
}
catch
(Error|RuntimeException localError) {
throw
localError;
}
catch
(Throwable localThrowable) {
throw
new
UndeclaredThrowableException(localThrowable);
}
}
public
final
int
hashCode() {
try
{
return
((Integer)
this
.h.invoke(
this
, m0,
null
)).intValue();
}
catch
(Error|RuntimeException localError) {
throw
localError;
}
catch
(Throwable localThrowable) {
throw
new
UndeclaredThrowableException(localThrowable);
}
}
public
final
String toString() {
try
{
return
(String)
this
.h.invoke(
this
, m2,
null
);
}
catch
(Error|RuntimeException localError) {
throw
localError;
}
catch
(Throwable localThrowable) {
throw
new
UndeclaredThrowableException(localThrowable);
}
}
static
{
try
{
m1 = Class.forName(
"java.lang.Object"
).getMethod(
"equals"
,
new
Class[] { Class.forName(
"java.lang.Object"
) });
m3 = Class.forName(
"com.mikan.proxy.HelloWorld"
).getMethod(
"sayHello"
,
new
Class[] { Class.forName(
"java.lang.String"
) });
m0 = Class.forName(
"java.lang.Object"
).getMethod(
"hashCode"
,
new
Class[
0
]);
m2 = Class.forName(
"java.lang.Object"
).getMethod(
"toString"
,
new
Class[
0
]);
return
;
}
catch
(NoSuchMethodException localNoSuchMethodException) {
throw
new
NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch
(ClassNotFoundException localClassNotFoundException) {
throw
new
NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
}
由此总结一下动态代理实现过程。
1.通过 Proxy.newProxyInstance() 方法,返回一个继承Proxy类,并且最终实现了指定接口的代理类的实例。
在这里分为两个大的步骤:
- 通过getProxyClass0()方法生成代理类。在这个方法里面,
- ProxyGenerator.generateProxyClass()的方法是最终生成代理类的字节码.
- defineClass0()方法把相应的字节码生成代理类
2. 调用 newInstance(Constructor cons, InvocationHandler h)方法 创建一个新的代理类实例,创建对象时,传入我们定义好的代理处理类,InvocationHandle类。
2. 调用新实例的方法,即此例中的add(), update()方法,即原InvocationHandler类中的invoke()方法。
5.动态代理的优点
1、最直观的,类少了很多
2、代理内容也就是InvocationHandler接口的实现类可以复用,可以给A接口用、也可以给B接口用,A接口用了InvocationHandler接口实现类A的代理,不想用了,可以方便地换成InvocationHandler接口实现B的代理
3、最重要的,用了动态代理,就可以在不修改原来代码的基础上,就在原来代码的基础上做操作,这就是AOP即面向切面编程
6.动态代理的缺点
动态代理的缺点,就是前面我们读源代码的时候遇到的。它只能针对接口生成代理,不能只针对某一个类生成代理。
如果需要为某一个单独的类实现一个代理的话,考虑使用CGLIB等第三方字节码(一种字节码增强技术)。
参考地址:http://blog.csdn.net/zhangerqing/article/details/42504281/
http://www.cnblogs.com/xrq730/p/4907999.html
http://blog.csdn.net/mhmyqn/article/details/4847481516:23:20
转载: https://www.cnblogs.com/haitaofeiyang/p/7724263.html
你可能感兴趣的:(java技术,底层,设计模式)