springAop

最新推荐文章于 2023-04-13 09:27:37 发布
最新推荐文章于 2023-04-13 09:27:37 发布
阅读量144 收藏
点赞数
分类专栏： java 文章标签： aop java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q270384247/article/details/104280590
版权

springAop

前言:这里介绍AOP的基本使用,aop知识点比较多后续会不断补充~

1.概念介绍(通俗易懂)

(1).Join point（连接点）对哪个方法进行处理增强,这个方法就是点
程序执行过程中的一点，例如方法执行或异常处理。在Spring AOP中，连接点始终代表方法的执行

(2).Pointcut（切入点）作用范围,如在哪个包下,哪个类中等等!
切入点是与连接点匹配的表达式

(3).Advice（增强/通知）拦截后做的事情增强,如:我在执行前了写日志,做了用户访问权限校验等!
所谓的通知是指拦截到Joinpoint之后所要做的事情就是通知，通知分为目的地通知，后置通知，异常通知，最终通知和环绕通知（切面要完成的功能）

(4).Aspect（切面）你写的aop的类,就是切面,再简单一点就是你加了@Aspect的类,专业名称叫做"切面"
Aspect切面表示Pointcut（切入点）和Advice（增强/通知）的结合
如图:
在这里插入图片描述

2.常用表达式

在这里插入图片描述

3.表达式符号解释

在这里插入图片描述
1.方法的修饰符 public
2.返回值 *
3.包名 com.xxxx
4.方法,方法参数 service.*(…)
包路径: 当前包和子包就是用…
匹配无参的就是 () 括号内是空的
(Long) 那么就是匹配一个long类型的入参
(…) 那么就是任意参数
5.匹配方法抛出了哪些异常 exception
(一般加载在括号后面,这里放一个图片案例如: 后面跟的throws…)
在这里插入图片描述

4.aop通知

在这里插入图片描述

5.JoinPoint & ProceedingJoinPoint API介绍

JoinPoint
String toString(); //连接点所在位置的相关信息
String toShortString(); //连接点所在位置的简短相关信息
String toLongString(); //连接点所在位置的全部相关信息
Object getThis(); //返回AOP代理对象
Object getTarget(); //返回目标对象
Object[] getArgs(); //返回被通知方法参数列表
Signature getSignature(); //返回当前连接点方法签名
(方法签名的含义: 就是方法名加括号里面的所有参数列表,注意没有返回值!举例: print(String name) print方法加它的入参String类型的name 这就是方法的签名)
SourceLocation getSourceLocation();//返回连接点方法所在类文件中的位置
String getKind(); //连接点类型
StaticPart getStaticPart(); //返回连接点静态部分

ProceedingJoinPoint
环绕通知的入参,包含了joinPoint的所有api并且多了两个方法
Object proceed() throws Throwable (这里就连接点执行本类的方法)
通过反射执行目标对象连接点处的方法。
Object proceed(Object[] var1) throws Throwable
使用新的入参（替换掉原来的入参），通过反射执行目标对象连接点处的方法。

6.代码演示!

1.依赖
框架用的springboot

springboot父~
<parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.1.4.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
</parent>

aop测试依赖
<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
 </dependency>
 <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-test</artifactId>
       <scope>test</scope>
  </dependency>

下面是测试的几个类!
在这里插入图片描述

package com.aop.aspect.testaop;

import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

**目标执行类**
@Component
public class MyTest {
    public String add(String userId) throws Exception {

        if (StringUtils.isBlank(userId)){
            throw new Exception("我没有userId...我是个没有理想的咸鱼!");
        }
        System.out.println("我是userId..." + userId);
        return userId;
    }
}

切面类

package com.aop.aspect.testaop;

import com.aop.aspect.exception.DAOException;
import com.aop.aspect.exception.ErrorCodeConstants;
import com.aop.aspect.exception.PandoraException;
import com.aop.aspect.exception.PandoraResult;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.MDC;
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.aspectj.lang.reflect.SourceLocation;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import static org.apache.commons.lang3.StringUtils.*;


@Aspect
@Component
@Slf4j
public class MyAop {

