AspectJ 对 AOP 的实现：
对于 AOP 这种编程思想，很多框架都进行了实现。Spring 就是其中之一，可以完成面向切面编程。然而，AspectJ 也实现了 AOP 的功能，且其实现方式更为简捷，使用更为方便，而且还支持注解式开发。所以，Spring 又将 AspectJ 的对于 AOP 的实现也引入到了自己的框架中。
在 Spring 中使用 AOP 开发时，一般使用 AspectJ 的实现方式。
AspectJ 中常用的通知有五种类型：
（1）前置通知
（2）后置通知
（3）环绕通知
（4）异常通知
（5）最终通知
其中最终通知是指，无论程序执行是否正常，该通知都会执行。类似于 try..catch 中的finally 代码块。
AspectJ 的切入点表达式 execution()：
AspectJ 除了提供了六种通知（还有一种引入通知？？？）外，还定义了专门的表达式用于指定切入点。表达式的原型是：
execution ( [modifiers-pattern] 访问权限类型
ret-type-pattern 返回值类型
[declaring-type-pattern] 全限定性类名
name-pattern(param-pattern) 方法名(参数名)
[throws-pattern] 抛出异常类型
)
切入点表达式要匹配的对象就是目标方法的方法名。所以，execution 表达式中明显就是方法的签名。注意，表达式中加[ ]的部分表示可省略部分，各部分间用空格分开。在其中可以使用以下符号：
* 0至多个任意字符
.. 用在方法参数中，表示任意多个参数；用在包名后，表示当前包及其子包路径
+ 用在类名后，表示当前类及其子类；用在接口后，表示当前接口及其实现类
AspectJ 对于 AOP 的实现有两种方式：
（1）注解方式
（2）XML 方式
AspectJ 基于注解的 AOP 实现：
Step1：定义业务接口与实现类：
package com.tongji.service; //主业务接口
public interface ISomeService {
public void doSome();
public String doSecond();
public String doThird();
}
package com.tongji.service; //目标类
public class SomeServiceImpl implements ISomeService { @Override
public void doSome() {
System.out.println("执行doSome()方法");
//System.out.println("执行doSome()方法" + 3/0);
} @Override
public String doSecond() {
System.out.println("执行doSecond()方法");
return "China";
} @Override
public String doThird() {
System.out.println("执行doThird()方法");
return "abcde";
} }
Step2：定义切面 POJO 类
该类为一个 POJO 类，将作为切面出现。其中定义了若干普通方法，将作为不同的通知方法。
Step3：在切面类上添加@Aspect 注解
在定义的 POJO 类上添加@Aspect 注解，指定当前 POJO 类将作为切面。
Step4：在 POJO 类的普通方法上添加通知注解
切面类是用于定义增强代码的，即用于定义增强目标类中目标方法的增强方法。这些增强方法使用不同的“通知”注解，会在不同的时间点完成织入。当然，对于增强代码，还要通过 execution 表达式指定具体应用的目标类与目标方法，即切入点。
package com.tongji.aspects; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before; @Aspect //表示当前POJO类为切面
public class MyAspect { //定义前置通知方法
@Before("execution(* *..service.*.doSome(..))")
public void myBefore() {
System.out.println("执行前置通知方法myBefore()");
} @Before("execution(* *..ISomeService.doSecond(..))")
public void myBefore(JoinPoint jp) {
System.out.println("执行前置通知方法myBefore() jp = " + jp);
} //定义后置通知方法
@AfterReturning("execution(* *..ISomeService.doSome(..))")
public void myAfterReturning() {
System.out.println("执行后置通知方法myAfterReturning()");
} @AfterReturning(value="execution(* *..ISomeService.doSecond(..))", returning="result")
public void myAfterReturning(Object result) {
System.out.println("执行后置通知方法myAfterReturning() result = " + result);
} //定义环绕通知方法
@Around("execution(* *..ISomeService.doThird(..))")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("执行环绕通知方法myAfter() 目标方法执行之前");
//执行目标方法
Object result = pjp.proceed();
System.out.println("执行环绕通知方法myAfter() 目标方法执行之后"); if (result != null) {
result = ((String)result).toUpperCase();
}
return result;
} //定义异常通知方法
@AfterThrowing("execution(* *..service.*.doSome(..))")
public void myAfterThrowing() {
System.out.println("执行异常通知方法myAfterThrowing()");
} @AfterThrowing(value="execution(* *..service.*.doSome(..))", throwing="ex")
public void myAfterThrowing(Exception ex) {
System.out.println("执行异常通知方法myAfterThrowing() ex = " + ex.getMessage());
} //定义最终通知方法
@After("execution(* *..service.*.doSome(..))")
public void myAfter() {
System.out.println("执行最终通知方法myAfter()");
} @After("mySomePointCut()")
public void myAfter2() {
System.out.println("执行最终通知方法myAfter2()");
} //定义切入点方法
@Pointcut("execution(* *..service.*.doSome(..))")
public void mySomePointCut() {
}
}
Step5：注册目标对象与 POJO 切面类
Step6：注册 AspectJ 的自动代理
在定义好切面 Aspect 后，需要通知 Spring 容器，让容器生成“目标类 + 切面”的代理对象。这个代理是由容器自动生成的。只需要在 Spring 配置文件中注册一个基于 aspectj的自动代理生成器，其就会自动扫描到@Aspect 注解，并按通知类型与切入点，将其织入，并生成代理。
<?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: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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 目标对象 -->
<bean id="someService" class="com.tongji.service.SomeServiceImpl"/>
<!-- 切面 -->
<bean id="myAspect" class="com.tongji.aspects.MyAspect"/> <!-- AspectJ的自动代理 -->
<aop:aspectj-autoproxy/> </beans>
<aop:aspectj-autoproxy/>的底层是由 AnnotationAwareAspectJAutoProxyCreator 实现的。从其类名就可看出，是基于 AspectJ 的注解适配自动代理生成器。其工作原理是，<aop:aspectj-autoproxy/>通过扫描找到@Aspect 定义的切面类，再由切面类根据切入点找到目标类的目标方法，再由通知类型找到切入的时间点。
Step7：测试类中使用目标对象的 id
package com.tongji.test; import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import com.tongji.service.ISomeService; public class MyTest { @Test
public void test01() {
String resource = "applicationContext.xml";
@SuppressWarnings("resource")
ApplicationContext ac = new ClassPathXmlApplicationContext(resource);
ISomeService service = (ISomeService) ac.getBean("someService");
service.doSome();
System.out.println("---------------------");
service.doSecond();
System.out.println("---------------------");
String result = service.doThird();
System.out.println(result);
} }
关于切面类的补充：
（1）@Before 前置通知-增强方法有 JoinPoint 参数
在目标方法执行之前执行。被注解为前置通知的方法，可以包含一个 JoinPoint 类型参数。该类型的对象本身就是切入点表达式。通过该参数，可获取切入点表达式、方法签名、目标对象等。
（2）@AfterReturning 后置通知-注解有 returning 属性
在目标方法执行之后执行。由于是目标方法之后执行，所以可以获取到目标方法的返回值。该注解的 returning 属性就是用于指定接收方法返回值的变量名的。所以，被注解为后置通知的方法，除了可以包含 JoinPoint 参数外，还可以包含用于接收返回值的变量。该变量最好为 Object 类型，因为目标方法的返回值可能是任何类型。
（3）@Around 环绕通知-增强方法有 ProceedingJoinPoint 参数
在目标方法执行之前之后执行。被注解为环绕增强的方法要有返回值，Object 类型。并且方法可以包含一个 ProceedingJoinPoint 类型的参数。接口 ProceedingJoinPoint 其有一个proceed()方法，用于执行目标方法。若目标方法有返回值，则该方法的返回值就是目标方法的返回值。最后，环绕增强方法将其返回值返回。该增强方法实际是拦截了目标方法的执行。
（4）@AfterThrowing 异常通知-注解中有 throwing 属性
在目标方法抛出异常后执行。该注解的 throwing 属性用于指定所发生的异常类对象。当然，被注解为异常通知的方法可以包含一个参数 Throwable，参数名称为 throwing 指定的名称，表示发生的异常对象。
（5）@After 最终通知
无论目标方法是否抛出异常，该增强均会被执行。
（6）@Pointcut 定义切入点
当较多的通知增强方法使用相同的 execution 切入点表达式时，编写、维护均较为麻烦。AspectJ 提供了@Pointcut 注解，用于定义 execution 切入点表达式。
其用法是，将@Pointcut 注解在一个方法之上，以后所有的 execution 的 value 属性值均可使用该方法名作为切入点。代表的就是@Pointcut 定义的切入点。这个使用@Pointcute注解的方法一般使用 private 的标识方法，即没有实际作用的方法。
AspectJ基于XML的AOP实现（这个方式是Spring实现AOP的最常用的方式）：
AspectJ 除了提供了基于注解的 AOP 的实现外，还提供了以 XML 方式的实现。切面就是一个 POJO 类，而用于增强的方法就是普通的方法。通过配置文件，将切面中的功能增强织入到了目标类的目标方法中。
Step1：定义业务接口与实现类（同上）
Step2：定义切面 POJO 类（没有注解）
Step3：注册目标对象与 POJO 切面类
Step4：在容器中定义 AOP 配置
<?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: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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 目标对象 -->
<bean id="someService" class="com.tongji.service.SomeServiceImpl"/>
<!-- 切面 -->
<bean id="myAspect" class="com.tongji.aspects.MyAspect"/> <!-- Aop配置 -->
<aop:config>
<aop:pointcut expression="execution(* *..service.*.doSome(..))" id="doSomePointCut"/>
<aop:pointcut expression="execution(* *..service.*.doSecond(..))" id="doSecondPointCut"/>
<aop:pointcut expression="execution(* *..service.*.doThird(..))" id="doThirdPointCut"/>
<aop:aspect ref="myAspect">
<aop:before method="myBefore" pointcut-ref="doSomePointCut"/>
<aop:before method="myBefore(org.aspectj.lang.JoinPoint)" pointcut-ref="doSomePointCut"/>
<aop:after-returning method="myAfterReturning" pointcut-ref="doSecondPointCut"/>
<aop:after-returning method="myAfterReturning(java.lang.Object)" pointcut-ref="doSecondPointCut" returning="result"/>
<aop:around method="myAround" pointcut-ref="doSecondPointCut"/>
<aop:after-throwing method="myAfterThrowing" pointcut-ref="doSomePointCut"/>
<aop:after-throwing method="myAfterThrowing(java.lang.Exception)" pointcut-ref="doSomePointCut" throwing="ex"/>
<aop:after method="myAfter" pointcut-ref="doSomePointCut"/>
</aop:aspect>
</aop:config>
</beans>
配置文件中，除了要定义目标类与切面的 Bean 外，最主要的是在<aop:config/>中进行aop 的配置。而该标签的底层，会根据其子标签的配置，生成自动代理。
通过其子标签<aop:pointcut/>定义切入点，该标签有两个属性，id 与 expression。分别用于指定该切入点的名称及切入点的值。expression 的值为 execution 表达式。
通过子标签<aop:aspect/>定义具体的织入规则：根据不同的通知类型，确定不同的织入时间；将 method 指定的增强方法，按照指定织入时间，织入到切入点指定的目标方法中。
<aop:aspect/>的 ref 属性用于指定使用哪个切面类。
<aop:aspect/>的子标签是各种不同的通知类型。不同的通知所包含的属性是不同的，但也有共同的属性。
method：指定该通知使用的切面中的增强方法。
pointcut-ref：指定该通知要应用的切入点。
AspectJ 的 6 种通知的 XML 标签如下：
<aop:before/>：前置通知，方法的参数类型必须是全限定类名。
<aop:after-returning/>： 后置通知，有一个属性 returning，指定用于接收目标方法的返回值所使用的变量名
<aop:around/>：环绕通知
<aop:after-throwing/>：异常通知，有一个属性 throwing，指定用于接收目标方法所抛出异常的变量名。
<aop:after/>：最终通知
<aop:declare-parents/>：引入通知???
Step5：测试类中使用目标对象的 id（同上）