【spring】Spring的aop

最新推荐文章于 2024-09-09 21:12:08 发布
最新推荐文章于 2024-09-09 21:12:08 发布
阅读量810 收藏 1
点赞数 2
分类专栏： Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43418737/article/details/122704568
版权

        之前的文章中我们介绍了Spring的控制反转和依赖注入，今天来详细说说Spring的aop。

        aop（Aspect Oriented Programming）即面向切面编程，它是Spring提出的一种思想，是为了在不修改源代码的基础上对原代码进行增强，Spring aop是aop思想的实现。

        我们知道java一贯接收的是OOP（Object Oriented Programming，面向对象开发）思想，在开发过程中一般遵循的是controller -> service -> dao层级开发，这种自上而下的开发思想可以让我们在开发过程中更加的清晰认识到层级之间的调用关系，但是这也存在一个明显的缺点，他只能从上而下不能定义横向的业务，比如我想在所有的service中都打印一句话，当service被调用的时候就打印这句话。在传统的OOP思想中，我们需要在每个service都先打印这句话，这样未免太过于臃肿，因此就需要引入aop的思想来弥补OOP中的不足了。

        在aop中引入切面的思想，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

        在使用切面思想时，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

一、aop中的核心概念

切面关注点：对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为切面关注的点。

切面（aspect）：类是对物体特征的抽象，切面就是对切面关注点的抽象，可以理解是对切入点+增强（通知）的描述。

连接点（joinpoint）：被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器。

切入点（pointcut）：对连接点进行拦截的定义。

通知（advice）：所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类。

目标对象：代理的目标对象。

织入（weave）：将切面应用到目标对象并导致代理对象创建的过程。

引入（introduction）：在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段。

增强：一个具体的功能，实际上可以理解是通知的具体内容。

二、Spring中的aop

aop和Spring中aop的关系：

        1、aop编程思想不是Spring独有的，Spring只是支持了aop变成思想，切勿搞反了两者之间的关系；

        2、在aop的编程思想的加持下，aop可以支持对切面中类、方法、文件、参数、返回值等等类型进行拦截、改变、执行、增强的操作，而Spring中的aop支持的是方法级别的类型操作；

        3、aop属于一种思想，而Spring的aop则是这个思想的实现。

        Spring的aop底层默认由Java的动态代理来创建aop代理，如果需要代理的是类而不是接口的时候，Spring会自动的切换成CGLIB代理，不过也可以强制使用CGLIB代理，至于两者如何切换将在后续文章中讨论。除此之外，Spring的aop也需要IOC容器负责生成、管理，其依赖关系同样由IOC容器负责管理，因此，Spring中的aop可以直接使用IOC中的其他bean作为目标，这种关系仍然由IOC容器依赖注入提供。

三、Spring中aop的使用

3.1、xml版

3.1.1、基础配置

1.引入相关依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sxx</groupId>
    <artifactId>custom</artifactId>
    <version>1.0-SNAPSHOT</version>


    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>5.1.6.RELEASE</spring.version>
        <junit.version>4.12</junit.version>
        <slf4j.version>1.7.35</slf4j.version>
        <aspectjweaver.version>1.8.9</aspectjweaver.version>
        <json.version>1.2.27</json.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectjweaver.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${json.version}</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                    <addResources>true</addResources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

 2.创建日志对象

public class SysLog {

    //请求ip
    private String ip;

    //操作用户
    private String userName;

    //请求方法名
    private String methodName;

    //请求入参
    private String params;

    //执行耗时
    private Long dateTime;
    
    //创建时间
    private Date createdTime;
    
    //操作类型
    private String operation;
}

3.配置注解（为了在通知时获取更加全面注解信息，可以忽略）

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ACL {
    
    //请求方法名
    String value();

    //请求所需权限
    String scope() default "";

    //请求所需角色
    String role() default "";

    //是否打印日志
    boolean printLog() default true;
}

 4.配置controller对象及请求方法

public class UserController {