    /**
     *
     * 这里要写一个切点表达式,表示你要作用于哪个类,哪个方法
     * 写在方法上是因为@Pointcut()表达式要在类上才生效啊! 方法名可以自己定义但是要见名知意!方法内可以不写任何东西
     *
     * public * com.aop.aspect..*.*(..)
     * 表达式解释: public修饰的/任意返回值的/com.aop.aspect包下和子包下的/任意类/任意方法/任意参数
     *
     * 其他解释: 包后面的..表示当前包, *表示任意   (..)括号里的..表示任意参数你可以把他看成方法的括号就好理解了,传几个参数都可以什么类型都可以
     */
    @Pointcut("execution(public * com.aop.aspect..*.*(..))")
    public void cut(){
        System.out.println("我是一个切入点方法... ");
    }

    /**
     * 切点通知,你要在这里面做的方法增强逻辑就写在这里面,
     * cut()表示你要把Before这个通知作用到上面的切入点的范围内.
     * @param joinPoint
     */
    @Before("cut()")
    public void beforeAdvice(JoinPoint joinPoint){
        System.out.println(joinPoint);
        log.info("我是前置通知...我在方法执行前做处理");
        printPointAgs(joinPoint);

    }
	
	//后置通知
    @After(value = "cut()",argNames = "joinPoint")
    public void afterAdvice(JoinPoint joinPoint){
        log.info("我是后置通知,在方法执行之后做处理");
    }
	
	//正常返回通知
    @AfterReturning(value = "cut()",returning = "result")
    public void afterReturningAdvice(Object result){
        log.info("我是返回通知,可以用来做正常返回值有关的逻辑!");
    }
	
	//异常通知
    @AfterThrowing(value = "cut()",throwing="e")
    public void afterThrowingAdvice(Exception e){
        log.info("我是一个异常处理通知,在抛出异常的时候执行");
    }
    
	//环绕通知
    @Around(value = "cut()")
    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable{
        log.info("我是环绕通知,我最强大! 我可以做任何事情!");
        //这里给一个案例!日志打印,并抛出自定义的异常!产生traceId
        long before = System.currentTimeMillis();
        String traceId = UUID.randomUUID().toString();
        try{
			//TraceIdUtil.set(traceId);
            //this.logInfo(pjp,traceId);
            MDC.put("traceId", traceId);
            return pjp.proceed();//执行该方法
        }catch (PandoraException pandoraException) {
            this.logError(pjp, pandoraException);
            if(isNotBlank(pandoraException.getErrorMSG())){
                return PandoraResult.fail(pandoraException.getErrorCode(), pandoraException.getErrorMSG());
            }
            return PandoraResult.fail(pandoraException);
        } catch (DAOException daoException) {
            this.logError(pjp, daoException);
            return PandoraResult.fail(ErrorCodeConstants.DA0_ERROR);
        } catch (Exception e) {
            this.logError(pjp, e);
            return PandoraResult.fail(ErrorCodeConstants.SERVICE_ERROR);
        } catch (Throwable e){
            this.logError(pjp, e);
            return PandoraResult.fail(ErrorCodeConstants.SERVICE_ERROR);
        }finally{
            this.logInfoRT(pjp, traceId, before);
            MDC.remove("traceId");
        }
    }

	//参数打印!
    private void printPointAgs(JoinPoint joinPoint) {
        System.out.println("================joinPoint参数列表!===================");
        String string = joinPoint.toString(); // execution(String com.aop.aspect.testaop.MyTest.add(String))
        log.info("string {}",string);
        String shortString = joinPoint.toShortString();//execution(MyTest.add(..))
        log.info("shortString {}",shortString);
        String longString = joinPoint.toLongString();//execution(public java.lang.String com.aop.aspect.testaop.MyTest.add(java.lang.String))
        log.info("longString {}",longString);
        Object aThis = joinPoint.getThis();//com.aop.aspect.testaop.MyTest@3711c71c
        log.info("aThis {}",aThis);
        Object target = joinPoint.getTarget();//com.aop.aspect.testaop.MyTest@3711c71c
        log.info("target {}",target);
        Object[] args = joinPoint.getArgs();//闲鱼~
        log.info("args {}",args);
        Signature signature = joinPoint.getSignature();//String com.aop.aspect.testaop.MyTest.add(String)
        log.info("signature {}",signature);
        SourceLocation sourceLocation = joinPoint.getSourceLocation();//org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint$SourceLocationImpl@30508066
        log.info("sourceLocation {}",sourceLocation);
        String kind = joinPoint.getKind();//method-execution
        log.info("kind {}",kind);
        JoinPoint.StaticPart staticPart = joinPoint.getStaticPart();//execution(String com.aop.aspect.testaop.MyTest.add(String))
        log.info("staticPart {}",staticPart);
    }


