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

Spring AOP动态代理原理与实现方式

2016-10-27 1400
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： AOP:面向切面、面向方面、面向接口是一种横切技术横切技术运用：1.事务管理: (1)数据库事务:(2)编程事务(3)声明事物:Spring AOP-->声明事物   2.

AOP:面向切面、面向方面、面向接口是一种横切技术
横切技术运用：
1.事务管理: (1)数据库事务:(2)编程事务(3)声明事物:Spring AOP-->声明事物   
2.日志处理:
3.安全验证: Spring AOP---OOP升级  
  

静态代理原理：目标对象：调用业务逻辑    代理对象：日志管理
表示层调用--->代理对象(日志管理)-->调用目标对象

动态代理原理：spring AOP采用动态代理来实现
(1)实现InvocationHandler接口

(2)创建代理类(通过java API)

Proxy.newProxyInstance(动态加载代理类,代理类实现接口,使用handler);

(3)调用invoke方法(虚拟机自动调用方法)

日志处理
 //调用目标对象
 method.invoke("目标对象","参数");
 日志处理

通过代理对象--(请求信息)-->目标对象---(返回信息)----> 代理对象

 

Spring 动态代理中的基本概念

1、关注点(concern)
   一个关注点可以是一个特定的问题，概念、或者应用程序的兴趣点。总而言之，应用程序必须达到一个目标
   安全验证、日志记录、事务管理都是一个关注点
   在oo应用程序中，关注点可能已经被代码模块化了还可能散落在整个对象模型中
2、横切关注点(crosscutting concern)
   如何一个关注点的实现代码散落在多个类中或方法中
3、方面(aspect)
   一个方面是对一个横切关注点模块化，它将那些原本散落在各处的，
   用于实现这个关注点的代码规整在一处
4、建议(advice)通知
   advice是point cut执行代码，是方面执行的具体实现
5、切入点(pointcut)
   用于指定某个建议用到何处
6、织入(weaving)
   将aspect(方面)运用到目标对象的过程
7、连接点(join point)
  程序执行过程中的一个点 

通知类型：
  try{
    //前置通知
         //环绕通知
            //调用目标对象方法
         //环绕通知
    //后置通知
  }catch(){
    //异常通知
  }finally{
    //终止通知
  }

 

流程图

 

一.静态代理原理实例：

项目结构图：                                                                    

IUserServ接口代码

[java] view plain copy
  1. public interface IUserServ {  
  2.     List<User> findAllUser();  
  3.     int deleteUserById(User user);  
  4.     int saveUser(User user);  
  5. }  


UserServImpl实现类代码

[java] view plain copy
  1. public class UserServImpl implements IUserServ {  
  2.     public int deleteUserById(User user) {  
  3.         System.out.println("******执行删除方法******");  
  4.         return 0;  
  5.     }  
  6.     public List<User> findAllUser() {  
  7.         System.out.println("*******执行查询方法*******");  
  8.         return null;  
  9.     }  
  10.     public int saveUser(User user) {  
  11.         System.out.println("*******执行添加方法********");  
  12.         return 0;  
  13.     }  
  14. }  

UserServProxyImpl实现类代码

[java] view plain copy
  1. //代理类:完成日志输出  
  2. public class UserServProxyImpl implements IUserServ {  
  3.     // 访问目标对象(UserServImpl)  
  4.     // 代理对象(UserServProxyImpl)  
  5.     // 创建目标对象  
  6.     private IUserServ iuserServ ;//= new UserServImpl();  
  7.   
  8.     public UserServProxyImpl(IUserServ iuserServ){  
  9.         this.iuserServ = iuserServ;  
  10.     }  
  11.     public int deleteUserById(User user) {  
  12.         beforeLog();  
  13.         //调用目标对象里方法  
  14.         iuserServ.deleteUserById(user);  
  15.         afterLog();  
  16.         return 0;  
  17.     }  
  18.   
  19.     public List<User> findAllUser() {  
  20.         beforeLog();  
  21.         //调用目标对象里方法  
  22.         iuserServ.findAllUser();  
  23.         afterLog();  
  24.         return null;  
  25.     }  
  26.   
  27.     public int saveUser(User user) {  
  28.         beforeLog();  
  29.         //调用目标对象里方法  
  30.         iuserServ.saveUser(user);  
  31.         afterLog();  
  32.         return 0;  
  33.     }  
  34.   
  35.     private void beforeLog() {  
  36.         System.out.println("开始执行");  
  37.     }  
  38.       
  39.     private void afterLog() {  
  40.         System.out.println("执行完毕");  
  41.     }  
  42. }  

