aop笔记整理

已于 2022-07-14 09:05:06 修改
阅读量121 收藏
点赞数 1
文章标签： java spring
于 2022-06-10 17:15:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48204844/article/details/125224742
版权

aop

aop通知类型，有如下几类。通过测试验证以下结论：

  • 前置通知（Before advice）：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）;当通知出现异常,连接点之后不会执行。
  • 后置通知（After returning advice）：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回;当通知出现异常,不影响连接点执行,影响连接点的返回。
  • 异常通知（After throwing advice）：在方法抛出异常退出时执行的通知;当通知出现异常,不影响连接点执行,影响连接点的返回。
  • 最终通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）,当通知出现异常,不影响连接点执行,影响连接点的返回。
  • 环绕通知（Around Advice）：包围一个连接点的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行。

下面是一个自定义注解

package com.example.mybatisplus.mybatisplusdamo.aop;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;


/**
 * {@link MyTestInterfaceBefore}
 *
 * @author clc
 * @date 2022/5/23  17:35
 */
@Target(METHOD)
@Retention(RUNTIME)
public @interface MyTestInterfaceBefore
{
}


package com.example.mybatisplus.mybatisplusdamo.aop;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;


/**
 * {@link MyTestInterfaceAfter}
 *
 * @author clc
 * @date 2022/5/23  17:35
 */
@Target(METHOD)
@Retention(RUNTIME)
public @interface MyTestInterfaceAfter
{
}


package com.example.mybatisplus.mybatisplusdamo.aop;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;


/**
 * {@link MyTestInterfaceAfterRetrun}
 *
 * @author clc
 * @date 2022/5/23  17:35
 */
@Target(METHOD)
@Retention(RUNTIME)
public @interface MyTestInterfaceAfterRetrun
{
}


package com.example.mybatisplus.mybatisplusdamo.aop;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;


/**
 * {@link MyTestInterfaceAfterThrow}
 *
 * @author clc
 * @date 2022/5/23  17:35
 */
@Target(METHOD)
@Retention(RUNTIME)
public @interface MyTestInterfaceAfterThrow
{
}


package com.example.mybatisplus.mybatisplusdamo.aop;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;


/**
 * {@link MyTestInterface}
 *
 * @author clc
 * @date 2022/5/23  17:35
 */
@Target(METHOD)
@Retention(RUNTIME)
public @interface MyTestInterface
{
}

下面是一个切面类

package com.example.mybatisplus.mybatisplusdamo.aop;

import com.example.mybatisplus.mybatisplusdamo.sql.p3.SqlMapper;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;


/**
 * <p>切面类</p>
 * 通知类型
 * 前置通知（Before advice）：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）;当通知出现异常,连接点之后不会执行。
 * 后置通知（After returning advice）：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回;当通知出现异常,不影响连接点执行,影响连接点的返回。
 * 异常通知（After throwing advice）：在方法抛出异常退出时执行的通知;当通知出现异常,不影响连接点执行,影响连接点的返回。
 * 最终通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）,当通知出现异常,不影响连接点执行,影响连接点的返回。
 * 环绕通知（Around Advice）：包围一个连接点的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行。
 */
@Component
@Aspect
public class MyTestInterfaceAspect
{
    private static Logger logger = LoggerFactory.getLogger(MyTestInterfaceAspect.class);

    @Autowired
    private SqlMapper sqlMapper;

    @Pointcut("@annotation(com.example.mybatisplus.mybatisplusdamo.aop.MyTestInterface01)")
    public void pointCut()
    {

    }

    @Before("pointCut()")
    public void before()
    {
        logger.info("pointCut()" + "-->" + "before");
    }

    @Before("@annotation(com.example.mybatisplus.mybatisplusdamo.aop.MyTestInterfaceBefore)")
    public Object handleLogResult(JoinPoint pjp)
        throws Throwable
    {
        logger.info("================================aop/MyTestInterfaceBefore,测试完成");
        Signature sig = pjp.getSignature();
        MethodSignature msig = (MethodSignature)sig;
        Object target = pjp.getTarget();
        Method currentMethod = target.getClass().getMethod(msig.getName(),
            msig.getParameterTypes());
        RequestMapping annotation = currentMethod.getAnnotation(RequestMapping.class);

        if (annotation == null)
        {
            return pjp;
        }
        else
        {
            logger.error("annotation: {}", annotation);
            if (new Random().nextBoolean())
            {
                //NPE
                HashMap<Object, Object> objectObjectHashMap = new HashMap<>();
                objectObjectHashMap.get("dd").toString();
            }
            Map<String, Object> user = new HashMap<>();
            user.put("id", new Random().nextInt(100000) + 101);
            user.put("name", "Before-chenlc");
            user.put("age", 100);
            sqlMapper.add(user);
        }
        return pjp;
    }

