Spring中@Pointcut()的execution, @annotation等参数说明

AOP的基本概念

  1. Advice(通知、切面): 某个连接点所采用的处理逻辑,也就是向连接点注入的代码, AOP在特定的切入点上执行的增强处理。
    1. @Before:?标识一个前置增强方法,相当于BeforeAdvice的功能.
    2. @After:?final增强,不管是抛出异常或者正常退出都会执行.
    3. @AfterReturning:? 后置增强,似于AfterReturningAdvice, 方法正常退出时执行.
    4. @AfterThrowing:? 异常抛出增强,相当于ThrowsAdvice.
    5. @Around: 环绕增强,相当于MethodInterceptor.
  2. JointPoint(连接点):程序运行中的某个阶段点,比如方法的调用、异常的抛出等。
  3. Pointcut(切入点):? ?JoinPoint的集合,是程序中需要注入Advice的位置的集合,指明Advice要在什么样的条件下才能被触发,在程序中主要体现为书写切入点表达式。
  4. Advisor(增强):?是PointCut和Advice的综合体,完整描述了一个advice将会在pointcut所定义的位置被触发。
  5. @Aspect(切面):? 通常是一个类的注解,里面可以定义切入点和通知
  6. AOP Proxy:AOP框架创建的对象,代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理,也可以是CGLIB代理,前者基于接口,后者基于子类。
<aop:aspectj-autoproxy/>
   <aop:config proxy-target-class="true">
       <aop:pointcut id="servicePointcut"
                     expression="execution(* com.cpic..*Service.*(..))" />
       <aop:advisor pointcut-ref="servicePointcut" advice-ref="txAdvice"
                    order="3" />
   </aop:config>
   <tx:advice id="txAdvice" transaction-manager="transactionManager">
       <tx:attributes>
           <tx:method name="list*" read-only="true" />
           <!-- log方法会启动一个新事务 -->
           <tx:method name="log*" propagation="REQUIRES_NEW"
                      isolation="READ_COMMITTED" />
       </tx:attributes>
   </tx:advice>
 
//OK所以一个Spring增强(advisor)=切面(advice)+切入点(PointCut)

Pointcut

表示式(expression)和签名(signature)

//Pointcut表示式
@Pointcut("execution(* com.savage.aop.MessageSender.*(..))")
//Point签名
private void log(){} 

由下列方式来定义或者通过 &&、 ||、 !、 的方式进行组合:

  • execution:用于匹配方法执行的连接点;
  • within:用于匹配指定类型内的方法执行;
  • this:用于匹配当前AOP代理对象类型的执行方法;注意是AOP代理对象的类型匹配,这样就可能包括引入接口也类型匹配;        
  • target:用于匹配当前目标对象类型的执行方法;注意是目标对象的类型匹配,这样就不包括引入接口也类型匹配;
  • args:用于匹配当前执行的方法传入的参数为指定类型的执行方法;
  • @within:用于匹配所以持有指定注解类型内的方法;
  • @target:用于匹配当前目标对象类型的执行方法,其中目标对象持有指定的注解;
  • @args:用于匹配当前执行的方法传入的参数持有指定注解的执行;
  • @annotation:用于匹配当前执行方法持有指定注解的方法;

格式

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

其中后面跟着“?”的是可选项

括号中各个pattern分别表示:

  • 修饰符匹配(modifier-pattern?)
  • 返回值匹配(ret-type-pattern):? ?可以为*表示任何返回值, 全路径的类名等
  • 类路径匹配(declaring-type-pattern?)
  • 方法名匹配(name-pattern):可以指定方法名 或者 *代表所有,?set* 代表以set开头的所有方法
  • 参数匹配((param-pattern)):可以指定具体的参数类型,多个参数间用“,”隔开,各个参数也可以用”*”?来表示匹配任意类型的参数,”..”表示零个或多个任意参数。
    如(String)表示匹配一个String参数的方法;(*,String) 表示匹配有两个参数的方法,第一个参数可以是任意类型,而第二个参数是String类型。
  • 异常类型匹配(throws-pattern?)

