Spring AOP 面向切面编程

最新推荐文章于 2024-10-08 21:03:21 发布
最新推荐文章于 2024-10-08 21:03:21 发布
阅读量793 收藏 17
点赞数 7
文章标签： spring java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lib_24/article/details/142426897
版权

一、为何需要切面编程

这里我们准备一个项目来进行场景设定和问题复现

1.准备AOP项目

项目名：spring-aop-annotation

pom.xml

<dependencies>
    <!--spring context依赖-->
    <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.6</version>
    </dependency>

    <!--junit5测试-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.3.1</version>
    </dependency>


    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>6.0.6</version>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>jakarta.annotation</groupId>
        <artifactId>jakarta.annotation-api</artifactId>
        <version>2.1.1</version>
    </dependency>
</dependencies>

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

3.接口实现

package com.atguigu.proxy;


/**
 * 实现计算接口,单纯添加 + - * / 实现! 掺杂其他功能!
 */
public class CalculatorPureImpl implements Calculator {
    
    @Override
    public int add(int i, int j) {
    
        int result = i + j;
    
        return result;
    }
    
    @Override
    public int sub(int i, int j) {
    
        int result = i - j;
    
        return result;
    }
    
    @Override
    public int mul(int i, int j) {
    
        int result = i * j;
    
        return result;
    }
    
    @Override
    public int div(int i, int j) {
    
        int result = i / j;
    
        return result;
    }
}

4.声明带日志接口实现

需求：需要在每个方法中，添加控制台输出，输出参数和输出计算后的返回值！

使用我们现有的知识就只能在每个方法的内部添加语句

package com.atguigu.proxy;

/**
 * 在每个方法中,输出传入的参数和计算后的返回结果!
 */
public class CalculatorLogImpl implements Calculator {
    
    @Override
    public int add(int i, int j) {
    
        System.out.println("参数是：" + i + "," + j);
        int result = i + j;
        System.out.println("方法内部 result = " + result);
      
        return result;
    }
    
    @Override
    public int sub(int i, int j) {
    
        System.out.println("参数是：" + i + "," + j);
    
        int result = i - j;
    
        System.out.println("方法内部 result = " + result);
        return result;
    }
    
    @Override
    public int mul(int i, int j) {
    
        System.out.println("参数是：" + i + "," + j);
    
        int result = i * j;
    
        System.out.println("方法内部 result = " + result);
    
        return result;
    }
    
    @Override
    public int div(int i, int j) {
    
        System.out.println("参数是：" + i + "," + j);
    
        int result = i / j;
    
        System.out.println("方法内部 result = " + result);
        
        return result;
    }
}

5.代码问题的分析

1. 代码缺陷
    - 对核心业务功能有干扰，导致程序员在开发核心业务功能时分散了精力
    - 附加功能代码重复，分散在各个业务功能方法中！冗余，且不方便统一维护！
2. 解决思路

      核心就是：解耦。我们需要把附加功能从业务功能代码中抽取出来。

      将重复的代码统一提取，并且[[动态插入]]到每个业务方法！
3. 技术困难

    解决问题的困难：提取重复附加功能代码到一个类中，可以实现

    但是如何将代码插入到各个方法中，我们不会，我们需要引用新技术！！！

所以我们需要学习一种新的技术：代理模式

二、解决技术代理模式

1.代理模式

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

举几个生活中的例子：

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

简单来说（说人话）：就是将多个方法中的相同的代码逻辑统一提出来，不再在每个方法中使用，然后通过代理类来运行那些相同逻辑的语句，调用目标类的方法。

相关术语：

- 代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。(中介)
    - 动词：指做代理这个动作，或这项工作
    - 名词：扮演代理这个角色的类、对象、方法
- 目标：**被代理**“套用”了核心逻辑代码的类、对象、方法。(房东)

代理在开发中实现的方式具体有两种：静态代理，[动态代理技术]

我们这里就不讲静态代理了，一般都用动态代理。

