在软件开发中，发布于应用中多处的功能被称为横切关注点。通常，这些横切关注点从概念上是与应用的业务逻辑相分离的（但往往直接嵌入到应用的业务逻辑之中）。将横切关注点与业务逻辑相分离是AOP所要解决的。
一、AOP术语
1.通知（Advice）：定义切面是什么以及何时使用。除了描述要完成的工作，还要解决何时执行工作。
5种类型的通知：
Before，在方法被调用之前调用通知
After，在方法完成之后调用通知，无论方法执行是否成功
After-returning，在方法成功执行之后调用通知
After-throwing，在方法抛出异常后调用通知
Around，通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为
2.连接点，是在应用执行过程中能够插入切面的一个点，切面可以利用这些点插入到应用的正常流程之中，并添加新的行为。
3.切点，切点的定义会匹配通知所要织入的一个或多个连接点。通常使用明确的类和方法名称来指定这些切点，或者利用正则表达式定义匹配的类和方法名称模式来指定这些切点。
4.切面，是通知和切点的结合，是什么，在何时和何处完成其功能。
5.引入，允许向现有的类添加新方法或属性，例如可以创建一个Auditable通知类，该类记录了对象最后一次修改时的状态，只需一种方法setLastModified（Date），和一个实例变量来保存这个状态。然后这个新方法和变量就可以被引入到现有的类中。从而在无需修改现有类的情况下，让它们具有新的行为和状态。
6.织入，将切面应用到目标对象来创建新的代理对象的过程，切面在指定的连接点被织入到目标对象中。在目标对象的声明周期有多个点可以进行织入。
编译期：在目标类编译时被织入，需要特殊编译器，AspectJ的织入编译器就是以这种方式织入切面的。
类加载期：在目标类加载到JVM时被织入，需要特殊的类加载器，可以在目标类被引入应用之前增强该目标类的字节码。AspectJ 5的LTW（load-time-weaving）支持以这种方式织入切面。
运行期：在应用运行的某个时刻被织入，一般情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代理对象，Spring AOP以这种方式织入切面。
二、Spring对AOP的支持
提供4种各具特色的AOP支持：
1.基于代理的经典AOP
2.@AspectJ注解驱动的切面
3.纯POJO切面
4.注入式AspectJ切面（适合Spring各版本）
前3种都是Spring基于代理的AOP变体，因此，Spring对AOP的支持局限于方法拦截。如果需要构造器或属性拦截，那么应该考虑在AspectJ里实现切面，利用Spring的DI把Spring Bean注入到AspectJ切面中。
AOP框架的关键点：
1.Spring通知是Java编写的，可以使用与普通Java开发一样的IDE来开发切面，而且，定义通知所应用的切点通常在Spring配置文件里采用XML来编写。
2.Spring在运行期通知对象，通过在代理类中包裹切面，Spring在运行期将切面织入到Spring管理的Bean中。
代理类封装了目标类，并拦截被通知的方法的调用，再将调用转发给真正的目标Bean
当拦截到方法调用时，在调用目标Bean方法之前，代理会执行切面逻辑
直到应用需要被代理的Bean时，Spring才创建代理对象。如果使用ApplicationContext，在ApplicationContext从BeanFactory中加载所有Bean时，Spring创建被代理的对象。因为Spring运行时才创建代理对象，所以不需要特殊的编译器织入Spring AOP的切面。
3.Spring只支持方法连接点
二、使用切点选择连接点
切点用于准确定位应该在什么地方应用切面的通知。
在Spring AOP中，需要使用AspectJ的切点表达语言来定义切点。
Spring仅支持AspectJ切点指示器的一个子集。
| AspectJ指示器 | 描述 |
| arg() | 限制连接点匹配参数为指定类型的执行方法 |
|
@arg() |
限制连接点匹配参数由指定注解标注的执行方法 |
| execution() | 用于匹配是链接点的执行方法 |
| this() | 限制链接点匹配AOP代理的Bean引用为指定类型的类 |
| target() | 限制链接点匹配目标对象为指定类型的类 |
| @target() | 限制连接点匹配待定的执行对象，这些对象对应的类要具备指定类型的注解 |
| within() | 限制连接点匹配指定的类型 |
| @within() | 限制连接点匹配指定注解所标注的类型（当使用Spring AOP时，方法定义在由指定的注解所标注的类里） |
| @annotaion | 限制匹配带有指定注解连接点 |
1.编写切点
该切点表达式指示选择Instrument的play()方法执行时触发通知。(..)标识其诶单选择任意的play()方法，不管方法的入参是什么。
指示器之间可以混合使用，用and、or、not(&&、||、!)连接。
2.使用Spring的bean指示器
Spring 2.5引入一个新的bean()指示器，允许在切点表达式中使用Bean的ID来标识Bean。
在执行Instrument的play()方法时应用通知，但限定Bean的ID为eddie。
三、在XML中声明切面
AOP配置元素
| AOP配置元素 | 描述 |
| <aop:advisor> | 定义AOP通知器 |
| <aop:after> | 定义AOP后置通知（不管被通知的方法是否执行成功） |
| <aop:after-returning> | 定义AOP after-returning通知 |
| <aop:after-throwing> | 定义AOP after-throwing通知 |
| <aop:around> | 定义AOP环绕通知 |
| <aop:aspect> | 定义切面 |
| <aop:aspectj-autoproxy> | 启用@AspectJ注解驱动的切面 |
| <aop:before> | 定义AOP前置通知 |
| <aop:config> | 顶层的AOP配置元素，大多数的<aop:*>元素必须包含在<aop:config>元素内 |
| <aop:declare-parents> | 为被通知的对象引入额外的接口，并透明地实现 |
| <aop:pointcut> | 定义切点 |
创建一个公众类：
import org.aspectj.lang.ProceedingJoinPoint;
public class Audience {
public void takeSeats() {
System.out.println("The audience is taking their seats.");
}
public void turnOffPhones() {
System.out.println("The audience is turning off their cellphones.");
}
public void applaud() {
System.out.println("CLAP CLAP CLAP CLAP CLAP...");
}
public void demandRefund() {
System.out.println("Boo! We want out money back!");
}
}
Audience只是一个有几个方法的简单Java类。把它注册为Spring应用上下文的一个Bean
<bean id="audience" class="cn.edu.stu.springidol.Audience" />
把audience Bean变成一个切面：
<aop:config>
<aop:aspect ref="audience">
<aop:pointcut expression="execution(* cn.edu.stu.springidol.Performer.perform(..))" id="performance"/>
<aop:before pointcut-ref="performance" method="takeSeats"/>
<aop:before pointcut-ref="performance" method="turnOffPhones"/>
<aop:after-returning pointcut-ref="performance" method="applaud"/>
<aop:after-throwing pointcut-ref="performance" method="demandRefund"/>
</aop:aspect>
</aop:config>
切点声明为当调用Performer的perform方法时，应用切面。
测试：
声明一个Instrumentalist Bean，它继承了Performer
<bean id="saxphone" class="cn.edu.stu.springidol.Saxphone" /> <bean id="kenny" class="cn.edu.stu.springidol.Instrumentalist">
<property name="song" value="Jingle Bells" />
<property name="instrument" ref="saxphone" />
</bean>
测试代码
ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-idol.xml");
Performer p = (Performer) ctx.getBean("kenny");
p.perform();
结果打印出
声明环绕通知：
前面的切面使用了前置通知和后置通知，但如果不使用成员变量存储信息，那么在前置通知和后置通知之间共享信息非常麻烦。
例如，希望Audience能够知道参赛者表演了多长时间，如果使用成员变量保存开始时间，以为Audience是单例，将存在线程安全问题。
使用环绕通知，因为整个通知逻辑在一个方法内实现，所以不需要使用成员变量。
public void watchPerformance(ProceedingJoinPoint jointpoint) {
try {
System.out.println("The audience is taking their seats.");
System.out.println("The audience is turning off their cellphone.");
long start = System.currentTimeMillis();
jointpoint.proceed();//执行被通知的方法
long end = System.currentTimeMillis();
System.out.println("CLAP CLAP CLAP CLAP CLAP");
System.out.println("The performance took " + (end - start) + " milliseconds.");
} catch(Throwable t) {
System.out.println("Boo! We want out money back!");
}
}
<aop:config>
<aop:aspect ref="audience">
<aop:pointcut expression="execution(* cn.edu.stu.springidol.Performer.perform(..))" id="performance"/>
<aop:around pointcut-ref="performance" method="watchPerformance"/> </aop:aspect>
</aop:config>
测试代码一样，打印结果一样。
为通知传递参数：
有时候，通知不仅仅是对方法进行简单包装，还需要校验传递给方法的参数值，这时候为通知传递参数就非常有用了。
public interface MindReader {
void interceptThoughts(String thoughts);
String getThoughts();
}
public class Magician implements MindReader {
private String thoughts;
@Override
public void interceptThoughts(String thoughts) {
System.out.println("Intercepting volunteer's thoughts");
this.thoughts = thoughts;
}
@Override
public String getThoughts() {
return thoughts;
}
}
public interface Thinker {
void thinkOfSomething(String thoughts);
}
public class Volunteer implements Thinker {
private String thoughts;
@Override
public void thinkOfSomething(String thoughts) {
this.thoughts = thoughts;
}
public String getThoughts() {
return thoughts;
}
}
MindReader可以截获Thinker的想法thoughts（一个String参数）<bean id="magician" class="cn.edu.stu.springidol.Magician" />
<bean id="magician" class="cn.edu.stu.springidol.Magician" />
<bean id="volunteer" class="cn.edu.stu.springidol.Volunteer" />
<aop:config>
<aop:aspect ref="magician">
<aop:pointcut expression="execution(* cn.edu.stu.springidol.Thinker.thinkOfSomething(String))
and args(thoughts)" id="thinking"/>
<aop:before pointcut-ref="thinking" method="interceptThoughts" arg-names="thoughts"/> </aop:aspect>
</aop:config>
切点标识了Thinker的thinkOfSomething方法，指定String参数，然后再args参数中标识了将thoughts作为参数，在<aop:before>元素引用了thoughts参数，标识该参数必须传递给Magician的interceptThoughts方法。
通过切面引入新功能：
切面只是实现了它们所包装Bean的相同接口的代理。如果代理还能发布新的接口，那么切面所通知的Bean看起来实现了新的接口，即便底层实现类并没有实现这些接口。
当引入接口的方法被调用时，代理将此调用委托给实现了新接口的某个其他对象。实际上，Bean的实现被拆分到多个类。
public interface Contestant {
void receiveAward();
}
public class GraciousContestant implements Contestant {
@Override
public void receiveAward() {
System.out.println("Receive Award");
}
}
XML配置
<aop:config>
<aop:aspect>
<aop:declare-parents
types-matching="cn.edu.stu.springidol.Performer+"
implement-interface="cn.edu.stu.springidol.Contestant"
default-impl="cn.edu.stu.springdiol.GraciousContestant"/>
</aop:aspect>
</aop:config>
四、注解切面
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(* cn.edu.stu.springidol.Performer.perform(..))")
public void performance() { } @Before("performance()")
public void takeSeats() {
System.out.println("The audience is taking their seats.");
} @Before("performance()")
public void turnOffPhones() {
System.out.println("The audience is turning off their cellphones.");
} @AfterReturning("performance()")
public void applaud() {
System.out.println("CLAP CLAP CLAP CLAP CLAP...");
} @AfterThrowing("performance()")
public void demandRefund() {
System.out.println("Boo! We want out money back!");
} }
除了注解和无操作的performance方法，Audience类在实现上没有任何改变。
让Spring将Audience应用为一个切面，需要在Spring上下文声明一个自动代理Bean，该Bean知道如何将@AspectJ注解所标注的Bean转变为代理通知。
aop提供的一个自定义的配置元素：
<aop:aspectj-autoproxy />
<aop:aspect>元素和@Aspect注解都是把一个POJO转变为一个切面的有效方式，但是<aop:aspect>相对@Aspect的优势是不需要实现切面功能的源码，通过@Aspect，我们必须标注类和方法，它需要源码，而<aop:aspect>可以引用任意一个Bean。
创建环绕通知：
@Around("performance()")
public void watchPerformance(ProceedingJoinPoint jointpoint) {
try {
System.out.println("The audience is taking their seats.");
System.out.println("The audience is turning off their cellphone.");
long start = System.currentTimeMillis();
jointpoint.proceed();//执行被通知的方法
long end = System.currentTimeMillis();
System.out.println("CLAP CLAP CLAP CLAP CLAP");
System.out.println("The performance took " + (end - start) + " milliseconds.");
} catch(Throwable t) {
System.out.println("Boo! We want out money back!");
}
}
传递参数给所标注的通知：
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut; @Aspect
public class Magician implements MindReader {
private String thoughts; @Pointcut("execution(* cn.edu.stu.springidol.Thinker.thinkOfSomething(String)) && args(thoughts)")
public void thinking(String thoughts) { } @Override
@Before("thinking(thoughts)")
public void interceptThoughts(String thoughts) {
System.out.println("Intercepting volunteer's thoughts : " + thoughts);
this.thoughts = thoughts;
} @Override
public String getThoughts() {
return thoughts;
} }
标注引入：
@Aspect
public class ContestantIntroducer {
@DeclareParents(value = "cn.edu.stu.springidol.Performer+", defaultImpl = GraciousContestant.class)
public static Contestant contestant;
}
ContestantIntroducer是一个切面，它为Performer Bean引入Contestant接口，单没有delegate-ref的对应物，所以单靠@DeclareParents还不行，必须借助<aop:declare-parents>
五、注入AspectJ切面
AspectJ提供比Spring AOP更细粒度的通知，例如拦截对象字段的修改，支持构造器链接点。
创建一个新切面（这是一个aspect）：
public aspect JudgeAspect {
public JudgeAspect() {
}
pointcut performance() : execution(* perform(..));
after() returning() : performance() {
System.out.println(criticismEngine.getCriticism());
}
private CriticismEngine criticismEngine;
public void setCriticismEngine(CriticismEngine criticismEngine) {
this.criticismEngine = criticismEngine;
}
}
JudgeAspect的职责是在表演结束后为表演发表评论，performance()切点匹配perform()方法，当它与after() returning()通知一起配合使用时，可以让该切面在表演结束时起作用。
并不是JudgeAspect本身发表评论，它与一个CriticismEngine对象相协作，调用该对象的getCriticism()方法发表一个评论，为了避免JudgeAspect和CriticismEngine产生耦合，通过setter依赖注入为JudgeAspect赋予CriticismEngine。
public interface CriticismEngine {
String getCriticism();
}
public class CriticismEngineImpl implements CriticismEngine {
@Override
public String getCriticism() {
int i = (int) (Math.random() * criticismPool.length);
return criticismPool[i];
}
private String[] criticismPool;
public void setCriticismPool(String[] criticismPool) {
this.criticismPool = criticismPool;
}
}
<bean id="criticismEngine" class="cn.edu.stu.springidol.CriticismEngineImpl">
<property name="criticisms">
<list>
<value>I'm not being rude, but that was appalling.</value>
<value>You may be the least talented person in this show.</value>
<value>Do every a favor and keep your day job.</value>
</list>
</property>
</bean> <bean class="cn.edu.stu.springidol.JudgeAspect" factory-method="aspectOf">
<property name="criticismEngine" ref="criticismEngine" />
</bean>
通常情况下，Spring Bean由Spring容器初始化，但是AspectJ切面是由AspectJ在运行期创建的。因为Spring无法负责创建JudgeAspect，就不能简单地将JudgeAspect声明为一个Bean，相反，需要一种方式为所有的AspectJ切面提供一个静态的aspectOf()方法，该方法返回切面的一个单例。必须使用factory-method来调用aspectOf()方法来代替调用JudgeAspect的构造器方法。