    private Method getMethod(JoinPoint pjp) throws ClassNotFoundException, NoSuchMethodException {
        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
        Class<?> targetClass = Class.forName(pjp.getTarget().getClass().getName());
        Class[] classes = methodSignature.getMethod().getParameterTypes();
        return targetClass.getDeclaredMethod(pjp.getSignature().getName(), classes);
    }

    private void logInfoRT(JoinPoint joinPoint, String traceId, long before) {
        try {
            Method method = getMethod(joinPoint);
            log.info("Info@{}#{}-traceId={}:RT={}", method.getDeclaringClass().getName(), method.getName(), traceId, (System.currentTimeMillis() - before));
        } catch (Exception e) {
        }
    }


    private void logError(JoinPoint joinPoint, Throwable e){
        try{
            String methodName = joinPoint.getSignature().getName();
            Object[] arguments = joinPoint.getArgs();
            StringBuilder sb = new StringBuilder();
            Method method = getMethod(joinPoint);
            Parameter[] parameters = method.getParameters();
            for (int i = 0; i < parameters.length; i++) {
                sb.append(parameters[i].getName()+"={},");
            }
            sb.append("errorMessage={}");
            List<Object> list = new ArrayList<Object>();
            for (Object object : arguments) {
                list.add(object);
            }
            if(e instanceof PandoraException){
                PandoraException exception = (PandoraException) e;
                list.add(exception.getErrorCode()+"-"+exception.getErrorMSG());
            }else{
                list.add(e.getMessage());
            }
            list.add(e);
            log.error("error@"+joinPoint.getTarget().getClass().getSimpleName()+"#"+methodName+":"+sb.toString(),list.toArray());
        }catch(Exception e1){}
    }
}

测试用例!

package com.aop.aspect.testaop;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

@SpringBootTest
@RunWith(SpringRunner.class)
public class JUnitMyTest {
    @Resource
    private MyTest myTest;

    @Test
    public void aopTest() throws Exception {
        myTest.add("闲鱼~");
    }
}

运行的日志结果!
在这里插入图片描述

注意: 如果在切面类中写了@Around 环绕通知! 那么@Before前置通知是不会执行的! 环绕通知中是可以处理前置后置等一系列的操作!

一往无前的闲鱼
关注
专栏目录
SpringAOP(图文详解)
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring AOP全面详解(超级详细)
热门推荐
Cr1556648487的博客
09-09 8万+
AOP （Aspect Orient Programming）,直译过来就是 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术，如下图所示：AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
aop配置切面controller层可以使用，service层不能使用问题
技术熊的博客小窝
12-08 7104
最近使用aop，想做一下service层的异常处理，使用的是注解的方式@Aspect 问题在于，我配置后，controller层的切面是正常的，在controller层我做了日志记录。但是在service层切面不执行。检查了很久都没有发现问题，切点与方法都正确，的确很让人郁闷。 检查了很久，意识到，为什么controller层可以用，service不能用呢？是不是配置出了问题？ 问题在于我配置ao...
Aop失效场景：Service自身方法调用自身方法
weixin_45697659的博客
04-13 1478
背景：当使用同一个service自身方法调用另一个自身方法，即使两个方法都使用了@translation，但事务依旧失效。
艾伟_转载：使用AOP动态调用WebService
weixin_34088838的博客
08-29 173
    在网上搜了一下“动态调用WebService”相信都能搜出上千篇文章，但是都出自同一个版本：使用ServiceDescriptionImporter导入wsdl然后进行动态编译，再调用相应的Method返回值。这种方法不足之处就是编译的时候可能会有些慢，毕竟是编译整个WebService，而且前台都是使用同一个方法传入调用的方法来进行调用的。再者，如果使用了Model，引用了WebSer...
