精华内容
下载资源
问答
  • 关于aop正确的是
    2020-04-22 22:25:37

    AOP简介

    1、术语

    横切关注点:从每个方法中抽取出来的同一类非核心业务。

    切面(Aspect):封装横切关注点信息的类,每个关注点体现为一个通知方法。

    通知(Advice):切面必须要完成的各个具体工作

    目标(Target):被通知的对象。

    代理(Proxy):向目标对象应用通知之后创建的代理对象。

    连接点(Joinpoint):横切关注点在程序代码中的具体体现,对应程序执行的某个特定位置。

    切入点(pointcut):定位连接点的方式。

    2、通知类型

    • 前置通知,在方法执行之前执行
    • 后置通知,在方法执行之后执行
    • 返回通知,在方法返回结果之后执行
    • 异常通知,在方法抛出异常之后执行
    • 环绕通知,围绕着方法执行
    更多相关内容
  • aop是spring的两大功能模块之一,功能非常强大,为解耦提供了非常优秀的解决方案。下面这篇文章主要给大家介绍了如何在Spring Boot框架中使用AOP的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考下
  • AOP面向切面编程(Aspect Oriented Programming),是通过预编译方式和运行期动态代理实现程序功能的统一...下面这篇文章主要给大家介绍了关于利用C#实现AOP常见的几种方法,需要的朋友可以参考借鉴,下面来一起看看吧。
  • 主要介绍了Spring AOP实现Redis缓存数据库查询的相关内容,源码部分还是不错的,需要的朋友可以参考下。
  • AOP拦截EL表达式

    2018-04-28 09:14:27
    网上很不容易找到的关于AOP拦截EL表达式的正确打开方式,比如:http://www.cnblogs.com/ph123/p/5631030.html这种根本就不准确
  • Springboot:如何正确使用AOP

    千次阅读 2022-03-10 16:25:12
    Springboot:如何正确使用AOP

    Springboot:如何正确使用AOP

    一、AOP概念

    • 切面(Aspect)

      一个关注点的模块化,这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在Spring AOP中,切面可以使用基于模式或者基于@Aspect注解的方式来实现
      
    • 连接点(JoinPoint)

      在程序执行过程中某个特定的点,比如某方法调用的时候或者处理异常的时候。在SpringAOP中,一个连接点总是表示一个方法的执行
      
    • 通知(Advice)

      在切面的某个特定的连接点上执行的动作。其中包括了Around、Before和After等不同类型的通知。许多AOP框架(包括Spring)都是以拦截器做通知模型,并维护一个以连接点为中心的拦截器链
      
    • 切入点(PointCut)

      匹配连接点的断言。通知和一个切入点表达式关联,并在满足这个切入点的连接点上运行(例如,当执行某个特定名称的方法时),切入点表达式如何和连接点匹配是AOP的核心:Spring缺省使用AspectJ切入点语法
      
    • 引入(Intorduction)

      用来给一个类型声明额外的方法或属性(也被称为连接类型声明)。Spring允许引入新的接口(以及一个对应的实现)到任何被代理的对象。例如,你可以使用引入来使一个bean实现接口,以便简化缓存机制
      
    • 目标对象(Target Object)

      被一个或者多个切面所通知的对象。也被称做被通知对象。既然Spring AOP是通过运行时代理实现的,这个对象永远是一个被代理对象
      
    • AOP代理(Aop proxy)

      AOP框架创建的对象,用来实现切面契约(例如通知方法执行等等)。在Spring中,AOP代理可以是JDK动态代理或者CGLIB代理
      
    • 植入(weaving)

      把切面连接到其它的应用程序类型或者对象上,并创建一个被通知的对象。这些可以在编译时(例如使用AspectJ编译器),类加载时和运行时完成。Spring和其他纯Java AOP框架一样,在运行时完成织入
      

    二、切点表达式

    execution表达式

    用于匹配方法执行的连接点,属于方法级别

    语法:

    execution(修饰符 返回值类型 方法名(参数)异常)

    语法参数描述
    修饰符可选,如public,protected,写在返回值前,任意修饰符填*号就可以
    返回值类型必选,可以使用*来代表任意返回值
    方法名必选,可以用*来代表任意方法
    参数()代表是没有参数,(..)代表是匹配任意数量,任意类型的参数,当然也可以指定类型的参数进行匹配,如要接受一个String类型的参数,则(java.lang.String), 任意数量的String类型参数:(java.lang.String..)
    异常可选,语法:throws 异常,异常是完整带包名,可以是多个,用逗号分隔

    符号:

    符号描述
    *匹配任意字符
    匹配多个包或者多个参数
    +表示类及其子类

    条件符:

    符号描述
    &&、and
    ||
    !

    案例

    拦截com.gj.web包下的所有子包里的任意类的任意方法

    execution(* com.gj.web..*.*(..))
    

    拦截com.gj.web.api.Test2Controller下的任意方法

    execution(* com.gj.web.api.Test2Controller.*(..))
    

    拦截任何修饰符为public的方法

    execution(public * * (..))
    

    拦截com.gj.web下的所有子包里的以ok开头的方法

    execution(* com.gj.web..*.ok*(..))
    

    三、AOP通知

    在切面类中需要定义切面方法用于响应响应的目标方法,切面方法即为通知方法,通知方法需要用注解标识,AspectJ支持5种类型的通知注解

    注解描述
    @Before前置通知, 在方法执行之前执行
    @After后置通知, 在方法执行之后执行
    @AfterReturn返回通知, 在方法返回结果之后执行
    @AfterThrowing异常通知, 在方法抛出异常之后
    @Around环绕通知,围绕方法的执行
    • @Before

          @Before("testCut()")
          public void cutProcess(JoinPoint joinPoint) {
              MethodSignature signature = (MethodSignature) joinPoint.getSignature();
              Method method = signature.getMethod();
              System.out.println("注解方式AOP开始拦截, 当前拦截的方法名: " + method.getName());
          }
      
    • @After

          @After("testCut()")
          public void after(JoinPoint joinPoint) {
              MethodSignature signature = (MethodSignature) joinPoint.getSignature();
              Method method = signature.getMethod();
              System.out.println("注解方式AOP执行的方法 :"+method.getName()+" 执行完了");
          }
      
    • @AfterReturn:其中value表示切点方法,returning表示返回的结果放到result这个变量中

          /**
           * returning属性指定连接点方法返回的结果放置在result变量中
           * @param joinPoint 连接点
           * @param result 返回结果
           */
          @AfterReturning(value = "testCut()",returning = "result")
          public void afterReturn(JoinPoint joinPoint, Object result) {
              MethodSignature signature = (MethodSignature) joinPoint.getSignature();
              Method method = signature.getMethod();
              System.out.println("注解方式AOP拦截的方法执行成功, 进入返回通知拦截, 方法名为: "+method.getName()+", 返回结果为: "+result.toString());
          }
      
    • @AfterThrowing:其中value表示切点方法,throwing表示异常放到e这个变量

          @AfterThrowing(value = "testCut()", throwing = "e")
          public void afterThrow(JoinPoint joinPoint, Exception e) {
              MethodSignature signature = (MethodSignature) joinPoint.getSignature();
              Method method = signature.getMethod();
              System.out.println("注解方式AOP进入方法异常拦截, 方法名为: " + method.getName() + ", 异常信息为: " + e.getMessage());
          }
      
    • @Around

          @Around("testCut()")
          public Object testCutAround(ProceedingJoinPoint joinPoint) throws Throwable {
              System.out.println("注解方式AOP拦截开始进入环绕通知.......");
                  Object proceed = joinPoint.proceed();
                  System.out.println("准备退出环绕......");
                  return proceed;
          }
      

    四、springboot中使用AOP

    导出依赖

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    

    在这里插入图片描述

    自定义注解

    package com.hl.springbootrunner.aop;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface AOPAnnotations {
    }
    

    创建切面类

    package com.hl.springbootrunner.aop;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    
    
    @Aspect
    @Component
    public class TestAspect {
    
        /**
         * 这里的路径填自定义注解的全路径
         */
        @Pointcut("@annotation(com.hl.springbootrunner.aop.AOPAnnotations)")
        public void testCut() {
    
        }
    
        @Before("testCut()")
        public void cutProcess(JoinPoint joinPoint) {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            System.out.println("注解方式AOP开始拦截, 当前拦截的方法名: " + method.getName());
        }
    
        @After("testCut()")
        public void after(JoinPoint joinPoint) {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            System.out.println("注解方式AOP执行的方法 :" + method.getName() + " 执行完了");
        }
    
    
        @Around("testCut()")
        public Object testCutAround(ProceedingJoinPoint joinPoint) throws Throwable {
            System.out.println("注解方式AOP拦截开始进入环绕通知.......");
            Object proceed = joinPoint.proceed();
            System.out.println("准备退出环绕......");
            return proceed;
        }
    
        /**
         * returning属性指定连接点方法返回的结果放置在result变量中
         *
         * @param joinPoint 连接点
         * @param result    返回结果
         */
        @AfterReturning(value = "testCut()", returning = "result")
        public void afterReturn(JoinPoint joinPoint, Object result) {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            System.out.println("注解方式AOP拦截的方法执行成功, 进入返回通知拦截, 方法名为: " + method.getName() + ", 返回结果为: " + result.toString());
        }
    
        @AfterThrowing(value = "testCut()", throwing = "e")
        public void afterThrow(JoinPoint joinPoint, Exception e) {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            System.out.println("注解方式AOP进入方法异常拦截, 方法名为: " + method.getName() + ", 异常信息为: " + e.getMessage());
        }
    
    }
    

    自定义一个接口

    @RestController
    public class TestController {
     
        @GetMapping("/ok")
        @AOPAnnotations
        public String test2() {
            return "ok";
        }
     
    }
    

    测试

    在这里插入图片描述

    展开全文
  • 关于AOP的理解

    2019-10-17 16:57:18
    AOP概览 什么是AOP 在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个 热点,也是...

    AOP概览

    什么是AOP

    在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方
    式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个
    热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑
    的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高
    了开发的效率。

    AOP中的相关概念

    Aspect(切面): Aspect 声明类似于 Java 中的类声明,在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
    Joint point(连接点):表示在程序中明确定义的点,典型的包括方法调用,对类成员的访问以及异常处理程序块的执行等等,它自身还可以嵌套其它 joint point。
    Pointcut(切点):表示一组 joint point,这些 joint point 或是通过逻辑关系组合起来,或是通过通配、正则表达式等方式集中起来,它定义了相应的 Advice 将要发生的地方。
    Advice(增强):Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作,它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
    Target(目标对象):织入 Advice 的目标对象.。
    Weaving(织入):将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程

    展开全文
  • 主要介绍了Spring Boot使用AOP防止重复提交的方法示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了Springboot接口项目如何使用AOP记录日志,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Spring AOP切面解决数据库读写分离实例详解 为了减轻数据库的压力,一般会使用数据库主从(master/slave)的方式,但是这种方式会给应用程序带来一定的麻烦,比如说,应用程序如何做到把数据写到master库,而读取数据...
  • 主要介绍了Spring AOP实现权限检查的功能,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 如何正确使用AOP

    千次阅读 2017-03-24 17:21:44
    这篇主要讲讲,AOP如何正确的使用它。 首先需要知道,目前毕竟流行的AOP框架,上篇文章也介绍了AOP实现的原理,对Spring这个大家庭来说,它的AOP远远没有这么简单。目前使用毕竟多的 几种方式如下: Jboss Aop:...

    AOP也发展了不久了,虽然在工作上也一直在用,不过毕竟没有深入了解过,停留在概念上的理解,和使用的阶段上。这篇主要讲讲,AOP如何正确的使用它。


    首先需要知道,目前毕竟流行的AOP框架,上篇文章也介绍了AOP实现的原理,对Spring这个大家庭来说,它的AOP远远没有这么简单。目前使用毕竟多的

    几种方式如下:

    • Jboss Aop:基本上没有用过,所以没有发言权,Jboos毕竟之前毕竟火AOP也有自己的一套,现在jboss慢慢分离出来很多东西,独立出来,感觉是Jboss Aop用的不多了。
    • Spring Aop:Spring自己原生的Aop,只能用一个词来形容:难用。 你需要实现大量的接口,继承大量的类,所以spring aop一度被千夫所指。这于他的无侵入,低耦合完全冲突。不过Spring对开源的优秀框架,组建向来是采用兼容,并入的态度。所以,后来的Spring 就提供了Aspectj支持,也就是我们后来所说的基于纯POJO的Aop。本人也是推进Aspectj实现AOP的
    •   Aspectj  这是一个AOP编程语言,一种基于Java平台的面向切面编程的语言,官网地址是http://www.eclipse.org/aspectj/,基本语法还是比较简单的,但毕竟整合起来,因此虽然比较好用,但也不常见了

       区别:spring Aop采用的动态织入,而Aspectj是静态织入。静态织入:指在编译时期就织入,即:编译出来的class文件,字节码就已经被织入了。动态织入又分静动两种,静则指织入过程只在第一次调用时执行;动则指根据代码动态运行的中间状态来决定如何操作,每次调用Target的时候都执行。有不清楚的同学,可以自己补下基础的代理知识。


    AOP的一些术语

        pointcut: 是一个(组)基于正则表达式的表达式,有点绕,就是说他本身是一个表达式,但是他是基于正则语法的。通常一个pointcut,会选取程序中的某些我们感兴趣的执行点,或者说是程序执行点的集合。"execution(public * cn.com.sinodata..*.*Controller.*(..))"

       joinPoint: 通过pointcut选取出来的集合中的具体的一个执行点,我们就叫JoinPoint.

       Advice: 在选取出来的JoinPoint上要执行的操作、逻辑。

       aspect: 就是我们关注点的模块化。这个关注点可能会横切多个对象和模块,事务管理是横切关注点的很好的例子。它是一个抽象的概念,从软件的角度来说是指在应用程序不同模块中的某一个领域或方面。由pointcut 和  advice组成。

       Target:被aspectj横切的对象。我们所说的joinPoint就是Target的某一行,如方法开始执行的地方、方法类调用某个其他方法的代码。


     aspect一般放在处理AOP最上面,我们把需要处理的AOP业务放在这个类里面,pointcut 和  advice组成。  pointcut 用类似正则表达式选择需要进行AOP的集合,joinPoint是针对pointcut 具体执行的一个点。而Advice则是具体需要做什么,Advice的參數需要和pointcut的方法名一致。有四种类型。

    1:before advice 在方法执行前执行。

    2:after  returning  advice 在方法执行后返回一个结果后执行。

    3:after  throwing advice 在方法执行过程中抛出异常的时候执行。

    4:Around  advice 在方法执行前后和抛出异常时执行,相当于综合了以上三种通知。

    一般 Around  就行了。

    展开全文
  • 文章目录Spring AOP 的登场什么是 Spring AOPSpring AOP 原理代理模式的两种常见实现方法:动态代理、静态代理Spring AOP 上手使用Spring AOP 的优势和缺点Spring AOP 总结 Spring AOP 的登场 在工作中经常会遇到...
  • 主要介绍了Spring Boot 通过AOP和自定义注解实现权限控制,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 本篇文章主要介绍了SpringBoot中使用AOP打印接口日志的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 面向切面编程(AOP)是面向对象编程的补充,简单来说就是统一处理某一“切面”的问题的编程思想。如果使用AOP的方式进行日志的记录和处理,所有的日志代码都集中于一处,不需要再每个方法里面都去添加,极大减少了...
  • 主要给大家介绍了关于Spring中IOC和AOP的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 最近公司重构项目,重构为最热的微服务框架 spring boot, 重构的时候遇到几个可以统一处理的问题。这篇文章主要介绍了spring boot+自定义 AOP 实现全局校验 ,需要的朋友可以参考下
  • 主要给大家介绍了关于Spring AOP在web应用中的使用方法,文中通过示例代码介绍的非常详细,对大家学习或者使用Spring AOP具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 主要介绍了spring boot aop 记录方法执行时间代码示例,分享了相关代码,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下
  • Spring Boot使用AOP正确姿势

    千次阅读 2020-07-22 22:56:57
    面向切面编程(AOP)是面向对象编程的补充,简单来说就是统一处理某一“切面”的问题的编程思想。如果使用AOP的方式进行日志的记录和处理,所有的日志代码都集中于一处,不需要再每个方法里面都去添加,极大减少了...
  • 什么是AOP & AspectJ AOP

    2018-08-03 16:50:52
    一、为什么要用AOP?什么是AOP? 为什么要用AOP?  面向对象的特点是继承、封装和多态,而封装要求将功能分散到不同的对象中,伴随着业务系统越来越复杂,我们的核心业务中会参杂一些特殊业务,比如日志记录、...
  • 主要介绍的Springboot使用@Valid 和AOP做参数校验及日志输出问题,本文通过代码讲解的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 介绍 Spring AOP 的概念、动态模式、入门案例。
  • 主要给大家介绍了关于Android中AOP的应用实践之过滤重复点击的相关资料,文中通过示例代码介绍的非常详细,对各位Android开发者们具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • aop详细介绍

    2018-12-06 23:17:42
    Spring中的AOP代理还是离不开Spring的IOC容器,代理的生成,管理及其依赖关系都是由IOC容器负责,Spring默认使用JDK动态代理,在需要代理类而不是代理接口的时候,Spring会自动切换为使用CGLIB代理,不过现在的项目...
  • 我们定义方法,写各种各样的表达式,目标就是要匹配正确的方法做类增强。 所以,我们就遇到了第一个坑点:为什么AOP的切点定义不起作用? 大方向有两个原因: 切点定义有问题 Spring为你生成的根本不是代理对象 第二...
  • Spring Mvc Aop

    2016-06-28 15:17:27
    AOP一直无效,如何如何设置都不生效,困扰了一天,终于可以了,特此说明一下,但不代表我理解的就是正确的。 环境: springmvc + maven 基于注解的配置方式
  • 保证理解 aop 这一篇就够了!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,731
精华内容 19,492
关键字:

关于aop正确的是