AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring对AOP的支持

2017-11-15 760
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
  Spring对AOP的支持
4.1 AOP介绍
首先让我们从一些重要的AOP概念和术语开始。这些术语不是Spring特有的。不过AOP术语并不是特别的直观，如果Spring使用自己的术语，将会变得更加令人困惑。
·          切面（Aspect） ：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在Spring AOP中，切面可以使用基于模式或者基于@Aspect注解的方式来实现。
·          连接点（Joinpoint） ：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是表示一个方法的执行。
·          通知（Advice） ：在切面的某个特定的连接点上执行的动作。其中包括了“around”、“before”和“after”等不同类型的通知（通知的类型将在后面部分进行讨论）。许多AOP框架（包括Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。
·          切入点（Pointcut） ：匹配连接点的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。
·          引入（Introduction） ：用来给一个类型声明额外的方法或属性（也被称为连接类型声明（inter-type declaration））。Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用引入来使一个bean实现IsModified接口，以便简化缓存机制。
·          目标对象（Target Object） ： 被一个或者多个切面所通知的对象。也被称做被通知（advised）对象。既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。
·          AOP 代理（AOP Proxy） ：AOP框架创建的对象，用来实现切面契约（例如通知方法执行等等）。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。
·          织入（Weaving） ：把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。
通知类型：
  • 前置通知（Before advice）：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
  • 后置通知（After returning advice）：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
  • 异常通知（After throwing advice）：在方法抛出异常退出时执行的通知。
  • 最终通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
  • 环绕通知（Around Advice）：包围一个连接点的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行。
    环绕通知是最常用的通知类型。和AspectJ一样，Spring提供所有类型的通知，我们推荐你使用尽可能简单的通知类型来实现需要的功能。例如，如果你只是需要一个方法的返回值来更新缓存，最好使用后置通知而不是环绕通知，尽管环绕通知也能完成同样的事情。用最合适的通知类型可以使得编程模型变得简单，并且能够避免很多潜在的错误。比如，你不需要在JoinPoint上调用用于环绕通知的proceed()方法，就不会有调用的问题。在Spring 2.0中，所有的通知参数都是静态类型，因此你可以使用合适的类型（例如一个方法执行后的返回值类型）作为通知的参数而不是使用Object数组。 通过切入点匹配连接点的概念是AOP的关键，这使得AOP不同于其它仅仅提供拦截功能的旧技术。 切入点使得通知可以独立对应到面向对象的层次结构中。例如，一个提供声明式事务管理的环绕通知可以被应用到一组横跨多个对象的方法上（例如服务层的所有业务操作）。
     4.2 创建通知
       我们通过一个简单的例子来理解AOP。
       代码清单1
public   class  Foo {
     public   void  printName(String name){
       System. out .println( "The Name is : "  + name);
    }
     public   void  printAge(String age){
       System. out .println( "The Age is : "  + age);
    }
}
import  java.lang.reflect.Method;
import  org.springframework.aop.MethodBeforeAdvice;
public   class  FooBeforeAdvice  implements  MethodBeforeAdvice{
     @Override
     public   void  before(Method method, Object[] args, Object object)
            throws  Throwable {
        // 打印出类的名称
       System. out .print( "Class Name is "  +
                     object.getClass().getSimpleName() +  " " );
        // 打印出参数的值
       System. out .println( "arg is " +(String)args[0] +  " " );
    }
}
import  org.springframework.aop.framework.ProxyFactory;
public   class  Test {
     public   static   void  main(String[] args) {
       Foo foo =  new  Foo();
       FooBeforeAdvice advice =  new  FooBeforeAdvice();
        //Spring 提供的代理工厂
       ProxyFactory pf =  new  ProxyFactory();
        // 设置代理目标
       pf.setTarget( foo );
        // 为代理目标添加增强
       pf.addAdvice(advice);
        // 生成代理实例
       Foo proxy = (Foo)pf.getProxy();
       proxy.printName( "Tony" );
       proxy.printAge( "27" );
    }  
}
控制台输出信息
Class Name is Foo arg is Tony
The Name is : Tony
Class Name is Foo arg is 27
The Age is : 27
代码清单 1 中我们的 Foo.java 类有两个方法，我们创建了 FooBeforeAdvice 继承前置增强接口 MethodBeforeAdvice ，在 before 方法中我同通过参数 object 获得代理的对象信息，通过参数 args 获得代理方法的参数值，最后我们通过 ProxyFactory 将目标类和增强类融合，生成了代理实例并调用代理实例的方法。而在 Spring 中又如何配置 AOP 呢？
4.3 前置增强
代码清单 2
< bean  id = "foo"  class = "com.tony.test.Foo"  scope = "singleton" />
< bean  id = "fooBeforeAdvice"  class = "com.tony.test.FooBeforeAdvice" />
< bean  id = "proxy"
        class = "org.springframework.aop.framework.ProxyFactoryBean" >
     < property  name = "interceptorNames" > <!--  指定增强  -->
        < list >
            < value > fooBeforeAdvice </ value >
        </ list >
     </ property >
     <!--  指定目标代理 Bean -->
     < property  name = "target"  ref = "foo" />