    @ACL(value = "getUserInfo", scope = "普通权限", role = "普通用户")
    public String getUserInfo(String id){
        return "用户:" + id + "登录成功！";
    }
}

 3.1.2、配置通知类型

public class AspectHandle {

    /**
     * 前置通知
     */
    public void beforeMethod() {
       System.out.println("前置通知执行了");
    }

    /**
     * 后置通知
     */
    public void afterMethod() {
        System.out.println("后置通知执行了");
    }

    /**
     * 最终通知
     */
    public void returningMethod() {
        System.out.println("最终通知执行了");
    }

    /**
     * 异常通知
     */
    public void throwingMethod() {
        System.out.println("异常通知执行了");
    }
}

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

    <bean id="aspectHandle" class="com.sxx.service.config.AspectHandle"/>
    <bean id="userController" class="com.sxx.service.controller.UserController"/>

    <!--aop配置-->
    <aop:config>
        <!--
        配置切点表达式:
            expression：切点表达式 
            * ：匹配一个或者多个  
            .. ：代表0个或者多个
        -->
        <aop:pointcut id="pt" expression="execution(* com.sxx.service.controller.*.* (..))"/>
        <!--aop:aspect：配置切面信息，可以配置多个-->
        <aop:aspect id="handle" ref="aspectHandle">
            <!--前置通知-->
            <aop:before method="beforeMethod" pointcut-ref="pt"/>
            <!--后置通知-->
            <aop:after method="afterMethod" pointcut-ref="pt"/>
            <!--最终通知-->
            <aop:after-returning method="returningMethod" pointcut-ref="pt"/>
            <!--异常通知-->
            <aop:after-throwing method="throwingMethod" pointcut-ref="pt"/>
        </aop:aspect>
    </aop:config>
</beans>

3.1.4、配置测试类

package com.sxx.web;

import com.sxx.service.controller.UserController;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserControllerTest {

    private static final Logger LOGGER = LoggerFactory.getLogger(UserControllerTest.class);

    @Test
    public void test01(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/bean.xml");
        UserController userController = (UserController) applicationContext.getBean("userController");
        String userInfo = userController.getUserInfo("123");
        LOGGER.info(userInfo);
    }
}

 3.1.5、打印结果

前置通知执行了
后置通知执行了
最终通知执行了

异常通知同理，只需要在执行过程中抛出异常即可测试 

3.1.6、环绕通知

环绕通知是四大通知的集合体，可以在环绕通知中加入四大通知，不同的是环绕通知必须要执行ProceedingJoinPoint中的proceed方法才能执行目标方法，其他和四大通知一样，在使用中要注意这一点。

通知类型改为：

package com.sxx.service.config;

import com.alibaba.fastjson.JSON;
import com.sxx.service.annotation.ACL;
import com.sxx.service.entity.SysLog;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Date;

public class AspectHandle {

    /**
     * 环绕通知,即包含了四大通知
     *
     * @param pjp
     */
    public void aroundMethod(ProceedingJoinPoint pjp) {
        System.out.println("环绕通知执行了。。。");
        try {
            System.out.println("前置通知执行了。。。");
            printLog(pjp);
            Object proceed = pjp.proceed();
            System.out.println("执行结果为:" + JSON.toJSONString(proceed));
            System.out.println("后置通知执行了。。。");
        } catch (Throwable throwable) {
            System.out.println("异常通知。。。");
            System.out.println(throwable.getMessage());
        }finally {
            System.out.println("最终通知执行了。。。");
        }
    }

