SpringAOP的概述与实现

前置通知(前置增强)- before()执行方法前通知
返回通知(返回增强)- afterReturn方法正常结束返回后的通知
异常抛出通知(异常抛出增强)- afetrThrow()
最终通知- after无论方法是否发生异常，均会执行该通知。
环绕通知– around包围一个连接点(join point)的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

切面

切入点与通知的结合，决定了切面的定义，切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么，切面则是横切关注点的抽象，与类相似，类是对物体特征的抽象，切面则是横切关注点抽象。

目标对象

被代理的对象

织入

将切面应用到目标对象并生成代理对象的这个过程即为织入

引入

在不修改原有应用程序代码的情况下，在程序运行期为类动态添加方法或者字段的过程称为引入

谈谈你对AOP的理解？

Aop是面向切面编程，Aop关注的不再是程序代码中某个类，某些方法，而是层与层之间的一种切入
应用于日志记录，性能统计，安全控制，事务处理等方面，实现公共功能性的重复使用。
作用：降低模块与模块之间的耦合度，提高业务代码的聚合度,提高了代码的复用性,可以在不影响原有的功能基础上添加新的功能
动态代理（JDK与CGLIB）实现AOP

SpringAOP的实现

依赖引用


            org.aspectj
            aspectjweaver
            1.9.6

spring.xml配置


xmlns:aop="http://www.springframework.org/schema/aop"
 
http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd

注解实现

1.定义切面设置通知


package com.lsf.aspect;
 
 
 
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
 
/**
 * 定义切面
 *  定义 切入点 与 通知 的结合
 *
 */
 
@Component  //将该类交给IOC实例化
@Aspect   //声明此类为切面类
public class LogCut {
 
/**
 * 定义切入点
 *      通过Pointcut定义规则
 *      @Pointcut("execution(* com.lsf.service.*.*(..))")   com.lsf.service下所有方法
 *      例：
 *      1，拦截所有方法
 *      @Pointcut("execution(* *(..))")
 *
 *      2,拦截所有公共的set方法方法
 *      @Pointcut("execution(public set*(..))")
 *
 *
 *  *
 *  *
  */
    @Pointcut("execution(* com.lsf.service.*.*(..))")
    public void cut(){
 
    }
    /**
     * 前置通知，引用在切入点
     *  在目标方法调用前
     */
 
 
    @Before(value = "cut()")
    public void before(){
        System.out.println("这是一个前面通知");
 
    }
 
    /**
     * 返回通知，引用在切入点
     *  在目标方法无异常返回时输出
     */
    @AfterReturning(value = "cut()")
    public void afterReturn(){
        System.out.println("返回通知");
    }
 
    /**
     * 最终通知，引用在切入点
     *  在目标方法是否异常 ，都输出
     */
    @After(value = "cut()")
    public void after(){
        System.out.println("最终通知");
    }
 
    /**
     * 异常通知，引用在切入点
     *  在目标方法发生异常时 ，都输出
     */
    @AfterThrowing(value = "cut()",throwing = "e")
    public void afterThrow(Exception e){
        System.out.println("异常通知：异常原因：  ");
    }
 
    /**
     * 环绕通知，引用在切入点
     *  在目标方法发生异常时 ，都输出
     */
    @Around(value = "cut()")
    public Object around(){
        System.out.println("前置通知");
        Object result = null;
        try {
            System.out.println("返回通知");
 
        }catch (Exception e){
        e.printStackTrace();
            System.out.println("异常通知");
        }catch (Throwable throwable){
            throwable.printStackTrace();
        }finally {
            System.out.println("最终通知");
        }
       
        return result;
    }
 
 
}

2.开启aop

3.测试


package com.lsf;
 
 
import com.lsf.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class Starter {
 
    public static void main(String[] args) {
 
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) ac.getBean("userService");
        userService.test();
    }
 
 
 
}

xml实现

1.写切面类


package com.lsf.aspect;
 
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
 
/**
 * 定义切面
 *  定义 切入点 与 通知 的结合
 *
 */
 
@Component  //将该类交给IOC实例化
@Aspect   //声明此类为切面类
public class LogCutxml {
 
    /**
     * 定义切入点
     */
 
    public void cut(){
 
    }
    /**
     * 前置通知，引用在切入点
     *  在目标方法调用前
     */
 
 
 
    public void before(){
        System.out.println("这是一个前面通知");
 
    }
 
    /**
     * 返回通知，引用在切入点
     *  在目标方法无异常返回时输出
     */
 
    public void afterReturn(){
        System.out.println("返回通知");
    }
 
    /**
     * 最终通知，引用在切入点
     *  在目标方法是否异常 ，都输出
     */
 
    public void after(){
        System.out.println("最终通知");
    }
 
    /**
     * 异常通知，引用在切入点
     *  在目标方法发生异常时 ，都输出
     */
 
    public void afterThrow(Exception e){
        System.out.println("异常通知：异常原因：  ");
    }
 
    /**
     * 环绕通知，引用在切入点
     *  在目标方法发生异常时 ，都输出
     */
 
    public Object around(){
        System.out.println("前置通知");
        Object result = null;
        try {
            System.out.println("返回通知");
 
        }catch (Exception e){
        e.printStackTrace();
            System.out.println("异常通知");
        }catch (Throwable throwable){
            throwable.printStackTrace();
        }finally {
            System.out.println("最终通知");
        }
 
        return result;
    }
 
 
}

2.配置aop相关配置


 
        
                
                "logCutxml">
                        
                        "cut" expression="execution(* com.lsf.service..*.*(..))"/>
                        "before" pointcut-ref="cut" />
                        
                        "afterReturn" pointcut-ref="cut"/>
                        "afterThrow" throwing="e" pointcut-ref="cut" />
                        
                        "after" pointcut-ref="cut" />
                        
                        "around" pointcut-ref="cut"/>

3.测试


package com.lsf;
 
 
import com.lsf.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class Starter {
 
    public static void main(String[] args) {
 
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) ac.getBean("userService");
        userService.test();
    }
 
 
 
}

相关阅读:
在单片机中什么是FLASH
鸿蒙布局List简介
 Day31 Web端自动化基础
 瀑布式开发和敏捷开发
 IntelliJ IDEA 常用的插件
 三分钟搞懂MySQL5.6优化&索引下推
 一起Talk Android吧（第三百九十回：关于Android版本12适配蓝牙权限的问题）
JavaBean处理器之MapStruct
ChatGPT高级数据分析功能
 C Primer Plus(6) 中文版第6章 C控制语句：循环 6.2 while语句
原文地址：https://blog.csdn.net/weixin_47514459/article/details/126909391

SpringAOP的概述与实现

SpringAOP的概述

什么是AOP

AOP能干什么

AOP的特点

AOP底层实现

AOP基本概念

连接点

切入点

通知

切面

目标对象

织入

引入

谈谈你对AOP的理解？

SpringAOP的实现

依赖引用

spring.xml配置

注解实现

1.定义切面 设置通知

2.开启aop

3.测试

xml实现

1.写切面类

2.配置aop相关配置

3.测试

1.定义切面设置通知