代理模式是常用的java设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
JAVA各种动态代理实现的比较
接口
|
1
2
3
4
5
6
7
|
interface AddInterface{ int add(int a, int b);}interface SubInterface{ int sub(int a, int b);} |
实现类
|
1
2
3
4
5
6
7
8
9
10
11
|
class Arithmetic implements AddInterface, SubInterface{ @Override public int sub(int a, int b) { return a-b; } @Override public int add(int a, int b) { return a+b; }} |
方式1: JDK自带的动态代理
1、实现方式
Java在JDK1.3后引入的动态代理机制，使我们可以在运行期动态的创建代理类。使用动态代理实现AOP需要有四个角色：被代理的类，被代理类的接口，织入器，和InvocationHandler，而织入器使用接口反射机制生成一个代理类，然后在这个代理类中织入代码。被代理的类是AOP里所说的目标，InvocationHandler是切面，它包含了Advice和Pointcut。
2、vInvocationHandler接口的实现
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class JdkDPQueryHandler implements InvocationHandler{ private Arithmetic real; public JdkDPQueryHandler(Arithmetic real){ this.real = real; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String methodName = method.getName(); System.out.println(method); System.out.println("the method: " + methodName + "开始, 参数: "+Arrays.asList(args)); Object result = method.invoke(real, args); System.out.println("the method: "+methodName+"结束, 结果: " + result); return result; }} |
3、创建代理类并且调用代理类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public class Main{ private static int a = 4, b = 2; public static Object createJDKProxy(Arithmetic real){ Object proxyArithmetic = Proxy.newProxyInstance(real.getClass().getClassLoader(), real.getClass().getInterfaces(), new JdkDPQueryHandler(real)); return proxyArithmetic; } public static void main(String[] args){ Arithmetic real = new Arithmetic(); Object proxyArithmetic = createJDKProxy(real); ((AddInterface)proxyArithmetic).add(a, b); ((SubInterface)proxyArithmetic).sub(a, b); }} |
方式2：动态字节码生成（cglib）
1、实现方式
Enhancer和MethodInterceptor。Enhancer可以用来动态的生成一个类，这个类可以继承指定的一个类，实现指定的一些接口。同时,Enhancer在生成一个类之前需要指定一个Callback，当类方法调用时，方法的执行被分配给这个Callback，MethodInterceptor是一个使用比较多的继承自Callback的接口，它只有一个方法声明。
2、接口InvocationHandler（jdk中）和接口MethodInterceptor（cglib中）对比
|
1
2
3
4
5
6
|
public interface MethodInterceptor extends Callback { public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,MethodProxy proxy) throws Throwable; } public interface InvocationHandler { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable; } |
从参数构成上，methodInterceptor的输入参数比Invocationhandler多1个，其实前3个参数对象的含义与Invocationhandler的含义是相同的。
第一个参数表示调用方法来自哪个对象；
第二个参数表示调用方法的Method对象；
第三个参数表示此次调用的输入参数列表；
多出来的参数是MethodProxy 类型的，它应该是cglib生成用来代替Method对象的一个对象，使用MethodProxy比调用JDK自身的Method直接执行方法效率会有提升。
3、实现1
MethodInterceptor接口的实现
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class CglibDPQueryInterceptor implements MethodInterceptor{ private Arithmetic real; public CglibDPQueryInterceptor(Arithmetic real){ this.real = real; } @Override public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable { String methodName = method.getName(); System.out.println(method); System.out.println("the method: " + methodName + "开始, 参数: "+Arrays.asList(args)); //Object result = method.invoke(real, args);//两种方式都是可以得 Object result = proxy.invoke(real, args); System.out.println("the method: "+methodName+"结束, 结果: " + result); return result; }} |
创建代理类并调用代理类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public class Main{ private static int a = 4, b = 2; public static Object createCglibProxy(Arithmetic real){ Enhancer enhancer = new Enhancer(); enhancer.setCallback(new CglibDPQueryInterceptor(real)); enhancer.setInterfaces(real.getClass().getInterfaces()); return enhancer.create(); } public static void main(String[] args){ Arithmetic real = new Arithmetic(); Object proxyArithmetic = createCglibProxy(real); ((AddInterface)proxyArithmetic).add(a, b); ((SubInterface)proxyArithmetic).sub(a, b); }} |
注意了，MethodProxy在对执行函数的时候，提供了2个方法
|
1
2
|
public Object invoke (Object obj, Object[] args) throws Throwable public Object invokeSuper(Object obj, Object[] args) throws Throwable |
其中，javadoc上说这个invoke()方法可以用于相同类中的其他对象的方法执行，也就是说这个方法中的obj需要传入相同一个类的另一个对象（上述方法中就是传入了Arithmetic类的不同对象），否则会进入无限递归循环（测试之后还真是出现了StackOverflowError）。仔细的想一想就会发现，public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy)中的target是实现的代理类对象，通过target调用add()方法时会触发intercept()方法被调用，如果在intercept()方法中再调用method.invoke(target， args)，就相当于add()方法中又调用add()方法，导致无限的递归循环。但是如果执行method.invoke(real， args)则不会，因为real和target是同一个类不同对象，real是真实逻辑主题，target是真实主题real的代理。
下面一个例子来模拟一下：
|
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
|
interface SolveInterface{ void solve();}class Real implements SolveInterface{ public void solve(){ System.out.println("Real Solve!"); }}class Target extends Real{ private Object obj; public void setObject(Object obj){ this.obj = obj; } private void invoke(){ try { Method method = SolveInterface.class.getMethod("solve", new Class[]{}); method.invoke(obj, new Class[]{}); } catch (Exception e) { e.printStackTrace(); } } public void solve(){ System.out.println("Target Solve!"); invoke(); }} |
|
1
2
3
4
5
6
7
|
public class Main{public static void main(String[] args) throws Exception{ Target target = new Target(); target.setObject(new Real());//正确 //target.setObject(target);//发生循环调用 target.solve(); }} |
其实Method的invoke()方法会根据obj的类型去调用对应的solve()方法，也就是多态性。
4、实现2
MethodInterceptor接口的实现
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class CglibDPQueryInterceptor implements MethodInterceptor{ @Override public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable { String methodName = method.getName(); System.out.println(method); System.out.println("the method: " + methodName + "开始, 参数: "+Arrays.asList(args)); // 打印类信息 ：target.getClass()；省略 Object result = proxy.invokeSuper(target, args); System.out.println("the method: "+methodName+"结束, 结果: " + result); return result; }} |
创建代理类并调用代理类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public class Main{ private static int a = 4, b = 2;public static Object createCglibProxy(){ Enhancer enhancer = new Enhancer(); enhancer.setCallback(new CglibDPQueryInterceptor()); enhancer.setSuperclass(Arithmetic.class); return enhancer.create(); } public static void main(String[] args){ Arithmetic real = new Arithmetic(); Object proxyArithmetic = createCglibProxy(); ((AddInterface)proxyArithmetic).add(a, b); ((SubInterface)proxyArithmetic).sub(a, b); }} |
注意了，实现2中Enhancer 没有设置接口，因为设置了Superclass了（也就是代理类的父类是Arithmetic），我们的代理类会继承它，而Arithmetic已经实现了我们的接口。为了证明这一点，可以在MethodInterceptor的 intercept方法中打印 target.getClass()的类信息，你会发现cglib的两种方式代理类的父类是不同的。如下：
实现1：
|
1
|
public class com.test.Arithmetic$$EnhancerByCGLIB$$4fa786eb extends java.lang.Object |
实现2：
|
1
|
public class com.test.Arithmetic$$EnhancerByCGLIB$$4fa786eb extends com.test.Arithmetic |
方式3：javassist生成动态代理（代理工厂创建 或者 动态代码创建）
Javassist是一个编辑字节码的框架，可以让你很简单地操作字节码。它可以在运行期定义或修改Class。使用Javassist实现AOP的原理是在字节码加载前直接修改需要切入的方法。这比使用Cglib实现AOP更加高效，并且没太多限制，实现原理如下图：
实现1：
接口的实现
|
1
2
3
4
5
6
7
8
9
10
11
12
|
class JavassistDPQueryHandler implements MethodHandler{ @Override public Object invoke(Object target, Method method, Method proxy, Object[] args) throws Throwable { String methodName = method.getName(); System.out.println(method); System.out.println("the method: " + methodName + "开始, 参数: "+Arrays.asList(args)); Object result = proxy.invoke(target, args); System.out.println("the method: "+methodName+"结束, 结果: " + result); return result; }} |
创建代理类并调用代理类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public class Main{ private static int a = 4, b = 2;public static Object createJavassistProxy() throws Exception{ ProxyFactory factory = new ProxyFactory(); factory.setSuperclass(Arithmetic.class); factory.setHandler(new JavassistDPQueryHandler()); return factory.createClass().newInstance(); } public static void main(String[] args) throws Exception{ Arithmetic real = new Arithmetic(); Object proxyArithmetic = createJavassistProxy(); ((AddInterface)proxyArithmetic).add(a, b); ((SubInterface)proxyArithmetic).sub(a, b); }} |
注意：MethodHandler接口中invoke方法的定义，如下：
|
1
|
public Object invoke(Object target, Method method, Method proxy, Object[] args) |
method代表调用方法的Method对象，proxy是代理类产生并代替method的对象，否则用method.invoke(target, args)会产生无限循环调用。
实现2：
javassist使用动态java代码常见代理过程和前文的方法略有不同。javassist内部可以通过动态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
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
//自定义拦截器接口interface InterceptorHandler { /** * 调用动态代理对象的方法将反射本方法，可在本方法实现中添加类似AOP的事前事后操作，只有在本方法体中加入如下代码 * 被代理的方法才会被执行，返回值将返回给代理最后返回给程序 * @param obj Object 被代理的对象 * @param method Method 被代理对象的方法 * @param args Object[] 被代理对象的方法的参数 * @return Object 被代理对象的方法执行后的返回值 * @throws Throwable */ public Object invoke(Object obj, Method method, Object[] args) throws Throwable; } //拦截器的实现class InterceptorHandlerImpl implements InterceptorHandler{ @Override public Object invoke(Object obj, Method method, Object[] args) throws Throwable { String methodName = method.getName(); System.out.println(method); System.out.println("the method: " + methodName + "开始, 参数: "+Arrays.asList(args)); Object result = method.invoke(obj, args); System.out.println("the method: "+methodName+"结束, 结果: " + result); return result; }}class MyProxyImpl { /** 动态代理类的类名后缀 */ private final static String PROXY_CLASS_NAME_SUFFIX = "$MyProxy_"; /** 拦截器接口 */ private final static String INTERCEPTOR_HANDLER_INTERFACE = "com.test.InterceptorHandler"; /** 动态代理类的类名索引，防止类名重复 */ private static int proxyClassIndex = 1; /** * 暴露给用户的动态代理接口，返回某个接口的动态代理对象，注意本代理实现需和com.cuishen.myAop.InterceptorHandler拦截器配合 * 使用，即用户要使用本动态代理，需先实现com.cuishen.myAop.InterceptorHandler拦截器接口 * @param interfaceClassName String 要动态代理的接口类名, e.g test.StudentInfoService * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl * @param interceptorHandlerImplClassName String 用户提供的拦截器接口的实现类的类名 * @return Object 返回某个接口的动态代理对象 * @throws InstantiationException * @throws IllegalAccessException * @throws NotFoundException * @throws CannotCompileException * @throws ClassNotFoundException * @see com.cuishen.myAop.InterceptorHandler */ public static Object newProxyInstance(String interfaceClassName, String classToProxy, String interceptorHandlerImplClassName) throws InstantiationException, IllegalAccessException, NotFoundException, CannotCompileException, ClassNotFoundException { Class interfaceClass = Class.forName(interfaceClassName); Class interceptorHandlerImplClass = Class.forName(interceptorHandlerImplClassName); return dynamicImplementsInterface(classToProxy, interfaceClass, interceptorHandlerImplClass); } /** * 动态实现要代理的接口 * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl * @param interfaceClass Class 要动态代理的接口类, e.g test.StudentInfoService * @param interceptorHandlerImplClass Class 用户提供的拦截器接口的实现类 * @return Object 返回某个接口的动态代理对象 * @throws NotFoundException * @throws CannotCompileException * @throws InstantiationException * @throws IllegalAccessException */ private static Object dynamicImplementsInterface(String classToProxy, Class interfaceClass, Class interceptorHandlerImplClass) throws NotFoundException, CannotCompileException, InstantiationException, IllegalAccessException { ClassPool cp = ClassPool.getDefault(); String interfaceName = interfaceClass.getName(); //动态指定代理类的类名 String proxyClassName = interfaceName + PROXY_CLASS_NAME_SUFFIX + proxyClassIndex++; //要实现的接口的包名+接口名 String interfaceNamePath = interfaceName; CtClass ctInterface = cp.getCtClass(interfaceNamePath); CtClass cc = cp.makeClass(proxyClassName); cc.addInterface(ctInterface); Method [] methods = interfaceClass.getMethods(); for(int i = 0; i < methods.length; i++) { Method method = methods[i]; dynamicImplementsMethodsFromInterface(classToProxy, cc, method, interceptorHandlerImplClass, i); } return (Object)cc.toClass().newInstance(); } /** * 动态实现接口里的方法 * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl * @param implementer CtClass 动态代理类的包装 * @param methodToImpl Method 动态代理类里面要实现的接口方法的包装 * @param interceptorClass Class 用户提供的拦截器实现类 * @param methodIndex int 要实现的方法的索引 * @throws CannotCompileException */ private static void dynamicImplementsMethodsFromInterface(String classToProxy, CtClass implementer, Method methodToImpl, Class interceptorClass, int methodIndex) throws CannotCompileException { String methodCode = generateMethodCode(classToProxy, methodToImpl, interceptorClass, methodIndex); CtMethod cm = CtNewMethod.make(methodCode, implementer); implementer.addMethod(cm); } /** * 动态组装方法体，当然代理里面的方法实现并不是简单的方法拷贝，而是反射调用了拦截器里的invoke方法，并将接收到的参数进行传递 * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl * @param methodToImpl Method 动态代理类里面要实现的接口方法的包装 * @param interceptorClass Class 用户提供的拦截器实现类 * @param methodIndex int 要实现的方法的索引 * @return String 动态组装的方法的字符串 */ private static String generateMethodCode(String classToProxy, Method methodToImpl, Class interceptorClass, int methodIndex) { String methodName = methodToImpl.getName(); String methodReturnType = methodToImpl.getReturnType().getName(); Class[] parameters = methodToImpl.getParameterTypes(); Class[] exceptionTypes = methodToImpl.getExceptionTypes(); StringBuffer exceptionBuffer = new StringBuffer(); //组装方法的Exception声明 if(exceptionTypes.length > 0) exceptionBuffer.append(" throws "); for(int i = 0; i < exceptionTypes.length; i++) { if(i != exceptionTypes.length - 1) exceptionBuffer.append(exceptionTypes[i].getName()).append(","); else exceptionBuffer.append(exceptionTypes[i].getName()); } StringBuffer parameterBuffer = new StringBuffer(); //组装方法的参数列表 for(int i = 0; i < parameters.length; i++) { Class parameter = parameters[i]; String parameterType = parameter.getName(); //动态指定方法参数的变量名 String refName = "a" + i; if(i != parameters.length - 1) parameterBuffer.append(parameterType).append(" " + refName).append(","); else parameterBuffer.append(parameterType).append(" " + refName); } StringBuffer methodDeclare = new StringBuffer(); //方法声明，由于是实现接口的方法，所以是public methodDeclare.append("public ").append(methodReturnType).append(" ").append(methodName).append("(").append(parameterBuffer).append(")").append(exceptionBuffer).append(" {\n"); String interceptorImplName = interceptorClass.getName(); //方法体 methodDeclare.append(INTERCEPTOR_HANDLER_INTERFACE).append(" interceptor = new ").append(interceptorImplName).append("();\n"); //反射调用用户的拦截器接口 methodDeclare.append("Object returnObj = interceptor.invoke(Class.forName(\"" + classToProxy + "\").newInstance(), Class.forName(\"" + classToProxy + "\").getMethods()[" + methodIndex + "], "); //传递方法里的参数 if(parameters.length > 0) methodDeclare.append("new Object[]{"); for(int i = 0; i < parameters.length; i++) { //($w) converts from a primitive type to the corresponding wrapper type: e.g. //Integer i = ($w)5; if(i != parameters.length - 1) methodDeclare.append("($w)a" + i + ","); else methodDeclare.append("($w)a" + i); } if(parameters.length > 0) methodDeclare.append("});\n"); else methodDeclare.append("null);\n"); //对调用拦截器的返回值进行包装 if(methodToImpl.getReturnType().isPrimitive()) { if(methodToImpl.getReturnType().equals(Boolean.TYPE)) methodDeclare.append("return ((Boolean)returnObj).booleanValue();\n"); else if(methodToImpl.getReturnType().equals(Integer.TYPE)) methodDeclare.append("return ((Integer)returnObj).intValue();\n"); else if(methodToImpl.getReturnType().equals(Long.TYPE)) methodDeclare.append("return ((Long)returnObj).longValue();\n"); else if(methodToImpl.getReturnType().equals(Float.TYPE)) methodDeclare.append("return ((Float)returnObj).floatValue();\n"); else if(methodToImpl.getReturnType().equals(Double.TYPE)) methodDeclare.append("return ((Double)returnObj).doubleValue();\n"); else if(methodToImpl.getReturnType().equals(Character.TYPE)) methodDeclare.append("return ((Character)returnObj).charValue();\n"); else if(methodToImpl.getReturnType().equals(Byte.TYPE)) methodDeclare.append("return ((Byte)returnObj).byteValue();\n"); else if(methodToImpl.getReturnType().equals(Short.TYPE)) methodDeclare.append("return ((Short)returnObj).shortValue();\n"); } else { methodDeclare.append("return (" + methodReturnType + ")returnObj;\n"); } methodDeclare.append("}"); System.out.println(methodDeclare.toString()); return methodDeclare.toString(); } } public class Main{ public static void main(String[] args) throws Exception{ //分别对应 代理类要实现的接口类名， 需要代理类的类名， 用户自定义拦截器实现类的类名 Object proxyArithmetic = MyProxyImpl.newProxyInstance("com.test.ArithmeticInterface", "com.test.Arithmetic", "com.test.InterceptorHandlerImpl"); ((ArithmeticInterface)proxyArithmetic).add(a, b); ((ArithmeticInterface)proxyArithmetic).sub(a, b); }} |
打印一下动态实现接口的代码如下：
|
1
2
3
4
5
6
7
8
9
10
|
public int add(int a0,int a1) {com.test.InterceptorHandler interceptor = new com.test.InterceptorHandlerImpl();Object returnObj = interceptor.invoke(Class.forName("com.test.Arithmetic").newInstance(), Class.forName("com.test.Arithmetic").getMethods()[0], new Object[]{($w)a0,($w)a1});return ((Integer)returnObj).intValue();}public int sub(int a0,int a1) {com.test.InterceptorHandler interceptor = new com.test.InterceptorHandlerImpl();Object returnObj = interceptor.invoke(Class.forName("com.test.Arithmetic").newInstance(), Class.forName("com.test.Arithmetic").getMethods()[1], new Object[]{($w)a0,($w)a1});return ((Integer)returnObj).intValue();} |
以上就是关于java中动态代理实现机制的详细介绍，希望对大家的学习有所帮助。
