【Spring实战【面向切面的Spring】1.5使用注解创建切面

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

@Aspect
public class Audience {
    @Before("execution(**concert.Performance.perform(..))")
    public void silenceCellPhones() {
        System.out.println("Silencing cell phones");
    }

    @Before("execution(**concert.Performance.perform(..))")
    public void takeSeats() {
        System.out.println("Taking seats");
    }

    @AfterReturning("execution(**concert.Performance.perform(..))")
    public void applause() {
        System.out.println("CLAP CLAP CLAP!!!");
    }

    @AfterThrowing("execution(**concert.Performance.perform(..))")
    public void demandRefund() {
        System.out.println("CLAP CLAP CLAP!!!");
    }
    }

该注解表明Audience不仅仅是一个POJO，还是一个切面。
Audience类中的方法都使用注解来定义切面的具体行为。

package com.spring.cut;

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

@Aspect
public class Audience {
    /**
     * 定义命名的切点
     */
    @Pointcut("execution(**concert.Performance.perform(..))")
    public void performace() {
    }

    /**
     * 表演之前
     */
    @Before("performace() ")
    public void silenceCellPhones() {
        System.out.println("Silencing cell phones");
    }

    @Before("performace() ")
    public void takeSeats() {
        System.out.println("Taking seats");
    }

    /**
     * 表演之后
     */
    @AfterReturning("performace() ")
    public void applause() {
        System.out.println("CLAP CLAP CLAP!!!");
    }

    /**
     * 表演失败之后
     */
    @AfterThrowing("performace() ")
    public void demandRefund() {
        System.out.println("CLAP CLAP CLAP!!!");
    }
    }

@Bean
public Audience. audience(){
 return new Audience();
}

@Configuration
@EnableAspectJAutoproxy//启用AspectJ自动代理
@ComponentScan
public class ConcertConfig{
   @Bean//声明Audience bean
   public Audience audience(){
      return new Audience();
   }
}

package com.spring.cut;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class Audience {
    /**
     * 定义命名的切点
     */
    @Pointcut("execution(**concert.Performance.perform(..))")
    public void performace(){}

    /**
     * 环绕通知方法
     */
    @Around("performace()")
    public void watchperformance(ProceedingJoinPoint jp){
        try{
            System.out.println("Silencing cell phones");
            System.out.println("Taking seats");
            //通知控制权转移
            jp.proceed();
            System.out.println("CLAP CLAP CLAP!!!");
        }catch (Throwable e){
            System.out.println("Demanding a refund");
        }
    }
}

唯一的例外是我们为环绕通知所编写的watchPerformance ()示例方法中使用了  ProceedingJoinPoint作为参数。
   除了环绕通知，我们编写的其他通知不需要关注传递给被通知方法的任意参数。这很正常，因为我们所通知的perform()方法本身没有任何参数。

package com.spring.cut;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

import java.util.HashMap;
import java.util.Map;

/**
 * @author huyang
 */
@Aspect
public class TrackCounter {

    private Map trackCounts = new HashMap();

    /**
     * 通知play-Track()方法，切面使用@Pointcut注解定义命名 的切点
     *
     * @param trackNumbers
     */
    @Pointcut("execution(* com.spring.cut(int))" + "&& args(trackNumbers)")
    public void trackPlayed(int trackNumbers) {
    }

    /**
     * 在播放前，为该磁道计数
     *用@Before将一个方法声明为前置通知
     *
     * @param trackNumbers
     */
    @Before("trackPlayed(trackNumbers)")
    public void countTrack(int trackNumbers) {
        int currentCount = getPlayCount(trackNumbers);
        trackCounts.put(trackNumbers, currentCount + 1);
    }

    public int getPlayCount(int trackNumbers) {
        return trackCounts.containsKey(trackNumbers) ? trackCounts.get(trackCounts) : 0;
    }


}

切点表达式中的args (trackNumber)限定 符。它表明传递给playTrack()方法的int类型参数也会传递到通 知中去。
   参数的名称trackNumber也与切点方法签名中的参数相匹配。
   这个参数会传递到通知方法中，这个通知方法是通过@Before注解 和命名切点trackPlayed(trackNumber)定义的。
   切点定义中的 参数与切点方法中的参数名称是一样的，这样就完成了从命名切点到通知方法的参数转移。

package com.spring.cut;

import com.spring.CompactDisc;
import com.spring.Constant.BlankDisc;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

import java.util.ArrayList;
import java.util.List;

/**
 * @author huyang
 */
@Configuration
@EnableAspectJAutoProxy
public class TrackCounterConfig {

    @Bean
    public CompactDisc sgtPeppers() {
        BlankDisc cd = new BlankDisc();
        cd服务器托管网.setTitle("Sgt");
        cd.setArtist("The Beatles");
        List tracks = new ArrayList();
        tracks.add("Sgt");
        tracks.add("With a Little Help from my Friends");
        tracks.add("Getting Better");
        tracks.add("Fixing a Hole");
        cd.setTracks(tracks);
        return cd;
    }

    public TrackCounter trackCounter() {
        return new TrackCounter();
    }
}

package com.spring.cut;

import com.spring.CompactDisc;
import org.aspectj.lang.annotation.AfterThrowing;
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;

import static junit.framework.TestCase.assertEquals;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = TrackCounterConfig.class)
public class TrackCounterConfigTest {

    @Autowired
    private CompactDisc cd;

    @Autowired
    private TrackCounter counter;

    @Test
    public void testTrackCounter(){
        cd.playTrack(1);
        cd.playTrack(2);
        cd.playTrack(3);
        cd.playTrack(3);
        cd.playTrack(7);
        
        assertEquals(1,counter.getPlayCount(1));
        assertEquals(1,counter.getPlayCount(1));
        assertEquals(1,counter.getPlayCount(1));
        assertEquals(1,counter.getPlayCount(1));
    }
}

我们需要注意的是，当引入接口的方法被调用时，代理会把此调用委 托给实现了新接口的某个其他对象。实际上，一个bean的实现被拆分到了多个类中。

package com.spring.cut;

/**
 * @author huyang
 */
public interface Encoreable {
    void performEncore();
}

package com.spring.cut;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;

/**
 * @author huyang
 */
@Aspect
public class EncoreableIntroducer {

    @DeclareParents(value = "com.spring.cut",defaultImpl=DEfaultEncoreable.class)
    public static Encoreable encoreable;
}

在本例中，也就是所有实现Performance的类型。  (标记符后面的加号表示 是Performance的所有子类型，而不是Performance本身。)

在这里，我们指定的是DefaultEncoreable提供实现。

在这里，我们所引入的是Encoreable接口。