面向切面编程
什么是面向切面编程?
面向切面的编程方式提供了更高的重用性和更好的低耦合性。以声明的方式定义一个功能在什么时候和什么地方使用,这样我们就可以不用在把需要的功能硬编码到其它功能中。例如:
public class UserDao{
/**
* 网站用户信息添加
* @param 用户注册信息
* @param 用户个人信息
*/
public int addUserDao(User user, Information info){
//向数据库表添加user
//向数据库表添加info
}
}
以上代码中我们需要使用到事务保持数据的一致性,我们的通常做法是在addUserDao()添加相同相关事务的代码,这里的事务管理是个横切关注点,并与业务代码混合在一起是耦合度变高,面向切面编程的目的就是把横切关注点和业务代码分离,让代码进一步变得简洁和明了。我们将事务管理模块化,把对其它模块提供的功能封装成一个类,这个类就叫做切面。这样做有两个好处:
1,首先,现在每个关注点都集中于一个地方,而不是分散到多处代码中;
2,其次,服务模块更简洁,因为它们只包含主要关注点(或核心功能)的代码,而次要关注点的代码被转移到切面中了。
术语
通知:通知表示切面要完成的工作,以及描述了在何时执行工作,这里的何时是指程序运行环节,例如:方法调用前、方法调用后等。
连接点:连接点是在应用执行过程中能够插入切面的一个点,这个点可以是方法、构造函数、字段等(Spring AOP中只支持将通知织入方法,所有Spring AOP的连接点都是只方法)。
切点:如果说通知定义了切面的“能做什么”和“何时做”的话,那么切点就定义了“何处”,也就是在哪里做。通常使用类名、方法名或正则表达式匹配切点。
切面:切面是通知和切点的结合。通知和切点共同定义了切面的全部内容——它是什么,在何时和何处完成其功能。
横切关注点:应用多个模块都需要使用到(依赖)的功能,这些功能影响应用的运行,这些影响应用运行的功能叫做横切关注点。例如日志、安全和事务管理都是横切关注点。
现在我们已经了解了如下的知识,通知包含了需要用于多个应用对象的横切行为;连接点是程序执行过程中能够应用通知的所有点;切点定义了通知被应用的具体位置(在哪些连接点)。其中关键的概念是切点定义了哪些连接点会得到通知。
Spring对AOP的支持
AOP功能是Spring框架中的一个子集,也有专业的AOP框架,比如AspectJ。Spring AOP借鉴了AspectJ框架的设计,有些用于AOP的配置和注解都和AspectJ一样。Spring AOP只能实现通知对方法的织入,不能是对构造方法或字段级别的细颗粒空中。
所有我们要使用Spring AOP需要到AspectJ的jar,下载地址如下:
Spring切面可以应用5种类型的通知:
1,前置通知(Before):在目标方法被调用之前调用通知功能。对应@Before注解。
2,后置通知(After):在目标方法完成之后调用通知,此时不会关心方法的输出是什么。对应@After注解
3,返回通知(After-returning):在目标方法成功执行之后调用通知。对应@AfterReturning注解。
4,异常通知(After-throwing):在目标方法抛出异常后调用通知。对应@AfterThrowing注解
5,环绕通知(Around):通知包裹了被通知的方法,在被通知的方法调用之前和调用之后执行自定义的行为。对应@Around注解。
我们思考这样的问题:
1,方法因为抛出异常而结束调用,后置通知先执行,还是异常通知先执行?答案是先执行异常通知,然后执行后置通知。
2,方法因为正常返回结果或无返回结果而结束调用,后置通知先执行,还是返回通知先执行?答案是先执行后置通知,然后执行返回通知。
1,前置通知(Before):在目标方法被调用之前调用通知功能。对应@Before注解。
2,后置通知(After):在目标方法完成之后调用通知,此时不会关心方法的输出是什么。对应@After注解
3,返回通知(After-returning):在目标方法成功执行之后调用通知。对应@AfterReturning注解。
4,异常通知(After-throwing):在目标方法抛出异常后调用通知。对应@AfterThrowing注解
5,环绕通知(Around):通知包裹了被通知的方法,在被通知的方法调用之前和调用之后执行自定义的行为。对应@Around注解。
我们思考这样的问题:
1,方法因为抛出异常而结束调用,后置通知先执行,还是异常通知先执行?答案是先执行异常通知,然后执行后置通知。
2,方法因为正常返回结果或无返回结果而结束调用,后置通知先执行,还是返回通知先执行?答案是先执行后置通知,然后执行返回通知。
Spring中的切点
切点用于准确定位连接点。Spring AOP中的切点表达式和AsceptJ中的切点表达式的一个子集表达式一样,如果我们了解了AsceptJ切点表达式也就了解了Spring AOP的切点表达式。
书上对AsceptJ的切点表达式比较笼统,有时间在细细研究。快速了解可参考url:
使用AspcetJ注解来配置切面(注解方式配置)
Spring AOP不但切点表达式使用了AsceptJ切点表达式的一个子集,用于配置Spring AOP的注解也使用了AsceptJ注解。
涉及注解
@After 通知方法会在目标方法返回或抛出异常后调用@AfterReturning 通知方法会在目标方法返回后调用。注意:如果方法执行过程中抛出异常将不会有返回值,此通知也不会执行。
@AfterThrowing 通知方法会在目标方法抛出异常后调用
@Around 通知方法会将目标方法封装起来
@Before 通知方法会在目标方法调用之前执行
@Aspect:标记在类上,表示此类为一个切面类。
@Pointcut:定义一个切点。切点名称是@Pointcut注解标记的方法名称。
@EnableAspectJAutoProxy:同@Configuration注解一起使用,表示启用AspectJ自动代理。
代码事例1
我们实现这样一个需求:观众看一场表演,在看表演之前观众需要关掉手机、禁止谈话。在看完表演后会观众鼓掌表示表演很赞。如果表演中发生失误,观众会要求退票。package com.zhangxy.chapter_4.aspectJ.main;
/**
* 表演接口
* @author Administrator
*
*/
public interface Performance {
public void perform();
}
package com.zhangxy.chapter_4.aspectJ.main;
import org.springframework.stereotype.Component;
/**
* 变魔术表演
* @author Administrator
*
*/
@Component
public class Magic implements Performance {
@Override
public void perform() {
System.out.println("敢问路在何方,路在脚下..."/*+(1/0)*/);
}
}
package com.zhangxy.chapter_4.aspectJ.main;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
/**
* 听众类
* @author Administrator
*
*/
@Aspect
@Component
public class Audience {
@Pointcut("execution(** com.zhangxy.chapter_4.aspectJ.main.Performance.perform(..))")
public void performance() {}
@Before("performance()")
public void silenceCellPhones() {
System.out.println("@Before,silenceCellPhones,关闭手机!");
}
@Before("performance()")
public void takeSeats() {
System.out.println("@Before,takeSeats,不要谈话!");
}
@After("performance()")
public void applause() {
System.out.println("@After,applause,好,为爱鼓掌!啪!啪!啪!");
}
@AfterReturning("performance()")
public void leave() {
System.out.println("@AfterReturning,leave,离开演出现场!");
}
@AfterThrowing("performance()")
public void demandRefund() {
System.out.println("@AfterThrowing,demandRefund,退票!退票!!!");
}
}
package com.zhangxy.chapter_4.aspectJ.main;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@EnableAspectJAutoProxy
@ComponentScan
public class SystemConfig {
}
~~~测试类~~~
package com.zhangxy.chapter_4.aspectJ.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.zhangxy.chapter_4.aspectJ.main.Performance;
import com.zhangxy.chapter_4.aspectJ.main.SystemConfig;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SystemConfig.class)
public class AspectJTest {
@Autowired
private Performance performance;
@Test
public void test1() {
performance.perform();
/* @Before,silenceCellPhones,关闭手机!
@Before,takeSeats,不要谈话!
敢问路在何方,路在脚下...
@After,applause,好,为爱鼓掌!啪!啪!啪!
@AfterReturning,leave,离开演出现场!*/
}
}
事例代码2
我们使用环绕通知方式实现上一个事例的需求。将Audience.java替换成AudienceAround.java
package com.zhangxy.chapter_4.aspectJ.main;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
/**
* 听众类环绕版本
* @author Administrator
*
*/
@Aspect
@Component
public class AudienceAround {
@Pointcut("execution(** com.zhangxy.chapter_4.aspectJ.main.Performance.perform(..))")
public void performance() {}
public void silenceCellPhones() {
System.out.println("@Before,silenceCellPhones,关闭手机!");
}
public void takeSeats() {
System.out.println("@Before,takeSeats,不要谈话!");
}
public void applause() {
System.out.println("@After,applause,好,为爱鼓掌!啪!啪!啪!");
}
public void leave() {
System.out.println("@AfterReturning,leave,离开演出现场!");
}
public void demandRefund() {
System.out.println("@AfterThrowing,demandRefund,退票!退票!!!");
}
@Around("performance()")
public void watchPerformance(ProceedingJoinPoint joinPoint) {
Throwable e1 = null;
silenceCellPhones();
takeSeats();
try {
joinPoint.proceed();
applause();
} catch (Throwable e) {
e1=e;
demandRefund();
applause();
e.printStackTrace();
}
if(e1==null) {
leave();
}
}
}
~~~测试类~~~
package com.zhangxy.chapter_4.aspectJ.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.zhangxy.chapter_4.aspectJ.main.Performance;
import com.zhangxy.chapter_4.aspectJ.main.SystemConfig;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SystemConfig.class)
public class AspectJAroundTest {
@Autowired
private Performance performance;
@Test
public void test1() {
performance.perform();
/* @Before,silenceCellPhones,关闭手机!
@Before,takeSeats,不要谈话!
敢问路在何方,路在脚下...
@After,applause,好,为爱鼓掌!啪!啪!啪!
@AfterReturning,leave,离开演出现场!*/
}
}
你首先注意到的可能是它接受ProceedingJoinPoint作为参数。这个对象是必须要有的,因为你要在通知中通过它来调用被通知的方法。通知方法中可以做任何的事情,当要将控制权交给被通知的方法时,它需要调用ProceedingJoinPoint的proceed()方法。需要注意的是,别忘记调用proceed()方法。如果不调这个方法的话,那么你的通知实际上会阻塞对被通知方法的调用。有可能这就是你想要的效果,但更多的情况是你希望在某个点上执行被通知的方法。有意思的是,你可以不调用proceed()方法,从而阻塞对被通知方法的访问,与之类似,你也可以在通知中对它进行多次调用。要这样做的一个场景就是实现重试逻辑,也就是在被通知方法失败后,进行重复尝试。
事例代码3
我们实现这样一个需求:我们一个歌单列表,根据歌曲在歌单中的顺序播放歌曲,并记录每首歌曲的播放次数。package com.zhangxy.chapter_4.paramAspectJ.main;
public interface CompactDisc {
public void play(int trackNumber);
}
package com.zhangxy.chapter_4.paramAspectJ.main;
import java.util.List;
public class BlankDisc implements CompactDisc {
private String title;
private String artist;
private List<String> tracks;
public BlankDisc(String title, String artist, List<String> tracks) {
this.title = title;
this.artist = artist;
this.tracks = tracks;
}
public void play(int trackCount) {
System.out.println("Playing " + this.tracks.get(trackCount));
}
}
package com.zhangxy.chapter_4.paramAspectJ.main;
import java.util.HashMap;
import java.util.Map;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
/**
* 记录光盘上歌曲的播出次数
* @author Administrator
*
*/
@Aspect
public class TrackCounter {
private Map<Integer, Integer> trackCounts = new HashMap<Integer, Integer>();
@Pointcut("execution(** com.zhangxy.chapter_4.paramAspectJ.main.CompactDisc.play(int)) && args(trackNumber)")
public void trackPlayed(int trackNumber) {
}
@Before("trackPlayed(trackNumber)")
public void trackCount(int trackNumber) {
int count = count(trackNumber) + 1;
trackCounts.put(trackNumber, count);
}
public int count(Integer trackNumber) {
return this.trackCounts.containsKey(trackNumber) ? trackCounts.get(trackNumber) : 0;
}
public int getPlayCount(int trackNumber) {
return this.trackCounts.get(trackNumber);
}
}
package com.zhangxy.chapter_4.paramAspectJ.main;
import java.util.Arrays;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
@Configuration
@EnableAspectJAutoProxy
@PropertySource(value="com\\zhangxy\\chapter_4\\paramAspectJ\\main\\config.properties")
public class SystemConfig {
@Autowired
Environment env;
@Bean
public CompactDisc blankDisc() {
String[] arrays = env.getProperty("disc.track").split(",");
return new BlankDisc(env.getProperty("disc.title"), env.getProperty("disc.artist"), Arrays.asList(arrays));
}
@Bean
public TrackCounter trackCounter() {
return new TrackCounter();
}
}
config.properties
disc.title=\u4e00\u4e2a\u4eba\u7684\u884c\u674e
disc.artist=\u6234\u4f69\u59ae
disc.track=\u9047\u89c1,\u9006\u5149,\u60f3\u5ff5\u662f\u4f1a\u547c\u5438\u7684\u75db
~~~测试类~~~
package com.zhangxy.chapter_4.paramAspectJ.test;
import static org.junit.Assert.assertEquals;
import java.util.HashMap;
import java.util.Map;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.zhangxy.chapter_4.paramAspectJ.main.CompactDisc;
import com.zhangxy.chapter_4.paramAspectJ.main.SystemConfig;
import com.zhangxy.chapter_4.paramAspectJ.main.TrackCounter;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SystemConfig.class)
public class ParamAspectJTest {
@Autowired
private CompactDisc compactDisc;
@Autowired
private TrackCounter trackCounter;
@Test
public void test() {
compactDisc.play(0);
compactDisc.play(1);
compactDisc.play(1);
compactDisc.play(2);
compactDisc.play(2);
compactDisc.play(2);
assertEquals(1, trackCounter.getPlayCount(0));
assertEquals(2, trackCounter.getPlayCount(1));
assertEquals(3, trackCounter.getPlayCount(2));
}
}
使用XML配置来配置切面
使用注解来配置切面要比XML配置简洁和方便一些(比如注解是类型安全的),但是在有些情况下是非XML配置来配置切面不可的,例如:如果要你要把第三方库中的类作为通知,而又没有源代码,或者你不能修改第三方库,这种情况下就只能使用XML配置。XML配置切面涉及元素
1,<aop:advisor>:定义AOP通知器2,<aop:after>:定义AOP后置通知(不管被通知的方法是否执行成功)
3,<aop:after-returning>:定义AOP返回通知
4,<aop:after-throwing>:定义AOP异常通知
5,<aop:around>:定义AOP环绕通知
6,<aop:aspect>:定义一个切面
7,<aop:aspectj-autoproxy>:启用@AspectJ注解驱动的切面
8,<aop:before>:定义一个AOP前置通知
9,<aop:config>:顶层的AOP配置元素。大多数的<aop:*>元素必须包含在<aop:config>元素内
10,<aop:declare-parents>:以透明的方式为被通知的对象引入额外的接口
11,<aop:pointcut>:定义一个切点
事例代码
使用XML配置的方法实现 事例代码3package com.zhangxy.chapter_4.xmlAspectj.main;
public interface CompactDisc {
public void play(int trackNumber);
}
package com.zhangxy.chapter_4.xmlAspectj.main;
import java.util.Arrays;
import java.util.List;
public class BlankDisc implements CompactDisc {
private String title;
private String artist;
private String tracksStr;
private List<String> tracks;
public BlankDisc(String title, String artist, String tracksStr) {
this.title = title;
this.artist = artist;
this.tracksStr = tracksStr;
this.tracks = Arrays.asList(tracksStr.split(","));
}
public void play(int trackCount) {
System.out.println("Playing " + this.tracks.get(trackCount));
}
}
package com.zhangxy.chapter_4.xmlAspectj.main;
import java.util.HashMap;
import java.util.Map;
public class TrackCounter {
private Map<Integer, Integer> trackCounts = new HashMap<Integer, Integer>();
public void trackCount(int trackNumber) {
int count = count(trackNumber) + 1;
trackCounts.put(trackNumber, count);
}
public int count(Integer trackNumber) {
return this.trackCounts.containsKey(trackNumber) ? trackCounts.get(trackNumber) : 0;
}
public int getPlayCount(int trackNumber) {
return this.trackCounts.get(trackNumber);
}
}
config.prpperties
disc.title=\u4e00\u4e2a\u4eba\u7684\u884c\u674e
disc.artist=\u6234\u4f69\u59ae
disc.track=\u9047\u89c1,\u9006\u5149,\u60f3\u5ff5\u662f\u4f1a\u547c\u5438\u7684\u75db
system-config.xml
<?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:p="http://www.springframework.org/schema/p"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>com\zhangxy\chapter_4\xmlAspectj\main\config.properties</value>
</list>
</property>
</bean>
<bean id="blankDisc"
class="com.zhangxy.chapter_4.xmlAspectj.main.BlankDisc">
<constructor-arg value="${disc.title}" />
<constructor-arg value="${disc.artist}"></constructor-arg>
<constructor-arg value="${disc.track}"></constructor-arg>
</bean>
<bean id="trackCounter" class="com.zhangxy.chapter_4.xmlAspectj.main.TrackCounter"></bean>
<!-- 启用切面自动代理,相当于@EnableAspectJAutoProxy注解-->
<aop:aspectj-autoproxy/>
<aop:config><!-- 定义切面 -->
<!-- 定义切点 -->
<aop:pointcut expression="execution(* com.zhangxy.chapter_4.xmlAspectj.main.CompactDisc.play(int)) and args(trackNumber)" id="trackPlayed"/>
<!-- 定义前置通知 -->
<aop:aspect ref="trackCounter">
<aop:before method="trackCount" pointcut-ref="trackPlayed"/>
</aop:aspect>
</aop:config>
</beans>
~~~测试类~~~
package com.zhangxy.chapter_4.xmlAspectj.test;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.zhangxy.chapter_4.xmlAspectj.main.CompactDisc;
import com.zhangxy.chapter_4.xmlAspectj.main.TrackCounter;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:com\\zhangxy\\chapter_4\\xmlAspectj\\main\\system-config.xml")
public class XmlAspectJTest {
@Autowired
private CompactDisc compactDisc;
@Autowired
private TrackCounter trackCounter;
@Test
public void test1() {
compactDisc.play(0);
compactDisc.play(1);
compactDisc.play(1);
compactDisc.play(2);
compactDisc.play(2);
compactDisc.play(2);
assertEquals(1, trackCounter.getPlayCount(0));
assertEquals(2, trackCounter.getPlayCount(1));
assertEquals(3, trackCounter.getPlayCount(2));
}
}