</ bean >
import  org.springframework.beans.factory.BeanFactory;
import  org.springframework.beans.factory.xml.XmlBeanFactory;
import  org.springframework.core.io.ClassPathResource;
public   class  Test {
     public   static   void  main(String[] args) {
       ClassPathResource resource =  new
                  ClassPathResource( "spring-config-beans.xml" );
        // 实例化 BeanFactory
       BeanFactory factory =  new  XmlBeanFactory(resource);
       Foo foo = (Foo)factory.getBean( "proxy" );
       foo.printName( "Tony" );
       foo.printAge( "27" );
    }  
}
控制台信息
Class Name is Foo arg is Tony
The Name is : Tony
Class Name is Foo arg is 27
The Age is : 27
代码清单 2 中我们只需修改 Spring 的配置文件，将增强类和目标类装配起来就可以了，我们在 Test.java 就像正常的调用 Foo 一样，可是控制台取已经是被拦截了。
4.4 后置增强
代码清单 1
public   class  Foo {
     public  String printName(String name){
        return   "The Name is : "  + name;
    }
     public  String printAge(String age){
        return   "The Age is : "  + age;
    }
}
import  java.lang.reflect.Method;
import  org.springframework.aop.AfterReturningAdvice;
public   class  FooAfterAdvice  implements  AfterReturningAdvice{
     @Override // 参数分别是代理方法的返回值，被代理的方法，方法的参数，代理对象
     public   void  afterReturning(Object returnValue, Method method,
                   Object[] args,Object object)  throws  Throwable {
        // 打印出类的名称
       System. out .print( "Class Name is "  +
                         object.getClass().getSimpleName() +  " " );
        // 打印出参数的值
       System. out .println( "arg is " +
                          (String)args[0] +  " " );
        // 打印出返回值图
       System. out .println( "ReturnValue is "  +
                            returnValue.toString());
    }
}
< bean  id = "foo"  class = "com.tony.test.Foo"  scope = "singleton" />
< bean  id = "fooAfterAdvice"  class = "com.tony.test.FooAfterAdvice" />
< bean  id = "proxy"
        class = "org.springframework.aop.framework.ProxyFactoryBean" >
     < property  name = "interceptorNames" > <!--  指定增强  -->
        < list >
            < value > fooAfterAdvice </ value >
        </ list >
     </ property >
     <!--  指定目标代理 Bean -->
     < property  name = "target"  ref = "foo" />
</ bean >
控制台输出
Class Name is Foo arg is Tony
ReturnValue is The Name is : Tony
Class Name is Foo arg is 27
ReturnValue is The Age is : 27
代码清单中我们修改了 Foo.java 类两个方法都返回 String 类型的参数，定义了一个 FooAfterAdvice.java 类这个类实现了 AfterReturningAdvice 接口，分别打印出被代理类的名称，方法参数值和返回值。我们查看控制台输出的信息，发现在目标方法执行结束后还打印出增强类输出的信息。
4.5 环绕增强
代码清单 1
public   class  Foo {
     public   void  printName(String name){
       System. out .println( "The Name is : "  + name);
    }
     public   void  printAge(String age){
       System. out .println( "The Age is : "  + age);
    }
}
import  org.aopalliance.intercept.MethodInterceptor;
import  org.aopalliance.intercept.MethodInvocation;
public   class  FooInterceptor  implements  MethodInterceptor{
     @Override
     public  Object invoke(MethodInvocation invocation)  throws  Throwable {
        // 目标方法入参
       Object[] args = invocation.getArguments();
        // 打印方法入参
       System. out .println( " 准备执行目标方法 " );
        // 执行目标方法
       Object obj = invocation.proceed();
       System. out .println( " 目标方法执行完成 " );
        // 返回方法返回值
        return  obj;
    }
}
< bean  id = "foo"  class = "com.tony.test.Foo"  scope = "singleton" />
< bean  id = "fooInterceptor"  class = "com.tony.test.FooInterceptor" />
< bean  id = "fooAfterAdvice"  class = "com.tony.test.FooAfterAdvice" />
< bean  id = "proxy"
        class = "org.springframework.aop.framework.ProxyFactoryBean" >
     < property  name = "interceptorNames" > <!--  指定增强  -->
        < list >
            < value > fooInterceptor </ value >
        </ list >
     </ property >
     <!--  指定目标代理 Bean -->
     < property  name = "target"  ref = "foo" />
