天天看点
返回

Spring实战-读书笔记(章节四)-面向切面的Spring面向切面编程Spring对AOP的支持Spring中的切点使用AspcetJ注解来配置切面（注解方式配置）使用XML配置来配置切面

面向切面编程

什么是面向切面编程？

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

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
 *
 */
@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配置的方法实现 事例代码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\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));
	}
}
Spring学习笔记 Srpng AOP before around after 面向切面
上一篇: 读书笔记-spring高级装配bean1.profile2 条件化的bean3处理自动装配的歧义性4 bean的作用域5 运行时值注入
下一篇: Spring技术内幕——读书笔记

继续阅读