文档章节

Spring AOP 之二:Pointcut注解表达式

trayvon
 trayvon
发布于 2017/06/30 20:18
字数 1543
阅读 3070
收藏 0

简介

Spring AOP概述中我们重点注意的是AOP的整体流程和Advice,简化了一些其他的东西,其中就有一些对灵活应用Spring AOP很重要的知识点,例如Pointcut表达式,下面就介绍一下Spring AOP的Pointcut表达式。

如果你对Pointcut表达式的作用还不是很了解,可以先看一下Spring AOP概述,也可以先了解一下匹配规则,后面会有一些具体的例子来帮助理解。

我们使用最多的就是execution表示了,下面就从execution表达式开始介绍吧。

注意:把designators翻译为表达式也许不太合适,所以不必纠结这个问题,只需要知道在看到Spring AOP中的designators知道对应的是个什么东西就可以了。管它是表达式还是指示器只是一个代称而已。

execution表达式

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern)
throws-pattern?)

上面的就是execution表达式的格式,execution匹配的就是连接点(Joinpoint,一般是方法),看上面的表达式execution是固定的,方法的修饰符是可选的,返回类型是必须的,定义的全限类型也是可选的,名称是必须的,参数是必须的,这些都可以使用通配符。

任何的public方法

execution(public * *(..))

以set开始的方法

execution(* set*(..))

定义在cn.freemethod.business.pack.Say接口中的方法

execution(* cn.freemethod.business.pack.Say.*(..))

任何cn.freemethod.business包中的方法

execution(* cn.freemethod.business.*.*(..))

任何定义在com.xyz.service包或者其子包中的方法

execution(* cn.freemethod.business..*.*(..))

其他表达式

任何在com.xyz.service包中的方法

within(com.xyz.service.*)

任何定义在com.xyz.service包或者其子包中的方法

within(com.xyz.service..*)

任何实现了com.xyz.service.AccountService接口中的方法

this(com.xyz.service.AccountService)

任何目标对象实现了com.xyz.service.AccountService的方法

target(com.xyz.service.AccountService)

一般情况下代理类(Proxy)和目标类(Target)都实现了相同的接口,所以上面的2个基本是等效的。

有且只有一个Serializable参数的方法

args(java.io.Serializable)

只要这个参数实现了java.io.Serializable接口就可以,不管是java.io.Serializable还是Integer,还是String都可以。

目标(target)使用了@Transactional注解的方法

@target(org.springframework.transaction.annotation.Transactional)

目标类(target)如果有Transactional注解中的所有方法

@within(org.springframework.transaction.annotation.Transactional)

任何方法有Transactional注解的方法

@annotation(org.springframework.transaction.annotation.Transactional)

有且仅有一个参数并且参数上类型上有Transactional注解

@args(org.springframework.transaction.annotation.Transactional)

注意是参数类型上有Transactional注解,而不是方法的参数上有注解。

bean的名字为tradeService中的方法

bean(simpleSay)

bean名字为simpleSay中的所有方法。

bean名字能匹配

bean(*Impl)

bean名字匹配*Impl的bean中的所有方法。

实例

这个实例是对Spring AOP概述中介绍的实例进行了扩展。当然下面给的实例也可以独立测试,最好是一个一个测试观察输出了验证,多个输出结果不够直观。

下面的图片是项目工程目录结构:

工程目录结构

下面的代码列表因为比较多,可以在后面找到完整的代码工程代码的附件链接,因为其他一些原因没有放到github或者码云上,可以直接下载附件解压使用maven方式导入。