动态代理技术分类

- JDK动态代理：JDK原生的实现方式，需要被代理的目标类必须**实现接口**！他会根据目标类的接口动态生成一个代理对象！代理对象和目标对象有相同的接口！（拜把子）
- cglib：通过继承被代理的目标类实现代理，所以不需要目标类实现接口！（认干爹）

代理工程：基于jdk代理技术，生成代理对象（了解即可）

public class ProxyFactory {

    private Object target;

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

    public Object getProxy(){

        /**
         * newProxyInstance()：创建一个代理实例
         * 其中有三个参数：
         * 1、classLoader：加载动态生成的代理类的类加载器
         * 2、interfaces：目标对象实现的所有接口的class对象所组成的数组
         * 3、invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接口中的抽象方法
         */
        ClassLoader classLoader = target.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /**
                 * proxy：代理对象
                 * method：代理对象需要实现的方法，即其中需要重写的方法
                 * args：method所对应方法的参数
                 */
                Object result = null;
                try {
                    System.out.println("[动态代理][日志] "+method.getName()+"，参数："+ Arrays.toString(args));
                    result = method.invoke(target, args);
                    System.out.println("[动态代理][日志] "+method.getName()+"，结果："+ result);
                } catch (Exception e) {
                    e.printStackTrace();
                    System.out.println("[动态代理][日志] "+method.getName()+"，异常："+e.getMessage());
                } finally {
                    System.out.println("[动态代理][日志] "+method.getName()+"，方法执行完毕");
                }
                return result;
            }
        };

        return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
    }
}

测试代码：

@Test
public void testDynamicProxy(){
    ProxyFactory factory = new ProxyFactory(new CalculatorLogImpl());
    Calculator proxy = (Calculator) factory.getProxy();
    proxy.div(1,0);
    //proxy.div(1,1);
}

3.代理总结

**代理方式可以解决附加功能代码干扰核心代码和不方便统一维护的问题！**

他主要是将附加功能代码提取到代理中执行，不干扰目标核心代码！

但是我们也发现，无论使用静态代理和动态代理(jdk,cglib)，程序员的工作都比较繁琐！

需要自己编写代理工厂等！

我们在实际开发中，不需要编写代理代码，我们可以使用[Spring AOP]框架，他会简化动态代理的实现！！！

3.面向切面编程思维（AOP）

AOP（面向切面编程）是一种编程范式，它通过将通用的横切关注点（如日志、事务、权限控制等）与业务逻辑分离，使得代码更加清晰、简洁、易于维护。AOP可以应用于各种场景，以下是一些常见的AOP应用场景：

1. 日志记录：在系统中记录日志是非常重要的，可以使用AOP来实现日志记录的功能，可以在方法执行前、执行后或异常抛出时记录日志。
2. 事务处理：在数据库操作中使用事务可以保证数据的一致性，可以使用AOP来实现事务处理的功能，可以在方法开始前开启事务，在方法执行完毕后提交或回滚事务。
3. 安全控制：在系统中包含某些需要安全控制的操作，如登录、修改密码、授权等，可以使用AOP来实现安全控制的功能。可以在方法执行前进行权限判断，如果用户没有权限，则抛出异常或转向到错误页面，以防止未经授权的访问。
4. 性能监控：在系统运行过程中，有时需要对某些方法的性能进行监控，以找到系统的瓶颈并进行优化。可以使用AOP来实现性能监控的功能，可以在方法执行前记录时间戳，在方法执行完毕后计算方法执行时间并输出到日志中。
5. 异常处理：系统中可能出现各种异常情况，如空指针异常、数据库连接异常等，可以使用AOP来实现异常处理的功能，在方法执行过程中，如果出现异常，则进行异常处理（如记录日志、发送邮件等）。
6. 缓存控制：在系统中有些数据可以缓存起来以提高访问速度，可以使用AOP来实现缓存控制的功能，可以在方法执行前查询缓存中是否有数据，如果有则返回，否则执行方法并将方法返回值存入缓存中。
7. 动态代理：AOP的实现方式之一是通过动态代理，可以代理某个类的所有方法，用于实现各种功能。

