Spring笔记：AOP面向切面编程
AOP（Aspect Oriented Programming）面向切面编程，是通过预编译和运行期间动态代理的方式实现程序功能的一种技术。Spring中常用的AOP实现方式有三种：Spring原生API、自定义类和注解。我先把不同实现方式的示例中共用的代码贴出来。
切入点，即要测试的接口和类：
package com.yun.service;
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}
package com.yun.service;
public class UserServiceImpl implements UserService{
public void add() {
System.out.println("Add a user.");
}
public void delete() {
System.out.println("Delete a user.");
}
public void update() {
System.out.println("Update a user.");
}
public void query() {
System.out.println("Query a user.");
}
}
测试类：
import com.yun.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
// 注意，由于Spring AOP的实现原理是动态代理，所以这里的对象类型必须指定为对应的接口，而不是具体的实现类
UserService userService = (UserService)context.getBean("userService");
userService.add();
}
}
1. AOP实现方式一：Spring原生API
使用Spring原生API的方式就需要实现特定的接口，具体接口见示例。
在需要切入的方法之前执行的操作：
package com.yun.log;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class BeforeLog implements MethodBeforeAdvice {
// method: 目标对象中要执行的方法
// args: 执行方法对应的参数
// target: 要执行的目标对象
// 此方法表示在目标对象target的method方法之前执行
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("before：" + target.getClass().getName() + "." + method.getName());
}
}
在需要切入的方法之后执行的操作：
package com.yun.log;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterReturnLog implements AfterReturningAdvice {
// 此方法表示在目标对象target的method方法之后执行，这个方法可以拿到method方法的返回值
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName() + "." + method.getName() + "的返回结果为：" + returnValue);
}
}
xml配置：为了使用Spring AOP，需要添加额外的扩展：
xmlns:aop="http://www.springframework.org/schema/aop"http://www.springframework.org/schema/aophttps://www.springframework.org/schema/aop/spring-aop.xsd
<?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
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 注册bean -->
<bean id="userService" class="com.yun.service.UserServiceImpl"/>
<bean id="beforeLog" class="com.yun.log.BeforeLog"/>
<bean id="afterReturnLog" class="com.yun.log.AfterReturnLog"/>
<!-- aop实现方式一：使用原生Spring API接口 -->
<aop:config>
<!-- pointcut：表示切入点，即要切入的方法，expression属性值是一个execution表达式，该表达式其实就是一个方法定义格式：修饰符 返回值类型 方法签名，
如果不想指定修饰符和返回值，可以直接写星号*，UserServiceImpl.*表示UserServiceImpl中的所有方法，(..)表示方法的任意参数 -->
<aop:pointcut id="pointcut" expression="execution(* com.yun.service.UserServiceImpl.*(..))"/>
<!-- advisor：执行环绕，即在要切入的方法执行前后或其他位置进行切入执行，advice-ref表示“环绕”的类对象（需要实现对应的方法） -->
<aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterReturnLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
输出：
before：com.yun.service.UserServiceImpl.add
Add a user.
com.yun.service.UserServiceImpl.add的返回结果为：null
2. AOP实现方式二：自定义类实现AOP
自定义类的方式可以指定自定义的类中哪些方法在“前”执行，哪些方法在“后”执行。
自定义类：
package com.yun.custom;
public class MyPointCut {
public void before(){
System.out.println("--------before-------");
}
public void after(){
System.out.println("--------after-------");
}
}
xml配置：
<?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
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 注册bean -->
<bean id="userService" class="com.yun.service.UserServiceImpl"/>
<bean id="myPointCut" class="com.yun.custom.MyPointCut"/>
<!-- aop实现方式二：使用自定义类 -->
<aop:config>
<!-- 配置切面，即自定义的类 -->
<aop:aspect ref="myPointCut">
<!-- 配置切入点，即被“包裹”的方法，也是使用execution表达式 -->
<aop:pointcut id="pointcut" expression="execution(* com.yun.service.UserServiceImpl.*(..))"/>
<!-- 配置在切入点之前执行的方法 -->
<aop:before method="before" pointcut-ref="pointcut"/>
<!-- 配置在切入点之后执行的方法 -->
<aop:after method="after" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
</beans>
输出：
--------before-------
Add a user.
--------after-------
3. AOP实现方式三：注解
注解的方式更加直观明了，而且同样会使用execution表达式，但是请注意，需要在xml中声明aop自动代理支持。
注解使用：
package com.yun.annotation;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
// 指定切面
@Aspect
public class AnnotationPointcut {
// 在切入点之前执行，参数为execution表达式
@Before("execution(* com.yun.service.UserServiceImpl.*(..))")
public void before(){
System.out.println("--------before-------");
}
// 在切入点之后执行，参数为execution表达式
@After("execution(* com.yun.service.UserServiceImpl.*(..))")
public void after(){
System.out.println("--------after-------");
}
}
xml配置：特别注意，需要声明使用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
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 注册bean -->
<bean id="userService" class="com.yun.service.UserServiceImpl"/>
<bean id="annotationPointcut" class="com.yun.annotation.AnnotationPointcut"/>
<!-- 声明使用aop自动代理 -->
<aop:aspectj-autoproxy/>
</beans>
输出：
--------before-------
Add a user.
--------after-------
