一、什么是 AOP
AOP（Aspect-OrientedProgramming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为（日志、安全、事务）的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，模块间的藕合度高，而不利于各个模块的重用。
而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即切面。所谓“切面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。
使用“横切”技术，AOP把软件系统分为两个部分：核心业务逻辑组件和横切关注点。横切关注点模块化为特殊的类，这些类被称为“切面”，好处：1.横切关注点都集中于一块，不会出现大量重复代码；2.核心模块只关注核心功能的代码，模块间藕合度降低。
二、AOP 的实现原理
如图：AOP 实际上是由目标类的代理类实现的。AOP 代理其实是由 AOP 框架动态生成的一个对象，该对象可作为目标对象使用。AOP 代理包含了目标对象的全部方法，但 AOP 代理中的方法与目标对象的方法存在差异，AOP 方法在特定切入点添加了增强处理，并回调了目标对象的方法。
三、AOP相关概念
连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是表示一个方法的执行。通俗的说就是加入切点的那个点
通知（Advice）：在切面的某个特定的连接点上执行的动作。其中包括了“around”、“before”和“after”等不同类型的通知（通知的类型将在后面部分进行讨论）。许多AOP框架（包括Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。
切入点（Pointcut）：匹配连接点的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。
引入（Introduction）：用来给一个类型声明额外的方法或属性（也被称为连接类型声明（inter-type declaration））。Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用引入来使一个bean实现IsModified接口，以便简化缓存机制。
织入（Weaving）：将切面应用到目标对象来创建新的代理对象的过程。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。
增强（Advice）：是织入到目标类连接点上的一段程序代码。Spring使用增强类定义横切逻辑，同时由于Spring只支持方法连接点，增强还包括了在方法上的哪一点加入横切代码的方位信息，所以增强既包括横切逻辑、还包含部分连接点的信息。
引介（Introduction）：是一种特殊的增强，为类添加一些属性和方法。
切面（Advisor）：代表一般切面，包含了横切代码和连接点信息，本身是一个简单的切面，横切的连接点是目标类的所有方法。3种类型：一般切面（advisor）、切点切面（PointcutAdvisor）、引介切面（IntroductionAdvisor）。
四、Spring中AOP的实现
第一种是基于xml配置文件方式的实现，
第二种是基于注解方式的实现。
首先我们来看一下业务逻辑service层：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/**
* RegisterService的实现类
* @author 曹胜欢 */
public
class
RegisterServiceImpl
implements
RegisterService {
private
RegisterDao registerDao;
public
RegisterServiceImpl() {}
/** 带参数的构造方法 */
public
RegisterServiceImpl(RegisterDao registerDao){
this
.registerDao =registerDao;
}
public
void
save(String loginname, String password) {
registerDao.save(loginname, password);
throw
new
RuntimeException(
"故意抛出一个异常。。。。"
);
}
/** set方法 */
public
void
setRegisterDao(RegisterDao registerDao) {
this
.registerDao = registerDao;
}}
|
对于业务系统来说，RegisterServiceImpl类就是目标实现类，它的业务方法，如save()方法的前后或代码会出现异常的地方都是AOP的连接点。
下面是日志服务类的代码：
|
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
|
/**
* 日志切面类
* @author 曹胜欢
*/
public
class
LogAspect {
//任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型
public
void
before(JoinPoint call) {
//获取目标对象对应的类名
String className = call.getTarget().getClass().getName();
//获取目标对象上正在执行的方法名
String methodName = call.getSignature().getName();
System.out.println(
"前置通知:"
+ className +
"类的"
+ methodName +
"方法开始了"
);
}
public
void
afterReturn() {
System.out.println(
"后置通知:方法正常结束了"
);
}
public
void
after(){
System.out.println(
"最终通知:不管方法有没有正常执行完成，一定会返回的"
);
}
public
void
afterThrowing() {
System.out.println(
"异常抛出后通知:方法执行时出异常了"
);
}
//用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型
public
Object doAround(ProceedingJoinPoint call)
throws
Throwable {
Object result =
null
;
this
.before(call);
//相当于前置通知
try
{
result = call.proceed();
this
.afterReturn();
//相当于后置通知
}
catch
(Throwable e) {
this
.afterThrowing();
//相当于异常抛出后通知
throw
e;
}
finally
{
this
.after();
//相当于最终通知
}
return
result;
}
}
|
这个类属于业务服务类，如果用AOP的术语来说，它就是一个切面类，它定义了许多通知。Before()、afterReturn()、after()和afterThrowing()这些方法都是通知。
下面我们就来看具体配置，首先来看一下：
<1>.基于xml配置文件的AOP实现：这种方式在实现AOP时，有4个步骤。
|
1
|
<
br
>
|
|
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
|
<?
xml
version
=
"1.0"
encoding
=
"UTF-8"
?>
<
beans
xmlns
=
"http://www.springframework.org/schema/beans"
xmlns:xsi
=
"http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop
=
"http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>
<
bean
id
=
"registerDaoImpl"
class
=
"com.zxf.dao.RegisterDaoImpl"
/>
<
bean
id
=
"registerService"
class
=
"com.zxf.service.RegisterServiceImpl"
>
<
property
name
=
" registerDaoImpl "
ref
=
" RegisterDaoImpl "
/>
</
bean
>
<!-- 日志切面类 -->
<
bean
id
=
"logAspectBean"
class
=
"com.zxf.aspect.LogAspect"
/>
<!-- 第1步： AOP的配置 -->
<
aop:config
>
<!-- 第2步：配置一个切面 -->
<
aop:aspect
id
=
"logAspect"
ref
=
"logAspectBean"
>
<!-- 第3步：定义切入点,指定切入点表达式 -->
<
aop:pointcut
id
=
"allMethod"
expression
=
"execution(* com.zxf.service.*.*(..))"
/>
<!-- 第4步：应用前置通知 -->
<
aop:before
method
=
"before"
pointcut-ref
=
"allMethod"
/>
<!-- 第4步：应用后置通知 -->
<
aop:after-returning
method
=
"afterReturn"
pointcut-ref
=
"allMethod"
/>
<!-- 第4步：应用最终通知 -->
<
aop:after
method
=
"after"
pointcut-ref
=
"allMethod"
/>
<!-- 第4步：应用抛出异常后通知 -->
<
aop:after-throwing
method
=
"afterThrowing"
pointcut-ref
=
"allMethod"
/>
<!-- 第4步：应用环绕通知 -->
<!--
<aop:around method="doAround" pointcut-ref="allMethod" />
-->
</
aop:aspect
>
</
aop:config
>
</
beans
>
|
上述配置针对切入点应用了前置、后置、最终，以及抛出异常后通知。这样在测试执行RegisterServiceImpl类的save()方法时，控制台会有如下结果输出：
前置通知：com.zxf.service.RegisterServiceImpl类的save方法开始了。
针对MySQL的RegisterDao实现中的save()方法。
后置通知:方法正常结束了。
最终通知:不管方法有没有正常执行完成，一定会返回的。
下面我们在来看一下第二种配置方式：
<2>基于注解的AOP的实现
首先创建一个用来作为切面的类LogAnnotationAspect，同时把这个类配置在spring的配置文件中。
在spring2.0以后引入了JDK5.0的注解Annotation的支持，提供了对AspectJ基于注解的切面的支持，从而 更进一步地简化AOP的配置。具体的步骤有两步。
Spring的配置文件是如下的配置：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
<?
xml
version
=
"1.0"
encoding
=
"UTF-8"
?>
<
beans
xmlns
=
"http://www.springframework.org/schema/beans"
xmlns:xsi
=
"http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop
=
"http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>
<
bean
id
=
"registerDao"
class
=
"com.zxf.dao.RegisterDaoImpl"
/>
<
bean
id
=
"registerService"
class
=
"com.zxf.service.RegisterServiceImpl"
>
<
property
name
=
"registerDao"
ref
=
"registerDao"
/>
</
bean
>
<!-- 把切面类交由Spring容器来管理 -->
<
bean
id
=
"logAspectBean"
class
=
"com.zxf.aspect.LogAnnotationAspect"
/>
<!-- 启用spring对AspectJ注解的支持 -->
<
aop:aspectj-autoproxy
/>
</
beans
>
|
这是那个切面的类LogAnnotationAspect
|
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
|
/**
* 日志切面类
*/
@Aspect
//定义切面类
public
class
LogAnnotationAspect {
@SuppressWarnings
(
"unused"
)
//定义切入点，提供一个方法，这个方法的名字就是改切入点的id
@Pointcut
(
"execution(* com.zxf.service.*.*(..))"
)
private
void
allMethod(){}
//针对指定的切入点表达式选择的切入点应用前置通知
@Before
(
"execution(* com. zxf.service.*.*(..))"
)
public
void
before(JoinPoint call) {
String className = call.getTarget().getClass().getName();
String methodName = call.getSignature().getName();
System.out.println(
"【注解-前置通知】:"
+ className +
"类的"
+ methodName +
"方法开始了"
);
}
//访问命名切入点来应用后置通知
@AfterReturning
(
"allMethod()"
)
public
void
afterReturn() {
System.out.println(
"【注解-后置通知】:方法正常结束了"
);
}
//应用最终通知
@After
(
"allMethod()"
)
public
void
after(){
System.out.println(
"【注解-最终通知】:不管方法有没有正常执行完成,"
+
"一定会返回的"
);
}
//应用异常抛出后通知
@AfterThrowing
(
"allMethod()"
)
public
void
afterThrowing() {
System.out.println(
"【注解-异常抛出后通知】:方法执行时出异常了"
);
}
//应用周围通知
//@Around("allMethod()")
public
Object doAround(ProceedingJoinPoint call)
throws
Throwable{
Object result =
null
;
this
.before(call);
//相当于前置通知
try
{
result = call.proceed();
this
.afterReturn();
//相当于后置通知
}
catch
(Throwable e) {
this
.afterThrowing();
//相当于异常抛出后通知
throw
e;
}
finally
{
this
.after();
//相当于最终通知
}
return
result;
}
}
|
五：Spring中AOP的两种代理方式（Java动态代理和CGLIB代理）
Spring AOP使用动态代理技术在运行期织入增强代码。使用两种代理机制：基于JDK的动态代理（JDK本身只提供接口的代理）；基于CGlib的动态代理。
1. JDK的动态代理主要涉及java.lang.reflect包中的两个类：Proxy和InvocationHandler。其中InvocationHandler只是一个接口，可以通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态的将横切逻辑与业务逻辑织在一起。而Proxy利用InvocationHandler动态创建一个符合某一接口的实例，生成目标类的代理对象。（只能为接口创建代理实例）
|
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
|
//需要被代理的接口
public
interface
ForumService {
public
void
removeTopic(
int
topicId);
public
void
removeForum(
int
forumId);
}
//被代理接口的实现类，包含核心的业务逻辑
public
class
ForumServiceImpl
implements
ForumService{
@Override
public
void
removeTopic(
int
topicId) {
System.out.println(
"模拟删除Topic记录："
+ topicId);
try
{
Thread.currentThread().sleep(
20
);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
@Override
public
void
removeForum(
int
forumId) {
System.out.println(
"模拟删除Forum记录："
+ forumId);
try
{
Thread.currentThread().sleep(
40
);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
}
|
|
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
|
//性能监控核心代码生成
public
class
MethodPerformance {
private
long
begin;
private
long
end;
private
String serviceMethod;
public
MethodPerformance(String serviceMethod) {
this
.serviceMethod = serviceMethod;
this
.begin = System.currentTimeMillis();
};
public
void
printPerformance(){
this
.end = System.currentTimeMillis();
long
elapse =
this
.end -
this
.begin;
System.out.println(serviceMethod +
" cost "
+ elapse +
"ms"
);
}
}
//线程安全的横切逻辑
public
class
PerformanceMonitor {
private
static
ThreadLocal<MethodPerformance> tl=
new
ThreadLocal<MethodPerformance>();
public
static
void
begin(String method){
System.out.println(
"begin monitor"
);
MethodPerformance mp =
new
MethodPerformance(method);
tl.set(mp);
}
public
static
void
end(){
System.out.println(
"end monitor"
);
MethodPerformance mp = tl.get();
mp.printPerformance();
}
}
//AOP横切模块
public
class
PerfermanceHandler
implements
InvocationHandler{
private
Object target;
public
PerfermanceHandler(Object target) {
this
.target = target;
}
@Override
public
Object invoke(Object proxy, Method method, Object[] args)
throws
Throwable {
PerformanceMonitor.begin(target.getClass().getName()+
"."
+method.getName());
Object object = method.invoke(target, args);
PerformanceMonitor.end();
return
object;
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
//测试
public
class
TestForumService {
public
static
void
main(String[] args) {
ForumService target =
new
ForumServiceImpl();
//将目标业务类与横切代码编织到一起
PerfermanceHandler handler =
new
PerfermanceHandler(target);
//创建代理实例
ForumService proxy = (ForumService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), handler);
proxy.removeForum(
10
);
proxy.removeTopic(
1012
);
}
}
|
begin monitor
模拟删除Forum记录：10
end monitor
com.baobaotao.proxy.ForumServiceImpl.removeForum cost 42ms
begin monitor
模拟删除Topic记录：1012
end monitor
com.baobaotao.proxy.ForumServiceImpl.removeTopic cost 21ms
2.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
|
package
com.baobaotao.proxy;
import
java.lang.reflect.Method;
import
org.springframework.cglib.proxy.Enhancer;
import
org.springframework.cglib.proxy.MethodInterceptor;
import
org.springframework.cglib.proxy.MethodProxy;
public
class
CglibProxy
implements
MethodInterceptor{
private
Enhancer enhancer =
new
Enhancer();
public
Object getProxy(Class clazz){
enhancer.setSuperclass(clazz);
//设置创建子类的类
enhancer.setCallback(
this
);
return
enhancer.create();
//通过字节码技术动态创建子类实例
}
@Override
public
Object intercept(Object target, Method method, Object[] args,
MethodProxy proxy)
throws
Throwable {
PerformanceMonitor.begin(target.getClass().getName()+
"."
+method.getName());
Object object = proxy.invokeSuper(target, args);
PerformanceMonitor.end();
return
object;
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
|
package
com.baobaotao.proxy;
import
java.lang.reflect.Proxy;
//测试
public
class
TestForumService {
public
static
void
main(String[] args) {
CglibProxy cglibProxy =
new
CglibProxy();
ForumServiceImpl service = (ForumServiceImpl) cglibProxy.getProxy(ForumServiceImpl.
class
);
service.removeForum(
10
);
service.removeTopic(
1012
);
}
}
|
begin monitor
模拟删除Forum记录：10
end monitor
com.baobaotao.proxy.ForumServiceImpl$$EnhancerByCGLIB$$626e31f5（子类）.removeForum cost 67ms
begin monitor
模拟删除Topic记录：1012
end monitor
com.baobaotao.proxy.ForumServiceImpl$$EnhancerByCGLIB$$626e31f5.removeTopic cost 20ms
Spring增强类
Spring支持5种增强类型：
1）前置增强：org.springframework.aop.BeforeAdvice代表前置增强，spring只支持方法级的增强，目前可用MethodBeforeAdvice。
|
1
2
3
4
|
public
interface
Waiter {
public
void
greetTo(String name);
public
void
serveTo(String name);
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public
class
NaiveWaiter
implements
Waiter {
@Override
public
void
greetTo(String name) {
System.out.println(
"greetTo "
+ name +
"..."
);
}
@Override
public
void
serveTo(String name) {
System.out.println(
"serveTo "
+ name +
"..."
);
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
|
import
java.lang.reflect.Method;
import
org.springframework.aop.MethodBeforeAdvice;
public
class
GreeteBeforeAdvice
implements
MethodBeforeAdvice{
@Override
public
void
before(Method arg0, Object[] arg1, Object arg2)
throws
Throwable {
String client = (String) arg1[
0
];
System.out.println(
"How are you!"
+client+
"."
);
}
}
|
|
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
|
import
org.springframework.aop.BeforeAdvice;
import
org.springframework.aop.framework.ProxyFactory;
public
class
TestBeforeAdvice {
public
static
void
main(String[] args) {
Waiter target =
new
NaiveWaiter();
BeforeAdvice advice =
new
GreeteBeforeAdvice();
//Spring提供的代理工厂
ProxyFactory pf =
new
ProxyFactory();
//使用Cglib2AOPProx 即CGlib代理技术创建代理
// pf.setInterfaces(target.getClass().getInterfaces());//使用JdkDynamicAopProxy
//设置代理目标
pf.setTarget(target);
//添加增强处理
pf.addAdvice(advice);
//生成代理实例
Waiter waiter = (Waiter) pf.getProxy();
waiter.greetTo(
"Tom"
);
waiter.serveTo(
"Lucy"
);
// ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
// Waiter waiter1 = (Waiter) ctx.getBean("waiter");
// waiter1.greetTo("John");
}
}
|
|
1
2
3
4
5
|
<
bean
id
=
"target"
class
=
"com.baobaotao.advice.NaiveWaiter"
/>
<
bean
id
=
"greeteAdvice"
class
=
"com.baobaotao.advice.GreeteBeforeAdvice"
/>
<
bean
id
=
"waiter"
class
=
"org.springframework.aop.framework.ProxyFactoryBean"
p:proxyInterfaces
=
"com.baobaotao.advice.Waiter"
p:interceptorNames
=
"greeteAdvice"
p:target-ref
=
"target"
/>
|
2）后置增强：org.springframework.aop.AfterReturningAdvice代表后置增强，在目标方法执行后实施增强。
|
1
2
3
4
5
6
7
8
9
|
import
java.lang.reflect.Method;
import
org.springframework.aop.AfterReturningAdvice;
public
class
GreeteAfterAdvice
implements
AfterReturningAdvice{
@Override
public
void
afterReturning(Object arg0, Method arg1, Object[] arg2,
Object arg3)
throws
Throwable {
System.out.println(
"Please enjoy yourself!"
);
}
}
|
|
1
2
3
|
<
bean
id
=
"waiter"
class
=
"org.springframework.aop.framework.ProxyFactoryBean"
p:proxyInterfaces
=
"com.baobaotao.advice.Waiter"
p:interceptorNames
=
"greeteBefore,greeteAfter"
p:target-ref
=
"target"
/>
|
3）环绕增强：org.aopalliance.intercept.MethodInterceptor代表环绕增强，在目标方法执行前后实施增强。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
import
org.aopalliance.intercept.MethodInterceptor;
import
org.aopalliance.intercept.MethodInvocation;
public
class
GreeteInterceptor
implements
MethodInterceptor{
@Override
public
Object invoke(MethodInvocation inv)
throws
Throwable {
Object[] args = inv.getArguments();
String client = (String) args[
0
];
System.out.println(
"How are you!"
+client+
"."
);
Object obj = inv.proceed();
System.out.println(
"Please enjoy yourself!"
);
return
obj;
}
}
|
4）异常抛出增强：org.springframework.aop.ThrowsAdvice，在目标方法执行抛出异常后实施增强。方法名必须为afterThrowing,如参前三个可选，最后一个是Throwable或其子类。
|
1
2
3
4
5
6
7
8
9
10
11
|
import
java.lang.reflect.Method;
import
org.springframework.aop.ThrowsAdvice;
public
class
TransactionManager
implements
ThrowsAdvice {
public
void
afterThrowing(Method method, Object[] args, Object target,
Exception ex)
throws
Throwable {
System.out.println(
"-----------"
);
System.out.println(
"method:"
+ method.getName());
System.out.println(
"抛出异常:"
+ ex.getMessage());
System.out.println(
"成功回滚事务。"
);
}
}
|
5）引介增强：org.springframework.aop.IntroductionInterceptor，表示目标类添加一些新的方法和属性，连接点是类级别，而不是方法级别。
|
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
|
import
org.aopalliance.intercept.MethodInvocation;
import
org.springframework.aop.support.DelegatingIntroductionInterceptor;
import
com.baobaotao.proxy.PerformanceMonitor;
public
class
ControllablePerformaceMonitor
extends
DelegatingIntroductionInterceptor
implements
Monitorable{
private
ThreadLocal<Boolean> MonitorStatusMap =
new
ThreadLocal<Boolean>();
@Override
public
void
setMonitorActive(
boolean
active) {
MonitorStatusMap.set(active);
}
@Override
public
Object invoke(MethodInvocation mi)
throws
Throwable {
Object obj =
null
;
if
(MonitorStatusMap.get() !=
null
&& MonitorStatusMap.get()) {
PerformanceMonitor.begin(mi.getClass().getName() +
"."
+ mi.getMethod().getName());
obj =
super
.invoke(mi);
PerformanceMonitor.end();
}
else
{
obj =
super
.invoke(mi);
}
return
obj;
}
}
|
|
1
2
3
4
5
|
<
bean
id
=
"forumService"
class
=
"org.springframework.aop.framework.ProxyFactoryBean"
p:interfaces
=
"com.baobaotao.introduce.Monitorable"
//引入引介增强要实现的接口
p:target-ref
=
"forumServiceTarget"
p:interceptorNames
=
"pmonitor"
p:proxyTargetClass
=
"true"
/>//只能通过为目标类型类创建子类的方式生成增强的代理
|
AOP切面的配置方式
1）基于Schema的配置：在xml中描述切点、增强类型，切面类为pojo
2）基于AspectJ的配置：切点、增强类型使用注解进行描述
转载：http://my.oschina.net/elain/blog/382494
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
