这篇文章主要介绍了Java的Spring框架中的AOP实现实例,AOP面向切面编程其实也可以被看作是一个设计模式去规范项目的结构,需要的朋友可以参考下
简介
面向切面编程（AOP）提供另外一种角度来思考程序结构，通过这种方式弥补了面向对象编程（OOP）的不足。 除了类（classes）以外，AOP提供了 切面。切面对关注点进行模块化，例如横切多个类型和对象的事务管理。 （这些关注点术语通常称作 横切（crosscutting） 关注点。）
Spring的一个关键的组件就是 AOP框架。 尽管如此，Spring IoC容器并不依赖于AOP，这意味着你可以自由选择是否使用AOP，AOP提供强大的中间件解决方案，这使得Spring IoC容器更加完善。
Spring 2.0 AOP：
Spring 2.0 引入了一种更加简单并且更强大的方式来自定义切面，用户可以选择使用基于模式（schema-based）的方式或者使用@AspectJ注解。 对于新的应用程序，如果用户使用Java 5开发，我们推荐用户使用@AspectJ风格，否则可以使用基于模式的风格。 这两种风格都完全支持通知（Advice）类型和AspectJ的切入点语言，虽然实际上仍然使用Spring AOP进行织入（Weaving）。
本章主要讨论Spring 2.0对基于模式和基于@AspectJ的AOP支持。 Spring 2.0完全保留了对Spring 1.2的向下兼容性，下一章 将讨论Spring 1.2 API所提供的底层的AOP支持。
Spring中所使用的AOP：
提供声明式企业服务，特别是为了替代EJB声明式服务。 最重要的服务是 声明性事务管理（declarative transaction management） ， 这个服务建立在Spring的抽象事务管理（transaction abstraction）之上。
允许用户实现自定义的切面，用AOP来完善OOP的使用。
实例
我们经常会用到的有如下几种
1、基于代理的AOP
2、纯简单java对象切面
3、@Aspect注解形式的
4、注入形式的Aspcet切面
下面我们就一个一个来应用吧.
下面先写一下几个基本的类。
接口类：
|
1
2
3
4
5
6
7
8
9
10
|
/**
* 定义一个接口
*/
public
interface
Sleepable {
/**
* 睡觉方法
*/
void
sleep();
}
|
实现类：
|
1
2
3
4
5
6
7
8
9
10
11
|
/**
* 本人实现睡觉接口
*/
public
class
ChenLliNa
implements
Sleepable {
@Override
public
void
sleep() {
// TODO Auto-generated method stub
System.out.println(
"乖,该睡觉了！"
);
}
}
|
增强类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/**
* 定义一个睡眠的增强 同时实现前置 和后置
*/
public
class
SleepHelper
implements
MethodBeforeAdvice, AfterReturningAdvice {
@Override
public
void
afterReturning(Object returnValue, Method method,
Object[] args, Object target)
throws
Throwable {
System.out.println(
"睡觉前要敷面膜"
);
}
@Override
public
void
before(Method method, Object[] args, Object target)
throws
Throwable {
System.out.println(
"睡觉后要做美梦"
);
}
}
|
一、基于代理的AOP
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
<!-- 创建一个增强 advice -->
<
bean
id
=
"sleepHelper"
class
=
"com.tgb.springaop.aspect.SleepHelper"
/>
<
bean
id
=
"lina"
class
=
"com.tgb.springaop.service.impl.ChenLliNa"
/>
<!-- 定义切点 匹配所有的sleep方法-->
<
bean
id
=
"sleepPointcut"
class
=
"org.springframework.aop.support.JdkRegexpMethodPointcut"
>
<
property
name
=
"pattern"
value
=
".*sleep"
></
property
>
</
bean
>
<!-- 切面 增强+切点结合 -->
<
bean
id
=
"sleepHelperAdvisor"
class
=
"org.springframework.aop.support.DefaultPointcutAdvisor"
>
<
property
name
=
"advice"
ref
=
"sleepHelper"
/>
<
property
name
=
"pointcut"
ref
=
"sleepPointcut"
/>
</
bean
>
<!-- 定义代理对象 -->
<
bean
id
=
"linaProxy"
class
=
"org.springframework.aop.framework.ProxyFactoryBean"
>
<
property
name
=
"target"
ref
=
"lina"
/>
<
property
name
=
"interceptorNames"
value
=
"sleepHelperAdvisor"
/>
<!-- <property name="proxyInterfaces" value="com.tgb.springaop.service.Sleepable"/> -->
</
bean
>
|
如配置文件中：
pattern属性指定了正则表达式，他匹配所有的sleep方法
使用org.springframework.aop.support.DefaultPointcutAdvisor的目的是为了使切点和增强结合起来形成一个完整的切面
最后配置完后通过org.springframework.aop.framework.ProxyFactoryBean产生一个最终的代理对象。
二、纯简单java对象切面
纯简单java对象切面这话怎么说呢，在我看来就是相对于第一种配置，不需要使用代理，，而是通过spring的内部机制去自动扫描，这时候我们的配置文件就该如下修改：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
<!-- 创建一个增强 advice -->
<
bean
id
=
"sleepHelper"
class
=
"com.tgb.springaop.aspect.SleepHelper"
/>
<!-- 目标类 -->
<
bean
id
=
"lina"
class
=
"com.tgb.springaop.service.impl.ChenLliNa"
/>
<!-- 配置切点和通知-->
<
bean
id
=
"sleepAdvisor"
class
=
"org.springframework.aop.support.RegexpMethodPointcutAdvisor"
>
<
property
name
=
"advice"
ref
=
"sleepHelper"
></
property
>
<
property
name
=
"pattern"
value
=
".*sleep"
/>
</
bean
>
<!-- 自动代理配置 -->
<
bean
class
=
"org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
/>
|
是不是相对于第一种简单了许多，不用再去配置代理了。
三、@Aspect注解形式
根据我们的经验也知道，注解的形式相对于配置文件是简单一些的，这时候需要在已有的方法或类上家注解：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/**
* 通过注解的方式 添加增强
*/
@Aspect
@Component
public
class
SleepHelper03 {
/*@Pointcut("execution(* com.tgb.springaop.service.impl..*(..))")*/
@Pointcut
(
"execution(* *.sleep(..))"
)
public
void
sleeppoint(){}
@Before
(
"sleeppoint()"
)
public
void
beforeSleep(){
System.out.println(
"睡觉前要敷面膜"
);
}
@AfterReturning
(
"sleeppoint()"
)
public
void
afterSleep(){
System.out.println(
"睡觉后要做美梦"
);
}
|
配置文件中只需写：
|
1
2
3
4
5
6
7
|
<!--扫描包 -->
<
context:component-scan
base-package
=
"com.tgb"
annotation-config
=
"true"
/>
<!-- ASPECTJ注解 -->
<
aop:aspectj-autoproxy
proxy-target-class
=
"true"
/>
<!-- 目标类 -->
<
bean
id
=
"lina"
class
=
"com.tgb.springaop.service.impl.ChenLliNa"
/>
|
四、注入形式的Aspcet切面
个人感觉这个是最简单的也是最常用的，也是最灵活的。配置文件如下：
|
1
2
3
4
5
6
7
8
9
10
|
<!-- 目标类 -->
<
bean
id
=
"lina"
class
=
"com.tgb.springaop.service.impl.ChenLliNa"
/>
<
bean
id
=
"sleepHelper"
class
=
"com.tgb.springaop.aspect.SleepHelper02"
/>
<
aop:config
>
<
aop:aspect
ref
=
"sleepHelper"
>
<
aop:before
method
=
"beforeSleep"
pointcut
=
"execution(* *.sleep(..))"
/>
<
aop:after
method
=
"afterSleep"
pointcut
=
"execution(* *.sleep(..))"
/>
</
aop:aspect
>
</
aop:config
>
|
配置文件中提到的SleepHelper02类如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
/**
* 通过注解的方式 添加增强
*/
public
class
SleepHelper02 {
public
void
beforeSleep(){
System.out.println(
"睡觉前要敷面膜"
);
}
public
void
afterSleep(){
System.out.println(
"睡觉后要做美梦"
);
}
}
|
是不是看上去都很简单呀，这样是不是大家都会使用spring 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
39
40
41
42
43
44
45
46
47
48
|
/**
* 配置文件 spring_aop.xml 通过代理
*/
@Test
public
void
test(){
ApplicationContext ct =
new
ClassPathXmlApplicationContext(
"spring_aop.xml"
);
Sleepable sleeper =(Sleepable) ct.getBean(
"linaProxy"
);
sleeper.sleep();
}
/**
* 配置文件 spring_aop_01.xml 简答的java对象
*/
@Test
public
void
test01(){
ApplicationContext ct =
new
ClassPathXmlApplicationContext(
"spring_aop_01.xml"
);
Sleepable sleeper = (Sleepable)ct.getBean(
"lina"
);
sleeper.sleep();
}
/**
* 配置文件 spring_aop_03.xml 通过aspect注解
*/
@Test
public
void
test03(){
ApplicationContext ct =
new
ClassPathXmlApplicationContext(
"spring_aop_03.xml"
);
Sleepable sleeper = (Sleepable)ct.getBean(
"lina"
);
sleeper.sleep();
}
/**
* 配置文件 spring_aop_02.xml 通过apsect配置文件
* @author 陈丽娜
* @version 2015年5月31日上午10:09:37
*/
@Test
public
void
test02(){
ApplicationContext ct =
new
ClassPathXmlApplicationContext(
"spring_aop_02.xml"
);
Sleepable sleeper = (Sleepable)ct.getBean(
"lina"
);
sleeper.sleep();
}
|
通过测试类可以看出，不管以什么样的方式来实现aop他们的使用都是没有差别的，这几个测试类的结果都是一样的：
扫一扫
1222
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