ActionTest测试类代码

[java] view plain copy
  1. public class ActionTest {  
  2.     public static void main(String[] args) {  
  3.         //用户访问代理对象---信息->目标对象  
  4.         IUserServ iuserServ = new UserServProxyImpl(new UserServImpl());  
  5.         iuserServ.findAllUser();  
  6.     }  
  7. }  

运行结果：

开始执行
*******执行查询方法*******
执行完毕
二.动态代理实例

项目结构图:

IUserServ接口代码与UserServImpl实现类代码和上述代码相同

LogHandler类代码

[java] view plain copy
  1. public class LogHandler implements InvocationHandler {  
  2.     //目标对象  
  3.     private Object targetObject;  
  4.     /** 
  5.      * 创建动态代理类 
  6.      * @return object(代理类) 
  7.      */  
  8.     public Object createProxy(Object targetObject){  
  9.         this.targetObject = targetObject;  
  10.         return Proxy.newProxyInstance(  
  11.                 targetObject.getClass().getClassLoader(),   
  12.                     targetObject.getClass().getInterfaces(), this);  
  13.     }  
  14.     @Override  
  15.     public Object invoke(Object proxy, Method method, Object[] args)  
  16.             throws Throwable {  
  17.         Object obj = null;  
  18.         try {  
  19.             beforeLog();  
  20.             //obj： 目标对象--->代理对象的返回值--->返回给调用者的信息  
  21.             //this.invoke("目标对象","代理对象给目标对象传递参数");  
  22.             //调用目标对象中方法  
  23.             obj = method.invoke(targetObject, args);  
  24.             afterLog();  
  25.         } catch (Exception e) {  
  26.             e.printStackTrace();  
  27.         }  
  28.         return obj;  
  29.     }  
  30.       
  31.     //日志管理方法  
  32.     private void beforeLog(){  
  33.         System.out.println("开始执行");  
  34.     }  
  35.       
  36.     private void afterLog(){  
  37.         System.out.println("执行完毕");  
  38.     }  
  39.   
  40. }  

ActionTest测试类代码:

[java] view plain copy
  1. public class ActionTest {  
  2.     public static void main(String[] args) {  
  3.         //创建代理对象iuserServ  
  4.         LogHandler handler = new LogHandler();  
  5.         IUserServ iuserServ = (IUserServ)handler.createProxy(new UserServImpl());  
  6.         iuserServ.deleteUserById(new User());  
  7.     }  
  8. }  

运行结果:
开始执行
******执行删除方法******
执行完毕
三.Spring AOP使用（2.x版本之前）

项目结构图:



IUserServ接口代码与UserServImpl实现类代码和上述代码相同

配置步骤：

1、配置目标对象(applicationContext.xml)

[html] view plain copy
  1. <bean id="userServTarget" class="com.tarena.biz.impl.UserServImpl"/>   

 2、配置通知
(a)前置通知(BeforeLogAdvice)

[java] view plain copy
  1. public class BeforeLogAdvice implements MethodBeforeAdvice {  
  2.      /** 
  3.         * Method method:调用目标对象的方法 
  4.         * Object[] args:发送给目标对象的参数列表 
  5.         * Object target:目标对象 
  6.         */  
  7.     public void before(Method method, Object[] args, Object target)  
  8.             throws Throwable {  
  9.         beforeLog();  
  10.     }  
  11.     private void beforeLog(){  
  12.         System.out.println("开始执行");  
  13.     }  
  14. }  


(b)后置通知(AfterLogAdvice)

[java] view plain copy
  1. public class AfterLogAdvice implements AfterReturningAdvice {  
  2.       /** 
  3.         * Object returnValue:目标对象返回值 
  4.         *  Method method:目标对象方法名 
  5.         *  Object[] args:目标对象参数列表 
  6.         *  Object target:目标对象 
  7.         */  
  8.     public void afterReturning(Object returnValue, Method method,  
  9.             Object[] args, Object target) throws Throwable {  
  10.         afterLog();  
  11.     }  
  12.     private void afterLog(){  
  13.         System.out.println("执行完毕");  
  14.     }  
  15. }  

       