OtherPointcutAspect

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class OtherPointcutAspect {
    
//    @After("cn.freemethod.pointcut.OtherPointcut.argsSerializable()")
    public void argsSerialize(){
        System.out.println("OtherPointcutAspect argsSerialize after...");
    }
    
//    @After("cn.freemethod.pointcut.OtherPointcut.inBusinessPackage()")
    public void inBusinessPackage(){
        System.out.println("OtherPointcutAspect inBusinessPackage after...");
    }
    
//    @After("cn.freemethod.pointcut.OtherPointcut.inBusinessOrSubPackage()")
    public void inBusinessOrSubPackage(){
        System.out.println("OtherPointcutAspect inBusinessOrSubPackage after...");
    }
    
//    @After("cn.freemethod.pointcut.OtherPointcut.proxyImplementHaveResultBusinessInteferce()")
    public void proxyImplementHaveResultBusinessInteferce(){
        System.out.println("OtherPointcutAspect proxyImplementHaveResultBusinessInteferce after...");
    }
    
//    @After("cn.freemethod.pointcut.OtherPointcut.targetImplementBusinessInteferce()")
    public void targetImplementBusinessInteferce(){
        System.out.println("OtherPointcutAspect targetImplementBusinessInteferce after...");
    }
    
//    @After("cn.freemethod.pointcut.OtherPointcut.targetHaveTransactional()")
    public void targetHaveTransactional(){
        System.out.println("OtherPointcutAspect targetHaveTransactional after...");
    }
    
//    @After("cn.freemethod.pointcut.OtherPointcut.targetDeclareHaveTransactional()")
    public void targetDeclareHaveTransactional(){
        System.out.println("OtherPointcutAspect targetDeclareHaveTransactional after...");
    }
    
//    @After("cn.freemethod.pointcut.OtherPointcut.methodHaveTransactional()")
    public void methodHaveTransactional(){
        System.out.println("OtherPointcutAspect methodHaveTransactional after...");
    }
    
    @After("cn.freemethod.pointcut.OtherPointcut.argsHaveValueAnnotation()")
    public void argsHaveTransactional(){
        System.out.println("OtherPointcutAspect argsHaveValueAnnotation after...");
    }
    
//    @After("cn.freemethod.pointcut.OtherPointcut.beanName()")
    public void beanName(){
        System.out.println("OtherPointcutAspect beanName after...");
    }
    
//    @After("cn.freemethod.pointcut.OtherPointcut.matchBeanName()")
    public void matchBeanName(){
        System.out.println("OtherPointcutAspect matchBeanName after...");
    }

}

上面是一个测试Pointcut表达式的切面,很多Advice都注释了,请为了从输出中直观的了解Pointcut表达式匹配到了什么方法(Joinpoint),请根据自己的需要测试的Pointcut表达式取消添加注释。

ExecutionPointcutAspect

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class ExecutionPointcutAspect {
    
    @Before("cn.freemethod.pointcut.ExecutionPointcut.allPublicMethod()")
    public void allPublicBefore(){
        System.out.println("PointcutExpressionAspect allPublicBefore...");
    }
    
    @After("cn.freemethod.pointcut.ExecutionPointcut.allStartSayMethod()")
    public void sayAfter(){
        System.out.println("PointcutExpressionAspect sayAfter...");
    }
    
    @AfterReturning("cn.freemethod.pointcut.ExecutionPointcut.allInSayInterfaceMethod()")
    public void allInSayInterfaceMethod(){
        System.out.println("PointcutExpressionAspect allInSayInterfaceMethod...");
    }
    
    @Before("cn.freemethod.pointcut.ExecutionPointcut.allInBusinessPackage()")
    public void allInBusinessPackageBefore(){
        System.out.println("PointcutExpressionAspect all business before...");
    }
    
    @After("cn.freemethod.pointcut.ExecutionPointcut.allInBusinessOrSubPackage()")
    public void allallInBusinessOrSubPackageAfter(){
        System.out.println("PointcutExpressionAspect allallInBusinessOrSubPackageAfter...");
    }

}

ParamBean

import org.springframework.transaction.annotation.Transactional;

@Transactional
public class ParamBean {

}

HaveResultBusinessImpl

import org.springframework.stereotype.Service;

import cn.freemethod.business.HaveResultBusiness;

@Service
public class HaveResultBusinessImpl implements HaveResultBusiness {

    @Override
    public Integer getResult(Integer div) {
        System.out.println("HaveResultBusinessImpl getResult");
        Integer result = 100 / div;
        return result;
    }

}

IOtherPointcutImpl

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import cn.freemethod.bean.ParamBean;
import cn.freemethod.business.pack.IOtherPointcut;

@Transactional
@Service
public class IOtherPointcutImpl implements IOtherPointcut {

    @Override
    public Integer printInteger(Integer arg) {
        System.out.println("IOtherPointcutImpl printInteger");
        return arg;
    }