    /**
     * 打印相关信息
     * @param pjp
     * @throws NoSuchMethodException
     */
    public void printLog(ProceedingJoinPoint pjp) throws NoSuchMethodException {
        long start = System.currentTimeMillis();
        //获取类的字节码对象，通过字节码对象获取方法信息
        Class<?> targetCls = pjp.getTarget().getClass();
        //获取方法签名(通过此签名获取目标方法信息)
        MethodSignature ms = (MethodSignature) pjp.getSignature();
        //获取目标方法上的注解指定的操作名称
        Method targetMethod = targetCls.getDeclaredMethod(
                ms.getName(),
                ms.getParameterTypes());
        ACL acl = targetMethod.getAnnotation(ACL.class);
        String operation = acl.value();
        System.out.println("targetMethod=" + targetMethod);
        //获取目标方法名(目标类型+方法名)
        String targetClsName = targetCls.getName();
        String targetObjectMethodName = targetClsName + "." + ms.getName();
        //获取请求参数
        String targetMethodParams = Arrays.toString(pjp.getArgs());
        //2.封装用户行为日志(SysLog)
        SysLog entity = new SysLog();
        entity.setIp("127.0.0.1");
        entity.setUserName("admin");
        entity.setMethodName(targetObjectMethodName);
        entity.setParams(targetMethodParams);
        entity.setDateTime(System.currentTimeMillis() - start);
        entity.setCreatedTime(new Date());
        entity.setOperation(operation);
        //3.将日志写入到数据库
        System.out.println(JSON.toJSONString(entity));
    }
}

 xml配置文件为

    <bean id="aspectHandle" class="com.sxx.service.config.AspectHandle"/>
    <bean id="userController" class="com.sxx.service.controller.UserController"/>

    <!--aop配置-->
    <aop:config>
        <!--
        配置切点表达式:
            expression：切点表达式
            * ：匹配一个或者多个
            .. ：代表0个或者多个
        -->
        <aop:pointcut id="pt" expression="execution(* com.sxx.service.controller.*.* (..))"/>
        <!--aop:aspect：配置切面信息，可以配置多个-->
        <aop:aspect id="handle" ref="aspectHandle">
             <!--环绕通知-->
             <aop:around method="aroundMethod" pointcut-ref="pt"/>
        </aop:aspect>
    </aop:config>

执行结果如下：

环绕通知执行了。。。
前置通知执行了。。。
targetMethod=public java.lang.String com.sxx.service.controller.UserController.getUserInfo(java.lang.String)
{"createdTime":1645005033614,"dateTime":2,"ip":"127.0.0.1","methodName":"com.sxx.service.controller.UserController.getUserInfo","operation":"getUserInfo","params":"[123]","userName":"admin"}
执行结果为:"用户:123登录成功！"
后置通知执行了。。。
最终通知执行了。。。 

3.2、注解版

注解版与xml思路一样，主要改动在xml配置文件和AspectHandle文件中

3.2.1、四大通知注解版

AspectHandle：

package com.sxx.service.config;

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

@Component
@Aspect
public class AspectHandle {

    //定义公共的切点表达式
    @Pointcut("execution(* com.sxx.service.controller.*.* (..))")
    public void pt() {
    }

    /**
     * 前置通知
     */
    @Before("pt()")
    public void beforeMethod() {
        System.out.println("前置通知执行了");
    }

    /**
     * 后置通知
     */
    @AfterReturning("pt()")
    public void afterMethod() {
        System.out.println("后置通知执行了");
    }

    /**
     * 最终通知
     */
    @After("pt()")
    public void returningMethod() {
        System.out.println("最终通知执行了");
    }

    /**
     * 异常通知
     */
    @AfterThrowing("pt()")
    public void throwingMethod() {
        System.out.println("异常通知执行了");
    }
}

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

    <!--添加spring扫描，范围是com.sxx下所有包及其子包-->
    <context:component-scan base-package="com.sxx"/>
    <!--.启用@AsjectJ支持-->
    <aop:aspectj-autoproxy/>
</beans>

执行结果如下：

前置通知执行了
最终通知执行了
后置通知执行了

注意：当使用注解版本的四大通知时,Spring是有bug的(最终执行会显示在最后执行之前)。

3.2.2、环绕通知注解版

AspectHandle：

package com.sxx.service.config;

import com.alibaba.fastjson.JSON;
import com.sxx.service.annotation.ACL;
import com.sxx.service.entity.SysLog;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Date;

@Component//交给Spring容器管理
@Aspect//标注为切面
public class AspectHandle {

    //定义公共的切点表达式
    @Pointcut("execution(* com.sxx.service.controller.*.* (..))")
    public void pt(){
    }

