Java框架学习之Spring—面向切面AOP

最新推荐文章于 2024-06-14 09:56:07 发布
最新推荐文章于 2024-06-14 09:56:07 发布
阅读量231 收藏 1
点赞数
文章标签： spring java Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54385159/article/details/128984221
版权

5、面向切面：AOP

5.1 场景模拟

模拟+ - * / 运算

5.1.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);

}

5.1.2加减乘除实现类

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;
    }
}

如上 日志和代码混在一起 从维护等各方面角度都不行 通过引入代理模式来解决该问题

5.2 代理模式

5.2.1 概念

一种设计模式 结构性模式 提供一个代理类 在调用方法时 不是直接对目标方法进行调用 而是通过代理类间接调用 让不属于目标方法的核心逻辑代码从目标方法中剥离出来 称解耦 减少目标方法的调用 让附加功能集中在一起有利于维护

5.2.2 静态代理

public class CalculatorStaticProxy implements Calculator{
    //被代理的目标对象传递过来
    private Calculator calculator;

    public CalculatorStaticProxy(Calculator calculator) {
        this.calculator = calculator;
    }

    @Override
    public int add(int i, int j) {
        //输出日志
        System.out.println("[日志] add 方法开始了 参数是 "+i+","+j);
        //调用目标对象的方法实现核心业务
        int addresult = calculator.add(i,j);
        
        
        System.out.println("[日志] add 方法结束了 结果是"+addresult);
        return addresult;
    }

    @Override
    public int sub(int i, int j) {
        return 0;
    }

    @Override
    public int mul(int i, int j) {
        return 0;
    }

    @Override
    public int div(int i, int j) {
        return 0;
    }
}

静态代理实现了解耦 但是把代码都写死了 不具备任何的灵活性 日志功能 其他地方需要加日志的话 需要声明更多的静态代理类 没有统一管理 过于分散

提出进一步要求 日志功能集中到一个代理类中 将来有任何日志需求 通过这一个代理类实现

5.2.3 动态代理

动态代理 只需要动态创建一个代理类 把日志统一管理

// 生产代理对象的工厂类
public class ProxyFactory {

