Spring的AOP

Hrgge^0^

已于 2023-04-10 19:07:03 修改

阅读量72

点赞数

文章标签： spring java 后端

于 2023-04-03 09:29:02 首次发布

本文链接：https://blog.csdn.net/Hrgge/article/details/129921138

版权

AOP是AspectOrientedProgramming的缩写，用于减少代码重复，提升可维护性。它通过预编译或动态代理实现程序功能的统一维护。在Spring中，AOP常用于事务处理、日志管理和权限控制等。主要概念包括连接点、切入点、通知、引介、目标对象、织入和代理。配置AOP可以通过XML或注解方式，实现如前置、后置、异常和最终通知等功能增强。

摘要由CSDN通过智能技术生成

什么是AOP？

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方
式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。AOP（面向切面编程）_百度百科 (baidu.com)

AOP的作用
AOP 采取横向抽取机制（动态代理），取代了传统纵向继承机制的重复性代码，其应用主要体现在事务处理、日志管理、权限控制、异常处理等方面。

主要作用是分离功能性需求和非功能性需求，使开发人员可以集中处理某一个关注点或者横切逻辑，减少对业务代码的侵入，增强代码的可读性和可维护性。

简单的说，AOP 的作用就是保证开发者在不修改源代码的前提下，为系统中的业务组件添加某种通用功能。

AOP的相关术语

Joinpoint(连接点):

所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。

Pointcut(切入点):

所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

Advice(通知/增强):

所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

Introduction(引介):

引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。

Target(目标对象):

代理的目标对象。

Weaving(织入):

是指把增强应用到目标对象来创建新的代理对象的过程。spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

Proxy（代理）:

一个类被 AOP 织入增强后，就产生一个结果代理类。

Aspect(切面):

是切入点和通知（引介）的结合。

AOP基于XML配置的入门案例：

1、首先导入IOC和AOP所需要的jar包

2、创建接口与核心类

package com.wen.service;

public interface BookService {
    int save(int n);
    int del();
    int update();
    void find();
}

创建BookServiceImpl类，完成核心功能操作

package com.wen.service.impl;

import com.wen.service.BookService;

/**
 * 核心类
 */
public class BookServiceImpl implements BookService {

    @Override
    public int save(int n) {
        System.out.println("添加");
        return 1;
    }

    @Override
    public int del() {
        System.out.println("删除");
        return 1;
    }

    @Override
    public int update() {
        System.out.println("修改");
        return 1;
    }

    @Override
    public void find() {
        System.out.println("查询");
    }
}

3、创建Loger类，这个类是用来做功能的增强

public class Loger {

    public void check() {
        System.out.println("前置通知/增强：执行系统的权限验证");
    }

    public void logPrint() {
        System.out.println("后置通知/增强：执行日志的打印");
    }

    public void exception() {
        System.out.println("异常通知/增强：做出异常的处理");
    }

    public void distory() {
        System.out.println("最终通知/增强：资源的释放");
    }
}

4、在spring的spring.xml中开始进行AOP的配置：

首先把核心类和增强类的bean配置到IOC的容器中
使用<aop:config>标签在进行AOP的配置，先通过aop:aspect标签标明谁是增强类。然后在标签中进行aop:before（前置）、aop:after-returning（后置）、aop:after-throwing（异常）、aop:after（最终）的配置，让增强类的某个方法对核心功能类的某一类方法进行功能增强。

<?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">

    <!--1.把所有类的对象交给IOC容器进行管理-->
    <bean id="loger" class="com.wen.advice.Loger"/>
    <bean id="bookService" class="com.wen.service.impl.BookServiceImpl"/>
    <!--2.AOP的配置：让增强类 的 哪个方法  动态进行何种增强   核心类 的 哪个方法-->
    <aop:config>
        <aop:aspect id="log" ref="loger">
            <aop:before method="check" pointcut="execution(* *..BookServiceImpl.*(..))"/>
            <aop:after-returning method="logPrint" pointcut="execution(* *..BookServiceImpl.*(..))"/>
            <aop:after-throwing method="exception" pointcut="execution(* *..BookServiceImpl.*(..))"/>
            <aop:after method="distory" pointcut="execution(* *..BookServiceImpl.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

5、在测试类中测试BookServiceImpl的方法是否被增强

public class Test01 {
    @Test
    public void test01(){
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        BookService bookService = context.getBean(BookService.class);
        bookService.save(6);
    }
}

日志信息

环绕通知

1、环绕通知是一种提供自由灵活对核心类方法进行增强的操作手段，首先还是在spring.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
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--1.把所有类的对象交给IOC容器进行管理-->
    <bean id="loger" class="com.wen.advice.Loger"/>
    <bean id="bookService" class="com.wen.service.impl.BookServiceImpl"/>
    <!--2.AOP的配置：让增强类 的 哪个方法  动态进行何种增强   核心类 的 哪个方法-->
    <aop:config>
        <aop:aspect id="log" ref="loger">
            <aop:around method="around" pointcut="execution(* *..BookServiceImpl.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

2、接着我们需要在增强类中完善我们环绕通知的方法，这个方法需要定义一个ProceedingJoinPoint接口对象作为方法参数，且方法返回值是Object。

 public Object around(ProceedingJoinPoint pjp) {
        try {
            System.out.println("环绕通知---前置增强");

            Object result = null;
            Object[] args = pjp.getArgs();
            result = pjp.proceed(args);

            System.out.println("环绕通知---后置增强");

            return result;
        } catch (Throwable throwable) {
            //异常增强
            System.out.println("环绕通知---异常增强");
            throw new RuntimeException(throwable);
        } finally {
            //最终增强
            System.out.println("环绕通知---最终增强");
        }
    }

基于注解的AOP配置

1、创建项目

2、首先关于定义IOC容器的bean标签使用注解替换

3、xml配置的切面配置信息我们在增强类中使用@Aspect注解替代

Aspect告诉spring框架类是一个切面类，用来做功能的增强

4、xml配置切入点的前置通知、后置通知、异常通知、最终通知分别使用@Before、@AfterReturning、@AfterThrowing、@After这四个注解替代，同时在注解中定义要增强那个包中那个类的那个方法，且使用表达式表示。

@Component
@Aspect
public class Loger {

    @Before("execution(* *..BookServiceImpl.*(..))")
    public void check(){
        System.out.println("前置通知/增强：执行系统的权限验证");
    }
    @AfterReturning("execution(* *..BookServiceImpl.*(..))")
    public void logPrint(){
        System.out.println("后置通知/增强：执行日志的打印");
    }
    @AfterThrowing("execution(* *..BookServiceImpl.*(..))")
    public void exception(){
        System.out.println("异常通知/增强：做出异常的处理");
    }
    @After("execution(* *..BookServiceImpl.*(..))")
    public void distory(){
        System.out.println("最终通知/增强：资源的释放");
    }

5、在spring.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">

    <!--1.扫描component及同名注解-->
    <context:component-scan base-package="com.wen"/>
    <!--2.开启AOP注解支持-->
    <aop:aspectj-autoproxy/>
</beans>

6、在测试类中测试注解配置的操作是否生效