    @After("@annotation(com.example.mybatisplus.mybatisplusdamo.aop.MyTestInterfaceAfter)")
    public Object handleLogResult1(JoinPoint pjp)
        throws Throwable
    {
        logger.info("================================aop/MyTestInterfaceAfter,测试完成");
        Signature sig = pjp.getSignature();
        MethodSignature msig = (MethodSignature)sig;
        Object target = pjp.getTarget();
        Method currentMethod = target.getClass().getMethod(msig.getName(),
            msig.getParameterTypes());
        RequestMapping annotation = currentMethod.getAnnotation(RequestMapping.class);
        if (new Random().nextBoolean())
        {
            //NPE
            HashMap<Object, Object> objectObjectHashMap = new HashMap<>();
            objectObjectHashMap.get("dd").toString();
        }
        if (annotation == null)
        {
            return pjp;
        }
        else
        {
            logger.error("annotation: {}", annotation);
            Map<String, Object> user = new HashMap<>();
            user.put("id", new Random().nextInt(100000) + 101);
            user.put("name", "After-chenlc");
            user.put("age", 100);
            sqlMapper.add(user);
        }
        return pjp;
    }

    @AfterReturning("@annotation(com.example.mybatisplus.mybatisplusdamo.aop.MyTestInterfaceAfterRetrun)")
    public Object handleLogResult2(JoinPoint pjp)
        throws Throwable
    {
        logger.info("================================aop/MyTestInterfaceAfterReturning,测试完成");
        Signature sig = pjp.getSignature();
        MethodSignature msig = (MethodSignature)sig;
        Object target = pjp.getTarget();
        Method currentMethod = target.getClass().getMethod(msig.getName(),
            msig.getParameterTypes());
        RequestMapping annotation = currentMethod.getAnnotation(RequestMapping.class);
        if (new Random().nextBoolean())
        {
            //NPE
            HashMap<Object, Object> objectObjectHashMap = new HashMap<>();
            objectObjectHashMap.get("dd").toString();
        }
        if (annotation == null)
        {
            return pjp;
        }
        else
        {
            logger.error("annotation: {}", annotation);
            Map<String, Object> user = new HashMap<>();
            user.put("id", new Random().nextInt(100000) + 101);
            user.put("name", "AfterReturning-chenlc");
            user.put("age", 100);
            sqlMapper.add(user);
        }
        return pjp;
    }

    @AfterThrowing("@annotation(com.example.mybatisplus.mybatisplusdamo.aop.MyTestInterfaceAfterThrow)")
    public Object handleLogResult3(JoinPoint pjp)
        throws Throwable
    {
        logger.info("================================aop/MyTestInterfaceAfterThrow,测试完成");
        Signature sig = pjp.getSignature();
        MethodSignature msig = (MethodSignature)sig;
        Object target = pjp.getTarget();
        Method currentMethod = target.getClass().getMethod(msig.getName(),
            msig.getParameterTypes());
        RequestMapping annotation = currentMethod.getAnnotation(RequestMapping.class);
        if (new Random().nextBoolean())
        {
            //NPE
            HashMap<Object, Object> objectObjectHashMap = new HashMap<>();
            objectObjectHashMap.get("dd").toString();
        }
        if (annotation == null)
        {
            return pjp;
        }
        else
        {
            logger.error("annotation: {}", annotation);
            Map<String, Object> user = new HashMap<>();
            user.put("id", new Random().nextInt(100000) + 101);
            user.put("name", "AfterThrowing-chenlc");
            user.put("age", 100);
            sqlMapper.add(user);
        }
        return pjp;
    }

