第4章 面向切面的Spring 笔记1

概述：

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和注解来配置切面

需要引用aspectJ jar包
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注解