Spring AOP面向切面编程理解（一）

最新推荐文章于 2023-06-26 22:17:02 发布
最新推荐文章于 2023-06-26 22:17:02 发布
阅读量848 收藏 8
点赞数 12
文章标签： java spring maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h123456789999999/article/details/124475827
版权

Spring AOP 理解

第一节 情景设定

1、声明接口

public interface Calculator {
    
    int add(int i, int j);
    
    int sub(int i, int j);
    
    int mul(int i, int j);
    
    int div(int i, int j);
    
}

2、给接口声明一个纯净版实现

在这里插入图片描述

没有额外功能

package com.atguigu.proxy.imp;
    
import com.atguigu.proxy.api.Calculator;
    
public class CalculatorPureImpl implements Calculator {
    
    @Override
    public int add(int i, int j) {
    
        int result = i + j;
    
        System.out.println("方法内部 result = " + result);
    
        return result;
    }
    
    @Override
    public int sub(int i, int j) {
    
        int result = i - j;
    
        System.out.println("方法内部 result = " + result);
    
        return result;
    }
    
    @Override
    public int mul(int i, int j) {
    
        int result = i * j;
    
        System.out.println("方法内部 result = " + result);
    
        return result;
    }
    
    @Override
    public int div(int i, int j) {
    
        int result = i / j;
    
        System.out.println("方法内部 result = " + result);
    
        return result;
    }
}

3、再声明一个带日志功能的实现

package com.atguigu.proxy.imp;
​
import com.atguigu.proxy.api.Calculator;
​
public class CalculatorLogImpl implements Calculator {
    
    @Override
    public int add(int i, int j) {
    
        System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
    
        int result = i + j;
    
        System.out.println("方法内部 result = " + result);
    
        System.out.println("[日志] add 方法结束了，结果是：" + result);
    
        return result;
    }
    
    @Override
    public int sub(int i, int j) {
    
        System.out.println("[日志] sub 方法开始了，参数是：" + i + "," + j);
    
        int result = i - j;
    
        System.out.println("方法内部 result = " + result);
    
        System.out.println("[日志] sub 方法结束了，结果是：" + result);
    
        return result;
    }
    
    @Override
    public int mul(int i, int j) {
    
        System.out.println("[日志] mul 方法开始了，参数是：" + i + "," + j);
    
        int result = i * j;
    
        System.out.println("方法内部 result = " + result);
    
        System.out.println("[日志] mul 方法结束了，结果是：" + result);
    
        return result;
    }
    
    @Override
    public int div(int i, int j) {
    
        System.out.println("[日志] div 方法开始了，参数是：" + i + "," + j);
    
        int result = i / j;
    
        System.out.println("方法内部 result = " + result);
    
        System.out.println("[日志] div 方法结束了，结果是：" + result);
    
        return result;
    }
}

4、提出问题

①现有代码缺陷

针对带日志功能的实现类，我们发现有如下缺陷：

对核心业务功能有干扰，导致程序员在开发核心业务功能时分散了精力
附加功能分散在各个业务功能方法中，不利于统一维护

②解决思路

解决这两个问题，核心就是：解耦。我们需要把附加功能从业务功能代码中抽取出来。

③困难

解决问题的困难：要抽取的代码在方法内部，靠以前把子类中的重复代码抽取到父类的方式没法解决。所以需要引入新的技术。

第二节 代理模式

1、概念

①介绍

二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。

images

使用代理后：

images

②生活中的代理

广告商找大明星拍广告需要经过经纪人
合作伙伴找大老板谈合作要约见面时间需要经过秘书
房产中介是买卖双方的代理

③相关术语

代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。
目标：被代理“套用”了非核心逻辑代码的类、对象、方法。
理解代理模式、AOP的核心关键词就一个字：套

2、静态代理

创建静态代理类：
​

public class CalculatorStaticProxy implements Calculator {
    
    // 将被代理的目标对象声明为成员变量
    private Calculator target;
    
    public CalculatorStaticProxy(Calculator target) {
        this.target = target;
    }
    
