Spring AOP之使用注解創建切面

上節中我們已經定義了Performance接口，他是切面中的切點的一個目標對象。那么現在就讓我們使用AspectJ注解來定義切面吧。

1.定義切面

下面我們就來定義一場舞臺劇中觀眾的切面類Audience：

package com.spring.aop.service.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

/**
 * <dl>
 * <dd>Description:觀看演出的切面</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：2016年9月3日 下午9:58:09</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 */
@Aspect
public class Audience {

    
    /**
     * 目標方法執行之前調用
     */
    @Before("execution(** com.spring.aop.service.perform(..))")
    public void silenceCellPhone() {
        System.out.println("Silencing cell phones");
    }

    /**
     * 目標方法執行之前調用
     */
    @Before("execution(** com.spring.aop.service.perform(..))")
    public void takeSeats() {
        System.out.println("Taking seats");
    }

    /**
     * 目標方法執行完后調用
     */
    @AfterReturning("execution(** com.spring.aop.service.perform(..))")
    public void applause() {
        System.out.println("CLAP CLAP CLAP");
    }

    /**
     * 目標方法發生異常時調用
     */
    @AfterThrowing("execution(** com.spring.aop.service.perform(..))")
    public void demandRefund() {
        System.out.println("Demanding a refund");
    }

}

我們可以看到使用了幾種注解，其實AspectJ提供了五中注解來定義通知：

注解 通知
@After 通知方法會在目標方法返回或拋出異常后調用
@AfterRetruening 通常方法會在目標方法返回后調用
@AfterThrowing 通知方法會在目標方法拋出異常后調用
@Around 通知方法將目標方法封裝起來
@Before 通知方法會在目標方法執行之前執行

聰明的你可能已經看到，同樣的切點我們寫了四遍，這是不科學的，強大的Spring怎么會沒有處理的方法呢。其實我們可以使用@Pointcut注解聲明一個通用的切點，在后面可以隨意使用：

package com.spring.aop.service.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

/**
 * <dl>
 * <dd>Description:觀看演出的切面</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：2016年9月3日 下午9:58:09</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 */
@Aspect
public class Audience {

    /**
     * 定義一個公共的切點
     */
    @Pointcut("execution(** com.spring.aop.service.Perfomance.perform(..))")
    public void performance() {
    }

    /**
     * 目標方法執行之前調用
     */
    @Before("performance()")
    public void silenceCellPhone() {
        System.out.println("Silencing cell phones");
    }

    /**
     * 目標方法執行之前調用
     */
    @Before("performance()")
    public void takeSeats() {
        System.out.println("Taking seats");
    }

    /**
     * 目標方法執行完后調用
     */
    @AfterReturning("performance()")
    public void applause() {
        System.out.println("CLAP CLAP CLAP");
    }

    /**
     * 目標方法發生異常時調用
     */
    @AfterThrowing("performance()")
    public void demandRefund() {
        System.out.println("Demanding a refund");
    }

}

這樣定義一個切點后，后面我們的方法想使用這個切點直接調用切點所在的方法就行了。實際上切面也是一個Java類，我們可以將它裝配到Spring中的bean中：

/**
 * 聲明Audience bean
 * @return
 */
@Bean
public Audience audience(){
    return new Audience();
}

但是現在Spring還不會將Audience視為一個切面，即便使用了@AspectJ注解，但它并不會被視為一個切面們這些注解不會被解析，也不會創建將其轉化為切面的代理。但我們可以使用JavaConfig，然后在JavaConfig類上使用注解@EnableAspectJAutoProxy注解啟動自動代理功能：

package com.spring.aop.config;

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

import com.spring.aop.service.aop.Audience;

/**
 * <dl>
 * <dd>Description:配置類</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：2016年9月3日 下午10:20:11</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 */

@Configuration
//啟動AspectJ自動代理
@EnableAspectJAutoProxy
@ComponentScan
public class ConcertConfig {
    
    /**
     * 聲明Audience bean
     * @return
     */
    @Bean
    public Audience audience(){
        return new Audience();
    }

}