综上所述，AOP可以应用于各种场景，它的作用是将通用的横切关注点与业务逻辑分离，使得代码更加清晰、简洁、易于维护。

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

- 前置通知：在被代理的目标方法前执行
- 返回通知：在被代理的目标方法成功结束后执行（**寿终正寝**）
- 异常通知：在被代理的目标方法异常结束后执行（**死于非命**）
- 后置通知：在被代理的目标方法最终结束后执行（**盖棺定论**）
- 环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

三、初步实现

1.加入依赖

<!-- spring-aspects会帮我们传递过来aspectjweaver -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>6.0.6</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>6.0.6</version>
</dependency>

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

3.纯净实现类

package com.atguigu.proxy;


/**
 * 实现计算接口,单纯添加 + - * / 实现! 掺杂其他功能!
 */
@Component
public class CalculatorPureImpl implements Calculator {
    
    @Override
    public int add(int i, int j) {
    
        int result = i + j;
    
        return result;
    }
    
    @Override
    public int sub(int i, int j) {
    
        int result = i - j;
    
        return result;
    }
    
    @Override
    public int mul(int i, int j) {
    
        int result = i * j;
    
        return result;
    }
    
    @Override
    public int div(int i, int j) {
    
        int result = i / j;
    
        return result;
    }
}

4.声明切面类

package com.atguigu.advice;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

// @Aspect表示这个类是一个切面类
@Aspect
// @Component注解保证这个切面类能够放入IOC容器
@Component
public class LogAspect {
        
