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()方法，从而阻塞对通知方法的访问。