aop笔记整理

已于 2022-07-14 09:05:06 修改
阅读量112 收藏
点赞数 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
    评论
Spring IOC和AOP代码与笔记整理
12-07
彻底学会Spring的IOC和AOP——理论+实操，参考：https://blog.csdn.net/qq_39735940/article/details/121754987
AOP笔记
最新发布
d456211的博客
07-04 73
AOP并不是Spring原创的技术，也不是Spring独家技术，而是源自AspectJ，只是Spring很好的支持了AOP。AOP技术只要解决了“横切关注”的相关问题，也就是“若干个不同的方法都需要执行相同的任务”的问题！AOP：面向切面编程。
Spring AOP 学习笔记
yxd961304738的博客
06-02 73
上面代码执行后，注册了AnnotationAwareAspectJAutoProxyCreator，它是一个后置处理器，当其他组件在创建对象时，都要经过创建Bean实例、给Bean属性赋值、初始化及前后处理器，所以它可以拦截到这些组件的创建过程，接下来要看它作为后置处理器都做了什么？（被代理后的）目标方法执行：容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）。
AOP复习笔记（上）
qq_51606563的博客
09-07 135
AOP的复习笔记
（三）Spring学习笔记（AOP）
weixin_44516623的博客
11-15 79
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。举例1:对com.demo.dao.BookDao类里面的add方法进行增强。举例2:对com.demo.dao.BookDao类里面所有方法进行增强。1.使用JDK动态代理，使用Proxy类里面的方法创建代理对象。增强方法所在类，这个类实现的接口，支持多个接口。（1）实际增强的逻辑部分称为通知（增强）创建接口实现类代理对象，增强类的方法。创建子类的代理对象，增强类的方法。
Aop的黑马学习笔记
qq_59746711的博客
07-19 251
aop的学习笔记
（java）AOP代理方面的简单介绍
11-08
在学习java面向过程中，关于AOP代理这块，当时思路不是很清晰，借鉴了很多资料进行了解，后面把自己的一些见解整理成浅显的笔记进行加深印象，现在把它分享给学习AOP代理思路的朋友们，希望我的一点浅显的总结能够...
JBoss ESB 学习笔记
02-27
自己辛苦整理的网上的JBoss ESB学习笔记 ,非常详细，代码操作都有截图； 希望大家多支持！ 学习笔记PDF的目录如下： 1——搭建ESB开发环境 2 2——第一个ESB代码Hello World 12 3——第二个ESB代码Hello World ...
spring框架整体学习笔记
08-05
spring框架整体知识点整理，代码样例
Spring aop 记录操作日志 Aspect 源码
01-04
时间过的真快，转眼就一年了，没想到随手写的笔记会被这么多人浏览，不想误人子弟，于是整理了一个优化版。感谢各位同道的支持!
spring aop 学习笔记
05-27
NULL 博文链接：https://microjava.iteye.com/blog/525796
spring-AOP简介和实现方式（包含动态代理）
我不想学习但是必须学习
09-14 206
1.Spring 的 AOP 简介 1.1 什么是 AOP AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP （面向对象程序设计）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 1.2 AOP 的作用
spring 学习笔记（AOP）
李意成的博客
07-30 1591
一、spring 的aop思想分析如下图: 二、aop 解释 1.1 Spring中的aop Spring能够为容器中管理的对象生成动态代理对象 以前我们要使用动态代理，我们需要自己调用下面的方法生成对象Proxy.newProxyInstance(xx,xx,xx) 生成代理对象，现在Spring能够帮我们生成代理对象。 1.2 Spring实现aop原理 动态代理（优先） ...
spring-aop学习笔记
wendy_fly的专栏
02-20 580
一 基本概念 通知(Advice):切面的工作被称为通知。定义了切面是什么以及何时使用。spring切面可以应用5种类型的通知(Before、After、After-retrunning，After-throwing, Around)。 连接点(JointPoint)：是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时、抛出异常时、甚至修改一个字段时。切面代码可以利用这些点插入到应
AOP 笔记（一）
qq_36654606的博客
02-14 216
一、AOP概述 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术 AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程...
Spring AOP学习笔记（1）：AOP基础知识
lmy86263的博客
02-27 2494
一、使用AOP前的经验
AOP 学习笔记
weixin_33826268的博客
09-21 81
　　代理是一个设计模式，提供了对目标对象另外的访问方式；即通过代理访问目标对象。 　　好处：可以在目标对象实现的基础上，增强额外的功能操作。   　　Cglib 代理，也叫作 子类代理。 　　JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB 实现。 　　CGLIB 是一个强大的高性能的代码生成包，它可以在运行期扩展...
AOP快速入门笔记
qq_52253125的博客
07-24 256
笔记预留
spring aop 学习笔记（一）
何欣澄的博客
03-14 326
AOP是什么 AOP是 Aspect Oriented Programing 的简称，普遍翻译为“面向方面编程”，但是“面向切面编程”更为合理。 当我们的代码无法通过抽象来消除重复性的横切代码时，aop为此提供了解决方案。 连接点（JoinPoint） 程序执行的某个特定位置，如类初始化前，初始化后，方法调用前后，抛出异常等。一个类或一段程序代码用友一些具有边界性质的特定点，...
spring Aop笔记,和源码讲解
06-09
好的，关于Spring AOP的笔记和源码讲解，我可以给你简单介绍一下。 Spring AOP是Spring框架中的一个重要模块，提供了基于代理的AOP实现。AOP（Aspect Oriented Programming）面向切面编程，是一种编程思想，它通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值