    /**
     * 环绕通知,即包含了四大通知
     *
     * @param pjp
     */
    @Around("pt()")
    public void aroundMethod(ProceedingJoinPoint pjp) {
        System.out.println("环绕通知执行了。。。");
        try {
            System.out.println("前置通知执行了。。。");
            printLog(pjp);
            Object proceed = pjp.proceed();
            System.out.println("执行结果为:" + JSON.toJSONString(proceed));
            System.out.println("后置通知执行了。。。");
        } catch (Throwable throwable) {
            System.out.println("异常通知。。。");
            System.out.println(throwable.getMessage());
        }finally {
            System.out.println("最终通知执行了。。。");
        }
    }

    /**
     * 打印相关信息
     * @param pjp
     * @throws NoSuchMethodException
     */
    public void printLog(ProceedingJoinPoint pjp) throws NoSuchMethodException {
        long start = System.currentTimeMillis();
        //获取类的字节码对象，通过字节码对象获取方法信息
        Class<?> targetCls = pjp.getTarget().getClass();
        //获取方法签名(通过此签名获取目标方法信息)
        MethodSignature ms = (MethodSignature) pjp.getSignature();
        //获取目标方法上的注解指定的操作名称
        Method targetMethod = targetCls.getDeclaredMethod(
                ms.getName(),
                ms.getParameterTypes());
        ACL acl = targetMethod.getAnnotation(ACL.class);
        String operation = acl.value();
        System.out.println("targetMethod=" + targetMethod);
        //获取目标方法名(目标类型+方法名)
        String targetClsName = targetCls.getName();
        String targetObjectMethodName = targetClsName + "." + ms.getName();
        //获取请求参数
        String targetMethodParams = Arrays.toString(pjp.getArgs());
        //2.封装用户行为日志(SysLog)
        SysLog entity = new SysLog();
        entity.setIp("127.0.0.1");
        entity.setUserName("admin");
        entity.setMethodName(targetObjectMethodName);
        entity.setParams(targetMethodParams);
        entity.setDateTime(System.currentTimeMillis() - start);
        entity.setCreatedTime(new Date());
        entity.setOperation(operation);
        //3.将日志写入到数据库
        System.out.println(JSON.toJSONString(entity));
    }
}

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

    <!--添加spring扫描，范围是com.sxx下所有包及其子包-->
    <context:component-scan base-package="com.sxx"/>
    <!--.启用@AsjectJ支持-->
    <aop:aspectj-autoproxy/>
</beans>

执行结果如下：

环绕通知执行了。。。
前置通知执行了。。。
targetMethod=public java.lang.String com.sxx.service.controller.UserController.getUserInfo(java.lang.String)
{"createdTime":1645009250206,"dateTime":1,"ip":"127.0.0.1","methodName":"com.sxx.service.controller.UserController.getUserInfo","operation":"getUserInfo","params":"[123]","userName":"admin"}
执行结果为:"用户:123登录成功！"
后置通知执行了。。。
最终通知执行了。。。 