(c)在spring容器中，让容器管理通知(applicationContext.xml)

[html] view plain copy
  1. <!-- 定义通知 -->  
  2.         <!-- 前置通知 -->  
  3.         <bean id="beforeLogAdvice" class="com.tarena.advice.BeforeLogAdvice"/>  
  4.         <!-- 后置通知 -->  
  5.         <bean id="afterLogAdvice" class="com.tarena.advice.AfterLogAdvice"/>  


3、配置代理对象(applicationContext.xml)  

[html] view plain copy
  1. <!-- 代理类作用: 生成代理类，织入通知 -->    
  2.   <bean id="userServProxy"   
  3.    class="org.springframework.aop.framework.ProxyFactoryBean">  
  4.    <property name="interfaces">  
  5.    <!-- 可以添加多个接口 -->  
  6.     <list>  
  7.      <value>com.tarena.biz.IUserServ</value>  
  8.     </list>  
  9.    </property>  
  10.    <!-- 引入通知 -->  
  11.    <property name="interceptorNames">  
  12.     <list>  
  13.      <value>beforeLogAdvice</value>  
  14.      <value>afterLogAdvice</value>  
  15.     </list>  
  16.    </property>  
  17.    <!-- 目标对象 -->  
  18.    <property name="target" ref="userServTarget"/>  
  19.   </bean>  


 4.访问()
Spring容器：通过代理对象调用-->织入通知--->目标对象
程序员:访问代理对象   

测试类(ActionTest):

[java] view plain copy
  1. public class ActionTest {  
  2.     public static void main(String[] args) {  
  3.         ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");  
  4.         IUserServ iuserServ = (IUserServ)ac.getBean("userServProxy");  
  5.         iuserServ.deleteUserById(new User());  
  6.         iuserServ.findAllUser();  
  7.     }  
  8. }  

运行结果:

开始执行
******执行删除方法******
执行完毕
开始执行
*******执行查询方法*******
执行完毕
四.Spring AOP使用（2.x版本之后）这种方式需要额外添加两个jar包，

存放位置在spring-framework-2.5.6.SEC01\lib\aspectj文件夹下。

项目结构图


IUserServ接口代码与UserServImpl实现类代码和上述代码相同

LogAdvice中

[java] view plain copy
  1. public class LogAdvice {  
  2.     public void beforeLog(){  
  3.         System.out.println("开始执行");  
  4.     }  
  5.     public void afterLog(){  
  6.         System.out.println("执行完毕");  
  7.     }  
  8. }  

applicationContext.xml中

[html] view plain copy
  1. <!-- spring2.x后 -->  
  2.     <!-- 目标对象 -->  
  3.     <bean id="userServImpl" class="com.tarena.biz.impl.UserServImpl"/>  
  4.     <!-- 通知 -->  
  5.     <bean id="logAdvice" class="com.tarena.advice.LogAdvice"/>  
  6.       
  7.     <aop:config>  
  8.         <aop:aspect id="logAspect" ref="logAdvice">  
  9.             <!-- 切入点 -->  
  10.             <aop:pointcut id="beforePointCut"   
  11.         expression="execution(* saveUser*(..))"/>  
  12.         <aop:pointcut id="afterPointCut"   
  13.         expression="execution(* saveUser*(..))"/>  
  14.               
  15.             <!-- 织入(通知作用于切入点) -->  
  16.             <aop:before method="beforeLog" pointcut-ref="beforePointCut"/>  
  17.             <aop:after method="afterLog" pointcut-ref="afterPointCut"/>  
  18.         </aop:aspect>  
  19.     </aop:config>  

测试类：

[java] view plain copy
  1. public class ActionTest {  
  2.     public static void main(String[] args) {  
  3.         ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");  
  4.         IUserServ iuserServ = (IUserServ)ac.getBean("userServImpl");  
  5.         iuserServ.deleteUserById(new User());  
  6.         iuserServ.findAllUser();  
  7.         iuserServ.saveUser(new User());  
  8.     }  
  9. }  

运行结果
******执行删除方法******
*******执行查询方法*******
开始执行
*******执行添加方法********
执行完毕