</ bean >
控制台输出
准备执行目标方法
The Name is : Tony
目标方法执行完成
准备执行目标方法
The Age is : 27
目标方法执行完成
代码清单 1 中我们定义了 FooInterceptor.java 实现 MethodInterceptor 接口对目标方法进行环绕增强，查看控制台我们就能看出 FooInterceptor 在每次方法的执行前后都进行了处理。









本文转自 tony_action 51CTO博客，原文链接：http://blog.51cto.com/tonyaction/85504，如需转载请自行联系原作者
文章标签：
Spring
Java
关键词：
Spring AOP
Spring支持
Spring AOP支持
余二五
目录
相关文章
游客wkqymr43luqiu
|
4月前
|
监控 安全 Java
Spring AOP实现原理
本内容主要介绍了Spring AOP的核心概念、实现机制及代理生成流程。涵盖切面（Aspect）、连接点（Join Point）、通知（Advice）、切点（Pointcut）等关键概念，解析了JDK动态代理与CGLIB代理的原理及对比，并深入探讨了通知执行链路和责任链模式的应用。同时，详细分析了AspectJ注解驱动的AOP解析过程，包括切面识别、切点表达式匹配及通知适配为Advice的机制，帮助理解Spring AOP的工作原理与实现细节。
游客wkqymr43luqiu
571 12
爱吃烤鸡翅的酸菜鱼
|
26天前
|
人工智能 监控 安全
如何快速上手【Spring AOP】？核心应用实战（上篇）
哈喽大家好吖~欢迎来到Spring AOP系列教程的上篇 - 应用篇。在本篇，我们将专注于Spring AOP的实际应用，通过具体的代码示例和场景分析，帮助大家掌握AOP的使用方法和技巧。而在后续的下篇中，我们将深入探讨Spring AOP的实现原理和底层机制。 AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架中的核心特性之一，它能够帮助我们解决横切关注点（如日志记录、性能统计、安全控制、事务管理等）的问题，提高代码的模块化程度和复用性。
爱吃烤鸡翅的酸菜鱼
264 1
爱吃烤鸡翅的酸菜鱼
|
24天前
|
设计模式 Java 开发者
如何快速上手【Spring AOP】？从动态代理到源码剖析（下篇）
Spring AOP的实现本质上依赖于代理模式这一经典设计模式。代理模式通过引入代理对象作为目标对象的中间层，实现了对目标对象访问的控制与增强，其核心价值在于解耦核心业务逻辑与横切关注点。在框架设计中，这种模式广泛用于实现功能扩展（如远程调用、延迟加载）、行为拦截（如权限校验、异常处理）等场景，为系统提供了更高的灵活性和可维护性。
爱吃烤鸡翅的酸菜鱼
104 0
运营研究坊
|
8月前
|
XML Java 开发者
Spring Boot中的AOP实现
Spring AOP（面向切面编程）允许开发者在不修改原有业务逻辑的情况下增强功能，基于代理模式拦截和增强方法调用。Spring Boot通过集成Spring AOP和AspectJ简化了AOP的使用，只需添加依赖并定义切面类。关键概念包括切面、通知和切点。切面类使用`@Aspect`和`@Component`注解标注，通知定义切面行为，切点定义应用位置。Spring Boot自动检测并创建代理对象，支持JDK动态代理和CGLIB代理。通过源码分析可深入了解其实现细节，优化应用功能。
运营研究坊
384 6
Cyan_RA9
|
7月前
|
XML Java 测试技术
Spring AOP—通知类型 和 切入点表达式 万字详解（通俗易懂）
Spring 第五节 AOP——切入点表达式 万字详解！
Cyan_RA9
344 25
Cyan_RA9
|
7月前
|
XML 安全 Java
Spring AOP—深入动态代理 万字详解（通俗易懂）
Spring 第四节 AOP——动态代理 万字详解！
Cyan_RA9
251 24
Quan_Chen
|
6月前
|
Java API 微服务
微服务——SpringBoot使用归纳——Spring Boot中的切面AOP处理——Spring Boot 中的 AOP 处理
本文详细讲解了Spring Boot中的AOP（面向切面编程）处理方法。首先介绍如何引入AOP依赖，通过添加`spring-boot-starter-aop`实现。接着阐述了如何定义和实现AOP切面，包括常用注解如`@Aspect`、`@Pointcut`、`@Before`、`@After`、`@AfterReturning`和`@AfterThrowing`的使用场景与示例代码。通过这些注解，可以分别在方法执行前、后、返回时或抛出异常时插入自定义逻辑，从而实现功能增强或日志记录等操作。最后总结了AOP在实际项目中的重要作用，并提供了课程源码下载链接供进一步学习。
Quan_Chen
672 0
Quan_Chen
|
6月前
|
Java 开发者 微服务
微服务——SpringBoot使用归纳——Spring Boot中的切面AOP处理——什么是AOP
本文介绍了Spring Boot中的切面AOP处理。AOP（Aspect Oriented Programming）即面向切面编程，其核心思想是分离关注点。通过AOP，程序可以将与业务逻辑无关的代码（如日志记录、事务管理等）从主要逻辑中抽离，交由专门的“仆人”处理，从而让开发者专注于核心任务。这种机制实现了模块间的灵活组合，使程序结构更加可配置、可扩展。文中以生活化比喻生动阐释了AOP的工作原理及其优势。
Quan_Chen
288 0
Harry技术
|
8月前
|
存储 安全 Java
Spring Boot 3 集成Spring AOP实现系统日志记录
本文介绍了如何在Spring Boot 3中集成Spring AOP实现系统日志记录功能。通过定义`SysLog`注解和配置相应的AOP切面，可以在方法执行前后自动记录日志信息，包括操作的开始时间、结束时间、请求参数、返回结果、异常信息等，并将这些信息保存到数据库中。此外，还使用了`ThreadLocal`变量来存储每个线程独立的日志数据，确保线程安全。文中还展示了项目实战中的部分代码片段，以及基于Spring Boot 3 + Vue 3构建的快速开发框架的简介与内置功能列表。此框架结合了当前主流技术栈，提供了用户管理、权限控制、接口文档自动生成等多项实用特性。
Harry技术
531 8
互联网课堂
|
10月前
|
XML Java 数据安全/隐私保护
Spring Aop该如何使用
本文介绍了AOP（面向切面编程）的基本概念和术语，并通过具体业务场景演示了如何在Spring框架中使用Spring AOP。文章详细解释了切面、连接点、通知、切点等关键术语，并提供了完整的示例代码，帮助读者轻松理解和应用Spring AOP。
互联网课堂
269 2
Spring Aop该如何使用

