精华内容
下载资源
问答
  • @PointCut

    2021-05-20 11:51:38
    import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Aspect;...import org.aspectj.lang.annotation.Pointcut; /** * @Aspect : 是aspectj框架中的注解。 * 作用:表示当前.
    package com.bjpowernode.ba06;
    
    
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    
    
    /**
     *  @Aspect : 是aspectj框架中的注解。
     *     作用:表示当前类是切面类。
     *     切面类:是用来给业务方法增加功能的类,在这个类中有切面的功能代码
     *     位置:在类定义的上面
     */
    @Aspect
    public class MyAspect {
    
        @After(value = "mypt()")
        public  void  myAfter(){
            System.out.println("执行最终通知,总是会被执行的代码");
            //一般做资源清除工作的。
        }
    
        @Before(value = "mypt()")
        public  void  myBefore(){
            System.out.println("前置通知,目标方法之前先执行");
            //一般做资源清除工作的。
        }
    
        /**
         * @Pointcut: 定义和管理切入点, 如果你的项目中有多个切入点表达式是重复的,可以复用的。
         *            可以使用@Pointcut
         *    属性:value 切入点表达式
         *    位置:在自定义的方法上面
         * 特点:
         *   当使用@Pointcut定义在一个方法的上面 ,此时这个方法的名称就是切入点表达式的别名。
         *   其它的通知中,value属性就可以使用这个方法名称,代替切入点表达式了
         */
        @Pointcut(value = "execution(* *..SomeServiceImpl.doThird(..))" )
        private void mypt(){
            //无需代码,
        }
    }
    

    展开全文
  • @Pointcut语法详解

    千次阅读 2019-12-05 11:33:20
    @Pointcut语法详解 目录 @Pointcut语法详解 定义 表达式标签 execution execution格式: 例子: AspectJ类型匹配的通配符: within和@within this @target @annotation args 和 @args 命名及匿名切入...

    @Pointcut语法详解

     

    目录

    @Pointcut语法详解

    定义

    表达式标签

    execution

    execution格式:

    例子:

    AspectJ类型匹配的通配符:

    within和@within

    this

    @target

    @annotation

    args 和 @args

    命名及匿名切入点

    切入点使用示例:

    通知参数

    AOP例子


    定义

    格式:@ 注解(value=“表达标签 ( 表达式格式)”)
    如:@Pointcut (value=“execution(* com.cn.spring.aspectj.NotVeryUsefulAspectService.*(…))”)

    表达式标签

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

    其中execution 是用的最多的,

    execution

    execution格式:

    execution(

    modifier-pattern?
    ret-type-pattern
    declaring-type-pattern?
    name-pattern(param-pattern)
    throws-pattern?

    )

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

    其中带 ?号的 modifiers-pattern?,declaring-type-pattern?,hrows-pattern?是可选项
    ret-type-pattern,name-pattern, parameters-pattern是必选项;

    • modifier-pattern? 修饰符匹配,如public 表示匹配公有方法
    • ret-type-pattern 返回值匹配,* 表示任何返回值,全路径的类名等
    • declaring-type-pattern? 类路径匹配
    • name-pattern 方法名匹配,* 代表所有,set*,代表以set开头的所有方法
    • (param-pattern) 参数匹配,指定方法参数(声明的类型),

             (..)代表所有参数,

             ()代表一个参数,

             (,String)代表第一个参数为任何值,第二个为String类型.

    • throws-pattern? 异常类型匹配

    例子:

    • execution(public * *(..)) 定义任意公共方法的执行
    • execution(* set*(..)) 定义任何一个以"set"开始的方法的执行
    • execution(* com.xyz.service.AccountService.*(..)) 定义AccountService 接口的任意方法的执行
    • execution(* com.xyz.service.*.*(..)) 定义在service包里的任意方法的执行
    • execution(* com.xyz.service ..*.*(..)) 定义在service包和所有子包里的任意类的任意方法的执行
    • execution(* com.test.spring.aop.pointcutexp…JoinPointObjP2.*(…)) 定义在pointcutexp包和所有子包里的JoinPointObjP2类的任意方法的执行:

    说明:最靠近(..)的为方法名,靠近.∗(..))的为类名或者接口名,如上例的JoinPointObjP2.∗(..))

    AspectJ类型匹配的通配符:

    • * 匹配任何数量字符;
    • . . 匹配任何数量字符的重复,如在类型模式中匹配任何数量子包;而在方法参数模式中匹配任何数量参数。
    • +:匹配指定类型的子类型;仅能作为后缀放在类型模式后边。

    如:

    • java.lang.String 匹配String类型;
    • java.*.String 匹配java包下的任何“一级子包”下的String类型;如匹配java.lang.String,但不匹配java.lang.ss.String
    • java..* 匹配java包及任何子包下的任何类型; 如匹配java.lang.String、java.lang.annotation.Annotation
    • java.lang.*ing 匹配任何java.lang包下的以ing结尾的类型;
    • java.lang.Number+ 匹配java.lang包下的任何Number的自类型;如匹配java.lang.Integer,也匹配java.math.BigInteger

    within和@within

    • within(com.test.spring.aop.pointcutexp.*) pointcutexp包里的任意类.
    • within(com.test.spring.aop.pointcutexp…*) pointcutexp包和所有子包里的任意类.
    • @within(org.springframework.transaction.annotation.Transactional) 带有@Transactional标注的所有类的任意方法.

    this

    • this(com.test.spring.aop.pointcutexp.Intf) 实现了Intf接口的所有类,如果Intf不是接口,限定Intf单个类.

    当一个实现了接口的类被AOP的时候,用getBean方法必须cast为接口类型,不能为该类的类型.

    @target

    • @target(org.springframework.transaction.annotation.Transactional) 带有@Transactional标注的所有类的任意方法.

    @annotation

    • @annotation(org.springframework.transaction.annotation.Transactional) 带有@Transactional标注的任意方法.

    @within和@target针对类的注解,@annotation是针对方法的注解

    args 和 @args

    • @args(org.springframework.transaction.annotation.Transactional) 参数带有@Transactional标注的方法.
    • args(String) 参数为String类型(运行是决定)的方法.

    命名及匿名切入点

    Pointcut定义时,还可以使用&&、∣∣、!运算符

    @Pointcut("execution(* com.savage.aop.MessageSender.*(..)) && args(param)")
    public void log(){
    }
    
    @Before("log(String param)") 
    public void beforeLog(){
         //todo something....
    }
    
    //等同于
    @Before("execution(* com.savage.aop.MessageSender.*(..)) && args(param)") 
    public void beforeLog(){
         //todo something....
    }

    又如:

    @Pointcut("execution(* com.savage.aop.MessageSender.*(..))")
    private void logSender(){}
    
    @Pointcut("execution(* com.savage.aop.MessageReceiver.*(..))")
    private void logReceiver(){}
    
    @Pointcut("logSender() || logReceiver()")
    private void logMessage(){} 

    这个例子中,logMessage()将匹配任何MessageSenderMessageReceiver中的任何方法

    切入点使用示例:

    • 一、execution:使用“execution(方法表达式)”匹配方法执行;
    示例描述
    public * *(..)任何公共方法的执行
    * cn.javass..IPointcutService.*()cn.javass包及所有子包下IPointcutService接口中的任何无参方法
    * cn.javass..*.*(..)cn.javass包及所有子包下任何类的任何方法
    * cn.javass..IPointcutService.*(*)cn.javass包及所有子包下IPointcutService接口的任何只有一个参数方法
    * (!cn.javass..IPointcutService+) .*(..)非“cn.javass包及所有子包下IPointcutService接口及子类型”的任何方法
    * cn.javass..IPointcutService+.*()cn.javass包及所有子包下IPointcutService接口及子类型的的任何无参方法
    * cn.javass..IPointcut*.test*(java.util.Date)cn.javass包及所有子包下IPointcut前缀类型的的以test开头的只有一个参数类型为java.util.Date的方法,注意该匹配是根据方法签名的参数类型进行匹配的,而不是根据执行时传入的参数类型决定的,如定义方法:public void test(Object obj);即使执行时传入java.util.Date,也不会匹配的;

    * cn.javass..IPointcut*.test*(..) throws IllegalArgumentException,

    ArrayIndexOutOfBoundsException,cn.javass

    包及所有子包下IPointcut前缀类型的的任何方法,且抛出IllegalArgumentException和ArrayIndexOutOfBoundsException异常
    * (cn.javass..IPointcutService+&& java.io.Serializable+).*(..)任何实现了cn.javass包及所有子包下IPointcutService接口和java.io.Serializable接口的类型的任何方法
    @java.lang.Deprecated * *(..)任何持有@java.lang.Deprecated注解的方法
    @java.lang.Deprecated @cn.javass..Secure* *(..)任何持有@java.lang.Deprecated和@cn.javass…Secure注解的方法
    @(java.lang.Deprecatedcn.javass..Secure) **(..)
    (@cn.javass..Secure*) *(..)任何返回值类型持有@cn.javass…Secure的方法
    *(@cn.javass..Secure*).*(..)任何定义方法的类型持有@cn.javass…Secure的方法
    **(@cn.javass..Secure(*) ,@cn.javass..Secure(*))任何签名带有两个参数的方法,且这个两个参数都被@ Secure标记了,如public void test(@Secure String str1, @Secure String str1);
    **((@ cn.javass..Secure *))或**(@ cn.javass..Secure*)
    任何带有一个参数的方法,且该参数类型持有@ cn.javass…Secure;
    如public void test(Model model);且Model类上持有@Secure注解 
    * *(@cn.javass…Secure (@cn.javass…Secure *) ,@ cn.javass…Secure (@cn.javass…Secure *))任何带有两个参数的方法,且这两个参数都被@ cn.javass…Secure标记了;且这两个参数的类型上都持有@ cn.javass…Secure;
    * *(java.util.Map<cn.javass…Model, cn.javass…Model>, …)任何带有一个java.util.Map参数的方法,且该参数类型是以< cn.javass…Model, cn.javass…Model >为泛型参数;注意只匹配第一个参数为java.util.Map,不包括子类型;如public void test(HashMap<Model, Model> map, String str);将不匹配,必须使用“* *(java.util.HashMap<cn.javass…Model,cn.javass…Model>, …)”进行匹配;而public void test(Map map, int i);也将不匹配,因为泛型参数不匹配
    * *(java.util.Collection<@cn.javass…Secure *>)任何带有一个参数(类型为java.util.Collection)的方法,且该参数类型是有一个泛型参数,该泛型参数类型上持有@cn.javass…Secure注解;如public void test(Collection collection);Model类型上持有@cn.javass…Secure
    * *(java.util.Set<? extends HashMap>)任何带有一个参数的方法,且传入的参数类型是有一个泛型参数,该泛型参数类型继承与HashMap;Spring AOP目前测试不能正常工作
    * *(java.util.List<? super HashMap>)任何带有一个参数的方法,且传入的参数类型是有一个泛型参数,该泛型参数类型是HashMap的基类型;如public voi test(Map map);Spring AOP目前测试不能正常工作
    (<@cn.javass…Secure *>)任何带有一个参数的方法,且该参数类型是有一个泛型参数,该泛型参数类型上持有@cn.javass…Secure注解;Spring AOP目前测试不能正常工作
    •  二、within:使用“within(类型表达式)”匹配指定类型内的方法执行;
    示例 描述
    within(cn.javass..*)    cn.javass包及子包下的任何方法执行
    within(cn.javass..IPointcutService+)  cn.javass包或所有子包下IPointcutService类型及子类型的任何方法
    within(@cn.javass..Secure *) 持有cn.javass…Secure注解的任何类型的任何方法必须是在目标对象上声明这个注解,在接口上声明的对它不起作用
    • 三、this:使用“this(类型全限定名)”匹配当前AOP代理对象类型的执行方法;注意是AOP代理对象的类型匹配,这样就可能包括引入接口方法也可以匹配;注意this中使用的表达式必须是类型全限定名,不支持通配符;
    示例    描述

    this(cn.javass.spring.chapter6.service.

    IPointcutService) 

    当前AOP对象实现了 IPointcutService接口的任何方法

    this(cn.javass.spring.chapter6.service.

    IIntroductionService) 

    当前AOP对象实现了 IIntroductionService接口的任何方法
    • 四、target:使用“target(类型全限定名)”匹配当前目标对象类型的执行方法;注意是目标对象的类型匹配,这样就不包括引入接口也类型匹配;注意target中使用的表达式必须是类型全限定名,不支持通配符;
    示例    描述

    target(cn.javass.spring.chapter6.

    service.IPointcutService)    

    当前目标对象(非AOP对象)实现了 IPointcutService接口的任何方法

    target(cn.javass.spring.

    chapter6.service.IIntroductionService) 

    当前目标对象(非AOP对象) 实现了IIntroductionService 接口的任何方法, 不可能是引入接口
    • 五、args:使用“args(参数类型列表)”匹配当前执行的方法传入的参数为指定类型的执行方法;注意是匹配传入的参数类型,不是匹配方法签名的参数类型;参数类型列表中的参数必须是类型全限定名,通配符不支持;args属于动态切入点,这种切入点开销非常大,非特殊情况最好不要使用;
    示例    描述
    args (java.io.Serializable,…) 任何一个以接受“传入参数类型为 java.io.Serializable” 开头,且其后可跟任意个任意类型的参数的方法执行,args指定的参数类型是在运行时动态匹配的
      
    • 六、@within:使用“@within(注解类型)”匹配所以持有指定注解类型内的方法;注解类型也必须是全限定类型名;
    示例    描述
    @within(cn.javass.spring.chapter6.Secure)  任何目标对象对应的类型持有Secure注解的类方法;
    • 七、@target:使用“@target(注解类型)”匹配当前目标对象类型的执行方法,其中目标对象持有指定的注解;注解类型也必须是全限定类型名;
    示例    描述
    @target (cn.javass.spring.chapter6.Secure) 任何目标对象持有Secure注解的类方法;必须是在目标对象上声明这个注解,在接口上声明的对它不起作用
    • 八、@args:使用“@args(注解列表)”匹配当前执行的方法传入的参数持有指定注解的执行;注解类型也必须是全限定类型名;
    示例    描述
    @args (cn.javass.spring.chapter6.Secure) 任何一个只接受一个参数的方法,且方法运行时传入的参数持有注解 cn.javass.spring.chapter6.Secure;动态切入点,类似于arg指示符;
    • 九、@annotation:使用“@annotation(注解类型)”匹配当前执行方法持有指定注解的方法;注解类型也必须是全限定类型名;
    示例    描述

    @annotation(cn.javass.spring.

    chapter6.Secure )

    当前执行方法上持有注解 cn.javass.spring.chapter6.Secure将被匹配
    • 十、bean:使用“bean(Bean id或名字通配符)”匹配特定名称的Bean对象的执行方法;Spring ASP扩展的,在AspectJ中无相应概念;
    示例    描述
    bean(*Service) 匹配所有以Service命名(id或name)结尾的Bean
    • 十一、reference pointcut:表示引用其他命名切入点;
    @Pointcut(value="bean(*Service)")
    private void pointcut1(){
    }
    
    @Pointcut(value="@args()cn.javass.spring.chaper6.Source")
    public referencePointcutTest(JoinPoint jp){
         ...
    }

    通知参数

    • 1)JoinPoint:提供访问当前被通知方法的目标对象、代理对象、方法参数等数据
    • 2)ProceedingJoinPoint:用于环绕通知,使用proceed()方法来执行目标方法
    • 3)JoinPoint.StaticPart:提供访问连接点的静态部分,如被通知方法签名、连接点类型等:

    使用如下方式在通知方法上声明,必须是在第一个参数,然后使用jp.getArgs()就能获取到被通知方法参数

    @Before(value="execution(* sayBefore(*))")  
    public void before(JoinPoint jp) {}  
      
    @Before(value="execution(* sayBefore(*))")  
    public void before(JoinPoint.StaticPart jp) {}  

    自动获取:通过切入点表达式可以将相应的参数自动传递给通知方法,例如前边章节讲过的返回值和异常是如何传递给通知方法的。
    Spring AOP中,除了executionbean指示符不能传递参数给通知方法,其他指示符都可以将匹配的相应参数或对象自动传递给通知方法。

    @Before(value="execution(* test(*)) && args(param)", argNames="param")  
    public void before1(String param) {  
        System.out.println("===param:" + param);  
    }  

     切入点表达式execution(* test()) && args(param)
    1)首先execution( test(*))匹配任何方法名为test,且有一个任何类型的参数;
    2)args(param)将首先查找通知方法上同名的参数,并在方法执行时(运行时)匹配传入的参数是使用该同名参数类型,即java.lang.String;如果匹配将把该被通知参数传递给通知方法上同名参数。
    其他指示符(除了executionbean指示符)都可以使用这种方式进行参数绑定。
    在此有一个问题,即前边提到的类似于【3.1.2构造器注入】中的参数名注入限制:在class文件中没生成变量调试信息是获取不到方法参数名字的。
    所以我们可以使用策略来确定参数名:
    如果我们通过“argNames”属性指定了参数名,那么就是要我们指定的;

    @Before(value=" args(param)", argNames="param") //明确指定了  
    public void before1(String param) {  
        System.out.println("===param:" + param);  
    }  

    如果第一个参数类型是JoinPoint、ProceedingJoinPoint或JoinPoint.StaticPart类型,应该从“argNames”属性省略掉该参数名(可选,写上也对),这些类型对象会自动传入的,但必须作为第一个参数;

    @Before(value=" args(param)", argNames="param") //明确指定了  
    public void before1(JoinPoint jp, String param) {  
        System.out.println("===param:" + param);  
    }  

    如果“class文件中含有变量调试信息”将使用这些方法签名中的参数名来确定参数名;

    @Before(value=" args(param)") //不需要argNames了  
    public void before1(JoinPoint jp, String param) {  
        System.out.println("===param:" + param);  
    }  

    如果没有“class文件中含有变量调试信息”,将尝试自己的参数匹配算法,如果发现参数绑定有二义性将抛出AmbiguousBindingException异常;对于只有一个绑定变量的切入点表达式,而通知方法只接受一个参数,说明绑定参数是明确的,从而能配对成功。

    @Before(value=" args(param)")   
    public void before1(JoinPoint jp, String param) {  
        System.out.println("===param:" + param);  
    }  

    以上策略失败将抛出IllegalArgumentException
    接下来让我们示例一下组合情况吧:

    @Before(args(param) && target(bean) && @annotation(secure)",   
            argNames="jp,param,bean,secure")  
    public void before5(JoinPoint jp, String param,  
     IPointcutService pointcutService, Secure secure) {  
    ……  
    }  

    也可以对使用命名切入点自动获取参数:

    @Pointcut(value="args(param)", argNames="param")  
    private void pointcut1(String param){}  
    @Pointcut(value="@annotation(secure)", argNames="secure")  
    private void pointcut2(Secure secure){}  
          
    @Before(value = "pointcut1(param) && pointcut2(secure)", argNames="param, secure")  
    public void before6(JoinPoint jp, String param, Secure secure) {  
    ……  
    }  

    AOP例子

    @Aspect
    @Component
    public class NotVeryUsefulAspect {
        @AfterReturning(value="execution(* com.cn.spring.aspectj.NotVeryUsefulAspectService.*(..))")
        private void logReceiver(){
            System.out.println("切入点logReceiver...");
        }
    
        @Pointcut(value="execution(* com.cn.spring.aspectj.NotVeryUsefulAspectService.*(..)) && args(param)")
        private void pointcut(String param){ 
            System.out.println("切入点pointcut()"+param);
        }
    
        //方法体将不执行
        @Pointcut("within(com.cn.spring.aspectj.*)")
        public String inWebLayer() {
            System.out.println("切入点inWebLayer()");
            return "返回值加载";
        }
    
        @Before(value="inWebLayer()")
            private void beforeinWebLayer(){ 
            System.out.println("beforeinWebLayer~~");
        }
    
        @Before(value="pointcut(param)")
            private void beforePointcut(String param){ 
            System.out.println("beforePointcut:"+param);
        }
    
    
        @AfterReturning(pointcut="inWebLayer()",returning="retVal")
            public void doAccessCheck(Object retVal) {
            System.out.println("doAccessCheck:"+retVal);
        }
    
        @Around(value="execution(* com.cn.spring.aspectj.NotVeryUsefulAspectService.*(..))")
        private Object aroundLayer(ProceedingJoinPoint pjp) throws Throwable{ 
            // start stopwatch
            Object retVal = pjp.proceed();
            // stop stopwatch
            System.out.println("aroundLayer~~");
            return retVal;
        }
    }

    参考自:
    https://www.mekau.com/4880.html
    https://blog.csdn.net/xiaoyiaoyou/article/details/45972363

    展开全文
  • @PointCut语法切点表达式1. execution2. within3. this和target4. args(paramType)5. @within(annotationType)6. @target(annotationType)7. @annotation(annotationType)8. @args(annotationType) @Pointcut可以是...


    @Pointcut可以是由切点表达式来定义或者通过&&、||和 ! 的方式进行组合的。

    切点表达式

    1. execution

        由于Spring切面粒度最小是方法级别,而execution表达式可以用于明确指定方法放回类型、类名、方法名和参数名等与方法相关的部件,并且在Spring中,大部分需要使用AOP的业务场景也只需要达到方法级别即可,因而execution表达式的使用时最为广泛的。
        语法(带问号的表示可选):

    execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
    
    • Modifiers-pattern(可选):方法访问修饰符,如public、private、protected;
    • Ret-type-pattern:方法的返回值类型,如void、String等;
    • Declaring-type-pattern(可选):方法所在类的全路径表达式,如com.xxx.controller;
    • Name-pattern:方法名类型表达式,如get*()、query*();
    • Param-pattern:方法的参数类型表达式,如java.lang.String、…(表示任意参数);
    • Throws-pattern(可选):方法抛出的异常类型,如java.lang.Exception;

        如下为一个execution表达式例子:

    execution(public * com..controller.*.insert*(..) java.lang.Exception)
    

        该切点表达式将会匹配在com…controller下的所有类中,方法修饰符为public的任意返回值,并且以insert为前缀名,抛出Exception异常类型的方法。该例子使用了 ..* 通配符。

    • * 通配符:该通配符主要用于匹配多个字符。
    • .. 通配符:该通配符表示0个或多个项,主要用于declaring-type-pattern和param-pattern中,如果用于declaring-type-pattern中,则表示匹配当前包及其子包,如果用于param-pattern中,则表示匹配0个或者多个参数。
    • +:匹配指定类型的子类型;仅能作为后缀放在类型模式后边。java.lang.Number+ 匹配java.lang包下的任何Number的自类型;如匹配java.lang.Integer,也匹配java.math.BigInteger

    2. within

        within表达式的粒度为类,用来限定类(可使用通配符),表示匹配当前表达式的所有类。
        语法:

    within(declaring-type-pattern)
    

        例如下面表达式表示匹配com.spring.xxx.service包及其子包下的所有类

    within(com.spring.xxx.service..*)
    

    3. this和target

        this表达式表示目标对象被代理之后生成的代理对象和指定的类型匹配才会被拦截。target表达式表示目标对象为指定的类型才会被拦截。由此可知,this作用于代理对象,target作用于目标对象。
        辣么什么是目标对象和代理对象呢?在Spring切面编程中,目标对象为业务逻辑对象,而代理多少是使用对业务逻辑进行封装包裹后而生成的对象。如果使用JDK动态代理,目标对象和代理对象为两个对象,如果是CGLib代理,则为一个对象。关于代理可以参考《》
        在Spring中,this将匹配代理对象为指定类型的类,target将匹配业务对象为指定类型的类。例子如下:

    this(com.spring.service.BaseService)
    target(com.spring.service.BaseService)
    

    4. args(paramType)

        args表达式的作用是匹配指定参数类型和数量的方法,无论其类路径或者是什么方法名称。可以使用 … 通配符,不能使用 * 。如下表达式表示匹配第一个参数为java.lang.String、其后可以为任意参数的方法。

    args(java.lang.String,..)
    

    5. @within(annotationType)

        指定匹配必须包好某个注解的类里的所有连接点,调用该目标对象的任意方法都会被拦截。

    6. @target(annotationType)

        匹配目标对象的类含有指定注解,调用该目标对象的任意方法都会被拦截。
        @target 和 @within 的不同点

    1. @target(注解A):判断被调用的目标对象中是否声明了注解A,如果有,会被拦截
    2. @within(注解A): 判断被调用的方法所属的类中是否声明了注解A,如果有,会被拦截
    3. @target关注的是被调用的对象,@within关注的是调用的方法所在的类

    7. @annotation(annotationType)

        匹配有指定注解的方法(注解作用在方法上面),被调用的方法包含指定的注解

    8. @args(annotationType)

        方法参数所属的类型上有指定的注解。注意:是方法参数所属的类型上有指定的注解,不是方法参数中有注解

    • 匹配1个参数,且第1个参数所属的类中有Anno1注解
    @args(com.spring.aop.jargs.annotation.Anno1)
    
    • 匹配多个参数,且多个参数所属的类型上都有指定的注解
    @args(com.spring.aop.jargs.annotation.Anno1,com.spring.aop.jargs.annotation.Anno2)
    
    • 匹配多个参数,且第一个参数所属的类中有Anno1注解
    @args(com.ms.aop.jargs.demo2.Anno1,..)
    
    展开全文
  • spring注解: @Pointcut 多个表达式

    千次阅读 2019-12-09 13:38:59
    @Pointcut("execution(* com.zzy.controller.*.*.*(..)) || execution(* com.zzy.controller.*.*(.... public void pointCut(){} @Pointcut多个表达式,扫描controller目录和子目录. @Around("pointCut()") publ...
     @Pointcut("execution(* com.zzy.controller.*.*.*(..)) || execution(* com.zzy.controller.*.*(..))")
     public void pointCut(){}

     @Pointcut多个表达式, 扫描controller目录和子目录.

        @Around("pointCut()")
        public Object handleControllerMethod(ProceedingJoinPoint pjp) throws Throwable{
            Stopwatch stopwatch = Stopwatch.createStarted();
            
            Object result = null;
     
            try {
                logger.info("-----执行Controller开始: " + pjp.getSignature() + " 参数:" + Lists.newArrayList(pjp.getArgs()).toString());
                
                //处理入参特殊字符和sql注入攻击
                checkRequestParam(pjp);
                //执行访问接口操作
                result = pjp.proceed(pjp.getArgs());
                
                Long consumeTime = stopwatch.stop().elapsed(TimeUnit.MILLISECONDS);
                
                logger.info("-----执行Controller结束: " + pjp.getSignature()+"-----耗时:" + consumeTime + "(毫秒).");
                //当接口请求时间大于5秒时,标记为异常调用时间,并记录入库
                if(consumeTime > NumberConst.NUM_1000){
                	logger.info("-----执行Controller" + pjp.getSignature()+" 耗时大于5秒");
                }
            } catch (Exception throwable) {
            	throwable.printStackTrace();
                handlerException(pjp, throwable);
            }
    		return result;
        }

     

    展开全文
  • spring aop @Pointcut execution离奇事件

    千次阅读 2018-10-09 18:29:56
    @Pointcut("execution (* *.Controller.*(..))") @Pointcut("execution (* *.Controller.testPost(..))") 但全路径却能用 @Pointcut("execution (* ...
  • 切入点@Pointcut的使用 在确定切面aspect之后,需要在切面上确定切入点pointcut 定义 注解@pointcut("{切入点}") 其中{切入点}格式如下: execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? ...
  • Spring AOP 中@Pointcut的使用

    千次阅读 2019-01-31 13:46:35
    Spring AOP 中@Pointcut的使用 在确定切面aspect之后,需要在切面上确定切入点pointcut 注解 @pointcut("{切入点}") 其中{切入点}格式如下: execution(modifiers-pattern? ret-type-pattern declaring-...
  • Spring Aop Annotation(@Pointcut) @Pointcut定义一个切入点 1 @Pointcut("execution(public * com.bxw.aop.service.*.*(..))") 2 public void myMethod(){}; 这表明定义一个切入点,该切入点...
  • Spring AOP 中@Pointcut的用法 ...
  • 场景:希望给service包下的所有public方法添加开始和结束的info log,但是需要排除和数据库相关的service ...这个关键字无法使用,只能使用and才能编译通过,并且@Pointcut只识别了前面半句表达..
  • @Pointcut这个注解之前的案例中也有使用过,但是小编都是用的同一种格式,参数只是大概的描述了一下。 趁着今晚花好月圆,来写下这个注解有几种常用的表达式。 常用的其实就那么几个,小编查看了官方的文档,还是...
  • Spring之AOP小结(二)@Pointcut注解 @Pointcut的格式: execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)throws-pattern?) 各个pattern含义: 修饰符匹配...
  • 本文主要内容:掌握@Pointcut的12种用法。Aop相关阅读阅读本文之前,需要先掌握下面3篇文章内容,不然会比较吃力。Spring系列第15篇:代理详解(java动态代理&C...
  • 切面非常核心的一个配置就是@Pointcut,其它基本上没啥太大的变化。 一、Pointcut的声明 一个 pointcut 的声明由两部分组成: • 一个方法签名, 包括方法名和相关参数 • 一个 pointcut 表达式, 用来指定哪些...
  • @Pointcut(value = "execution(* com.snow.demo7.ProductDao.delete(..))") private void myPoint(){ } } 增强的方法直接引入 @Before(value = "myPoint()") public void before(JoinPoint join...
  • Spring AOP 中@Pointcut的用法 –原文地址 格式: execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)throws-pattern?) 括号中各个pattern分别表示: 修饰符匹配...
  • @Aspect 定义一个切面 public class LogAspect { // Service层切点 切点,所有被... @Pointcut("@annotation(com.xe.demo.common.annotation.ServiceLog)") public void serviceAspect() { } // 增强,在ser...
  • @Pointcut("execution(public * com.dao..*.*(..))") public void myMethod(){}; 其他方法调用myMethid()如: @Before("myMethod()") 运行时报错,查到另一个解释是eclipse版本太新,换个旧版本就解决了,不...
  • Spring AOP 中 @Pointcut的用法: execution (modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)throws-pattern?) 括号中pattern分别表示: 1、修饰符匹配(modifier-...
  • 继上一篇 springboot日志切面与拦截器...@Pointcut("execution(public * com.bigdata.bigdata.controller..*(..))") 切点 定义拦截的点 [ public * ] [ com.bigdata.bigdata.controller ] . .* (..) 公共部分 ...
  • @Pointcut的表达式-execution spring应用手册(第三部分) 上一章我们讲解@Pointcut的含义和用法,这一章我将详细讲解和罗列spring中的@Pointcut中表达式的写法。 Spring AOP 支持以下 AspectJ 切入点指示符...
  • AOP:面向切面编程,提取重复代码,在指定方法执行前或执行后,动态切入...@PointCut:使切点复用 1、添加jar包: &amp;amp;amp;lt;!-- spring-aop相关依赖 --&amp;amp;amp;gt; &amp;amp;amp;lt;depen.
  • @Pointcut的表达式-逻辑运算 spring应用手册(第三部分) 在@Pointcut中spring还提供了逻辑运算,主要就是逻辑非 “!”逻辑与"&&" 逻辑或"||"。这个非常好理解,直接看官方的案例就可以立刻理解: ...
  • spring的@Pointcut注解使用多个表达式

    千次阅读 2018-11-17 21:52:07
    spring的@Pointcut注解匹配多个表达式   解决方法: 假如我想匹配spring的JdbcTemplate所有增删改查操作,也就是说JdbcTemplate的所有操作都会执行doBeforeForJdbc这个方法。 方法:http://​...
  • @Pointcut——切点表达式重用

    千次阅读 2017-12-18 23:04:54
    关于切面的五种通知方法,这篇博客中已经介绍了,但是若几种切面方法用的切面...下面通过重用切面表达式的方法重新定义了切面——使用 @Pointcut 来声明切入点表达式.。package lzj.com.spring.aop; import java.util

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 94,769
精华内容 37,907
关键字:

@pointCut