    @Override
    public void withAnotationParam(ParamBean arg) {
        System.out.println("IOtherPointcutImpl withAnotationParam");
    }

}

SimpleSay

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import cn.freemethod.business.pack.Say;

@Transactional
@Service
public class SimpleSay implements Say {

    @Override
    public String sayChiness(String name) {
        String result = "你好:" + name;
        System.out.println(result);
        return result;
    }

    @Override
    public String sayEnglish(String name) {
        String result = "Hello " + name;
        System.out.println(result);
        return result;
    }

    @Transactional
    @Override
    public String whatSay() {
        System.out.println("what say");
        return "what say";
    }

}

IOtherPointcut

import cn.freemethod.bean.ParamBean;

public interface IOtherPointcut {
    
    Integer printInteger(Integer arg);
    
    void withAnotationParam(ParamBean arg);

}

Say

public interface Say {
    
    String sayChiness(String name);
    
    String sayEnglish(String name);
    
    String whatSay();

}

HaveResultBusiness

public interface HaveResultBusiness {
    
    Integer getResult(Integer div);

}

AspectConfig

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

@Configuration
@EnableAspectJAutoProxy
@ComponentScan(basePackages = {"cn.freemethod"})
public class AspectConfig {

}

ExecutionPointcut

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

@Aspect
public class ExecutionPointcut {

    @Pointcut("execution(public * *(..))")
    public void allPublicMethod(){}
    
    @Pointcut("execution(* say*(..))")
    public void allStartSayMethod(){}
    
    @Pointcut("execution(* cn.freemethod.business.pack.Say.*(..))")
    public void allInSayInterfaceMethod(){}
    
    @Pointcut("execution(* cn.freemethod.business.*.*(..))")
    public void allInBusinessPackage(){}
    
    @Pointcut("execution(* cn.freemethod.business..*.*(..))")
    public void allInBusinessOrSubPackage(){}
    
    
}

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

@Aspect
public class OtherPointcut {
    
    @Pointcut("within(cn.freemethod.business.impl.*)")
    public void inBusinessPackage(){}
    
    @Pointcut("within(cn.freemethod.business..*)")
    public void inBusinessOrSubPackage(){}
    
    @Pointcut("this(cn.freemethod.business.HaveResultBusiness)")
    public void proxyImplementHaveResultBusinessInteferce(){}
    
    @Pointcut("target(cn.freemethod.business.HaveResultBusiness)")
    public void targetImplementBusinessInteferce(){}
    
    @Pointcut("args(java.io.Serializable)")
//    @Pointcut("args(java.lang.Integer)")
    public void argsSerializable(){}
    
    
    @Pointcut("@target(org.springframework.transaction.annotation.Transactional)")
    public void targetHaveTransactional(){}
    
    @Pointcut("@within(org.springframework.transaction.annotation.Transactional)")
    public void targetDeclareHaveTransactional(){}
    
    @Pointcut("@annotation(org.springframework.transaction.annotation.Transactional)")
    public void methodHaveTransactional(){}

    @Pointcut("@args(org.springframework.transaction.annotation.Transactional)")
    public void argsHaveValueAnnotation(){}
    
    @Pointcut("bean(simpleSay)")
    public void beanName(){}
    
    @Pointcut("bean(*Impl)")
    public void matchBeanName(){}

}

AnnotationConfigStart

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;

import cn.freemethod.business.HaveResultBusiness;
import cn.freemethod.business.pack.Say;
import cn.freemethod.config.AspectConfig;

public class AnnotationConfigStart {
    
    public static void main(String[] args) {
        AbstractApplicationContext  context = new AnnotationConfigApplicationContext(AspectConfig.class);
        HaveResultBusiness haveResultBusiness = context.getBean(HaveResultBusiness.class);
        haveResultBusiness.getResult(100);
        Say say = context.getBean(Say.class);
        say.sayChiness("tim");
        say.sayEnglish("tim");
        say.whatSay();
        context.close();
    }

}

PointcutExpressionStart

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;

import cn.freemethod.bean.ParamBean;
import cn.freemethod.business.HaveResultBusiness;
import cn.freemethod.business.pack.IOtherPointcut;
import cn.freemethod.business.pack.Say;
import cn.freemethod.config.AspectConfig;