如果你想使用XML配置也是可以的,我們要使用Spring aop命名空間中的<aop:aspectj-autoproxy>元素：

<?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:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:task="http://www.springframework.org/schema/task"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/cache
        http://www.springframework.org/schema/cache/spring-cache.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd">
    

    <context:component-scan base-package="com.spring.aop" />\
    
    <!-- 啟動AspectJ自動代理 -->
    <aop:aspectj-autoproxy/>
    
    <bean class="com.spring.aop.Audience" />
</beans>

其實不管使用JAvaConfig還是Xml，AspectJ都會為使用@ApsectJ注解的Bean創建一個代理，這個代理會環繞著所有該切面所匹配的bean。

2.創建環繞通知

環繞通知是這幾種通知中相對復雜的一種，它可以在一個同時中同時編寫前置和后置通知：

/**
 * 環繞通知
 * @param jp 通過它調用目標方法
 */
@Around("perforance()")
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");
    }
}

3.處理通知中的參數

其實我們可以使用指示器args為切面中的方法傳遞參數，比如我們想統計唱片中每首歌曲的播放次數，這時我們想使用切面來完成這個工作，我們就需要向切面傳遞一個歌曲的編號，這時我們可以通過args向切面中的方法傳遞參數：

package com.spring.aop.service.aop;

import java.util.HashMap;
import java.util.Map;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

/**
 * <dl>
 * <dd>Description:統計每首歌曲播放次數的AOP</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：2016年9月4日 上午8:19:24</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 */
@Aspect
public class TrackCounter {
        
    private Map<Integer,Integer> trackCounts = new HashMap<Integer,Integer>();
    
    @Pointcut("execution(* com.spring.aop.service.CompactDisc.playTrack(int)) && args(trackNumber)")
    public void trackPlayed(int trackNumber){}
    
    @Before("trackPlayed(trackNumber)")
    public void countTrack(int trackNumber){
        int currentCount = getPlayCount(trackNumber);
        trackCounts.put(trackNumber, currentCount+1);
    }
    
    public int getPlayCount(int trackNumber) {
        return trackCounts.containsKey(trackNumber)?trackCounts.get(trackNumber):0;
        
    }
    
}

然后我們將這個切面配置到Spring中：

package com.spring.aop.config;

import java.util.List;

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

import com.google.common.collect.Lists;
import com.spring.aop.service.CompactDisc;
import com.spring.aop.service.aop.TrackCounter;
import com.spring.aop.service.impl.BlankDisc;

/**
 * <dl>
 * <dd>Description:顯示配置播放歌曲的bean和記錄播放次數的AOP</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：2016年9月4日 上午8:52:05</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 */
@Configuration
@EnableAspectJAutoProxy
public class TrackCounterConfig {
    
    @Bean
    public CompactDisc sgtPeppers(){
        BlankDisc cd = new BlankDisc();
        cd.setTitle("Sgt. Pepper's Lonely Hearts Club Band");
        cd.setArtist("The Beatles");
        
        List<String> tracks = Lists.newArrayList();
        tracks.add("Sgn. Pepper's Lonelu Hears Club Band");
        tracks.add("Wiith a Litter Help from My Friends");
        tracks.add("Lucy in the Sky with Diamonds");
        tracks.add("Getting Better");
        tracks.add("Fixing a Hole");
        
        //...other tracks omitted for brevity ...
        cd.setTracks(tracks);
        return cd;
    }
    
    @Bean
    public TrackCounter trackCOunter(){
        return  new TrackCounter();
    }
}

為了證明他能夠正常運行我們編寫一個測試類進行測試：

package service;

import static org.junit.Assert.assertEquals;

import org.junit.Rule;
import org.junit.Test;
import org.junit.contrib.java.lang.system.StandardOutputStreamLog;
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 com.spring.aop.config.TrackCounterConfig;
import com.spring.aop.service.CompactDisc;
import com.spring.aop.service.aop.TrackCounter;