    // @Before注解：声明当前方法是前置通知方法
    // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
    @Before(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogBeforeCore() {
        System.out.println("[AOP前置通知] 方法开始了");
    }
    
    @AfterReturning(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogAfterSuccess() {
        System.out.println("[AOP返回通知] 方法成功返回了");
    }
    
    @AfterThrowing(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogAfterException() {
        System.out.println("[AOP异常通知] 方法抛异常了");
    }
    
    @After(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")
    public void printLogFinallyEnd() {
        System.out.println("[AOP后置通知] 方法最终结束了");
    }
    
}

5.开启aspectj注解支持

        1.xml方式

<?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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 进行包扫描-->
    <context:component-scan base-package="com.atguigu" />
    <!-- 开启aspectj框架注解支持-->
    <aop:aspectj-autoproxy />
</beans>

        2.配置类方式

@Configuration
@ComponentScan(basePackages = "com.atguigu")
//作用等于 <aop:aspectj-autoproxy /> 配置类上开启 Aspectj注解支持!
@EnableAspectJAutoProxy
public class MyConfig {
}

6.测试效果

//@SpringJUnitConfig(locations = "classpath:spring-aop.xml")
@SpringJUnitConfig(value = {MyConfig.class})
public class AopTest {

    @Autowired
    private Calculator calculator;

    @Test
    public void testCalculator(){
        calculator.add(1,1);
    }
}

 输出结果：


[AOP前置通知] 方法开始了
[AOP返回通知] 方法成功返回了
[AOP后置通知] 方法最终结束了

四、获取通知细节信息

1.JointPoint接口

如何在增强方法中获取目标方法的方法名，传入的实参 等等信息

- 要点1：JoinPoint 接口通过 getSignature() 方法获取目标方法的签名（方法声明时的完整信息）
- 要点2：通过目标方法签名对象获取方法名
- 要点3：通过 JoinPoint 对象获取外界调用目标方法时传入的实参列表组成的数组

// @Before注解标记前置通知方法
// value属性：切入点表达式，告诉Spring当前通知方法要套用到哪个目标方法上
// 在前置通知方法形参位置声明一个JoinPoint类型的参数，Spring就会将这个对象传入
// 根据JoinPoint对象就可以获取目标方法名称、实际参数列表
@Before(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))")
public void printLogBeforeCore(JoinPoint joinPoint) {
    
    // 1.通过JoinPoint对象获取目标方法签名对象
    // 方法的签名：一个方法的全部声明信息
    Signature signature = joinPoint.getSignature();
    
    // 2.通过方法的签名对象获取目标方法的详细信息
    String methodName = signature.getName();
    System.out.println("methodName = " + methodName);
    
    int modifiers = signature.getModifiers();
    System.out.println("modifiers = " + modifiers);
    
    String declaringTypeName = signature.getDeclaringTypeName();
    System.out.println("declaringTypeName = " + declaringTypeName);
    
    // 3.通过JoinPoint对象获取外界调用目标方法时传入的实参列表
    Object[] args = joinPoint.getArgs();
    
    // 4.由于数组直接打印看不到具体数据，所以转换为List集合
    List<Object> argList = Arrays.asList(args);
    
    System.out.println("[AOP前置通知] " + methodName + "方法开始了，参数列表：" + argList);
}

在增强方法中加入参数JoinPoint joinPoint随后调用jointPoint的方法即可获得方法的详细信息。

2.方法返回值

在返回通知中，通过@AfterReturning注解的returning属性获取目标方法的返回值！

// @AfterReturning注解标记返回通知方法
// 在返回通知中获取目标方法返回值分两步：
// 第一步：在@AfterReturning注解中通过returning属性设置一个名称
// 第二步：使用returning属性设置的名称在通知方法中声明一个对应的形参
@AfterReturning(
        value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))",
        returning = "targetMethodReturnValue"
)
public void printLogAfterCoreSuccess(JoinPoint joinPoint, Object targetMethodReturnValue) {
    
    String methodName = joinPoint.getSignature().getName();
    
    System.out.println("[AOP返回通知] "+methodName+"方法成功结束了，返回值是：" + targetMethodReturnValue);
}

3.异常对象捕捉

在异常通知中，通过@AfterThrowing注解的throwing属性获取目标方法抛出的异常对象

// @AfterThrowing注解标记异常通知方法
// 在异常通知中获取目标方法抛出的异常分两步：
// 第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称
// 第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们
@AfterThrowing(
        value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))",
        throwing = "targetMethodException"
)
public void printLogAfterCoreException(JoinPoint joinPoint, Throwable targetMethodException) {
    
    String methodName = joinPoint.getSignature().getName();
    
    System.out.println("[AOP异常通知] "+methodName+"方法抛异常了，异常类型是：" + targetMethodException.getClass().getName());
}

五、切点表达式语法

1. **切点表达式作用**

    AOP切点表达式（Pointcut Expression）是一种用于指定切点的语言，它可以通过定义匹配规则，来选择需要被切入的目标对象。

语法细节

- 第一位：execution( ) 固定开头
- 第二位：方法访问修饰符

public private 直接描述对应修饰符即可


- 第三位：方法返回值
 

int String void 直接描述返回值类型

    注意：

    特殊情况 不考虑 访问修饰符和返回值

      execution(* * ) 这是错误语法

      execution(*) == 你只要考虑返回值 或者 不考虑访问修饰符 相当于全部不考虑了
- 第四位：指定包的地址   

 固定的包: com.atguigu.api | service | dao
 单层的任意命名: com.atguigu.*  = com.atguigu.api  com.atguigu.dao  * = 任意一层的任意命名
 任意层任意命名: com.. = com.atguigu.api.erdaye com.a.a.a.a.a.a.a  ..任意层,任意命名 用在包上!
 注意: ..不能用作包开头   public int .. 错误语法  com..
 找到任何包下: *..


- 第五位：指定类名称

固定名称: UserService
任意类名: *
部分任意: com..service.impl.*Impl
任意包任意类: *..*


- 第六位：指定方法名称

