Spring AOP之使用注解创建切面

摘要:
其实我们可以使用@Pointcut注解声明一个通用的切点,在后面可以随意使用:packagecom.spring.aop.service.aop;importorg.aspectj.lang.ProceedingJoinPoint;importorg.aspectj.lang.annotation.AfterReturning;importorg.aspectj.lang.annotation.AfterThrowing;importorg.aspectj.lang.annotation.Around;importorg.aspectj.lang.annotation.Aspect;importorg.aspectj.lang.annotation.Before;importorg.aspectj.lang.annotation.Pointcut;/****Description:观看演出的切面*Company:黑科技*@date:2016年9月3日下午9:58:09*@author:Kong**/@AspectpublicclassAudience{/***定义一个公共的切点*/@Pointcutpublicvoidperformance(){}/***目标方法执行之前调用*/@BeforepublicvoidsilenceCellPhone(){System.out.println;}/***目标方法执行之前调用*/@BeforepublicvoidtakeSeats(){System.out.println;}/***目标方法执行完后调用*/@AfterReturningpublicvoidapplause(){System.out.println;}/***目标方法发生异常时调用*/@AfterThrowingpublicvoiddemandRefund(){System.out.println;}}这样定义一个切点后,后面我们的方法想使用这个切点直接调用切点所在的方法就行了。

上节中我们已经定义了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   />
</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 />
至此在Java类中配置切面的内容已经全部介绍完了

免责声明:文章转载自《Spring AOP之使用注解创建切面》仅用于学习参考。如对内容有疑问,请及时联系本站处理。

上篇在VC中定制Doxygen注释宏ASP.NET Core笔记(4)下篇

宿迁高防,2C2G15M,22元/月;香港BGP,2C5G5M,25元/月 雨云优惠码:MjYwNzM=

相关文章

ORACLE EBS 多OU总结

1.  Form多OU实现 1)  创建一个Table,以CUX_OM_ORDER_HEADER_ALL为例 2)  创建Table的两个Synonym(一个不含_ALL,一个以_ALL结尾):CUX_OM_ORDER_HEADER和CUX_OM_ORDER_HEADER_ALL 3)  给不含_ALL的Synonym:CUX_OM_ORDER_HEADE...

swift 画虚线

1. CAShapeLayer:适用于 动态显示 虚线, 通过控制添加虚线view的 ishidden 控制虚线的显示隐藏 ///绘制虚线 ///- Parameters: ///- lineView: 添加虚线的view ///- strokeColor: 虚线颜色 ///- lineWidth: 虚线宽度...

Adroid Studio app远程升级

 手机APP开发完了,远程升级自动更新版本必不可少,不然每次更新版本就要重新安装,那就不合理了。刚开始感觉还没啥头绪,不会了就问百度,复制粘贴修修改改就搞定了,直接上代码: 首先要在AndroidManifest添加版本号。  远程升级类 package com.example.appview.Common; import android.app.Do...

Spring学习笔记(14)——SpEL

是什么 Spring表达式语言全称为“Spring Expression Language”,缩写为“SpEL”,类似于Struts2x中使用的OGNL表达式语言,能在运行时构建复杂表达式、存取对象图属性、对象方法调用等等,并能与Spring功能完美整合。 表达式语言给静态Java语言增加了动态功能。 SpEL是单独模块,只依赖于core模块,...

spring boot: spring-data-jpa (Repository/CrudRepository) 数据库操作, @Entity实体类持久化

SpringBoot实现的JPA封装了JPA的特性, Repository是封装了jpa的特性(我是这么理解的) 1在pom.xml引入mysql, spring-data-jpa依赖 2.在src/main/resource/下新建applicatoin.properties配置文件,并配置数据库连接 3.在application.properties配...

SpringBoot开发文档

一、引言 1.1 初始化配置 为了使用SSM框架去开发,准备SSM框架的模板配置。 1.2 整合第三方框架 为了Spring整合第三方框架,单独的去编写xml文件。 1.3 后期维护 后期SSM项目后期xml文件特别多,维护xml文件的成本是很高的 1.4 部署工程 SSM工程部署也是很麻烦,依赖第三方的容器 1.5 敏捷式开发 基于Java的SSM开发...