    //目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    //返回代理对象
    public Object getProxy(){

        /**
         * 有三个参数
         * 1 ClassLoader:加载动态生成代理的类加载器
         * 2 Class[] interfaces:目标对象实现所有接口的class类型的数组
         * 3 invocationHandler: 设置代理对象实现目标对象方法的过程
         */

        //1 ClassLoader:加载动态生成代理的类加载器
        ClassLoader classLoader = target.getClass().getClassLoader();
        //2 Class[] interfaces:目标对象实现所有接口的class类型的数组
        Class<?>[] interfaces = target.getClass().getInterfaces();
        //3 invocationHandler: 设置代理对象实现目标对象方法的过程
        InvocationHandler invocationHandler =new InvocationHandler(){

            /**
                第一个参数 代理对象
                第二个参数 需要重写目标对象的方法
                第三个参数 method方法里的参数
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //方法调用之前输出日志
                System.out.println("[动态代理][日志]"+method.getName()+"参数："+ Arrays.toString(args));
                //调用目标的方法
                Object result = method.invoke(target, args);
                //方法调用之后输出
                System.out.println("[动态代理][日志]"+method.getName()+"结果:"+result);
                return result;
            }
        };

        return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
    }
}
//测试类
public class TestCal {
    public static void main(String[] args) {

        //创建代理对象
        ProxyFactory proxyFactory = new ProxyFactory(new CaculatorImpl());
        Calculator proxy = (Calculator) proxyFactory.getProxy();
        proxy.add(1,2);

    }
}

5.3 AOP概念和相关术语

5.3.1 概述

AOP 面向切面编程 对面向对象的补充和完善 通过预编译和运行期动态代理的方式实现 不修改源码的情况下 给程序动态的添加额外的功能 利用AOP可以对业务的逻辑各部分进行隔离 从而使业·务逻辑之间的耦合读降低 提高程序得到复用性

5.3.2 相关术语

5.3.2.1横切关注点

分散在各个模块中解决同一样的问题 用户验证 日志管理 事务处理 数据缓存 都属于横切关注点

从每个方法中把非核心业务抽取出来 即为横切关注点 可以使用多个横切关注点读相关方法进行多个不同方面增强

可以根据附加功能逻辑上的需要：有10个附加功能 可有10个横切关注点

5.3.2.2 通知(增强)

要增强的功能

每一个横切关注点上要做的事情都需要一个方法来实现 这样的方法就交通知方法

  • 前置通知 被代理的目标方法前执行

  • 返回通知 在被代理的目标方法成功结束后执行**(寿终正寝)**

  • 异常通知 在被代理的目标方法异常结束后执行**(死于非命)**

  • 后置通知 在被代理的目标方法最终结束后执行**(盖棺定论)**

  • 环绕通知 使用try..catch..finally 结构围绕整个被代理的目标方法 包括上面四种通知对应的所有位置

5.3.2.3 切面

封装通知方法的类

5.3.2.4 目标

被代理的目标对象

5.4.2.5 代理

向目标对象应用通知之后创建的代理对象

5.4.2.6 连接点

一个纯逻辑概念 不是语法定义

把方法排成一排 每个横切位置看出x轴方向 把方法从上到下执行的顺序看成y轴 x轴y轴的交叉店就是连接点 通俗来讲

就是spring运行你使用通知的方法

5.4.2.7 切入点

定位连接点的方式

每个类的方法都包含多个连接点 如果把连接点看作是数据库中的记录 那么切入点就是查询记录的SQL语句

Spring的AOP技术可以通过切入点定位到特点的连接点 通俗说 要去实际增加的方法

切点通过org.springframework.aop.Pointcut 接口进行描述 它使用类和方法作为连接点的查询条件

5.3.2 作用

  • 简化代码 把方法中固定的位置的重复代码抽离出来 让被抽取的方法更加专注自己的核心功能 提高内聚性

  • 代码增强 把特定的功能封装到切面类中 哪里有需要 就往哪里用 被套用了切面逻辑的方法就被切面给增强了

5.4 基于注解的AOP

5.4.1 技术说明

5.4.1.1 JDK动态代理和cglib动态代理

有接口 使用JDK动态代理 生成接口实现类代理对象 代理对象和目标对象实现同样的接口

没有接口 使用cglib动态代理 生成子类代理对象 通过继承被代理的目标类

5.4.1.2 AspectJ

AOP思想的一种的实现 本质上是静态代理 将代理逻辑织入被代理的目标类编译得到的字节码文件 所以最终效果是动态的 weaver就是织入器 Spring只是借用了AspectJ中的注解

5.4.2 准备工作

5.4.2.1添加依赖
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.3.21</version>
</dependency
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.3.21</version>
</dependency>
5.4.2.2创建目标资源

①接口

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);

}

②实现类

@Component
public class CaculatorImpl 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;
    }
}

配置文件

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

<!--开启组件的扫描-->
    <context:component-scan base-package="com.szy.spring.aop.annoaop"></context:component-scan>
<!--开启aspectj自动代理 并为目标对象生成代理-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>


</beans>

5.4.3 创建切面类

切入点与通知类型

//切面类
@Component//交给IOC管理
@Aspect//切面类
public class LogAspect {
    //设置切入点和通知类型
    //通知类型:前置 返回 异常 后置 环绕
    /**
     * @Before
     * @AfterReturnong
     * @After
     * @Around
     */

    //前置 @Before(value = "切入点表达式配置切入点")
    //切入点表达式 execution(访问修饰符 增强方法返回类型 增强方法所在类全路径.方法名称(方法参数))
    @Before(value = "execution(public int com.szy.spring.aop.annoaop.CaculatorImpl.*(..))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("Loger--> 前置通知 方法名称"+methodName+" 参数 "+ Arrays.toString(args));
    }


    //后置
    @After(value = "execution(* com.szy.spring.aop.annoaop.CaculatorImpl.*(..))")
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Loger--> 后置通知 方法名称"+methodName);
    }

    //返回 @AfterReturning
    @AfterReturning(value = "execution(* com.szy.spring.aop.annoaop.CaculatorImpl.*(..))",returning = "result")
    public void afterReturningMethod(JoinPoint joinPoint,Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Loger--> 返回通知 方法名称"+methodName+"返回结果"+result);
    }

    //异常
    @AfterThrowing(value = "execution(* com.szy.spring.aop.annoaop.CaculatorImpl.*(..))",throwing = "ex")
    public void afterThrowingMethod(JoinPoint joinPoint,Throwable ex){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Loger--> 异常通知 方法名称"+methodName+"异常信息"+ex);
    }

    //环绕
    @Around(value = "execution(* com.szy.spring.aop.annoaop.CaculatorImpl.*(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        Object result=null;
        try {
            System.out.println("环绕通知==目标方法之前");
            //调用目标方法
            result = joinPoint.proceed();

            System.out.println("环绕通知==目标方法返回值之后");

        }catch (Throwable throwable){
            throwable.printStackTrace();
            System.out.println("环绕通知==目标方法出现异常执行");
        }finally {
            System.out.println("环绕通知==目标方法执行完毕执行");
        }
        return result;
    }

}

5.4.4 重用切入点表达式

5.4.4.1 声明
@Pointcut(value = "execution(* com.szy.spring.aop.annoaop.CaculatorImpl.*(..))")
public void pointcut(){
    

}
5.4.4.2 在同一个切面中使用
@Before(value = "pointcut()")
public void beforeMethod(JoinPoint joinPoint){
    String methodName = joinPoint.getSignature().getName();
    Object[] args = joinPoint.getArgs();
    System.out.println("Loger--> 前置通知 方法名称"+methodName+" 参数 "+ Arrays.toString(args));
}
5.4.4.3 在不同切面使用
@Before(value = "com.szy.spring.aop.annoaop.LogAspect.pointcut()")
public void beforeMethod(JoinPoint joinPoint){
    String methodName = joinPoint.getSignature().getName();
    Object[] args = joinPoint.getArgs();
    System.out.println("Loger--> 前置通知 方法名称"+methodName+" 参数 "+ Arrays.toString(args));
}

5.5 基于XML的AOP

配置类

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

<!--开启组件扫描-->