语法和类名一致
任意访问修饰符,任意类的任意方法: * *..*.*


- 第七位：方法参数
 

第七位: 方法的参数描述
       具体值: (String,int) != (int,String) 没有参数 ()
       模糊值: 任意参数 有 或者 没有 (..)  ..任意参数的意识
       部分具体和模糊:
         第一个参数是字符串的方法 (String..)
         最后一个参数是字符串 (..String)
         字符串开头,int结尾 (String..int)
         包含int类型(..int..)

bigdataing
关注
AOP(面向切面编程)
StudyJava01的博客
12-08 1386
  我们在编写代码时，只想关注逻辑代码的实现。但是我们的程序是要放到服务器上去跑的，我们在代码中如果只有业务逻辑代码。虽然代码简洁，但是万一程序在服务器跑的时候数据出现问题时，没办法快速定位到问题所在。但是将日志等非逻辑代码和我们的逻辑代码放在一起，会使得代码冗余，代码的可读性难度加大。   基于上面的问题，Spring为我们提供了一种解决方案，将业务功能逻辑代码和非功能代码分开来写，然后使用动态代理，将非功能性代码嵌入到功能代码中，这就是所谓的AOP(面向切面编程)。  1、我们要使用Aop对我们的bea
springAOP面向切面编程以及对事务的支持
qq_43814760的博客
04-21 1660
目录 一、springAOP 面向切面编程 （一）springAOP概念解析 （二）springAOP的XML文件配置 1.入门案例 2.AOP的工作流程 3.通知类型 4.切点表达式 5.配置所有通知类型 （三）springAOP通过注解去配置 二、springAOP对事务的支持 （一）事务的简介 1.jdbc中的事务 2.spring中的事务控制 3.spring中事务管理的核心类和方法 (二) 使用xml配置事务 1.使用spring创建一个转账的功能实...
Spring-Aop 底层源码解析--Spring中Aspect切面逻辑的实现
拽着尾巴的鱼儿的博客
12-06 401
在Spring项目中我们可以在启动类上开启切面，并为已经存在的bean 增加@Aspect 声明为切面类，这样就可以为特定bean 中的方法增加对应的逻辑，那么Spring对于@Aspect 是如何支持的呢？可以看到注如了一个AspectJAutoProxyRegistrar 类型的 bean// bean 的注册 ,注册 AnnotationAwareAspectJAutoProxyCreator 类型的bean。
AOP（面向切面编程）
最新发布
cyt涛的博客
10-08 1064
AOP (Aspect-Oriented Programming) 是 Spring 框架的核心功能之一，旨在通过切面来增强程序的功能，特别是在不修改原始代码的情况下为方法添加额外的逻辑，比如日志记录、权限校验、事务管理等。AOP的作用：在程序运行期间在不修改源代码的基础上对已有方法进行增强（无侵入性: 解耦）AOP面向切面编程和OOP面向对象编程一样，它们都仅仅是一种编程思想，而动态代理技术是这种思想最主流的实现方式。而Spring的AOP是Spring框架的高级技术，旨在管理bean对象的过程中底层使用
aop切面编程
笑看人生的博客
07-31 160
传统spring aop开发总结 第一步:编写目标对象(target) 第二步:编写通知(advice) 传统的aop开发中，通知是需要实现指定接口。 第三步在配置文件中配置切面(切面=切点+通知) <aop:config>来声明要对aop进行配置 <aop:pointcut>它是用于声明切点(简单说就是对哪些方法进行拦截) <aop:advis...
AOP切面编程
weixin_44195615的博客
05-07 2099
一、AOP切面编程 1、什么是AOP编程 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 2、AOP编程特点 AOP采取横向抽取机制，取代了
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
Java Spring AOP 面向切面编程的4种实现
07-16
Spring AOP (面向切面编程框架): Spring框架内建了支持动态代理的功能，使用@AspectJ注解可以轻松地创建AOP代理。Spring AOP既支持JDK动态代理也支持CGLIB，会根据目标类是否实现了接口选择合适的底层技术。 Guice ...
Spring——面向切面编程(AOP)
行者无疆的博客
06-05 3820
本文介绍了切向切面编程(AOP)中的各个概念，并用两个案例分别讲解了如何通过注解和XML配置的方式使用AOP。
Spring AOP(面向切面编程)
Fong灵
11-03 753
Spring AOP(面向切面编程)
Aop切面编程
weixin_42600788的博客
05-06 185
应用场景: 判断接口是否缓存,业务添加操作日志等 1.添加核心依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> </dependency> 2.添加注解 import java.lang.annotation.*; /** * 自定义权限认证注解 */ @Target({El
AOP——面向切面编程
azrealq的博客
11-16 490
1.什么是AOP 想必我们第一次接触这个概念一定会进行百度百科，那么我们先来看一下比较官方的说法 AOP就是Aspect Oriented Programming的缩写，也可以称为面向方面编程，它通过预编译和动态代理来实现，目的是对程序功能进行统一的维护。我们知道一个大型项目的成本不仅仅在于代码的编写，更是代码的维护，庞大的代码对维护很不友好。试想如果添加一个新的功能要在原有代码的基础上修改，而这部分代码又与很多地方的代码耦合，那么我们就要首先读懂相关部分的代码，并且在多个地方的源码进行修改，这是一件繁琐
AOP切面编程（一）
m0_37166734的博客
08-19 232
今天给大家带来的是Spring框架中除开IOC(控制反转)之外的第二大特性-AOP(切面编程)，在实际开发中，方法执行情况中都要添加日志或者权限验证的事情，而这时候，不需要将流程式的代码加到主体业务逻辑代码中就可以走过上面常用的流程。 AOP则将封装好的对象剖开，找出其中对多个对象产生影响的公共行为，并将其封装为一个可重用的模块，这个模块被命名为“切面”（Aspect）。 切面将那些与业务无关，...
AOP面向切面编程
weixin_52296931的博客
03-04 187
AOP面向切面编程 也是一种编程思想。主要的工作就是对应用当中重复的代码进行横向抽取。在运行过程之中，采用的是动态代理技术把一些代码内容植入到应用当中。主要是植入到目标方法当中进行增强。 在Spring中有两种代理模式。（AOP就是基于动态代理来实现的，底层依赖于反射机制） JDK原生 动态代理 首先先在pom.xml里面映入c3p0依赖 <!--引入C3P0--> <dependency> <groupId>com.mcha
Spring AOP面向切面编程（附实现源码）
weixin_43287508的博客
08-03 428
Spring AOP面向切面编程
spring aop面向切面编程
08-15
对的，Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一个重要特性。它允许开发者通过在应用程序中定义横切关注点（cross-cutting concerns），将这些关注点与核心业务逻辑分离开来。 在传统的面向对象编程中，我们通常将核心业务逻辑集中在一个或多个类中，然后通过在这些类中调用其他类或方法来实现特定功能。这样做的问题是，横切关注点（如日志记录、事务管理、安全检查等）会被散布在各个类和方法中，导致代码的重复性和难以维护性。 而使用Spring AOP，我们可以通过定义切面（Aspect）来集中处理这些横切关注点。切面是一个模块化单元，它包含了一组通知（Advice），以及定义了切入点（Pointcut）的规则。通知定义了在切入点执行前、执行后、抛出异常时等不同时间点要执行的逻辑。 通过将切面与核心业务逻辑进行织入（Weaving），即将切面的逻辑插入到核心业务逻辑中，我们可以实现横切关注点的功能，并且不需要修改原有的业务逻辑代码。 总结来说，Spring AOP提供了一种解耦横切关注点与核心业务逻辑的方式，使得应用程序的代码更加清晰、模块化，同时也提高了代码的可重用性和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

bigdataing

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

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

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

打赏作者

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

抵扣说明：

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

余额充值