概述
aop（aspect orient programming），我们一般称为面向方面（切面）编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。 spring aop采用的是动态代理，在运行期间对业务方法进行增强，所以不会生成新类，spring aop提供了对jdk动态代理的支持以及cglib的支持。本章我们不关注aop代理类的实现，我简单实现一个指定次序的链式调用。
实现链式调用的
methodinterceptor定义拦截器链,methodinvocation 递归进入下一个拦截器链中。类图如下：
methodinterceptor
|
1
2
3
4
|
public interface methodinterceptor { object invoke(methodinvocation invocation) throws throwable;} |
methodinvocation
|
1
2
3
4
|
public interface methodinvocation { object proceed() throws throwable;} |
abstractaspectjadvice
抽象类,实现methodinterceptor
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public abstract class abstractaspectjadvice implements methodinterceptor{ private method advicemethod; private object adviceobject; public abstractaspectjadvice(method advicemethod, object adviceobject) { this.advicemethod = advicemethod; this.adviceobject = adviceobject; } public method getadvicemethod() { return this.advicemethod; } public void invokeadvicemethod() throws throwable { advicemethod.invoke(adviceobject); }} |
aspectjbeforeadvice
前置通知
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class aspectjbeforeadvice extends abstractaspectjadvice { public aspectjbeforeadvice(method method, object adviceobject) { super(method, adviceobject); } @override public object invoke(methodinvocation invocation) throws throwable{ this.invokeadvicemethod(); object o = invocation.proceed(); return o; }} |
aspectjafterreturningadvice
后置通知
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class aspectjafterreturningadvice extends abstractaspectjadvice { public aspectjafterreturningadvice(method method, object adviceobject) { super(method, adviceobject); } @override public object invoke(methodinvocation invocation) throws throwable{ object o = invocation.proceed(); this.invokeadvicemethod(); return o; }} |
reflectivemethodinvocation
实现methodinvocation，proceed()方法递归实现链式调用。
|
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
|
public class reflectivemethodinvocation implements methodinvocation { private final object targetobject; private final method targetmethod; private final list<methodinterceptor> interceptorlist; private int currentinterceptorindex = -1; public reflectivemethodinvocation(object targetobject, method targetmethod, list<methodinterceptor> interceptorlist) { this.targetobject = targetobject; this.targetmethod = targetmethod; this.interceptorlist = interceptorlist; } @override public object proceed() throws throwable { if (this.currentinterceptorindex == this.interceptorlist.size() - 1) { return invokejoinpoint(); } this.currentinterceptorindex++; methodinterceptor interceptor = this.interceptorlist.get(this.currentinterceptorindex); return interceptor.invoke(this); } private object invokejoinpoint() throws throwable { return this.targetmethod.invoke(this.targetobject); }} |
niocoderservice
模拟service类
|
1
2
3
4
5
6
|
public class niocoderservice { public void testaop() { system.out.println("http://niocoder.com/"); }} |
transactionmanager
模拟通知类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class transactionmanager { public void start() { system.out.println("start tx"); } public void commit() { system.out.println("commit tx"); } public void rollback() { system.out.println("rollback tx"); }} |
reflectivemethodinvocationtest
beforeadvice->afterreturningadvice
测试类，测试通知
|
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
|
public class reflectivemethodinvocationtest { private aspectjbeforeadvice beforeadvice = null; private aspectjafterreturningadvice afterreturningadvice = null; private niocoderservice niocoderservice; private transactionmanager tx; public void setup() throws exception { niocoderservice = new niocoderservice(); tx = new transactionmanager(); beforeadvice = new aspectjbeforeadvice(transactionmanager.class.getmethod("start"), tx); afterreturningadvice = new aspectjafterreturningadvice(transactionmanager.class.getmethod("commit"), tx); } public void testmethodinvocation() throws throwable { method method = niocoderservice.class.getmethod("testaop"); list<methodinterceptor> interceptorlist = new arraylist<>(); interceptorlist.add(beforeadvice); interceptorlist.add(afterreturningadvice); reflectivemethodinvocation mi = new reflectivemethodinvocation(niocoderservice, method, interceptorlist); mi.proceed(); } public static void main(string[] args) throws throwable { reflectivemethodinvocationtest reflectivemethodinvocationtest = new reflectivemethodinvocationtest(); reflectivemethodinvocationtest.setup(); reflectivemethodinvocationtest.testmethodinvocation(); }} |
输出:
start tx
http://niocoder.com/
commit tx
时序图 beforeadvice->afterreturningadvice
afterreturningadvice->beforeadvice
修改interceptorlist的顺序
|
1
2
3
4
5
6
7
8
9
10
|
public void testmethodinvocation() throws throwable { method method = niocoderservice.class.getmethod("testaop"); list<methodinterceptor> interceptorlist = new arraylist<>(); interceptorlist.add(afterreturningadvice); interceptorlist.add(beforeadvice); reflectivemethodinvocation mi = new reflectivemethodinvocation(niocoderservice, method, interceptorlist); mi.proceed(); } |
输出:
start tx
http://niocoder.com/
commit tx
时序图 afterreturningadvice->beforeadvice
代码下载
github:https://github.com/longfeizheng/data-structure-java/blob/master/src/main/java/cn/merryyou/aop
代码下载
github:https://github.com/longfeizheng/data-structure-java
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：https://segmentfault.com/a/1190000018206756