    <context:component-scan base-package="com.szy.spring.aop.xmlaop"></context:component-scan>


<!--配置aop的五中类型-->
    <aop:config>
    <!--配置切面类-->
        <aop:aspect ref="logAspect">
        <!--配置切入点-->
            <aop:pointcut id="pointcut" expression="execution(* com.szy.spring.aop.xmlaop.CaculatorImpl.*(..))"/>
        <!--配置五种通知类型-->
            <!--前置-->
            <aop:before method="beforeMethod" pointcut-ref="pointcut"></aop:before>
            <!--后置-->
            <aop:after method="afterMethod" pointcut-ref="pointcut"></aop:after>
            <!--返回通知-->
            <aop:after-returning method="afterReturningMethod" returning="result" pointcut-ref="pointcut"></aop:after-returning>

            <!--异常-->
            <aop:after-throwing method="afterThrowingMethod" throwing="ex" pointcut-ref="pointcut"></aop:after-throwing>

            <!--环绕-->
            <aop:around method="aroundMethod" pointcut-ref="pointcut"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>
//切面类
@Component//交给IOC管理
public class LogAspect {
    //设置切入点和通知类型
    //通知类型:前置 返回 异常 后置 环绕
    /**
     * @Before
     * @AfterReturnong
     * @After
     * @Around
     */

    //前置
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("Loger--> 前置通知 方法名称"+methodName+" 参数 "+ Arrays.toString(args));
    }