注:如果要在业务层所有的方法前后添加日志文件,则需要更改为以下配置

[html] view plain copy
  1. <aop:pointcut id="beforePointCut"   
  2.         expression="execution(* com.tarena.biz.*.*(..))"/>  
  3.         <aop:pointcut id="afterPointCut"   
  4.         expression="execution(* com.tarena.biz.*.*(..))"/>  


运行结果:

开始执行
******执行删除方法******
执行完毕
开始执行
*******执行查询方法*******
执行完毕
开始执行
*******执行添加方法********
执行完毕
文章标签：
日志服务
Java
Spring
容器
关键词：
Spring AOP
Spring原理
Spring动态代理
aop动态代理
Spring AOP动态代理
相关实践学习
【涂鸦即艺术】基于云应用开发平台CAP部署AI实时生图绘板
【涂鸦即艺术】基于云应用开发平台CAP部署AI实时生图绘板
biubiubiu!
目录
相关文章
爱吃烤鸡翅的酸菜鱼
|
2月前
|
缓存 Java 开发者
【Spring】原理：Bean的作用域与生命周期
本文将围绕 Spring Bean 的作用域与生命周期展开深度剖析，系统梳理作用域的类型与应用场景、生命周期的关键阶段与扩展点，并结合实际案例揭示其底层实现原理，为开发者提供从理论到实践的完整指导。
爱吃烤鸡翅的酸菜鱼
450 22
爱吃烤鸡翅的酸菜鱼
|
2月前
|
人工智能 Java 开发者
【Spring】原理解析：Spring Boot 自动配置
Spring Boot通过“约定优于配置”的设计理念，自动检测项目依赖并根据这些依赖自动装配相应的Bean，从而解放开发者从繁琐的配置工作中解脱出来，专注于业务逻辑实现。
爱吃烤鸡翅的酸菜鱼
1112 0
HELLO程序员
|
2月前
|
XML 安全 Java
使用 Spring 的 @Aspect 和 @Pointcut 注解简化面向方面的编程 (AOP)
面向方面编程（AOP）通过分离横切关注点，如日志、安全和事务，提升代码模块化与可维护性。Spring 提供了对 AOP 的强大支持，核心注解 `@Aspect` 和 `@Pointcut` 使得定义切面与切入点变得简洁直观。`@Aspect` 标记切面类，集中处理通用逻辑；`@Pointcut` 则通过表达式定义通知的应用位置，提高代码可读性与复用性。二者结合，使开发者能清晰划分业务逻辑与辅助功能，简化维护并提升系统灵活性。Spring AOP 借助代理机制实现运行时织入，与 Spring 容器无缝集成，支持依赖注入与声明式配置，是构建清晰、高内聚应用的理想选择。
HELLO程序员
405 0
一枚后端工程狮
|
1月前
|
XML Java 数据格式
《深入理解Spring》：AOP面向切面编程深度解析
Spring AOP通过代理模式实现面向切面编程，将日志、事务等横切关注点与业务逻辑分离。支持注解、XML和编程式配置，提供五种通知类型及丰富切点表达式，助力构建高内聚、低耦合的可维护系统。
一枚后端工程狮
429 7
一枚后端工程狮
|
1月前
|
XML Java 测试技术
《深入理解Spring》：IoC容器核心原理与实战
Spring IoC通过控制反转与依赖注入实现对象间的解耦，由容器统一管理Bean的生命周期与依赖关系。支持XML、注解和Java配置三种方式，结合作用域、条件化配置与循环依赖处理等机制，提升应用的可维护性与可测试性，是现代Java开发的核心基石。
一枚后端工程狮
144 5
凉凉心.
|
1月前
|
XML Java 应用服务中间件
【SpringBoot（一）】Spring的认知、容器功能讲解与自动装配原理的入门，带你熟悉Springboot中基本的注解使用
SpringBoot专栏开篇第一章，讲述认识SpringBoot、Bean容器功能的讲解、自动装配原理的入门，还有其他常用的Springboot注解！如果想要了解SpringBoot，那么就进来看看吧！
凉凉心.
345 2
游客wkqymr43luqiu
|
6月前
|
监控 安全 Java
Spring AOP实现原理
本内容主要介绍了Spring AOP的核心概念、实现机制及代理生成流程。涵盖切面（Aspect）、连接点（Join Point）、通知（Advice）、切点（Pointcut）等关键概念，解析了JDK动态代理与CGLIB代理的原理及对比，并深入探讨了通知执行链路和责任链模式的应用。同时，详细分析了AspectJ注解驱动的AOP解析过程，包括切面识别、切点表达式匹配及通知适配为Advice的机制，帮助理解Spring AOP的工作原理与实现细节。
游客wkqymr43luqiu
1043 13
游客qtwmfxysyhxz2
|
3月前
|
人工智能 监控 安全
Spring AOP切面编程颠覆传统！3大核心注解+5种通知类型，让业务代码纯净如初
本文介绍了AOP（面向切面编程）的基本概念、优势及其在Spring Boot中的使用。AOP作为OOP的补充，通过将横切关注点（如日志、安全、事务等）与业务逻辑分离，实现代码解耦，提升模块化程度、可维护性和灵活性。文章详细讲解了Spring AOP的核心概念，包括切面、切点、通知等，并提供了在Spring Boot中实现AOP的具体步骤和代码示例。此外，还列举了AOP在日志记录、性能监控、事务管理和安全控制等场景中的实际应用。通过本文，开发者可以快速掌握AOP编程思想及其实践技巧。
游客qtwmfxysyhxz2
438 5
爱吃烤鸡翅的酸菜鱼
|
3月前
|
Java 关系型数据库 数据库
深度剖析【Spring】事务：万字详解，彻底掌握传播机制与事务原理
在Java开发中，Spring框架通过事务管理机制，帮我们轻松实现了这种“承诺”。它不仅封装了底层复杂的事务控制逻辑（比如手动开启、提交、回滚事务），还提供了灵活的配置方式，让开发者能专注于业务逻辑，而不用纠结于事务细节。
爱吃烤鸡翅的酸菜鱼
720 1
爱吃烤鸡翅的酸菜鱼
|
3月前
|
人工智能 监控 安全
如何快速上手【Spring AOP】？核心应用实战（上篇）
哈喽大家好吖~欢迎来到Spring AOP系列教程的上篇 - 应用篇。在本篇，我们将专注于Spring AOP的实际应用，通过具体的代码示例和场景分析，帮助大家掌握AOP的使用方法和技巧。而在后续的下篇中，我们将深入探讨Spring AOP的实现原理和底层机制。 AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架中的核心特性之一，它能够帮助我们解决横切关注点（如日志记录、性能统计、安全控制、事务管理等）的问题，提高代码的模块化程度和复用性。
爱吃烤鸡翅的酸菜鱼
540 1