    @Around("@annotation(com.example.mybatisplus.mybatisplusdamo.aop.MyTestInterface)")
    public Object handleLogResult4(ProceedingJoinPoint pjp)
        throws Throwable
    {
        logger.info("================================aop/MyTestInterfaceAround,测试完成");
        Signature sig = pjp.getSignature();
        MethodSignature msig = (MethodSignature)sig;
        Object target = pjp.getTarget();
        Method currentMethod = target.getClass().getMethod(msig.getName(),
            msig.getParameterTypes());
        RequestMapping annotation = currentMethod.getAnnotation(RequestMapping.class);
        if (new Random().nextBoolean())
        {
            //NPE
            HashMap<Object, Object> objectObjectHashMap = new HashMap<>();
            objectObjectHashMap.get("dd").toString();
        }
        if (annotation == null)
        {
            return pjp.proceed();
        }
        else
        {
            logger.error("annotation: {}", annotation);
            Map<String, Object> user = new HashMap<>();
            user.put("id", new Random().nextInt(100000) + 101);
            user.put("name", "Around-chenlc");
            user.put("age", 100);
            sqlMapper.add(user);
        }
        return pjp.proceed();
    }
}

下面是测试接口，分别对几个aop通知模型做了测试

package com.example.mybatisplus.mybatisplusdamo.sql.p1;

import com.alibaba.fastjson.JSON;
import com.example.mybatisplus.mybatisplusdamo.aop.*;
import com.example.mybatisplus.mybatisplusdamo.sql.p2.SqlService;
import io.swagger.annotations.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;

import java.util.*;


@Slf4j
@RestController
@ApiOperation(notes = "clc-测试controller", value = "测试-SqlController")
public class SqlController
{
    @Autowired
    private SqlService sqlService;
    
    @MyTestInterfaceBefore
    @RequestMapping(path = "/test/aop/MyTestInterfaceBefore", method = RequestMethod.GET)
    public String testBefore()
        throws Exception
    {
        List<Map<String, Object>> maps = sqlService.allOrgs();
        log.error("map:{}", maps);
        if (new Random().nextBoolean())
        {
            log.info("===========出现异常=====================aop/MyTestInterfaceBefore,测试完成");
            throw new Exception();
        }
        log.info("================================aop/MyTestInterfaceBefore,测试完成");
        return "aop/MyTestInterfaceBefore,测试完成";
    }

    @MyTestInterfaceAfterRetrun
    @RequestMapping(path = "/test/aop/MyTestInterfaceAfterRetrun", method = RequestMethod.GET)
    public String testAfterRetrun()
        throws Exception
    {
        List<Map<String, Object>> maps = sqlService.allOrgs();
        log.error("map:{}", maps);
        if (new Random().nextBoolean())
        {
            log.info("===========出现异常=====================aop/MyTestInterfaceAfterRetrun,测试完成");
            throw new Exception();
        }
        log.info("================================aop/MyTestInterfaceAfterRetrun,测试完成");
        return "aop/MyTestInterfaceAfterRetrun,测试完成";
    }

    @MyTestInterfaceAfterThrow
    @RequestMapping(path = "/test/aop/MyTestInterfaceAfterThrow", method = RequestMethod.GET)
    public String testAfterThrow()
        throws Exception
    {
        List<Map<String, Object>> maps = sqlService.allOrgs();
        log.error("map:{}", maps);
        if (new Random().nextBoolean())
        {
            log.info("===========出现异常=====================aop/MyTestInterfaceAfterThrow,测试完成");
            throw new Exception();
        }
        log.info("================================aop/MyTestInterfaceAfterThrow,测试完成");
        return "aop/MyTestInterfaceAfterThrow,测试完成";
    }

    @MyTestInterfaceAfter
    @RequestMapping(path = "/test/aop/MyTestInterfaceAfter", method = RequestMethod.GET)
    public String testAfter()
        throws Exception
    {
        List<Map<String, Object>> maps = sqlService.allOrgs();
        log.error("map:{}", maps);
        if (new Random().nextBoolean())
        {
            log.info("===========出现异常=====================aop/MyTestInterfaceAfter,测试完成");
            throw new Exception();
        }
        log.info("================================aop/MyTestInterfaceAfter,测试完成");
        return "aop/MyTestInterfaceAfter,测试完成";
    }