    //后置
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Loger--> 后置通知 方法名称"+methodName);
    }

    //返回
    public void afterReturningMethod(JoinPoint joinPoint,Object result){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Loger--> 返回通知 方法名称"+methodName+"返回结果"+result);
    }

    //异常
    public void afterThrowingMethod(JoinPoint joinPoint,Throwable ex){
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Loger--> 异常通知 方法名称"+methodName+"异常信息"+ex);
    }

    //环绕
    public Object aroundMethod(ProceedingJoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        Object result=null;
        try {
            System.out.println("环绕通知==目标方法之前");
            //调用目标方法
            result = joinPoint.proceed();

            System.out.println("环绕通知==目标方法返回值之后");

        }catch (Throwable throwable){
            throwable.printStackTrace();
            System.out.println("环绕通知==目标方法出现异常执行");
        }finally {
            System.out.println("环绕通知==目标方法执行完毕执行");
        }
        return result;
    }
    
}
随手一行代码
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中的面向切面编程（AOP）
pedro7k的博客
04-03 1万+
一、什么是AOP？ Aspect Oriented Programming ，即面向切面编程。 AOP是对面向对象编程的一个补充。 它的目的是将复杂的需求分解为不同的切面，将散布在系统中的公共功能集中解决。 它的实际含义是在运行时将代码切入到类的指定方法、指定位置上，将不同方法的同一个位置抽象为一个切面对象，并对该对象进行编程。 下面是AOP的一个示意图 二、AOP的优点和一些概念 1、AOP的优点 降低模块之间的耦合度 使系统更容易扩展 更好的代码复用 非业务代码更加集中，不分散，便于统一管理
Java--Spring之AOP面向切面编程
MinggeQingchun的博客
08-13 1098
一、JDK动态代理 具体可参考之前博文Java--JDK动态代理(AOP) 在这里只做简单说明 动态代理是指代理类在程序运行时进行创建的代理方式。这种情况下，代理类并不是在Java代码中定义的，而是在运行时根据Java代码中的“指示”动态生成的。（动态代理中的代理类并不要求在编译期就确定，而是可以在运行期动态生成，从而实现对目标对象的代理功能） 相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数 动态代理又分为两种方式 （1）JDK动态代...
深入理解Java中的AOP（面向切面编程）
最新发布
weixin_53840353的博客
06-14 1551
AOP是一种编程思想，它允许开发者将横切关注点从业务逻辑中分离出来，形成所谓的“切面”（Aspect）。切面可以定义在程序执行的特定点（如方法调用前后）插入额外的逻辑，这些点被称为“连接点”（Join Points）。AOP的主要目标是提高模块化，使得业务逻辑更加清晰，同时减少代码的重复。
Java AOP(面向切面编程)实现
mazaiting的博客
04-12 460
动态代理 AOP概念解释 AOP用在哪些方面：AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任，例如事务处理、日志管理、权限控制，异常处理等，封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。 AOP中的概念 Aspect(切面)：指横切性关注点的抽象即为切面，它与类相似，只是两者的关注点不一样，类是对物...
【Java 初级】Spring核心之面向切面编程(AOP)
激流丶的博客
06-12 2937
AOP（面向切面编程）是一种编程范式，用于将横切关注点（如日志记录、性能统计等）从主要业务逻辑中分离出来。通过将这些横切关注点与业务逻辑分离开来，可以提高代码的可重用性、可维护性和可扩展性。在AOP中，切面是一个模块化的单元，它封装了与横切关注点相关的行为，并可以在多个不同的应用程序中重用。切面可以通过一种称为“织入”的过程将其与主要业务逻辑相结合，从而创建一个完整的应用程序。
JavaEE——Spring AOP(面向切面编程)
威威的博客
04-01 3626
1.面向切面编程（AOP） AOP 的全称是“Aspect Oriented Programming”，译为“面向切面编程”，和 OOP（面向对象编程）类似，它也是一种编程思想。 通常情况下，我们会根据业务使用 OOP（面向对象）思想，将应用划分为多个不同的业务模块，每个模块的核心功能都只为特定的业务领域提供服务，例如电商系统中的订单模块、商品模块、库存模块就分别是为维护电商系统的订单信息、商品信息以及库存信息而服务的。 但除此之外，应用中往往还存在一些非业务的通用功能，例如日志管理、权限管理、事务管理、异
java---------AOP面向切面
qq_35504206的博客
07-05 489
面向切面的aspect注解: @Aspect  @Pointcut  @AdviceAOP的使用场景：authentication 权限caching 缓存context passing 内容缓存Error handling 错误处理Lazy loading 懒加载Debugging 调试PerSistence持久化Resource pooling 资源池Synchronization 同步Tra...
Java基础之面向切面编程（AOP）
qq_53350943的博客
02-19 1475
Java基础之面向切面编程（AOP）面向切面编程中，切面就是可以加入到源功能位置中的代码。
Java中的AOP面向切面编程
weixin_42095178的博客
04-07 833
AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它允许程序员将横切关注点（cross-cutting concerns）从业务逻辑中分离出来，从而提高代码的可维护性和可重用性。在Java中，AOP通常通过代理模式实现，允许在不修改现有代码的情况下，为程序添加额外的行为。
java 切面详解_Java-AOP(面向切面编程)详解
weixin_31115505的博客
02-25 6402
AOP(面向切面编程)是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。(以上为抄的，纯理论)。例如：在一个web工程(利用spring mvc搭建)中做了一个拦截器，拦截所有的url请求，对异常的请求进行拦截，实现安全...
JAVA：使用 Spring AOP 实现面向切面编程
木头
04-12 1243
使用 Spring AOP 实现面向切面编程
Java AOP实践指南：切面编程详解
xuewenyu_的博客
11-06 4457
通过本文的讲解，我们深入了解了切面编程的核心概念、动态代理的实现原理，并通过一个实际的例子展示了使用Java AOP的完整过程。AOP可以帮助我们将横切关注点（例如日志记录、事务管理等）从核心业务逻辑中解耦出来，提高代码的可维护性和重用性。同时，AOP也是实现设计模式和架构思想的重要手段之一，我们在开发中可以灵活运用AOP来优化代码结构并提高系统的整体性能。
JAVA 制作切面，AOP的使用
qq_42403906的博客
08-10 2253
在实际工作中，可能会存在需要在调用方法前后调用其它接口，例如：1.调用业务方法前，需要根据头部信息来调用外部接口获取到所需的信息，来决定后续方法执行的逻辑；2.调用业务方法后，日志信息的记录（请求参数、返回结果、执行时长等）。...
JAVA：面向切面编程AOP
weixin_42277946的博客
06-04 2166
面向切面编程AOP
JavaWeb开发（三）3.7——Spring AOP（面向切面编程） 详解
qq_36216193的博客
03-14 433
AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件,AspectJ不是Spring组成部分,独立AOP框架,一般把AspectJ和Spring框架一起使用,进行AOP操作。
Java核心知识体系4：AOP原理和切面应用
Reische的博客
12-16 64
这部分内容会放到下一篇文章中专门分析。等生成的，然后调用通过注解方式即@Before，@After，@Around、@Pointcut,@AfterThrowing生成的advisor，可以说，这两个方法分别处理了基于xml配置文件的方式和基于注解的配置方式，因为所有的分析都是基于AnnotationAwareAspectJAutoProxyCreator这个类进行的，所以在这个地方会先获取配置文件的，再生成基于注解类的Advisor，这样就将基于xml配置的和基于注解的配置都会解析到。
【JavaEE】Spring AOP （面向切面）详解
xqs196301的博客
08-26 1611
【JavaEE】Spring AOP （面向切面）详解
JAVA- AOP 面向切面编程 Aspect切面工具类 记录特定方法执行时的入参、执行时间、返参等内容
君琴 的博客
03-05 3615
面向切面编程 使用AOP对指定函数进行切面。能够记录特定方法执行时的入参、执行时间、返参结果等内容；例如：请求URL、请求IP、请求类名、请求方法名、请求参数等、返回值、请求耗时、浏览器类型、操作系统、header等。解决同类中调用切面无记录解决事务失效问题。
Spring AOP：面向切面编程详解与实战
本章节深入探讨了面向切面编程(AOP)这一强大的软件设计模式，它是软件开发中的一种热点技术，特别在Spring框架中占有重要地位。AOP旨在通过预先编译或运行时动态代理，实现对程序功能的集中管理和维护，从而提高代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值