概述:
AOP是Spring第二大特性,将一些琐事交给Spring去做,让我们专注于业务,减少程序冗余的编码。
主要涉及的内容:
- 面向切面编程的基本原理
- 通过POJO创建切面
- 使用@AspectJ注解
- 为AspectJ切面注入依赖
切面的用得最多就是日志和事务,例如日志,在进行操作的时候需要记录操作记录,如果是硬编码的话,就会在很多地方出现记录的冗余代码,AOP简单理解就是方法拦截,可以做一些其他的事情。
1.专业术语
通知(Advice):就是拦截的目的是什么?是劫钱还是劫*,还要找准时机,什么动手?听口令
所有通知解决的是what+when
在通知的when的含义有五种
- 前置通知(Before):在目标方法被调用之前调用通知的功能
- 后置通知(After):在目标方法完成之后调用通知,此时不会关心方法的输出是什么
- 返回通知(After-returning): 在目标方法成功执行后调用通知
- 异常通知(After-throwing):在目标方法抛出异常后调用通知、
- 环绕通知(Around):通知包裹了被通知的方法,在被通知的方法调用的之前和调用之后执行自定义的行为
连接点(Join point) :那个地方适合做?山匪会规划好哪些地方适合打劫,这地方肯定很多。
对于程序来说什么时候做日志记录地方,地方也很多。这时候需要选择了
切点(Pointcut):这就是具体实施的地方,(也就是山匪进行蹲点的地方)这里解决 where问题
连接起来就形成一个句子 山匪在哪里?什么时候?做什么?
切面(Aspect):等于通知+切点(形成一个完整的流程)
AOP具体实施细节:
引入(Introduction):它可以帮助你在你现有的类基础上增加一些方法和属性称为引入,不然电脑怎么知道做啥?根据的AOP配置在前期做好准备工作
织入(Weaving):把切面应用到目标对象并创建新的代理对象的过程。(所做准备工作,入侵)
什么时候织入?
- 编译期:在编译的时候织入,AspectJ就是这种方式
- 类加载器:切面在目标类加载到JVM时被织入,AspectJ5支持这种
- 运行期:运行时候织入SpringAOP就是这种方式
2、Spring对AOP的支持
Spring很多地方借鉴了AspectJ实现AOP功能
Spring提供了4中类型的AOP的支持:
- 基于代理的经典Spring AOP
- 纯POJO切面
- @AspectJ注解驱动的切面
- 注入式AspectJ切面(适用于Spring各版本)
Spring只支持方法级别的连接点
2.1编写切点
满足多个条件&& 单个条件|| 非!
execution((* concert.Performance.perform(..)) && within(concert.*))
within表示在什么里面,包含的意思
execution(* concert.Performance.perform()) and bean("woodstock")
bean:只有当前woodstock才能执行aop操作
3.基于JavaConfig和注解来配置切面
package learn.chapter4;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class Audience {
@Before("execution(** chapter4.Performance.perform(..)")
public void silenceCellPhones(){
System.out.println("手机设置成静音状态");
}
@Before("execution(** chapter4.Performance.perform(..))")
public void takeSeats(){
System.out.println("选择位子坐下");
}
@AfterReturning("execution(** chapter4.Performance.perform(..))")
public void applause() {
System.out.println("表演很精彩,鼓掌!");
}
@AfterThrowing("execution(** chapter4.Performance.perform(..))")
public void demandRefund() {
System.out.println("太烂了,请求退款");
}
}
总结:原则就是dry (don‘t repeat yourself) 改变一下
package learn.chapter4;
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;
@Aspect
public class Audience {
@Pointcut("execution(* *.chapter4.Performance.perform(..))")
public void performance(){}
@Before("performance()")
public void silenceCellPhones(){
System.out.println("手机设置成静音状态");
}
@Before("performance()")
public void takeSeats(){
System.out.println("选择位子坐下");
}
@AfterReturning("performance()")
public void applause() {
System.out.println("表演很精彩,鼓掌!");
}
@AfterThrowing("performance()")
public void demandRefund() {
System.out.println("太烂了,请求退款");
}
}
package learn.chapter4;
public interface Performance {
public void perform();
}
实现类
package learn.chapter4;
public class Chaplin implements Performance{
public void perform() {
System.out.println("卓别林正在表演哑剧。。。。。");
}
}
package learn.chapter4.javaConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import learn.chapter4.Audience;
import learn.chapter4.Chaplin;
import learn.chapter4.Performance;
@Configuration
@EnableAspectJAutoProxy //启动AspectJ自动代理
@ComponentScan
/**
* 如果你是基于xml配置需要做如下事情
* 1.声明Spring的aop命名空间
* 2.<context:component-scan base-packeget="learn.chapter4"/> 启动自动扫描注解的功能
* 3.<aop:aspectj-autoproxy /> 启用自动代理功能
* 4.<bean class="learn.chapter4.Audience" /> 注入bean
* @author Administrator
*
*/
public class AspectJConfig {
@Bean
public Audience audience(){
return new Audience();
}
@Bean
public Performance performance(){
return new Chaplin();
}
}
总结:这是javaConfig配置类,注意的注解 @EnableAspectJAutoProxy开启自动代理模式 @ComponentScan开启扫描模式(这个可以不要,因为显式配置bean)
测试类:
package learn.chapter4;
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 learn.chapter4.javaConfig.AspectJConfig;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes={AspectJConfig.class})
public class AspectJTest {
@Autowired
private Performance performance;
@Test
public void play(){
performance.perform();
}
}
结果:
手机设置成静音状态
选择位子坐下
卓别林正在表演哑剧。。。。。
表演很精彩,鼓掌!
采用环绕通知方式
package learn.chapter4;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class Audience {
@Pointcut("execution(* *.chapter4.Performance.perform(..))")
public void performance(){}
@Around("performance()")
public void watchPerformance(ProceedingJoinPoint jp){
try{
System.out.println("手机设置成静音状态");
System.out.println("选择位子坐下");
jp.proceed();
System.out.println("表演很精彩,鼓掌!");
} catch (Throwable e) {
System.out.println("太烂了,请求退款");
}
}
}
必须要传入参数 ProceedingsJoinPoint ,同时要调用 proceed()方法
3.2. 考虑传入的参数
package learn.chapter4;
/**
* 定义一个CD接口
* @author chenliang
*
*/
public interface CompactDisc {
void play();
void playTrack(int num);
}
package learn.chapter4;
import java.util.List;
public class BlankDisc implements CompactDisc {
private String title;
private String artist;
private List<String> tracks;
public BlankDisc() {
super();
// TODO Auto-generated constructor stub
}
public BlankDisc(String title, String artist) {
super();
this.title = title;
this.artist = artist;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getArtist() {
return artist;
}
public void setArtist(String artist) {
this.artist = artist;
}
public List<String> getTracks() {
return tracks;
}
public void setTracks(List<String> tracks) {
this.tracks = tracks;
}
@Override
public String toString() {
return "BlankDisc [title=" + title + ", artist=" + artist + ", tracks=" + tracks + "]";
}
public void play() {
System.out.println("专辑为" + title + "\t 歌手为:" + artist);
if(null!=tracks && tracks.size() > 0){
for (String track : tracks){
System.out.println("---磁道: " + track);
}
}
}
public void playTrack(int num) {
System.out.println("获取对应磁道:" + num +"\t 歌曲为:"+ tracks.get(num));
}
}
一个磁盘有多个磁道,每个磁道写入的歌曲是不一样的
package learn.chapter4;
import java.util.HashMap;
import java.util.Map;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class TrackCounter {
private Map<Integer, Integer> trackCounts =
new HashMap<Integer, Integer>();
@Pointcut(
"execution(* learn.chapter4.CompactDisc.playTrack(int)) "+
"&& args(trackNumber)")
public void trackPlayed(int trackNumber){}
@Before("trackPlayed(trackNumber)")
public void countTrack(int trackNumber) {
System.out.println("===================");
int currentCount = getPlayCount(trackNumber);
trackCounts.put(trackNumber, currentCount+1);
}
public int getPlayCount(int trackNumber) {
return trackCounts.containsKey(trackNumber)
? trackCounts.get(trackNumber) : 0;
}
}
配置一个切面,一定要注意类上面 @Aspect注解,不然没有效果
package learn.chapter4.javaConfig;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import learn.chapter4.BlankDisc;
import learn.chapter4.CompactDisc;
import learn.chapter4.TrackCounter;
@Configuration
@EnableAspectJAutoProxy //启用自动代理
public class TrackCounterConfig {
@Bean
public CompactDisc blankDisc(){
BlankDisc cd = new BlankDisc();
cd.setTitle("beyond乐队");
cd.setArtist("25年精选");
List<String> tracks = new ArrayList<String>();
tracks.add("海阔天空");
tracks.add("情人");
tracks.add("不在犹豫");
tracks.add("光辉岁月");
tracks.add("大地");
tracks.add("谁伴我闯荡");
cd.setTracks(tracks);
return cd;
}
@Bean
public TrackCounter trackCounter() {
return new TrackCounter();
}
}
配置javaConfig,注入bean
测试类:
package learn.chapter4;
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 learn.chapter4.javaConfig.TrackCounterConfig;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes={TrackCounterConfig.class})
public class TrackCounterTest {
@Autowired
private CompactDisc cd;
@Autowired
private TrackCounter counter;
@Test
public void testCounter(){
cd.playTrack(0);
cd.playTrack(1);
cd.playTrack(2);
cd.playTrack(3);
cd.playTrack(3);
cd.playTrack(4);
cd.playTrack(5);
cd.playTrack(5);
cd.playTrack(5);
System.out.println(counter.getPlayCount(1));
System.out.println(counter.getPlayCount(2));
System.out.println(counter.getPlayCount(3));
System.out.println(counter.getPlayCount(4));
System.out.println(counter.getPlayCount(5));
System.out.println(counter.getPlayCount(0));
}
}
结果:
===================
获取对应磁道:0 歌曲为:海阔天空
===================
获取对应磁道:1 歌曲为:情人
===================
获取对应磁道:2 歌曲为:不在犹豫
===================
获取对应磁道:3 歌曲为:光辉岁月
===================
获取对应磁道:3 歌曲为:光辉岁月
===================
获取对应磁道:4 歌曲为:大地
===================
获取对应磁道:5 歌曲为:谁伴我闯荡
===================
获取对应磁道:5 歌曲为:谁伴我闯荡
===================
获取对应磁道:5 歌曲为:谁伴我闯荡
1
1
2
1
3
1
总结:
1.注意配置切点的时候,配置的参数类型,&& args(名称) 将传递的参数的值赋给该变量
@Pointcut(
"execution(* learn.chapter4.CompactDisc.playTrack(int)) "+
"&& args(trackNumber)")
2.调用的时候用的参数名,而不是类型
3.在配置时候@EnableAspectJAutoProxy 和在切面类增加@Aspect注解