eg.

  • 任意公共方法的执行:execution(public * *(..))
  • 任何一个以“set”开始的方法的执行:execution(* set*(..))
  • AccountService 接口的任意方法的执行:execution(* com.xyz.service.AccountService.*(..))
  • 定义在service包里的任意方法的执行: execution(* com.xyz.service.*.*(..))
  • 定义在service包和所有子包里的任意类的任意方法的执行:execution(* com.xyz.service..*.*(..))
    第一个*表示匹配任意的方法返回值, ..(两个点)表示零个或多个,第一个..表示service包及其子包,第二个*表示所有类, 第三个*表示所有方法,第二个..表示方法的任意参数个数
  • 定义在pointcutexp包和所有子包里的JoinPointObjP2类的任意方法的执行:execution(* com.test.spring.aop.pointcutexp..JoinPointObjP2.*(..))”)
  • pointcutexp包里的任意类: within(com.test.spring.aop.pointcutexp.*)
  • pointcutexp包和所有子包里的任意类:within(com.test.spring.aop.pointcutexp..*)
  • 实现了Intf接口的所有类,如果Intf不是接口,限定Intf单个类:this(com.test.spring.aop.pointcutexp.Intf)
    当一个实现了接口的类被AOP的时候,用getBean方法必须cast为接口类型,不能为该类的类型
  • 带有@Transactional标注的所有类的任意方法: 
    • @within(org.springframework.transaction.annotation.Transactional)
    • @target(org.springframework.transaction.annotation.Transactional)
  • 带有@Transactional标注的任意方法:@annotation(org.springframework.transaction.annotation.Transactional)
    @within和@target针对类的注解,@annotation是针对方法的注解
  • 参数带有@Transactional标注的方法:@args(org.springframework.transaction.annotation.Transactional)
  • 参数为String类型(运行是决定)的方法: args(String)

JoinPoint

常用的方法:

  • Object[] getArgs:返回目标方法的参数
  • Signature getSignature:返回目标方法的签名
  • Object getTarget:返回被织入增强处理的目标对象
  • Object getThis:返回AOP框架为目标对象生成的代理对象

当使用@Around处理时,需要将第一个参数定义为ProceedingJoinPoint类型,该类是JoinPoint的子类。

织入

@AfterReturning(
        pointcut="execution(* com.abc.service.*.access*(..)) && args(time, name)",
        returning="returnValue")
public void access(Date time, Object returnValue, String name) {
    System.out.println("目标方法中的参数String = " + name);
    System.out.println("目标方法中的参数Date = " + time);
    System.out.println("目标方法的返回结果returnValue = " + returnValue);
}

? ? ?表达式中增加了args(time, name)部分,意味着可以在增强处理的签名方法(access方法)中定义”time”和”name”两个属性。这两个形参的类型可以随意指定(access方法中指定),但一旦指定了这两个参数的类型,则这两个形参类型将用于限制该切入点只匹配第一个参数类型为Date,第二个参数类型为String的方法(方法参数个数和类型若有不同均不匹配);access方法只需要满足”time”, “name”参数的顺序和pointcut中args(param1, param2)的顺序相同即可,”returnValue”位置顺序无所谓。?

//将被access方法匹配
public String accessAdvice(Date d, String n) {
    System.out.println("方法:accessAdvice");
    return "aa";
}
174904_iHXq_1434710

切面执行顺序

一个方法只被一个Aspect类拦截

正常:

04170857_Aoog

异常:

04170857_eto5

同一个方法被多个Aspect类拦截

