Spring实战-读书笔记(章节四)-面向切面的Spring

面向切面编程

什么是面向切面编程？

面向切面的编程方式提供了更高的重用性和更好的低耦合性。以声明的方式定义一个功能在什么时候和什么地方使用，这样我们就可以不用在把需要的功能硬编码到其它功能中。例如：

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，方法因为正常返回结果或无返回结果而结束调用，后置通知先执行，还是返回通知先执行？答案是先执行后置通知，然后执行返回通知。

Spring中的切点

切点用于准确定位连接点。Spring AOP中的切点表达式和AsceptJ中的切点表达式的一个子集表达式一样，如果我们了解了AsceptJ切点表达式也就了解了Spring AOP的切点表达式。

书上对AsceptJ的切点表达式比较笼统，有时间在细细研究。快速了解可参考url：

http://blog.csdn.net/qwe6112071/article/details/50951720

使用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 * */@Componentpublic class Magic implements Performance {@Overridepublic 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@Componentpublic 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@ComponentScanpublic 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 {@Autowiredprivate Performance performance;@Testpublic 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@Componentpublic 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 {@Autowiredprivate Performance performance;@Testpublic 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 * */@Aspectpublic 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 {@AutowiredEnvironment env;@Beanpublic CompactDisc blankDisc() {String[] arrays = env.getProperty("disc.track").split(",");return new BlankDisc(env.getProperty("disc.title"), env.getProperty("disc.artist"), Arrays.asList(arrays));}@Beanpublic TrackCounter trackCounter() {return new TrackCounter();}}

config.properties

disc.title=\u4e00\u4e2a\u4eba\u7684\u884c\u674edisc.artist=\u6234\u4f69\u59aedisc.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 {@Autowiredprivate CompactDisc compactDisc;@Autowiredprivate TrackCounter trackCounter;@Testpublic 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配置的方法实现 事例代码3

package 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\u674edisc.artist=\u6234\u4f69\u59aedisc.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 {@Autowiredprivate CompactDisc compactDisc;@Autowiredprivate TrackCounter trackCounter;@Testpublic 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));}}