精华内容
下载资源
问答
  • 4.4 基于@AspectJ的AOP

    2020-07-12 23:35:30
    Spring除了支持Schema方式配置AOP,还支持注解方式:使用@AspectJ风格的切面声明 1 启用对@AspectJ的支持 Spring默认不支持@AspectJ风格的切面声明,为了支持需要使用如下配置: <aop:aspectj-autoproxy/> ...

    Spring除了支持Schema方式配置AOP,还支持注解方式:使用@AspectJ风格的切面声明

    1 启用对@AspectJ的支持

         Spring默认不支持@AspectJ风格的切面声明,为了支持需要使用如下配置:
         <aop:aspectj-autoproxy/>  
    

    这样Spring就能发现@AspectJ风格的切面并且将切面应用到目标对象

    2 声明切面

    @Aspect()  
    Public class Aspect{  
    }  
    

    然后将该切面在配置文件中声明为Bean后,Spring就能自动识别并进行AOP方面的配置

    <bean id="aspect" class="……Aspect"/>  
    

    3 声明切入点

    @AspectJ 风格的命名切入点使用 org.aspectj.lang.annotation 包下的@Pointcut+方法(方法必须是返回void类型)实现

    @Pointcut(value="切入点表达式", argNames = "参数名列表")  
    public void pointcutName(……) {}  
    
    value:指定切入点表达式;
    argNames:指定命名切入点方法参数列表参数名字,可以有多个用“,”分隔,这些参数将传递给通知方法同名的参数,同时比如切入点表达式“args(param)”将匹配参数类型为命名切入点方法同名参数指定的参数类型。
    pointcutName:切入点名字,可以使用该名字进行引用该切入点表达式。
    
    @Pointcut(value="execution(* cn.yang..*.before(..)) && args(param)", argNames = "param")  
    public void beforePointcut(String param) {}  
    

    定义了一个切入点,名字为“beforePointcut”,该切入点将匹配目标方法的第一个参数类型为通知方法实现中参数名为“param”的参数类型。

    4 声明通知

    @AspectJ风格的声明通知也支持5种通知类型
    一、前置通知:使用org.aspectj.lang.annotation 包下的@Before注解声明;

    @Before(value = "切入点表达式或命名切入点", argNames = "参数列表参数名")  
    
    value:指定切入点表达式或命名切入点;
    argNames:与Schema方式配置中的同义。
    

    接下来用实例演示一下
    1、定义接口和实现
    2、定义切面aspect

    package cn.yang.spring.aop;  
    import org.aspectj.lang.annotation.Aspect;  
    @Aspect  
    public class HelloWorldAspect2 {  
    } 
    

    3、定义切入点

    @Pointcut(value="execution(* cn.yang..*.sayAdvisorBefore(..)) && args(param)", argNames = "param")  
    public void beforePointcut(String param) {}  
    

    4、定义通知

    @Before(value = "beforePointcut(param)", argNames = "param")  
    public void beforeAdvice(String param) {  
        System.out.println("===========before advice param:" + param);  
    }  
    

    5、在chapter6/advice2.xml配置文件中进行如下配置

    <?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:aop="http://www.springframework.org/schema/aop"
            xsi:schemaLocation="
               http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
               http://www.springframework.org/schema/aop
               http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">     
      <aop:aspectj-autoproxy/>
      <bean id="helloWorldService"
                class="cn.yang.spring.service.impl.HelloWorldService"/>
      <bean id="aspect"
                 class="cn.yang.spring.aop.HelloWorldAspect2"/>
    </beans>
    
    切面、切入点、通知全部使用注解完成:
           1)使用@Aspect将POJO声明为切面;
           2)使用@Pointcut进行命名切入点声明,同时指定目标方法第一个参数类型必须是java.lang.String,对于其他匹配的方法但参数类型不一致的将也是不匹配的,通过argNames = "param"指定了将把该匹配的目标方法参数传递给通知同名的参数上;
           3)使用@Before进行前置通知声明,其中value用于定义切入点表达式或引用命名切入点;
           4)配置文件需要使用<aop:aspectj-autoproxy/>来开启注解风格的@AspectJ支持;
           5)需要将切面注册为Bean,如“aspect”Bean;
           6)测试代码完全一样。
    

    二、后置返回通知:使用org.aspectj.lang.annotation 包下的@AfterReturning注解声明;

    @AfterReturning(  
    value="切入点表达式或命名切入点",  
    pointcut="切入点表达式或命名切入点",  
    argNames="参数列表参数名",  
    returning="返回值对应参数名")  
    
    @AfterReturning(
        value="execution(* cn.yang..*.sayBefore(..))",
        pointcut="execution(* cn.yang..*.sayAfterReturning(..))",
        argNames="retVal", returning="retVal")
    public void afterReturningAdvice(Object retVal) {
        System.out.println("===========after returning advice retVal:" + retVal);
    }
    

    三、后置异常通知:使用org.aspectj.lang.annotation 包下的@AfterThrowing注解声明;

    @AfterThrowing (
    value="切入点表达式或命名切入点",
    pointcut="切入点表达式或命名切入点",
    argNames="参数列表参数名",
    throwing="异常对应参数名")
    
    @AfterThrowing(  
        value="execution(* cn.yang..*.sayAfterThrowing(..))",  
        argNames="exception", throwing="exception")  
    public void afterThrowingAdvice(Exception exception) {  
        System.out.println("===========after throwing advice exception:" + exception);  
    }  
    

    四、后置最终通知:使用org.aspectj.lang.annotation 包下的@After注解声明;

    @After (
    value="切入点表达式或命名切入点",
    argNames="参数列表参数名")
    
    @After(value="execution(* cn.yang..*.sayAfterFinally(..))")
    public void afterFinallyAdvice() {
        System.out.println("===========after finally advice");
    }
    

    五、环绕通知:使用org.aspectj.lang.annotation 包下的@Around注解声明;

    @Around (
    value="切入点表达式或命名切入点",
    argNames="参数列表参数名")
    
    @Around(value="execution(* cn.yang..*.sayAround(..))")
    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("===========around before advice");
        Object retVal = pjp.proceed(new Object[] {"replace"});
        System.out.println("===========around after advice");
        return retVal;
    }
    
    展开全文
  • 着手使用@AspectJ

    2017-07-22 16:13:19
    在使用@AspectJ之前,首先必须保证所使用的Java版本是5.0及以上版本,否则无法使用注解技术。 Spring在处理@AspectJ注解表达式时,需要将Spring的asm模块添加到类路径中。asm是轻量级的字节码处理框架,因为Java的...

    在使用@AspectJ之前,首先必须保证所使用的Java版本是5.0及以上版本,否则无法使用注解技术。

    Spring在处理@AspectJ注解表达式时,需要将Spring的asm模块添加到类路径中。asm是轻量级的字节码处理框架,因为Java的反射机制无法获取入参名,Spring就利用asm处理@AspectJ中所描述的方法入参。

    此外,Spring采用AspectJ提供的@AspectJ注解类库及相应的解析类库,需要在pom.xml文件中添加aspectj.weaver和aspectj.tools类包的依赖。

    AspectJ使用

    编写目标类

    编写切面

    ③通过AspectProxyFactory为目标类生成织入PreGreetingAspect切面代理

    此外还可以通过xml配置的方式实现


    不同的增强类型

    @Before

    AfterReturning

    Around

    AfterThrowing

    After

    DeclareParents


    切点函数详解

    切点函数是AspectJ表达式语言的核心,也是使用AspectJ进行切面定义的难点

    @annotation():表示标注了某个注解的所有方法

    例如:@AfterReturning("@annotation(com.smart.anno.NeedTest)") //后置增强切面

    @execution()

    1.通过方法签名定义切点

    execution(public * *(..):匹配所有目标类的public方法,第一个*代表返回类型,第二个*代表方法签名,而..代表任意

    入参。

    execution(* *To(..)):匹配所有以To为后缀的方法。

    2.通过类定义切点

    execution(* com.smart.Waiter.*(..)):匹配Waiter接口的所有方法。

    execution(* com.smart.Waiter+.*(..)):匹配Waiter接口的所有方法以及子类所特有的方法。

    3.通过类包定义切点

    execution(* com.smart.*(..)):匹配com.smart包下的所有类的所有方法。

    execution(* com.smart..*(..)):匹配com.smart包、子包下所有类的所有方法。

    execution(* com..*.*Dao.find*(..)):匹配包名前缀为com的任何包下类名后缀为Dao的方法,方法名

    必须以find为前缀。









    展开全文
  • Spring4 In Action-4.2-@AspectJ-切面,Spring4 In Action-4.2-@AspectJ-切面。Spring4 In Action-4.2-@AspectJ-切面
  • 文章目录@AspectJ形式的 Spring AOP @AspectJ形式的 Spring AOP 为了方便理解,先加个说明:AspectJ是aop的一种技术,spring aop也是一种技术,他们是兄弟关系,可以互相替换的。@AspectJ是一种语法,最早是AspectJ...

    @AspectJ形式的 Spring AOP

    为了方便理解,先加个说明:AspectJ是aop的一种技术,spring aop也是一种技术,他们是兄弟关系,可以互相替换的。@AspectJ是一种语法,最早是AspectJ引入的,spring aop借鉴了@AspectJ和其他的一些标签,含义也基本相同,但是spring aop新写了一套语法解释器的代码,也就是说底层实现是不一样。

    Spring 框架2.0版本发布之后, Spring AOP增加了新的特性,或者说增加了新的使用方式

    • 支持 Aspect.5发布的@ AspectJ形式的AOP实现方式。

      现在,我们可以直接使用POJO来定义Aspect以及相关的 Advice,并使用一套标准的注解标注这些POJO。 Spring AOP会根据注解信息查找相关的 Aspect定义,并将其声明的横切逻辑织入当前系统

    • 简化了的XML配置方式。现在,使用新的基于XSD的配置方式,我们可以使用aop独有的命名空间,并且注册和使用POO形式实现的AOP概念实体。因为引入了 Aspect的 Pointcut描述语言,也可以在新的配置方式中使用 AspectJ形式的 Pointcut表达式。

    但这只是从使用的角度来看。如果从更本质”一点儿的角度进行分析的话,我们会发现当升级到2.0版本之后,实际上如下两点是最主要的:

    • 可以使用POJO声明 Aspect和相关的 Advice,而再也不用像1.x版本中那样,要实现特定的 Advice就需要实现规定的接口。

      例如:MethodBeforeAdvice前置增强、AfterReturningAdvice后置增强等

    • 获得了新的 Pointcut表述方式,因为现在引入了 AspectJ的 Pointcut表述语言,再也不用在“直接指定方法名”还是“使用正则表达式”之间选择了。至于说基于XSD的简化的配置方式,应该算是锦上添花之作

    虽然2.0之后的 Spring AOP集成了 AspectJ,但实际上只能说是仅仅拿来 Aspec的“皮大衣”用一下。而底层各种概念的实现以及织入方式,依然使用的是 Spring1x原先的实现体系。这就好像我们中国人说中国话,而英语在世界上较为普及并且有范围较广的影响力,我们可以学习英语,把英语拿过来为我所用,但本质上,我们还是中国人,而不是英国人。换句话说, Spring AOP还是 Spring AOP,只不过多学了门外语而已。

    spring aop是用java实现的,借鉴了@AspectJ的一些标签的名称,但是这些标签的实现仍然是spring用java写的。

    下面让我们看一下当 Spring AOP拥有了 Aspect这种表达能力之后,同样的话该怎么来说吧!@ Aspect代表一种定义 Aspect的风格,它让我们能够以POJO的形式定义 Aspect,没有其他接口定义限制。唯一需要的,就是使用相应的注解标注这些 Aspect定义的POJO类。之后, Spring AOP会根据标注的注解搜索这些 Aspect定义类,然后将其织入系统。

    这种方式是从AspectJ所引入的,定义的Aspect类基本可以在Spring AOP和 AspectJ之间通用。

    就是说同样的语法,可以简单的复制粘贴到spring aop或AspectJ系统中都可以用,但是spring aop底层仍然使用的是代理模式的原理,只是增加了支持标签这种新的外在形式而已。


    参考:
    《31–基于@AspectJ的AOP》 一个简单的基于@AspectJ的AOP例子

    展开全文
  • Spring-AOP @AspectJ切点函数导读

    千次阅读 2017-08-26 13:50:04
    target和this概述切点函数是AspectJ表达式语言的核心,也是使用@AspectJ进行切面定义的难点,本篇博文将为你揭开@AspectJ切点函数的神秘面纱@annotation()因篇幅原因,请查看另外一篇博文:Spring-AOP @AspectJ切点...

    概述

    切点函数是AspectJ表达式语言的核心,也是使用@AspectJ进行切面定义的难点,本篇博文将为你揭开@AspectJ切点函数的神秘面纱


    @annotation()

    因篇幅原因,请查看另外一篇博文:Spring-AOP @AspectJ切点函数之@annotation


    execution()

    因篇幅原因,请查看另外一篇博文: Spring-AOP @AspectJ切点函数之execution()


    args()和@args()

    因篇幅原因,请查看另外一篇博文: Spring-AOP @AspectJ切点函数之args()和@args()


    within()

    因篇幅原因,请查看另外一篇博文: Spring-AOP @AspectJ切点函数之within()


    @within()和@target()

    因篇幅原因,请查看另外一篇博文: Spring-AOP @AspectJ切点函数之@within()和@target


    target()和this()

    因篇幅原因,请查看另外一篇博文: Spring-AOP @AspectJ切点函数之target()和this()

    展开全文
  • 基于@AspectJ的AOP

    2014-10-29 13:16:33
    @aspectj
  • Spring 中基于 AOP 的 @AspectJ @AspectJ 作为通过 Java 5 注释注释的普通的 Java 类,它指的是声明 aspects 的一种风格。通过在你的基于架构的 XML 配置文件中包含以下元素,@AspectJ 支持是可用的。 &lt;...
  • Spring4.X系列之AOP-@AspectJ

    千次阅读 2017-09-22 10:03:24
    源码专栏欢迎关注 :专栏一 :Spring-AOP基础手札专栏二:Spring-AspectJ手札导读Spring-AOP注解基础Java5.0注解解读Spring-AOP 使用@AspectJSpring-AOP @AspectJ语法基础Spring-AOP @AspectJ切点函数导读Spring-AOP...
  • 本文来说下@AspectJ中的切点表达式 文章目录概述 概述
  • Spring中基于注解@AspectJ的AOP实现

    千次阅读 2020-07-26 13:09:28
    @AspectJ 作为通过 Java 5 注释注释的普通的 Java 类,它指的是声明aspects 的一种风格。通过在基于架构的 XML 配置文件中包含以下元素,@AspectJ 支持是可用的。 aop:aspectj-autoproxy/ 大致流程如下: (1) 首先...
  • @AspectJ配置Spring AOP,demo

    热门讨论 2012-03-14 01:07:56
    @AspectJ配置Spring AOP,文档,Aspect jar包, 可运行的demo,
  • @AspectJ 语法概要

    2012-04-18 23:46:00
    这是继上篇《AspectJ传统语法概要》之后,对@AspectJ语法的一个整理。 传统的AspectJ固然强大,但需要特定的编译器ajc支持。为了避免这样的依赖,以“Keeping the code plain Java”的方式去实现AOP,AspectJ提供了...
  • Spring采用AspectJ提供的@AspectJ注解类库及相应的解析类库,需要在pom.xml文件中添加aspectj.weaver和aspectj.tools类包的依赖。 1、@AspectJ使用实例: 首先是业务类的代码: public class NaiveWa
  • 基于接口的AOP配置,过于繁琐,所以Spring就使用了@AspectJ注解来简化AOP的配置。对于没有Java5.0的项目, 可以通过基于Schema的配置定义切面。 1.@AspectJ (1)使用前的准备:java是5.0以上,将Spring的asm模块...
  • 2.使用@AspectJ  2.1 使用前准备:JDK5.0以上版本 +将Spring的asm模块引入进来 +将AspcectJ注解类库及相应解析类库引入  2.2 通过代码或者spring配置使用@AspectJ切面(书P227) 3.@AspectJ语法基础(书P230) ...
  • Spring AOP 对 @AspectJ 的支持 AspectJ 是一个使用java语言编写的AOP框架,是AOP 思想的落地。AspectJ 是一个功能非常完整的AOP框架。AspectJ 里既支持对方法的建言,也支持对字段的建言。 Spring AOP 框架也是...
  • 基于@AspectJ的AOP的使用
  • 通过配置织入@Aspectj切面虽然可以通过编程的方式织入切面,但是一般情况下,我们还是使用spring的配置自动完成创建代理织入切面的工作。 通过aop命名空间的&lt;aop:aspectj-autoproxy /&gt;声明自动为...
  • Spring-AOP 使用@AspectJ

    千次阅读 2017-08-24 06:19:32
    基于Schema的aop命名空间配置的方式概述我们之前一个系列的文章,分别使用Pointcut和Advice接口描述切点和增强,并用Advisor整合二者描述切面,@AspectJ则采用注解来描述切点、增强,二者只是表述方式不同,描述内容...
  • AspectJ注解实例 使用 1、如果Spring应用程序基于XML配置,那么使用aop名称空间,因为可以让aop和DI配置保持一致; 2、如果Spring应用程序基于注解配置,那么使用@AspectJ样式注解; 3、不管使用哪种尽量保持...
  • Spring基于注解@AspectJ的AOP

    万次阅读 2015-07-07 08:55:59
    Spring除了支持XML方式配置AOP,还支持注解方式:使用@AspectJ风格的切面声明。 但是用注解方式需要在XML启用对@AspectJ的支持,将在Spring上下文创建一个AnnotationAwareAspectJAutoProxyCreator类,它会自动代理...
  • @AspectJ提供不同的通知类型 1.@Before 前置通知,相当于BeforeAdvice 2.@AfterReturning 后置通知,相当于AfterReturningAdvice 3.@Around 环绕通知,相当于MethodInterceptor 4.@AfterThrowing抛出通知,相当于...
  • @AspectJ相关文章 《spring AOP 之二:@AspectJ注解的3种配置》 《spring AOP 之三:使用@AspectJ定义切入点》 《spring AOP 之四:@AspectJ切入点标识符语法详解》 使用注解来创建切面是AspectJ 5所引入的关键...
  •  在做好上节中所提到的前置工作后,我们就可以开始编写一个基于@AspectJ的切面了,首先来看一个简单的例子,以便对@AspectJ有一个切身的认识。 下面,我们用@AspectJ注解对一个POJO进行标注,将使其成为一个切面
  • 通过编程创建@AspectJ代理 除了使用<aop:config>或<aop:aspectj-autoproxy>在配置中声明方面之外,还可以通过编程方式创建通知目标对象的代理。有关Spring的AOP API的完整细节,请参阅下一章。在这里,...
  • 1、什么是@AspectJ: @AspectJ是采用注解方法来描述切点、增强,两者只是表述的方式不同,描述的内容的本质是完全相同的,这好比一个用中文描述简爱,一个用英文描述简爱 2、@AspectJ语法基础: Spring支持9个@...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 101,445
精华内容 40,578
关键字:

@aspectj