优先级高的切面类里的增强处理的优先级总是比优先级低的切面类中的增强处理的优先级高。       
在“进入”连接点时,最高优先级的增强处理将先被织入(eg.给定的两个不同切面类Before增强处理中,优先级高的那个会先执行);在“退出”连接点时,最高优先级的增强处理会最后被织入(eg.给定的两个不同切面类After增强处理中,优先级高的那个会后执行)。eg.优先级为1的切面类Bean1包含了@Before,优先级为2的切面类Bean2包含了@Around,虽然@Around优先级高于@Before,但由于Bean1的优先级高于Bean2的优先级,因此Bean1中的@Before先被织入。
Spring提供了如下两种解决方案指定不同切面类里的增强处理的优先级:

  1. 让切面类实现org.springframework.core.Ordered接口:实现该接口的int getOrder()方法,该方法返回值越小,优先级越高
  2. 直接使用@Order注解来修饰一个切面类:使用这个注解时可以配置一个int类型的value属性,该属性值越小,优先级越高

同一个切面类里的两个相同类型的增强处理在同一个连接点被织入时,Spring AOP将以随机的顺序来织入这两个增强处理,没有办法指定它们的织入顺序。即使给这两个 advice 添加了 @Order 这个注解,也不行!

c39bc366deef29b29ebda481538fa5942a1

eg.

spring的xml开启AOP配置:?

<aop:config proxy-target-class="false" />
<aop:aspectj-autoproxy />
<bean id="opLogAspectj" class="com.noob.aspectj.OpLogAspectj"></bean>
package com.noob.aspectj;
 
import lombok.extern.slf4j.Slf4j;
 
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
 
import com.noob.annotation.OpLog;
 
 
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OpLog {
 
	/**
	 * 
	 * 操作类型
	 */
	int opModule();
 
	/**
	 * 
	 * 是否批量 
	 */
	String batch();
 
	/**
	 * 
	 * 操作来源(页面+操作)
	 */
	String source();
 
}
 
@Aspect
@Slf4j
public class OpLogAspectj {
	
	@Pointcut(value = "@annotation(com.noob.annotation.OpLog)")  
    public void methodPointcut(){}
 
	
    /**
     * 对带注解@OpLog的方法进行切面,并获取到注解的属性值
     */
    @Around(value= "methodPointcut() && @annotation(opLog)" , argNames="opLog")
    public Object around(ProceedingJoinPoint point, OpLog opLog) throws Throwable{
        Object obj = null;
        Object[] args = point.getArgs();
        
        try {
            obj = point.proceed(args);
        } catch (Throwable e) {
            log.error("方法执行异常", e);
        }
        long endTime = System.currentTimeMillis();
        MethodSignature signature = (MethodSignature) point.getSignature();
        String methodName = signature.getDeclaringTypeName() + "." + signature.getName();
        return obj;
    }
 
 
    @Pointcut(value = "@annotation(org.apache.shiro.authz.annotation.RequiresPermissions)")  
    public void methodPointcut2(){}
 
    /**
     * 配置指定位置指定类型的参数
     */
    @Around(value= "methodPointcut2() && (args(request, ..) || args(.., request))")
    public Object around2(ProceedingJoinPoint point, HttpServletRequest request) throws Throwable{
        Object obj = null;
        Object[] args = point.getArgs();
        
        try {
            SsoUser ssoUser = SsoSession.getCurrentUser(request);
            obj = point.proceed(args);
        } catch (Throwable e) {
            log.error("方法执行异常", e);
        }
        
        return obj;
    }    
}

进入切面的方法:

@OpLog(batch = YesOrNo.NO, source = FuncPointEnum.GROUP_ADD)
public Response<Integer> add(RuleGroupModifyReq addModel) {
   		// do somethings
}
 
 
@RequestMapping(value = "/delete")
@ResponseBody
@RequiresPermissions("rule:delete")
public Response<Integer> delete(
		@RequestBody Map<String, String> params,
		HttpServletRequest request) {
	// do somethings
}
Spring中@Pointcut()的execution, @annotation等参数说明
滚动到顶部