    @MyTestInterface
    @RequestMapping(path = "/test/aop/MyTestInterface", method = RequestMethod.GET)
    public String testAround()
        throws Exception
    {
        List<Map<String, Object>> maps = sqlService.allOrgs();
        log.error("map:{}", maps);
        if (new Random().nextBoolean())
        {
            log.info("===========出现异常=====================aop/MyTestInterfaceAround,测试完成");
            throw new Exception();
        }
        log.info("================================aop/interface,测试完成");
        return "aop/interface,测试完成";
    }
    @MyTestInterface01
    @RequestMapping(path = "/test/aop/MyTestInterface01", method = RequestMethod.GET)
    public String testPointcut()
        throws Exception
    {
        List<Map<String, Object>> maps = sqlService.allOrgs();
        log.error("map:{}", maps);
        if (new Random().nextBoolean())
        {
            log.info("===========出现异常=====================aop/MyTestInterfaceAround,测试完成");
            throw new Exception();
        }
        log.info("================================aop/interface,测试完成");
        return "aop/interface,测试完成";
    }
}
A person who is the onlyone
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AOP笔记
d456211的博客
07-04 77
AOP并不是Spring原创的技术，也不是Spring独家技术，而是源自AspectJ，只是Spring很好的支持了AOP。AOP技术只要解决了“横切关注”的相关问题，也就是“若干个不同的方法都需要执行相同的任务”的问题！AOP：面向切面编程。
Spring AOP 学习笔记
yxd961304738的博客
06-02 79
上面代码执行后，注册了AnnotationAwareAspectJAutoProxyCreator，它是一个后置处理器，当其他组件在创建对象时，都要经过创建Bean实例、给Bean属性赋值、初始化及前后处理器，所以它可以拦截到这些组件的创建过程，接下来要看它作为后置处理器都做了什么？（被代理后的）目标方法执行：容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）。
AOP复习笔记（上）
qq_51606563的博客
09-07 144
AOP的复习笔记
（三）Spring学习笔记（AOP）
weixin_44516623的博客
11-15 82
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。举例1:对com.demo.dao.BookDao类里面的add方法进行增强。举例2:对com.demo.dao.BookDao类里面所有方法进行增强。1.使用JDK动态代理，使用Proxy类里面的方法创建代理对象。增强方法所在类，这个类实现的接口，支持多个接口。（1）实际增强的逻辑部分称为通知（增强）创建接口实现类代理对象，增强类的方法。创建子类的代理对象，增强类的方法。
Aop的黑马学习笔记
qq_59746711的博客
07-19 268
aop的学习笔记
Spring IOC和AOP代码与笔记整理
12-07
Spring框架是Java开发中不可或缺的一部分，它以IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）为核心，极大地简化了企业级应用的开发工作。本篇将深入探讨Spring的这两...
java web 笔记整理
12-22
这份"java web 笔记整理"涵盖了该领域的关键概念和技术，包括Servlet、JSP、MVC模式、JNDI、JTA以及EJB等核心内容。以下是根据笔记内容整理出的知识点详解： 1. **Servlet**：Servlet是Java平台上的服务器端组件，...
Java面试笔记整理
03-08
这份“Java面试笔记整理”旨在帮助求职者系统性地复习和掌握Java面试的关键知识点。 首先，Java基础是面试的基石。这包括对Java语法的理解，如变量、数据类型、运算符、流程控制语句（如if-else、switch-case、for...
Spring笔记整理.zip
11-22
本笔记将深入讲解Spring的核心概念和使用方法，帮助你快速掌握这一重要的技术。 1. **注解装配**：在Java世界中，注解（Annotation）是一种元数据，它可以提供额外的信息给编译器或运行时环境。在Spring中，注解被...
spring002笔记整理
03-13
本笔记整理了Spring002的相关知识点，主要围绕Spring的核心特性、配置方式以及常见模块进行深入讲解。 1. **Spring核心特性** - **依赖注入（Dependency Injection, DI）**：Spring的核心特性之一，通过DI，对象间...
spring aop 学习笔记
05-27
NULL 博文链接：https://microjava.iteye.com/blog/525796
spring-AOP简介和实现方式（包含动态代理）
我不想学习但是必须学习
09-14 214
1.Spring 的 AOP 简介 1.1 什么是 AOP AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP （面向对象程序设计）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 1.2 AOP 的作用
spring 学习笔记（AOP）
李意成的博客
07-30 1599
一、spring 的aop思想分析如下图: 二、aop 解释 1.1 Spring中的aop Spring能够为容器中管理的对象生成动态代理对象 以前我们要使用动态代理，我们需要自己调用下面的方法生成对象Proxy.newProxyInstance(xx,xx,xx) 生成代理对象，现在Spring能够帮我们生成代理对象。 1.2 Spring实现aop原理 动态代理（优先） ...
AOP基础讲解笔记
weixin_44710184的博客
05-13 189
AOP笔记
Spring学习笔记----AOP编程
太匆匆
07-14 3467
先用代码讲一下什么是传统的AOP(面向切面编程)编程 需求：实现一个简单的计算器，在每一步的运算前添加日志。最传统的方式如下： Calculator.java package cn.limbo.spring.aop.calculator; /** * Created by Limbo on 16/7/14. */ public interface Calculator { in
spring-aop学习笔记
wendy_fly的专栏
02-20 585
一 基本概念 通知(Advice):切面的工作被称为通知。定义了切面是什么以及何时使用。spring切面可以应用5种类型的通知(Before、After、After-retrunning，After-throwing, Around)。 连接点(JointPoint)：是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时、抛出异常时、甚至修改一个字段时。切面代码可以利用这些点插入到应
spring aop 学习笔记（一）
何欣澄的博客
03-14 329
AOP是什么 AOP是 Aspect Oriented Programing 的简称，普遍翻译为“面向方面编程”，但是“面向切面编程”更为合理。 当我们的代码无法通过抽象来消除重复性的横切代码时，aop为此提供了解决方案。 连接点（JoinPoint） 程序执行的某个特定位置，如类初始化前，初始化后，方法调用前后，抛出异常等。一个类或一段程序代码用友一些具有边界性质的特定点，...
AOP 笔记（一）
qq_36654606的博客
02-14 226
一、AOP概述 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术 AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程...
spring aop笔记（使用demo）
MUTOUYIHAO的专栏
08-03 2053
定义 切面（Aspect） ：官方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”，在本例中，“切面”就是类TestAspect所关注的具体行为，例如，AServiceImpl.barA()的调用就是切面TestAspect所关注的行为之一。“切面”在App
spring Aop笔记,和源码讲解
最新发布
06-09
好的，关于Spring AOP的笔记和源码讲解，我可以给你简单介绍一下。 Spring AOP是Spring框架中的一个重要模块，提供了基于代理的AOP实现。AOP（Aspect Oriented Programming）面向切面编程，是一种编程思想，它通过将横切关注点与业务逻辑分离，使得系统的关注点更加清晰，代码更加简洁易懂，同时也提高了代码的可维护性和可扩展性。 在Spring AOP中，切面（Aspect）是一个类，它包含了通知（Advice）和切点（Pointcut）。通知是在切点上执行的操作，例如在方法执行前或执行后执行一些额外的逻辑。而切点则是一个表达式，用于匹配目标对象中的方法，从而确定哪些方法会被通知所影响。 Spring AOP提供了四种通知类型，分别是： 1. 前置通知（Before advice）：在目标方法执行之前执行。 2. 后置通知（After returning advice）：在目标方法执行之后执行，在目标方法没有抛出异常的情况下。 3. 异常通知（After throwing advice）：在目标方法抛出异常后执行。 4. 最终通知（After advice）：无论目标方法是否抛出异常，最终通知都会执行。 除了通知之外，Spring AOP还提供了环绕通知（Around advice），它可以在目标方法执行前和执行后执行一些额外的逻辑，并且可以控制目标方法的执行。 在Spring AOP中，代理是通过JDK动态代理或者CGLIB字节码生成技术生成的。如果目标对象实现了接口，则使用JDK动态代理实现代理；如果目标对象没有实现接口，则使用CGLIB字节码生成技术实现代理。 在Spring AOP中，通知和切点都可以使用注解的方式来声明。例如，使用@Aspect注解声明一个切面类，使用@Before、@After、@AfterReturning、@AfterThrowing和@Around注解声明通知方法，使用@Pointcut注解声明切点表达式。 关于Spring AOP源码讲解，它的实现主要涉及到以下几个类： 1. AdvisedSupport类：封装了目标对象、切面和通知等信息。 2. ProxyFactory类：用于生成代理对象的工厂类。 3. AopProxy接口：代理对象的接口。 4. JdkDynamicAopProxy和CglibAopProxy类：实现了AopProxy接口，分别用于基于JDK动态代理和CGLIB字节码生成技术的代理对象。 以上是Spring AOP的笔记和简单源码讲解，希望能对你有所帮助。如果有什么不清楚的地方，可以继续问我。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值