概述：
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注解
611
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