热门文章

最新文章

  • 1
    Spring AI Alibaba Admin 开源！以数据为中心的 Agent 开发平台
  • 2
    基于 Spring AI Alibaba + Nacos 的分布式 Multi-Agent 构建指南
  • 3
    《深入理解Spring》：AOP面向切面编程深度解析
  • 4
    AOP 切面编程
  • 5
    SpringBoot+kafka+ELK分布式日志收集
  • 6
    Spring Security系列教程07--前后端分离时的安全处理方案
  • 7
    Spring Security 自定义认证
  • 8
    Spring EL hello world实例
  • 9
    Spring MVC 父子容器是什么？这篇文章讲清楚了
  • 10
    Sentinel 实现网关限流(Spring-Gateway)
  • 1
    《深入理解Spring》：AOP面向切面编程深度解析
    429
  • 2
    AOP 切面编程
    367
  • 3
    使用 Spring 的 @Aspect 和 @Pointcut 注解简化面向方面的编程 (AOP)
    405
  • 4
    Spring AOP切面编程颠覆传统！3大核心注解+5种通知类型，让业务代码纯净如初
    438
  • 5
    AOP切面编程快速入门
    324
  • 6
    如何快速上手【Spring AOP】？从动态代理到源码剖析（下篇）
    258
  • 7
    如何快速上手【Spring AOP】？核心应用实战（上篇）
    540
  • 8
    如何用go语言实现类似AOP的功能
    150
  • 9
    Spring AOP实现原理
    1043
  • 10
    面向切面编程（AOP）介绍--这是我见过最易理解的文章
    396

    • 相关课程

    更多
  • 全面讲解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仓库
    • 下一篇
    oss云网关配置