闲着无聊整些资料
关注
专栏目录
spring aop 五个依赖jar
05-16
spring aop依赖包，想要的可以下，我用的spring 3.1,其他版本的不知道支不支持。
spring AOP依赖配置大全
热门推荐
qq_44534541的博客
04-21 1万+
pom.xml文件的依赖配置 <dependencies> <!--junit单元测试--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <versio...
Spring AOP
2201_76027754的博客
09-09 845
Spring AOP
AOP详解
weixin_47331155的博客
12-21 2078
AOP:面向切面编程，AOP是一种编程思想，和语言无关。 拦截器和AOP之间的关系？ 拦截器的拦截粒度比较粗，而SpringAOP拦截粒度更细 什么是AOP AOP称为面向切面编程，在系统开发中主要用来解决一些系统层面上的问题，比如：日志，权限，事务等等。 AOP利用一种称为“横切”的技术，将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect",即切面。 使用“横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关
什么是AOP？AOP配置需要哪些依赖？
TangMonk的博客
08-25 1560
1. **什么是AOP？**AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它与传统的面向对象编程（OOP）相辅相成。AOP的核心思想是将程序的功能划分为不同的关注点（concerns），然后，以。AOP引入了概念如下：- **,切面类、拦截处理类）：** 切面是关注点的模块化单元。它定义了一系列的通知（Advice），以及切点（Pointcut），指定在何处应用这些通知。- **
Spring的依赖注入和AOP使用详解
qq_49195366的博客
10-18 1266
Spring的依赖注入和AOP使用详解
SpringSpring Aop基础入门
最新发布
09-26
Spring Aop基于xml练习
Spring AOP教程
12-07
Spring框架的关键组件之一是面向方面编程(AOP)框架。 面向方面的编程需要将程序逻辑分解成不同的部分。 此教程将通过简单实用的方法来学习Spring框架提供的AOP/面向方面编程。
Spring aop.docx
12-14
**Spring AOP 入门** 在深入探讨Spring AOP之前，我们先理解AOP（面向切面编程）的概念。AOP是一种编程范式，旨在减少代码的重复性，提高代码的可维护性和可读性。它通过将关注点（如日志记录、事务管理、安全性等...
spring aop jar 包
07-26
Spring AOP(Aspect Oriented Programming，面向切面编程)是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口，...
Spring 入门AOP材料
02-13
**Spring AOP 入门教程** 在Java开发中，Spring框架是不可或缺的一部分，它提供了许多强大的功能，其中就包括面向切面编程（AOP）。面向切面编程是一种编程范式，旨在将关注点分离，使得业务逻辑代码与系统级服务...
spring AOP依赖三个jar包
04-10
spring做AOP开发所依赖的三个jar包 aopalliance-1.0.jar aspectjweaver-1.7.0.jar spring-aspects-4.0.2.RELEASE.jar
spring aop依赖jar包
11-22
springaop依赖的jar包，spring版本2.5.6，如果需要，可以下载使用，欢迎各位评论指出不足
aop所依赖的所有包
08-03
aop所依赖的所有包+文档+源码，最新版全套aop aspectjweaver aopalliance aspects aspectjrt
Spring面试重点（三）——AOP&循环依赖
qq_43409401的博客
02-12 884
Spring AOP&循环依赖面经
Spring基础三（AOP）
我的博客
08-18 345
Spring基础三—AOP 一.概述 AOP又称为面向切面编程，是对面向对象编程（OOP）的补充。一些常见的横切关注点如：日志记录，事务管理，数据验证等。在面向对象编程中，应用程序的模块化是通过类实现的，而在面向方面编程应用程序中，模块化由Aspects实现，并且它们被配置为跨越不同的类。Spring AOP从通过普通面向对象编程模型无法实现的类中获取横切任务的直接依赖性。例如，我们可以有...
Spring Aop
会写Bug的攻城狮
08-30 1372
Spring MVC：需要在XML配置中手动添加来启用AOP。：通过引入依赖，启用AOP功能，简化了配置过程。这种设计让Spring Boot提供了一种更为简便和现代的开发体验，减轻了开发者的负担。每种方案都有其适用的场景和优劣所在。大部分情况下，将方法拆分到不同的 Service 中是最佳实践，它能够保持代码的清晰性和可维护性。在复杂的应用中，可以根据具体的需求考虑其他方法，但在选择方案时要注意事务管理的影响。
Spring5—AOP
来杯奶茶
10-21 462
AOP基本概念 1、什么是AOP （1）面向切面编程（方面），利用AOP可以对业务逻辑的每个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 （2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能 （3）使用登录例子说明AOP AOP的底层原理 1、AOP底层使用动态代理 （1）有两种情况动态代理 第一种：有接口情况，使用JDK动态代理 *创建接口实现类...
Spring AOP：聚焦方法拦截
"Spring AOP是Spring框架中的一个重要模块，专注于面向切面编程，它通过提供方法级别的Joinpoint来实现AOP的功能。虽然Spring AOP仅支持方法执行类型的Joinpoint，但这已经足够应对大部分开发场景。" Spring AOP，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值