Sping——使用注解创建切面

为讲解例子，我们首先定义一个Performance接口：

 package aoptest;

 public interface Performance {
     public void perform();
 }

再定义一个该接口的实现：

 package aoptest;

 public class PianoPerform implements Performance {

     @Override
     public void perform() {
         // TODO Auto-generated method stub
         System.out.println("i am playing piano");
     }

 }

在创建切面之前，我们先来看一下切点表达式的用法，如图所示：

关于切点表达式的更多用法，可查看相关文档。

接着，我们使用注解定义一个切面，Audience类会在perform方法执行前后织入指定的方法：

 package aoptest;

 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.*;

 @Aspect
 public class Audience {

     @Pointcut("execution(** aoptest.Performance.perform(..))")
     public void performance() {}
     //performance()方法的实际内容并不重要，在这里它是空的。
     //其实该方法本身只是一个标识，供@Pointcut注解依附
     //不这样做的话，就需要在每个方法前都使用这个长点的表达式

     @Before("performance()")
     public void silenceCellPhones() {
         System.out.println("Slience cell phones");
     }

     @Before("performance()")
     public void takeSeats() {
         System.out.println("takeSeats");
     }

     @AfterReturning("performance()")
     public void applause() {
         System.out.println("applause");
     }

     @AfterThrowing("performance()")
     public void demandRefund() {
         System.out.println("demandRefund");
     }
 }

• @Before:通知方法会在目标方法调用之前调用
• @AfterReturning:通知方法在目标方法成功返回后调用
• @AfterThrowing:通知方法在目标方法抛出异常后调用
• @Around:通知方法会将目标方法封装起来

接着，进行测试，首先使用JavaConfig进行相关bean的配置：

 package aoptest;

 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;

 @Configuration
 @EnableAspectJAutoProxy   //启用aspectJ自动代理
 @ComponentScan
 public class AopConfig {
     @Bean
     public Audience audience() {
         return new Audience();
     }

     @Bean
     Performance performance() {
         return new PianoPerform();
     }
 }

然后，创建测试类：

 package aoptest;

 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;

 //用于在测试开始时自动创建Spring上下文
 @RunWith(SpringJUnit4ClassRunner.class)
 //告诉上下文需要在AopConfig中加载配置
 @ContextConfiguration(classes = { AopConfig.class })
 public class PerformTest {
     @Autowired
     public Audience audience;
     @Autowired
     public Performance performance;
         @Test
         public void play() {
             performance.perform();
     }
 }

测试结果，符合预期：

现在，我们利用@Around创建环绕通知，重新实现切面，可以达到相同的效果：

package aoptest;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class Audience {

    @Pointcut("execution(** aoptest.Performance.perform(..))")
    public void performance() {}
    //performance()方法的实际内容并不重要，在这里它是空的。
    //其实该方法本身只是一个标识，供@Pointcut注解依附
    //不这样做的话，就需要在每个方法前都使用这个长点的表达式

    @Around("performance()")
        //ProceedingJoinPoint这个对象是必须有的，因为需要通过它来调用被通知的方法，使用proceed()方法
    public void watchPerformance(ProceedingJoinPoint jp) {
        System.out.println("Slience cell phones");
        System.out.println("takeSeats");
        try {
            jp.proceed();
        } catch (Throwable e) {
            System.out.println("demandRefund");
        }
        System.out.println("applause");
    }
}

当然，你也可以不调用proceed()方法，从而阻塞对通知方法的访问。