public class PointcutExpressionStart {
    
    public static void main(String[] args) {
        AbstractApplicationContext  context = new AnnotationConfigApplicationContext(AspectConfig.class);
        IOtherPointcut iOtherPointcut = context.getBean(IOtherPointcut.class);
        iOtherPointcut.printInteger(new Integer(10));
        iOtherPointcut.withAnotationParam(new ParamBean());
        
        HaveResultBusiness haveResultBusiness = context.getBean(HaveResultBusiness.class);
        haveResultBusiness.getResult(100);
        
        Say say = context.getBean(Say.class);
        say.sayChiness("tim");
        say.sayEnglish("tim");
        say.whatSay();
        context.close();
    }

}

参考

完整工程代码

Spring AOP 之一:基本概念与流程

Spring AOP 之二:Pointcut注解表达式

Spring AOP 之三:通知(Advice)方法参数

© 著作权归作者所有

trayvon
粉丝 16
博文 141
码字总数 214168
作品 1
程序员
私信 提问
Spring AOP @AspectJ 入门实例

从Spring 2.0开始,可以使用基于schema及@AspectJ的方式来实现AOP,本文以一个简单的实例介绍了如何以@AspectJ方式在Spring中实现AOP。由于@Aspect是基于注解的,因此要求支持注解的5.0版本以...

Zero零_度
2015/04/08
198
0
Spring关于AOP的学习总结

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 https://blog.csdn.net/fengxinlinux/article/details/99228444 AOP相关术语 JoinPoint(连接...

Rotation.
08/11
0
0
Spring中的AOP(七)——基于XML配置文件方式的AOP

除了前面介绍的基于JDK1.5的注解方式来定义切面,切入点和增强处理外,Spring AOP也允许直接使用XML配置文件来管理它们。在JDK1.5之前,只能使用配置文件的方式来管理,在Spring2.X后提供了一...

摆渡者
2014/03/24
4.4K
0
SpringBoot系列之AOP实现的两种方式

AOP常用的实现方式有两种,一种是采用声明的方式来实现(基于XML),一种是采用注解的方式来实现(基于AspectJ)。 首先复习下AOP中一些比较重要的概念: Joinpoint(连接点):程序执行时的...

文文1
03/11
725
0
Spring笔记4---前置后置通知

开始聊聊注解! Spring切面可以应用5种类型的通知: 1 Before---在方法被调用之前调用通知 2 After--- 在方法完成之后调用通知,无论方法执行是否成功 3 After-returning---在方法成功执行之...

强子哥哥
2015/01/11
83
0

没有更多内容

加载失败,请刷新页面

加载更多

关于AsyncTask的onPostExcute方法是否会在Activity重建过程中调用的问题

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 本文链接:https://blog.csdn.net/XG1057415595/article/details/86774575 假设下面一种情况...

shzwork
今天
6
0
object 类中有哪些方法?

getClass(): 获取运行时类的对象 equals():判断其他对象是否与此对象相等 hashcode():返回该对象的哈希码值 toString():返回该对象的字符串表示 clone(): 创建并返此对象的一个副本 wait...

happywe
今天
6
0
Docker容器实战(七) - 容器中进程视野下的文件系统

前两文中,讲了Linux容器最基础的两种技术 Namespace 作用是“隔离”,它让应用进程只能看到该Namespace内的“世界” Cgroups 作用是“限制”,它给这个“世界”围上了一圈看不见的墙 这么一...

JavaEdge
今天
8
0
文件访问和共享的方法介绍

在上一篇文章中,你了解到文件有三个不同的权限集。拥有该文件的用户有一个集合,拥有该文件的组的成员有一个集合,然后最终一个集合适用于其他所有人。在长列表(ls -l)中这些权限使用符号...

老孟的Linux私房菜
今天
7
0
面试套路题目

作者:抱紧超越小姐姐 链接:https://www.nowcoder.com/discuss/309292?type=3 来源:牛客网 面试时候的潜台词 抱紧超越小姐姐 编辑于 2019-10-15 16:14:56APP内打开赞 3 | 收藏 4 | 回复24 ...

MtrS
今天
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部