    @Override
    public int add(int i, int j) {
    
        // 附加功能由代理类中的代理方法来实现
        System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
    
        // 通过目标对象来实现核心业务逻辑
        int addResult = target.add(i, j);
    
        System.out.println("[日志] add 方法结束了，结果是：" + addResult);
    
        return addResult;
    }
    ……

静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。
提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。这就需要使用动态代理技术了。

3、动态代理

在这里插入图片描述

①生产代理对象的工厂类

JDK本身就支持动态代理，这是反射技术的一部分。下面我们还是创建一个代理类（生产代理对象的工厂类）：

// 泛型T要求是目标对象实现的接口类型，本代理类根据这个接口来进行代理
public class LogDynamicProxyFactory<T> {
    
    // 将被代理的目标对象声明为成员变量
    private T target;
    
    public LogDynamicProxyFactory(T target) {
        this.target = target;
    }
    
    public T getProxy() {
    
        // 创建代理对象所需参数一：加载目标对象的类的类加载器
        ClassLoader classLoader = target.getClass().getClassLoader();
    
        // 创建代理对象所需参数二：目标对象的类所实现的所有接口组成的数组
        Class<?>[] interfaces = target.getClass().getInterfaces();
    
        // 创建代理对象所需参数三：InvocationHandler对象
        // Lambda表达式口诀：
        // 1、复制小括号
        // 2、写死右箭头
        // 3、落地大括号
        InvocationHandler handler = (
                                    // 代理对象，当前方法用不上这个对象
                                    Object proxy,
    
                                     // method就是代表目标方法的Method对象
                                     Method method,
    
                                     // 外部调用目标方法时传入的实际参数
                                     Object[] args)->{
    
            // 我们对InvocationHandler接口中invoke()方法的实现就是在调用目标方法
            // 围绕目标方法的调用，就可以添加我们的附加功能
    
            // 声明一个局部变量，用来存储目标方法的返回值
            Object targetMethodReturnValue = null;
    
            // 通过method对象获取方法名
            String methodName = method.getName();
    
            // 为了便于在打印时看到数组中的数据，把参数数组转换为List
            List<Object> argumentList = Arrays.asList(args);
    
            try {
    
                // 在目标方法执行前：打印方法开始的日志
                System.out.println("[动态代理][日志] " + methodName + " 方法开始了，参数是：" + argumentList);
    
                // 调用目标方法：需要传入两个参数
                // 参数1：调用目标方法的目标对象
                // 参数2：外部调用目标方法时传入的实际参数
                // 调用后会返回目标方法的返回值
                targetMethodReturnValue = method.invoke(target, args);
    
                // 在目标方法成功后：打印方法成功结束的日志【寿终正寝】
                System.out.println("[动态代理][日志] " + methodName + " 方法成功结束了，返回值是：" + targetMethodReturnValue);
    
            }catch (Exception e){
    
                // 通过e对象获取异常类型的全类名
                String exceptionName = e.getClass().getName();
    
                // 通过e对象获取异常消息
                String message = e.getMessage();
    
                // 在目标方法失败后：打印方法抛出异常的日志【死于非命】
                System.out.println("[动态代理][日志] " + methodName + " 方法抛异常了，异常信息是：" + exceptionName + "," + message);
    
            }finally {
    
                // 在目标方法最终结束后：打印方法最终结束的日志【盖棺定论】
                System.out.println("[动态代理][日志] " + methodName + " 方法最终结束了");
    
            }
    
            // 这里必须将目标方法的返回值返回给外界，如果没有返回，外界将无法拿到目标方法的返回值
            return targetMethodReturnValue;
        };
    
        // 创建代理对象
        T proxy = (T) Proxy.newProxyInstance(classLoader, interfaces, handler);
    
        // 返回代理对象
        return proxy;
    }
}

②测试

@Test
public void testDynamicProxy() {
    
    // 1.创建被代理的目标对象
    Calculator target = new CalculatorPureImpl();
    
    // 2.创建能够生产代理对象的工厂对象
    LogDynamicProxyFactory<Calculator> factory = new LogDynamicProxyFactory<>(target);
    
    // 3.通过工厂对象生产目标对象的代理对象
    Calculator proxy = factory.getProxy();
    
    // 4.通过代理对象间接调用目标对象
    int addResult = proxy.add(10, 2);
    System.out.println("方法外部 addResult = " + addResult + "\n");
    
    int subResult = proxy.sub(10, 2);
    System.out.println("方法外部 subResult = " + subResult + "\n");
    
    int mulResult = proxy.mul(10, 2);
    System.out.println("方法外部 mulResult = " + mulResult + "\n");
    
    int divResult = proxy.div(10, 2);
    System.out.println("方法外部 divResult = " + divResult + "\n");
}

③练习

动态代理的实现过程不重要，重要的是使用现成的动态代理类去套用到其他目标对象上。
声明另外一个接口：

public interface SoldierService {
    