Spring boot中使用aop详解
tianyaleixiaowu的专栏
04-27 2万+
aop是spring的两大功能模块之一，功能非常强大，为解耦提供了非常优秀的解决方案。 现在就以springboot中aop的使用来了解一下aop。 一：使用aop来完成全局请求日志处理 创建一个springboot的web项目，勾选aop，pom如下： <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="htt
SpringAOP学习--SpringAOP简介及原理
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
spring aop详解
hanbin1998的博客
04-13 6244
1.前言 spring aop是一个面向切面的编程，在自己第一遍学习的时候，感觉aop没有什么作用，但是真实接触下来，感觉spring aop还是很有用途的，感觉自己之前的想法太年轻了。 2.概念 Spring 提供了两种AOP 的实现：基于注解式配置和基于XML配置，我这里主要就是介绍一下，基于注解式配置。 2.1 AOP 即 Aspect Oriented Program 面向切面编程 首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。 所谓的核心业务，工作中做的最多的
Spring AOP详解
chongbaozhong的博客
05-26 3766
前言 什么是AOP AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面，是Spring的核心思想之一。 AOP 实现分类 AOP 要达到的效果是，保证开发者不修改源代码的前提下，去为系统中的业务组件添加某种通用功能。AOP 的本质是由 AOP 框架修改业务组件的多个方法的源代码，按照 AOP 框架修改源代码的时机，可以将其分为两类：
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
Spring源码最难问题：当Spring AOP遇上循环依赖.docx
06-15
Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...
spring aop参数传递
weixin_43931625的博客
04-23 2720
spring aop参数传递
mybatis sql 判空和空串踩的坑解决,以及转义字符的用法
q270384247的博客
03-11 1744
mybatis sql 判空和空串踩的坑解决,以及转义字符的用法 写注解式 sql 的时候一直报错,不知道怎么转义这里做个举例和列举一些转义符 踩坑点: 入参是字符串列下,我并没有传入参数,但是 sql 再组装的时候还是把字符串拼接进去了,所以必须要判断是否为 null 和是否是空串 @Select() 但是在 mybatis 中判断空窜的写法必须转义单引号,这样转义即可 ‘’ ...
fastjson常用api接口举例
q270384247的博客
02-22 658
fastjson使用教程 1.这里推荐一篇博客,博主写的挺好的,我这里做一些fastjson使用举例 https://blog.csdn.net/srj1095530512/article/details/82529759 2.Json是一种轻量级的数据交换格式，采用一种“键：值”对的文本格式来存储和表示数据，在系统交换数据过程中常常被使用，是一种理想的数据交换语言,下面代码演示下阿里fastjs...
fork/join任务拆分的用法
q270384247的博客
06-15 559
1.当我们遇到任务量比较大，计算耗时任务可以用该框架充分利用cpu的并行处理快速得到结果！ import java.util.concurrent.ExecutionException; import java.util.concurrent.ForkJoinPool; import java.util.concurrent.ForkJoinTask; import java.util.concurrent.RecursiveTask; /** * @program: * @description:
springboot的main方法启动原理源码跟踪
q270384247的博客
09-16 253
启动流程步骤开始: 1.首先点击run方法进入 SpringApplication.run(WechatPortalBootServletInitializer.class, args); 2.找到run方法的直接调用方法 public ConfigurableApplicationContext run(String... args) { StopWatch stopWatch = new StopWatch(); stopWatch.start();
spring aop
最新发布
09-11
Spring AOP（Aspect-Oriented Programming）是Spring框架中的一个重要特性，它提供了一种在应用程序中实现横切关注点（cross-cutting concerns）的方法。所谓横切关注点，指的是那些在应用程序中散布于各个模块之中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值