首页 > 代码库 > 动态代理与AOP
动态代理与AOP
1. 代理的分类：
静态代理：每个代理类只能为一个接口服务
动态代理：可以通过一个代理类完成全部的代理功能（由JVM生成实现一系列接口的代理类，即：生成实现接口的类的代理）
2. 动态代理：
在Java中要想实现动态代理机制，需要 java.lang.reflect.InvocationHandler 接口和 java.lang.reflect.Proxy 类的支持
java.lang.reflect.InvocationHandler 接口的定义如下：
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}
Object proxy：被代理的对象
Method method：要调用的方法
Object[] args：方法调用时传递的参数
注意：并不是对象的所有方法均通过代理来完成，对如继承自Object的方法，只将hashCode()、equals()、toString()转交给InvocationHandler来处理。
可以通过Proxy中的getProxyClass()或newProxyInstance()方法获取代理
其中newProxyInstance()方法定义如下：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
ClassLoader loader：类加载器
Class<?>[] interfaces：要实现的接口
InvocationHandler h：InvocationHandler子类的实例对象
下面来实现动态代理：
首先定义接口：
1 public interface Sourceable {
2 void function();
3 }
然后定义实现类：
1 public class Source implements Sourceable {
2
3 @Override
4 public void function() {
5 System.out.println("function");
6 }
7 }
定义工具类：
1 import java.lang.reflect.Constructor;
2 import java.lang.reflect.InvocationHandler;
3 import java.lang.reflect.Method;
4 import java.lang.reflect.Proxy;
5
6 public class SourceableProxyUtil {
7 private Sourceable source;
8
9 public SourceableProxyUtil(Sourceable source) {
10 super();
11 this.source = source;
12 }
13
14 public Sourceable getProxy() throws Exception {
15 Class<Sourceable> clazzSource = (Class<Sourceable>) Proxy
16 .getProxyClass(source.getClass().getClassLoader(), source
17 .getClass().getInterfaces());
18 Constructor<Sourceable> constructor = clazzSource
19 .getConstructor(InvocationHandler.class); // 没有无参构造函数
20
21 return constructor.newInstance(new InvocationHandler() {
22
23 @Override
24 public Object invoke(Object proxy, Method method, Object[] args)
25 throws Throwable {
26 System.out.println("before");
27 Object retVal = method.invoke(source, args);
28 System.out.println("after");
29 return retVal;
30 }
31 });
32 }
33 }
但是，使用getProxyClass()方式过于复杂，改用newProxyInstance()：
1 import java.lang.reflect.Constructor;
2 import java.lang.reflect.InvocationHandler;
3 import java.lang.reflect.Method;
4 import java.lang.reflect.Proxy;
5
6 public class SourceableProxyUtil {
7 private Sourceable source;
8
9 public SourceableProxyUtil(Sourceable source) {
10 super();
11 this.source = source;
12 }
13
14 public Sourceable getProxy() throws Exception {
15 return (Sourceable)Proxy.newProxyInstance(source.getClass().getClassLoader(),
16 source.getClass().getInterfaces(), new InvocationHandler() {
17
18 @Override
19 public Object invoke(Object proxy, Method method,
20 Object[] args) throws Throwable {
21 System.out.println("before");
22 Object retVal = method.invoke(source, args);
23 System.out.println("after");
24 return retVal;
25 }
26 });
27 }
28 }
测试代码：
1 public class Main {
2
3 public static void main(String[] args) throws Exception {
4 Sourceable source = new Source();
5 Sourceable proxy = new SourceableProxyUtil(source).getProxy();
6 proxy.function();
7 }
8 }
测试结果：
before
function
after
可以看出，代理类能够正常使用。
但是上述方式只能用于生成Sourceable接口的代理类，可以进一步将其抽象得到通用的代理类生成工具：
1 import java.lang.reflect.InvocationHandler;
2 import java.lang.reflect.Method;
3 import java.lang.reflect.Proxy;
4
5 public final class ProxyUtil {
6 public static Object getProxy(final Object target) throws Exception {
7 return Proxy.newProxyInstance(target.getClass().getClassLoader(),
8 target.getClass().getInterfaces(), new InvocationHandler() {
9
10 @Override
11 public Object invoke(Object proxy, Method method,
12 Object[] args) throws Throwable {
13 System.out.println("before");
14 Object retVal = method.invoke(target, args);
15 System.out.println("after");
16 return retVal;
17 }
18 });
19 }
20 }
这样，无论任何类型的对象都可以通过此种方法获得相应的代理对象。此时，测试代码如下：
1 public class Main {
2
3 public static void main(String[] args) throws Exception {
4 // TODO Auto-generated method stub
5 Sourceable proxy = (Sourceable)ProxyUtil.getProxy(new Source());
6 proxy.function();
7 }
8 }
3. 抽取切面：
将上述代码中的目标方法执行前后的操作进一步地抽象，将其抽取为切面。将切面代码进行封装得到通告。
定义通告接口：
1 public interface Advice {
2 void before();
3 void after();
4 }
改写工具类：
1 import java.lang.reflect.InvocationHandler;
2 import java.lang.reflect.Method;
3 import java.lang.reflect.Proxy;
4
5 public final class ProxyUtil {
6 public static Object getProxy(final Object target, final Advice advice) throws Exception {
7 return Proxy.newProxyInstance(target.getClass().getClassLoader(),
8 target.getClass().getInterfaces(), new InvocationHandler() {
9
10 @Override
11 public Object invoke(Object proxy, Method method,
12 Object[] args) throws Throwable {
13 advice.before();
14 Object retVal = method.invoke(target, args);
15 advice.after();
16 return retVal;
17 }
18 });
19 }
20 }
此时的测试代码为：
1 public class Main {
2
3 public static void main(String[] args) throws Exception {
4 Sourceable proxy = (Sourceable)ProxyUtil.getProxy(new Source(), new Advice() {
5
6 @Override
7 public void before() {
8 // TODO Auto-generated method stub
9 System.out.println("before");
10 }
11
12 @Override
13 public void after() {
14 // TODO Auto-generated method stub
15 System.out.println("after");
16 }
17 });
18 proxy.function();
19 }
20 }
此种方式更具有普遍适用性，无论对于任意类型都可以产生相对应的代理对象，同时可以自定义所要进行的操作（通过通告）。
在整个过程中需要手动写的只有通告Advice
4. AOP编程：
AOP（Aspect-Oriented Programming）可以通过代理方式完成诸如：安全控制、事务管理、性能统计、日志记录、错误处理...等功能。
在实际过程中，更多是通过getter/setter方式传递target与advice的：
1 import java.lang.reflect.InvocationHandler;
2 import java.lang.reflect.Method;
3 import java.lang.reflect.Proxy;
4
5 public class ProxyFactoryBean {
6
7 private Object target;
8 private Advice advice;
9
10
11 public Object getTarget() {
12 return target;
13 }
14
15
16 public void setTarget(Object target) {
17 this.target = target;
18 }
19
20
21 public Advice getAdvice() {
22 return advice;
23 }
24
25
26 public void setAdvice(Advice advice) {
27 this.advice = advice;
28 }
29
30
31 public Object getProxy() {
32
33 return Proxy.newProxyInstance(target.getClass().getClassLoader(),
34 target.getClass().getInterfaces(), new InvocationHandler() {
35
36 @Override
37 public Object invoke(Object proxy, Method method,
38 Object[] args) throws Throwable {
39 advice.before();
40 Object retVal = method.invoke(target, args);
41 advice.after();
42 return retVal;
43 }
44 });
45 };
46 }
通过AOP的方式可以在运行时动态地将代码切入到类的指定方法、指定位置上。
Spring框架的核心即是IoC和AOP。
动态代理与AOP
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。