Spring AOP

AOP简介

AOP的全称是 Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。

AOP作用

在软件开发中，散布于应用中多处的功能被称为横切关注点，通常来讲，这些横切关注点从概念上是与应用的业务逻辑相分离的(但是往往会直接嵌入到应用的业务逻辑之中)，比如通常会进行事务处理、日志记录等操作。在OOP设计中，它们导致了大量代码的重复，而不利于各个模块的重用；但在面向切面编程中，我们仍然在一个地方定义这些功能，但是可以通过声明的方式定义这些功能要以何种方式在何处使用，而无需修改受影响的类，这样使得服务模块更加简洁，因为这些次要关注点的代码已经被转移到切面中了。

AOP相关术语

1.Aspect（切面）：是通知和切点的结合，共同定义了切面的全部内容——它是什么，在何时和何处完成其功能。
2.Joinpoint（连接点）：是应用执行过程中能够插入切面的一个点，切面代码可以利用这些点插入到应用的正常流程之中来添加新的行为，也就是指方法的调用。
3.Pointcut（切入点）：定义了切面中何处完成其功能，即在哪些类以及哪些方法上切入。
4.Advice（通知/增强处理）：定义了切面中何时做什么功能。比如应该在目标方法被调用之前、之后还是抛出异常后调用通知？
5.Introduction（引入）：在不修改代码的前提下，允许我们向现有的类添加新方法或属性。
6.Weaving（织入）：是把切面应用到目标对象并创建新的代理对象的过程。

相关通知类型

1.@After：通知方法会在目标方法返回或抛出异常后调用。
2.@AfterReturning：通知方法会在目标方法返回后调用。
3.@AfterThrowing：通知方法会在目标方法抛出异常后调用。
4.@Around：通知方法会将目标方法封装起来。
5.@Before：通知方法会在目标方法调用之前执行。

使用注解创建切面

现在模拟一个场景，在某个演出中我们需要引入观众的一些反应，这里演出是核心功能，而观众的反应是次要功能，因此要将观众定义为一个切面并应用到表演家演出上。
1.AOP相关的pom依赖

    
      org.springframework
      spring-aop
      5.0.7.RELEASE
    
    
      aopalliance
      aopalliance
      1.0
    
    
      org.aspectj
      aspectjweaver
      1.9.1
    
    
      org.springframework
      spring-aspects
      5.0.7.RELEASE
    

2.创建表演类

@Component("performance") //声明为一个bean
public class Performance {
    public void perform(){
        System.out.println("表演家正在表演中!");
    }
}

3.创建观众类

@Component("audience") //声明为一个bean
@Aspect //声明此类是个切面
public class Audience {
    /**
     * 表演家演出前需要的观众反应
     */
    @Before("execution(* com.mybean.concert.Performance.perform())")
    public void beforePerform(){
        System.out.println("观众入席!");
        System.out.println("观众手机调至静音!");
    }

    /**
     * 表演家演出成功后需要的观众反应
     */
    @AfterReturning("execution(* com.mybean.concert.Performance.perform())")
    public void afterReturningPerform(){
        System.out.println("观众鼓掌!");
    }

    /**
     * 表演家演出出状况后需要的观众反应
     */
    @AfterThrowing("execution(* com.mybean.concert.Performance.perform())")
    public void afterThrowingPerform(){
        System.out.println("观众要求退款!");
    }
}

可以看出我们在频繁地使用切点表达式，可以用@Pointcut使代码变得简介：

@Component("audience")
@Aspect
public class Audience {

    @Pointcut("execution(* com.mybean.concert.Performance.perform())")
    public void performance(){
    }

    @Before("performance()")
    public void beforePerform(){
        System.out.println("观众入席!");
        System.out.println("观众手机调至静音!");
    }

    @AfterReturning("performance()")
    public void afterReturningPerform(){
        System.out.println("观众鼓掌!");
    }

    @AfterThrowing("performance()")
    public void afterThrowingPerform(){
        System.out.println("观众要求退款!");
    }
}

通过两个注解可以看出，虽然此类被声明为一个切面，但是它仍然能够像普通类一样被其他java类调用，它的方法也能够进行独立的单元测试，只不过@Aspect表明它会被作为切面使用而已，这里还将它声明为一个bean。

4.在配置类上启动注解的自动代理

@Configuration //说明此类是个配置类
@ComponentScan //启动组件扫描
@EnableAspectJAutoProxy //启用Aspect自动代理
public class BeanConfig {
}

5.测试

public class App {
    public static void main( String[] args ) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanConfig.class);
        Performance performance = (Performance) applicationContext.getBean("performance");
        performance.perform();
    }
}

控制台打印结果如下：

截图

创建环绕通知

环绕通知是最为强大的通知类型，它能够让你编写的逻辑将被通知的目标方法完全包装起来。实际上就像在一个通知方法中同时编写前置通知和后置通知。
例如上方的观众类可写为：

@Component("audience")
@Aspect
public class Audience {