    int saveSoldier(String soldierName);
    
    int removeSoldier(Integer soldierId);
    
    int updateSoldier(Integer soldierId, String soldierName);
    
    String getSoldierNameById(Integer soldierId);
    
}

给接口一个实现类：

public class SoldierServiceImpl implements SoldierService {
    
    @Override
    public int saveSoldier(String soldierName) {
    
        System.out.println("核心业务逻辑：保存到数据库……");
    
        return 1;
    }
    
    @Override
    public int removeSoldier(Integer soldierId) {
    
        System.out.println("核心业务逻辑：从数据库删除……");
    
        return 1;
    }
    
    @Override
    public int updateSoldier(Integer soldierId, String soldierName) {
    
        System.out.println("核心业务逻辑：更新……");
    
        return 1;
    }
​
    @Override
    public String getSoldierNameById(Integer soldierId) {
    
        System.out.println("核心业务逻辑：查询数据库……");
    
        return "good";
    }
}

测试：


@Test
public void testSoldierServiceDynamicProxy() {
    
    // 1.创建被代理的目标对象
    SoldierService soldierService = new SoldierServiceImpl();
    
    // 2.创建生产代理对象的工厂对象
    LogDynamicProxyFactory<SoldierService> factory = new LogDynamicProxyFactory<>(soldierService);
    
    // 3.生产代理对象
    SoldierService proxy = factory.getProxy();
    
    // 4.通过代理对象调用目标方法
    String soldierName = proxy.getSoldierNameById(1);
    System.out.println("soldierName = " + soldierName);
    
}

第三节 AOP的核心套路

在这里插入图片描述
终于会写目录了！！！！ 感谢家人们三连支持

红糖番薯
关注
  • 12
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 15
    评论
Spring——面向切面编程(AOP)
行者无疆的博客
06-05 3501
本文介绍了切向切面编程(AOP)中的各个概念，并用两个案例分别讲解了如何通过注解和XML配置的方式使用AOP。
16.2 Spring框架-AOP面向切面编程
最新发布
04-12
16.2 Spring框架-AOP面向切面编程
spring的面向切面编程AOP最强解释
qq_36250202的博客
12-11 462
面向切面编程AOP 也就是面向横切面编程,在软件原有流程中横向织入扩展功能代码,在不改变原有功能的情况下扩展横切功能. 生活中的横切面功能: 面向切面编程解决的横切问题: 面向切面编程中的关键概念: 切面组件 通知 切入点 运行期间织入 1.切面组件 切面组件本身也是一个被Spring管理的Bean组件,这个组件用于封装面向切面的功能扩展方法....
Spring切面编程
BadBoyxiaolin的博客
05-08 1399
*** @Description: 操作日志注解*/ @Documented @Target(ElementType . METHOD) // 作用在方法上 @Retention(RetentionPolicy . RUNTIME) // 运行时有效 public @interface Operation {/*** 操作模块/*** 操作类型/*** 操作说明。
Spring之面向切面编程（AOP）
旭日的芬芳
10-29 7027
1. 面向切面编程 以下内容来自百度百科： 定义：面向切面编程（AOP，Aspect Oriented Programming）是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。 作用：利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 主要功能：日志记录、性能统计、安全控制、事务处理、异常处理等。 总结：面向切面编程是希望能够将通用需求功能从不相关的类当中分离出来，能够使得很多类共享一个行为，一旦发生
Spring之理解AOP（面向切面）
qq_42338744的博客
06-30 796
Aop AspectJ 框架
Spring AOP面向切面编程实现原理方法详解
08-18
主要介绍了Spring AOP面向切面编程实现原理方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring 面向切面编程AOP实现详解
08-25
主要介绍了Spring 面向切面编程AOP实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring4AOP 面向切面编程实例之方法拦截
10-13
Spring4AOP 面向切面编程实例之方法拦截实例 一下利用Spring4的最后一个版本Spring4.3.9，实现简单的方法拦截实例。 Eclipse 建立java工程,导入必要的jar包，工程目录如下:
SpringBoot整合aop面向切面编程过程解析
08-24
主要介绍了SpringBoot整合aop面向切面编程过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
15.Spring 面向切面编程
qq_41775769的博客
09-09 971
Spring 面向切面编程 AOP 是 Spring 框架除了 IOC 之外的另一个核心概念。   AOP：Aspect Oriented Programming，意为面向切面编程。这是一个新的概念，但是我们知道 Java 是面向对象编程(OOP：Object Oriented Programming)的，指将所有的一切都看作对象，通过对象与对象之间相互作用来解决问题。AOP 是对 OOP 的一个补充，是在另外一个维度抽象出来的对象，具体是指程序在运行时，动态地将非业务代码切入业务代码中，从而实现代码的
Spring之AOP切面编程
从基础到源码解析的学习记录
06-26 649
AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程它是面向对象编程的一种补充和完善它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下，给程序动态统一添加额外功能的一种技术。
SpringAop(切面)理解
__Forward
03-23 709
1.什么是面向切面编程 切面通俗来说，可以帮助我们简化重复代码。 我们在日常开发中，我们可能会在各个增删改接口中记录日志，以便出现问题时可以及时有效地找出原因，但是系统中增删改的接口不是一个两个，而是会有很多个，我们如果在所有增删改的接口中编写记录日志的代码，就会导致记录日志的的逻辑散布于系统中的任何犄角旮旯，导致接口臃肿，接口核心功能不明确。 切面正好可以帮助我们解决这个问题，切面正如其名，好像...
Spring面向切面编程（介绍及使用）
qq_39559641的博客
08-10 1589
文章目录Spring 面向切面编程AOP 概念AOP 代理@AspectJ 支持启用@AspectJ 支持声明一个切面声明一个切入点表达式标签（10种）1. execution标签2. within标签3. this4. targetwithin、this、target对比5. args6. @within7. @target8. @args9. @annotation10. bean切点表达式的组合声明通知@Before：前置通知JoinPoint：连接点信息@After：后置通知介绍特点@AfterRe
JavaWeb开发（三）3.7——Spring AOP（面向切面编程） 详解
qq_36216193的博客
03-14 404
AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件,AspectJ不是Spring组成部分,独立AOP框架,一般把AspectJ和Spring框架一起使用,进行AOP操作。
Spring核心AOP（面向切面编程）总结
冷血之心的博客
07-16 3万+
（尊重劳动成果，转载请注明出处：http://blog.csdn.net/qq_25827845/article/details/75208354冷血之心的博客） 目录 1、AOP概念： 2、AOP特点： 3、AOP底层实现： JDK动态代理实现： cglib动态代理实现： 代理方式的选择： 静态代理和动态代理的区别： 4、AOP原理 5、AOP操作术语： 6、AOP操作案例...
Spring AOP面向切面编程:理解篇（一看就明白）
热门推荐
healer的博客
09-28 7万+
一直想着怎么去通俗的讲解AOP，看了一篇文章受到了启发（https://blog.csdn.net/qukaiwei/article/details/50367761），下面我加入自己的理解，咱们来说说AOP! 一、到底什么是AOP（面向切面编程）？ 无论在学习或者面试的时候，大家都会张口说spring的特性AOP和IOC(控制反转咱们下一篇讲)，有些大神理解的很到位，但是对于大多数初中级工程...
Spring in Action 入门之面向切面编程AOP
weixin_34008784的博客
11-02 139
注明：这篇文章一是当成学习笔记，二是给大家提供另一个快速理解学习Spring的参考。欢迎留言讨论，持续更新中~ （该部分是Spring的面向切面编程AOP） 第四章 通知Bean 在软件编程中，散布于程序中多个地点的函数被称为“交叉事务”（日志管理、权限控制等）。从概念上来说，它们一般是与程序业务逻辑分开的，但经常却是直接嵌入其中的。把这些交叉事务与业务逻辑分离开正式面向切面编程（AOP）的...
spring aop面向切面编程
08-15
对的，Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一个重要特性。它允许开发者通过在应用程序中定义横切关注点（cross-cutting concerns），将这些关注点与核心业务逻辑分离开来。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

红糖番薯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值