/**
 * <dl>
 * <dd>Description: 測試統計歌曲播放的AOP</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：2016年9月4日 上午9:08:09</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = TrackCounterConfig.class)
public class TrackCounterTest {

    @SuppressWarnings("deprecation")
    @Rule
    public final StandardOutputStreamLog log = new StandardOutputStreamLog();
    
    @Autowired
    private CompactDisc cd;
    
    @Autowired 
    private TrackCounter counter;
    
    @Test
    public void testTrackCounter(){
        cd.playTrack(1);
        cd.playTrack(2);
        cd.playTrack(3);
        cd.playTrack(4);
        cd.playTrack(2);
        cd.playTrack(4);
        cd.playTrack(2);
        
        assertEquals(1,counter.getPlayCount(1));
        assertEquals(3,counter.getPlayCount(2));
        assertEquals(1,counter.getPlayCount(3));
        assertEquals(2,counter.getPlayCount(4));
        assertEquals(0,counter.getPlayCount(5));
        assertEquals(0,counter.getPlayCount(0));
    }
}

運行后確定我們的代碼是正確的！

4.通過注解引入新功能

像Java這種靜態語言，一般一般類定義完成后，類中的方法屬性就已經確定了，如果我們想要為這些類添加新方法、功能，就可以使用Spring Aop。現在我們想為所有的Performance實現引入下面的Encoreable接口：

package com.spring.aop.service;
/**
 * <dl>
 * <dd>Description:添加新功能</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：2016年9月4日 上午9:48:36</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 */
public interface Encoreable {
    
    void performEncore();
}

要實現該功能我們要創建一個新的切面：

package com.spring.aop.service.aop;

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

import com.spring.aop.service.Encoreable;
import com.spring.aop.service.impl.DefaultEncoreable;

/**
 * <dl>
 * <dd>Description:為目標bean添加新功能的AOP bean</dd>
 * <dd>Company: 黑科技</dd>
 * <dd>@date：201
 6年9月4日 上午9:45:34</dd>
 * <dd>@author：Kong</dd>
 * </dl>
 */
@Aspect
public class EncoreableIntroducer {
    
    @DeclareParents(value="com.spring.aop.service.Perforance+",defaultImpl=DefaultEncoreable.class)
    public static Encoreable encoreable;

}

我們可以看到在切面中它并沒有使用前置、后置等通知的注解，而是使用了@DeclareParents注解，將Encoreable接口引入到Performance bean中。
@DeclareParents注解由三部分組成：

  • value屬性指定了哪種類型的bean要引入該接口（加號表示是Performance的所有子類）。
  • defaultImpl屬性指定了為引入功能提供實現類
  • @DeclareParents注解所標注的靜態屬性指明了要引入了接口，在這里，我們所引入的是Encoreable接口。

和其他切面一樣，我們需要在Spring應用中將EncoreableIntroducer聲明為一個bean：
<bean class="com.spring.aop.service.aop.EncoreableIntroducer" />
至此在Java類中配置切面的內容已經全部介紹完了，下節我們會介紹在XML中配置切面,一定很期待吧，那就趕緊來啊......

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • 本章內容： 面向切面編程的基本原理 通過POJO創建切面 使用@AspectJ注解 為AspectJ切面注入依賴 ...
    謝隨安閱讀 3,203評論 0贊 9
  • Spring Cloud為開發人員提供了快速構建分布式系統中一些常見模式的工具（例如配置管理，服務發現，斷路器，智...
    卡卡羅2017閱讀 134,993評論 19贊 139
  • 當他不愛你的時候，你的愛便是他的負擔。請不要去計算自己的付出，不要希望有什么回報。 愛著不愛自己的人...
    風雨一起走閱讀 112評論 0贊 0
  • 今兒個見的客戶很特別，她讓我了解一個新定義，顛覆誰并不是讓誰消失，是這個誰在別人的價值鏈中被邊緣化了，如：有了微信...
    呂明超閱讀 145評論 0贊 0
  • 這兩天脾氣爆了。昨天只看待產孕婦求剖腹產未果跳樓自殺的新聞，就有了想拿刀把那些逼得孕婦跳樓的家屬給劈了。今天突然又...
    大漠鈴兒響閱讀 423評論 0贊 0