    @Pointcut("execution(* com.mybean.concert.Performance.perform())")
    public void performance(){
    }

    @Around("performance()")
    public void aroundPerformance(ProceedingJoinPoint joinPoint) {
        try {
            System.out.println("观众入席!");
            System.out.println("观众手机调至静音!");
            joinPoint.proceed();
            System.out.println("观众鼓掌!");
        } catch (Throwable e) {
            System.out.println("观众要求退款!");
        }
    }
}

其它代码不变，运行后控制台结果和上方一样。
其中通过ProceedingJoinPoint来调用被通知的方法，当要将控制权交给被通知的方法时(这里指表演类的表演方法)，需要调用ProceedingJoinPoint的proceed()方法。

处理通知中的参数

如果被通知的方法中有参数，且切面需要使用到这些参数呢？接着上面的情景，如果表演家表演的内容需要被指定，通过以下例子切面能够获得被通知方法中的参数：

@Component("performance")
public class Performance {
    public void perform(String performanceName){
        System.out.println("表演家正在演奏" + performanceName);
    }
}

@Component("performanceNumber")
@Aspect
public class PerformanceNumber {

    @Pointcut("execution(* com.mybean.concert.Performance.perform(String))" + "&& args(performanceName)")
    public void performance(String performanceName){
    }

    @Before("performance(performanceName)")
    public void beforePerform(String performanceName){
        System.out.println("观众入席!");
        System.out.println("观众手机调至静音!");
    }

    @AfterReturning("performance(performanceName)")
    public void afterReturningPerform(String performanceName){
        System.out.println("观众为表演家演奏的" + performanceName + "节目鼓掌!");
    }

    @AfterThrowing("performance(performanceName)")
    public void afterThrowingPerform(String performanceName){
        System.out.println("观众要求退款!");
    }
}

args(performanceName)表明传递给perform()方法的string类型的参数也会传递到通知去，参数的名称performanceName也与切点方法签名中的参数相匹配。

如果是环绕通知，则：

@Component("performanceNumber")
@Aspect
public class Audience {

    @Pointcut("execution(* com.mybean.concert.Performance.perform(String))")
    public void performance(){
    }

    @Around("performance()")
    public void aroundPerformance(ProceedingJoinPoint joinPoint) {
        try {
            System.out.println("观众入席!");
            System.out.println("观众手机调至静音!");
            joinPoint.proceed();
            Object[] args = joinPoint.getArgs();
            System.out.println("观众为表演家演奏的" + args[0] + "节目鼓掌!");
        } catch (Throwable e) {
            System.out.println("观众要求退款!");
        }
    }
}

部分ProceedingJoinPoint对象的方法信息如下：

截图

测试：

public class App {
    public static void main( String[] args ) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanConfig.class);
        Performance performance = (Performance) applicationContext.getBean("performance");
        performance.perform("钢琴");
    }
}

运行结果如下：

截图

通过注解为被通知方法引入新功能

切面可以为Spring bean添加新方法。 在Spring中，切面只是实现了它们所包装bean相同接口的代理。实际上，除了实现这些接口，代理也能暴露新接口，那样的话，切面所通知的bean看起来像是实现了新的接口，即便底层实现类并没有实现这些接口也无所谓。
先引入新接口和对应的实现：

public interface Encoreable {
    void performEncore();
}

@Component("encoreableImpl")
public class EncoreableImpl implements Encoreable{

    @Override
    public void performEncore() {
        System.out.println("添加的新方法");
    }
}

创建一个用于注入新方法的切面EncoreableIntroducer:

@Component("encoreableIntroducer")
@Aspect
public class EncoreableIntroducer {

    @DeclareParents(value="com.mybean.concert.Performance+",defaultImpl= EncoreableImpl.class)
    public static Encoreable encoreable;
}

可以看到，EncoreableIntroducer是一个切面，但是它与我们之前所创建的切面不同，它并没有提供前置、后置或环绕通知，而是通过@DeclareParents注解，将Encoreable接口引入 到Performance bean中。@DeclareParents注解由三部分组成：
1.value属性：指定了哪种类型的bean要引入该接口。
2.defaultImpl：指定了为引入功能提供实现的类。
3.@DeclareParents：所标注的静态属性指明了要引入的接口。

测试：

public class App {
    public static void main( String[] args ) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanConfig.class);
        Performance performance = (Performance) applicationContext.getBean("performance");
        ((Encoreable) performance).performEncore();
    }
}

控制台打印如下，说明Encoreable的方法已经添加到Performance中，注意要进行强制转换：

截图

在xml中声明切面

如果需要声明切面，但是又不能为通知类添加注解的时候，就必须转向xml配置了。
去掉上面类的@Aspect和@Component注解后，把声明bean和切面全在xml文件中配置：

如果用pointcut，则：

如果是声明环绕通知，则：

如果是为通知传递参数，则：

因为“&”在xml中有特殊含义，是转义字符的前缀，所以用and来代替“&&”。

如果要通过切面引入新功能，则：