热门文章

最新文章

  • 1
    如何快速上手【Spring AOP】？核心应用实战（上篇）
  • 2
    深度剖析【Spring】事务：万字详解，彻底掌握传播机制与事务原理
  • 3
    如何快速上手【Spring AOP】？从动态代理到源码剖析（下篇）
  • 4
    （ElasticsSearch学习）歌词检索Demo的实现：二. 搭建spring boot+spring data+jest+elasticsearch环境，实现歌词的全文检索
  • 5
    SpringMVC Spring MyBatis整合（二）
  • 6
    SpringCloud极简入门-配置中心Spring Cloud Config
  • 7
    Spring Boot多数据源配置与使用
  • 8
    详细解读 Spring AOP 面向切面编程（二）
  • 9
    Spring4-EL表达式-xml形式
  • 10
    spring笔记--使用springAPI以及自定义类 实现AOP的一个例子
  • 1
    一键上天！如何将Spring PetClinic瞬间迁移到云端函数计算平台
    123
  • 2
    手动实现 Spring Boot 日志链路追踪：提升调试效率的利器
    475
  • 3
    SpringBoot的三种缓存技术(Spring Cache、Layering Cache 框架、Alibaba JetCache 框架)
    2498
  • 4
    Spring Boot 基于 SCRAM 认证集成 Kafka 的详解
    545
  • 5
    如何快速搭建一个 Spring Boot 项目？
    468
  • 6
    Spring Boot 项目怎么使用策略模式？
    476
  • 7
    JeecgBoot 低代码平台快速集成 Spring AI
    397
  • 8
    Spring Boot API参数读取秘籍大公开！6大神器助你秒变参数处理大师，让你的代码飞起来！
    237
  • 9
    深入解析 Spring 配置文件：从基础到高级
    206
  • 10
    使用 @Audited 增强Spring Boot 应用程序的数据审计能力
    371

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第三阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库
    • 下一篇
    蛋白质语言模型 ProGen：在实验室合成由 AI 预测的蛋白质