SpringAOP基础入门与日志实践详解

已于 2022-06-07 17:49:10 修改
阅读量1.3k 收藏 4
点赞数
分类专栏： Spring # logger 文章标签： spring AOP Aspect
于 2016-12-15 09:44:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/J080624/article/details/53665692
版权

SpringAOP基础入门与日志实践详解
Spring中使用AspectJ实现AOP的五种通知
SpringAOP中Aspect优先级与切面表达式详解
Spring AOP使用(踩坑)实践总结
Spring AOP中如何为Bean创建代理

【1】AOP是什么

SpringBoot下我们可以添加如下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

① 基本概念

(Aspect-Oriented Programming, 面向切面编程)，是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充。作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。

Aspect是一种新的模块化机制，用来描述分散在对象、类或函数中的横切关注点(crosscutting concern)。从关注点中分离出横切关注点是面向切面的程序设计的核心概念。

AOP实现的关键在于AOP框架自动创建的AOP代理

AOP代理主要分为静态代理和动态代理，静态代理的代表为AspectJ。而动态代理则以Spring AOP为代表。静态代理是编译期实现(编译期间生成代理类)，动态代理是运行期实现，可想而知前者拥有更好的性能。

AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点.

在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用, 并且不必修改受影响的类. 这样一来横切关注点就被模块化到特殊的对象(切面)里.

静态代理 是编译阶段生成AOP代理类，也就是说生成的字节码就织入了增强后的AOP对象。

动态代理 则不会修改字节码，而是在内存中临时生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。

Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理

JDK动态代理通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口。JDK动态代理的核心是InvocationHandler接口和Proxy类。

如果目标类没有实现接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成某个类的子类。注意，CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的，诸如private的方法也是不可以作为切面的。

这里要说明下，由于Spring AOP是使用JDK动态代理和CGLIB代理实现的(缺省使用jdk动态代理)，因此Spring AOP只可以对方法的执行进行拦截，如果需要拦截字段的访问或更新，则需要像AspectJ这样的AOP语言。

另外Spring可以无缝的集成IOC，Spring AOP 以及AspectJ AOP。

AspectJ

Java 社区里最完整最流行的 AOP 框架。在 Spring2.0 以上版本中, 可以使用基于 AspectJ 注解或基于 XML 配置的 AOP。

AspectJ的底层技术是静态代理，即用一种AspectJ支持的特定语言编写切面，通过一个命令来 编译，生成一个新的代理类，该代理类增强了业务类，这是在编译时增强，相对于运行时增强，编译时增强的性能更好。

此外还有以下AOP技术：

  • AspectWerkz：AOP框架，使用字节码动态编织器和xml配置；
  • JBoss-AOP：基于拦截器和元数据的AOP框架，运行在JBoss应用服务器上。以及在AOP中用到的一些相关的技术实现
  • BCEL(Byte-Code Engineering Library)：Java字节码操作类库
  • Javassist：Java字节码操作类库，JBoss的一个子项目

② Spring AOP与AspectJ

与 AspectJ 相同的是，Spring AOP 同样需要对目标类进行增强，也就是生成新的 AOP 代理类。与AspectJ 不同的是，Spring AOP 无需使用任何特殊命令对 Java 源代码进行编译，它采用运行时动态地、在内存中临时生成”代理类”的方式来生成 AOP 代理。

Spring 允许使用 AspectJ Annotation 用于定义切面（Aspect）、切入点（Pointcut）和增强处理（Advice）。Spring 框架则可识别并根据这些 Annotation 来生成 AOP 代理。

Spring 只是使用了和AspectJ 5 一样的注解，但并没有使用 AspectJ 的编译器或者织入器（ Weaver ），底层依然使用的是Spring AOP，依然是在运行时动态生成 AOP 代理，并不依赖于 AspectJ 的编译器或者织入器。

简单地说，Spring 依然采用运行时生成动态代理的方式来增强目标对象，所以它不需要增加额外的编译，也不需要 AspectJ 的织入器支持。而 AspectJ 在采用编译时增强，所以 AspectJ 需要使用自己的编译器来编译 Java 文件，还需要织入器。

为了启用 Spring 对 @AspectJ 方面配置的支持，并保证 Spring 容器中的目标 Bean 被一个或多个方面自动增强，必须在 Spring 配置文件中配置如下片段：

<!-- 启动 @AspectJ 支持 -->
<aop:aspectj-autoproxy/>

如果不打算使用 Spring 的 XML Schema 配置方式，则应该在 Spring 配置文件中增加如下片段来启用@AspectJ 支持。

<!-- 启动 @AspectJ 支持 -->
<bean class="org.springframework.aop.aspectj.annotation.
AnnotationAwareAspectJAutoProxyCreator"/>

上面配置文件中的 AnnotationAwareAspectJAutoProxyCreator 是一个 Bean 后处理器
（BeanPostProcessor），该 Bean 后处理器将会为容器中 Bean 生成 AOP 代理。

SpringBoot环境下需要加上如下配置：

<!-- springboot下加上如下配置 -->
@EnableAspectJAutoProxy(proxyTargetClass = true)

③ 通知类型

主要有前置通知、后置通知、返回通知、异常通知以及环绕通知。

@Before: 前置通知, 在方法执行之前执行，这个通知不能阻止连接点前的执行（除非它抛出一个异常）。

@After: 后置通知, 在方法执行之后执行（不论是正常返回还是异常退出）。

@AfterRunning:返回通知, 在方法正常返回结果之后执行 。

@AfterThrowing: 异常通知, 在方法抛出异常之后。

@Around: 包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

AOP 主要应用场景有：

  • Authentication 权限
  • Caching 缓存
  • Context passing 内容传递
  • Error handling 错误处理
  • Lazy loading 懒加载
  • Debugging 调试
  • logging, tracing, profiling and monitoring 记录跟踪 优化 校准
  • Performance optimization 性能优化
  • Persistence 持久化
  • Resource pooling 资源池
  • Synchronization

【2】AOP术语

  • 切面(Aspect): 横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象
  • 通知(Advice): 切面必须要完成的工作，是拥有某个功能的方法。所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类。
  • 目标(Target): 被通知的对象
  • 代理(Proxy): 向目标对象应用通知之后创建的对象
  • 连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。
  • 切入点（pointcut）：对连接点进行拦截的定义。

    每个类都拥有多个连接点：例如 类的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。AOP 通过切点定位到特定的连接点。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

  • 横切关注点：对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点。
  • 织入（weave）：将切面应用到目标对象并导致代理对象创建的过程。
  • 引入（introduction）：在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段。

① 通知和切面

将多处地方具有类似功能的代码（横切关注点）抽取出来，进行模块化为一个方法（通知-Advice）。

将同一事务的不同方法（如前置通知、后置通知）放在一个类中（即，切面–Aspect）。

在方法上利用Aspect表达式定义切点，当有匹配其表达式的目标对象方法执行时，会自动为其建立代理对象-Proxy。

Advice(通知)定义在连接点做什么，为切面增强提供织入接口。在Spring AOP中，它主要描述Spring AOP围绕方法调用而诸如的切面行为。

切面(Aspect):  横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象--类级别

通知(Advice):  切面必须要完成的工作--即方法（方法级别）

目标(Target): 被通知的对象

代理(Proxy): 向目标对象应用通知之后创建的对象

切面泛指[交叉业务逻辑]，类级别，包含了同一类型事务的不同增强方法(通知)。

比如：事务处理和日志处理可以理解为两个切面。

通知(Advice)实际就是对主业务逻辑的一种增强，是一种在目标方法执行之外额外的方法。

如，日志处理–在目标方法执行前后添加日志。

这些被添加日志的方法称为连接点；
·
通知方法执行的位置称为切入点；
·
对目标方法增强的方法称为通知；
·
对日志增强的所有通知方法所属的类称为切面。

② 连接点（Joinpoint）

程序执行的某个特定位置。如类某个方法调用前、调用后、方法抛出异常后等。被拦截到的点，因为 Spring 只支持方法类型的连接点，所以在 Spring 中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器。

连接点由两个信息确定：

方法(表示程序执行点,即-在哪个目标方法)；
相对点(表示方位，即-目标方法的什么位置，如调用前、后。。。)

例如 ：ArithmethicCalculator#add()方法执行前的连接点：

方法为ArithmethicCalculator#add()； 

相对点为该方法执行前的位置

③ 切入点（pointcut）

匹配连接点（Joinpoint）的断言，AOP 通过切点定位到特定的连接点。换句话说即通过某种定义来决定哪些方法将会被通知（即需要事物处理），我们将这个定义称为切入点（Pointcut）。

Pointcut(切点)决定Advice通知应该作用于哪个连接点，也就是说通过Pointcut来定义需要增强的方法的集合，这些集合的选取可以按照一定的规则来完成。在这种情况下，Pointcut通常意味着标识方法，例如这些需要增强的地方可以由某个正则表达式进行标识或根据某个方法名进行匹配。

通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。

切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。

每个类都拥有多个连接点，即连接点是程序类中客观存在的事务。也就是说通过某种定义来决定哪些方法将会被通知（即需要事物处理），我们将这个定义评为切入点（Pointcut），而每一个被处理的方法我们称之为连接点（Join Point）。

类比：连接点相当于数据库中的记录，切点相当于查询条件。

切点和连接点不是一对一的关系，一个切入点常常匹配多个连接点.

切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

注意：被标记为final的方法是不能作为连接点与切入点的。因为final的是不能被修改的，不能被增强的。

④ 通知

在切面的某个特定的连接点（Joinpoint）上执行的动作(切面类中的某个方法)。

通知有各种类型，其中包括“around”、“before”和“after”等通知。许多AOP框架，包括Spring，都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。

通知定义了增强代码切入到目标代码的时间点(是目标方法执行之前执行，还是执行之后执行等)和增强功能。

完整通知包括：通知类型+切入点表达式+增强方法。

如下所示：

//抽取公共的切入点表达式
//1、本类引用
//2、其他的切面引用
@Pointcut("execution(public int com.web.aop.MathCalculator.*(..))")
public void pointCut(){};

//@Before在目标方法之前切入；切入点表达式（指定在哪个方法切入）
@Before("pointCut()")
public void logStart(JoinPoint joinPoint){
	Object[] args = joinPoint.getArgs();
	System.out.println(""+joinPoint.getSignature().getName()+"运行。。。@Before:参数列表是：{"+Arrays.asList(args)+"}");
}

综上，切入点定义切入的位置，通知定义切入的时间和增强功能。通知需要与切入点配合使用。

⑤ 目标对象（Target Object）

目标对象指将要被增强的对象，即包含主业务逻辑的类的对象。被一个或者多个切面（aspect）所通知（advice）的对象。也有人把它叫做 被通知（adviced） 对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个 被代理（proxied） 对象。

⑥ AOP代理

AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。

⑦ 织入

把切面（aspect）连接到其它的应用程序类型或者对象上，并创建一个被通知（adviced）的对象。 这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。

织入是指将切面代码插入到目标对象的过程。代理的invoke方法完成的工作，可以称为织入。

Spring和其他纯Java AOP框架一样，在运行时完成织入。

【3】AOP图示与实例

① AOP图示

这里写图片描述

② AOP简单实例

package com.web.aop.impl;

import java.util.Arrays;
import java.util.List;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
/*
	@Component表示将其放入IOC容器中，使其可以被自动扫描；
	@Aspect表示其为一个切面
*/
@Aspect
@Component
public class LoggingAspect {
	
	@Before("execution(int com.web.aop.impl.ArithmeticCalculatorImpl.*(int , int ))")
	public void beforMethod(JoinPoint joinPoint){
		/*获取方法名*/
		String methodName = joinPoint.getSignature().getName();
		/*获取方法的参数*/
		List<Object> args = Arrays.asList(joinPoint.getArgs());
		
		System.out.println("The method"+methodName+" begins with"+args);
	}
	
	/*
	 * 后置通知：在目标方法执行后执行，无论是否抛出异常；
	 * 后置通知中不能访问目标方法执行后返回的结果；
	 * */
	
	@After("execution(* com.web.aop.impl.*.*(int , int ))")
	/*表示该包下所有返回类型的所有类的所有方法*/
	public void afterMethod(JoinPoint joinPoint){
		/*获取方法名*/
		String methodName = joinPoint.getSignature().getName();
		
		System.out.println("The method"+methodName+" ends ");
		
	}

}

③ 自定义log注解与AOP整合

① 自定义注解

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
	String value() default "";
}

② AOP日志切片实例

import java.lang.reflect.Method;
import java.util.Date;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import javax.servlet.http.HttpServletRequest;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LogAspect {
    private static final Logger logger = LoggerFactory.getLogger(LogAspect.class);

    @Autowired
    LogService logService;


    @Pointcut("@annotation(com.family.common.annotation.Log)")
    public void logPointCut() {
    }

    @Around("logPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        long beginTime = System.currentTimeMillis();
        // 执行方法
        Object result = point.proceed();
        // 执行时长(毫秒)
        long time = System.currentTimeMillis() - beginTime;
        //异步保存日志
        saveLog(point, time);
        return result;
    }

    void saveLog(ProceedingJoinPoint joinPoint, long time) throws InterruptedException {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        LogDO sysLog = new LogDO();
        Log syslog = method.getAnnotation(Log.class);
        if (syslog != null) {
            // 注解上的描述
            sysLog.setOperation(syslog.value());
        }
        // 请求的方法名
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = signature.getName();
        sysLog.setMethod(className + "." + methodName + "()");
        // 请求的参数
        Object[] args = joinPoint.getArgs();
        try {
            String params = JSONUtils.beanToJson(args[0]).substring(0, 4999);
            sysLog.setParams(params);
        } catch (Exception e) {

        }
        // 获取request
        HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
        // 设置IP地址
        sysLog.setIp(IPUtils.getIpAddr(request));
        // 用户名
        UserDO currUser = ShiroUtils.getUser();
        if (null == currUser) {
            if (null != sysLog.getParams()) {
                sysLog.setUserId(-1L);
                sysLog.setUsername(sysLog.getParams());
            } else {
                sysLog.setUserId(-1L);
                sysLog.setUsername("获取用户信息为空");
            }
        } else {
            sysLog.setUserId(ShiroUtils.getUserId());
            sysLog.setUsername(ShiroUtils.getUser().getUsername());
        }
        sysLog.setTime((int) time);
        // 系统当前时间
        Date date = new Date();
        sysLog.setGmtCreate(date);
        // 保存系统日志
        logService.save(sysLog);
    }
}

这里我们使用的注解是org.aspectj包下的哦，如下图所示。
在这里插入图片描述

【4】Advisor(增强器/顾问)

完成对目标方法的切片增强设计(Advice)和关注点的设计(Pointcut)以后，需要一个对象把它们结合起来，完成这个作用的就是Advisor(通知器)。通过Advisor，可以定义应该使用哪个通知并在哪个关注点使用它，也就是说通过Advisor，把Advice和Pointcut结合起来，这个结合为使用IOC容器配置AOP应用，或者说即开即用地使用AOP基础设施提供了便利。

Advisor是切面的另一种实现，能够将通知以更为复杂的方式织入到目标对象中，是将通知包装为更复杂切面的装配器。Advisor由切入点和Advice组成。

DefaultPointcutAdvisor

方便的切入点驱动的Advisor实现（Convenient Pointcut-driven Advisor implementation）。

这是最常用的Advisor实现。它可以用于任何切入点和advice类型，introductions除外。通常不需要对此类进行子类化，也不需要实现自定义Advisors。

public class DefaultPointcutAdvisor extends AbstractGenericPointcutAdvisor implements Serializable {

	private Pointcut pointcut = Pointcut.TRUE;

	public DefaultPointcutAdvisor() {
	}

	public DefaultPointcutAdvisor(Advice advice) {
		this(Pointcut.TRUE, advice);
	}

// Pointcut  和 Advice
	public DefaultPointcutAdvisor(Pointcut pointcut, Advice advice) {
		this.pointcut = pointcut;
		setAdvice(advice);
	}

	public void setPointcut(@Nullable Pointcut pointcut) {
		this.pointcut = (pointcut != null ? pointcut : Pointcut.TRUE);
	}

	@Override
	public Pointcut getPointcut() {
		return this.pointcut;
	}


	@Override
	public String toString() {
		return getClass().getName() + ": pointcut [" + getPointcut() + "]; advice [" + getAdvice() + "]";
	}

}

在Pointcut接口中Pointcut TRUE = TruePointcut.INSTANCE;

public interface Pointcut {

	/**
	 * Return the ClassFilter for this pointcut.
	 * @return the ClassFilter (never {@code null})
	 */
	ClassFilter getClassFilter();

	/**
	 * Return the MethodMatcher for this pointcut.
	 * @return the MethodMatcher (never {@code null})
	 */
	MethodMatcher getMethodMatcher();


	/**
	 * Canonical Pointcut instance that always matches.
	 */
	Pointcut TRUE = TruePointcut.INSTANCE;

}

"advisors"这个概念来自Spring1.2对AOP的支持，在AspectJ中是没有等价的概念。advisor就像一个小的自包含的切面，这个切面只有一个通知。 切面自身通过一个bean表示，并且必须实现一个通知接口，大多数情况下会和transactional advice一起使用。

Advisor能够将通知以更为复杂的方式织入到目标对象中，是将通知包装为更复杂切面的装配器。Advisor由切入点和Advice组成。如Spring中的事务应用：

<!-- 拦截器方式配置事物 -->
<tx:advice id="transactionAdvice" transaction-manager="transactionManager">
   <tx:attributes>
       <tx:method name="add*" propagation="REQUIRED"/>
       <tx:method name="append*" propagation="REQUIRED"/>
       <tx:method name="insert*" propagation="REQUIRED"/>
       <tx:method name="save*" propagation="REQUIRED"/>
       <tx:method name="update*" propagation="REQUIRED"/>
       <tx:method name="modify*" propagation="REQUIRED"/>
       <tx:method name="edit*" propagation="REQUIRED"/>
       <tx:method name="delete*" propagation="REQUIRED"/>
       <tx:method name="remove*" propagation="REQUIRED"/>
       <tx:method name="repair" propagation="REQUIRED"/>
       <tx:method name="release*" propagation="REQUIRED"/>
       <tx:method name="delAndRepair" propagation="REQUIRED"/>
       <tx:method name="get*" propagation="SUPPORTS"/>
       <tx:method name="find*" propagation="SUPPORTS"/>
       <tx:method name="load*" propagation="SUPPORTS"/>
       <tx:method name="search*" propagation="SUPPORTS"/>
       <tx:method name="datagrid*" propagation="SUPPORTS"/>
       <tx:method name="*" propagation="SUPPORTS"/>
   </tx:attributes>
</tx:advice>
<aop:config>
   <aop:pointcut id="transactionPointcut" expression="execution(* com.sychine.tower.service..*Impl.*(..))"/>
   <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice"/>
</aop:config>

若<aop:advisor advice-ref="beanName" pointcut-ref="txPointCut" />，则该bean的class应为org.aopalliance.aop.Advice类型。

【Tips】

● <aop:advisor>：用来定义只有一个通知和一个切入点的切面；

● <aop:aspect>：用来定义切面，该切面可以包含多个切入点和通知，而且标签内部的通知和切入点定义是无序的。其和advisor的区别就在此，advisor只包含一个通知和一个切入点。

aop:aspect配置实例如下：

<bean id="arithmeticCalculator" class="com.web.aop.impl.xml.ArithmeticCalculatorImpl"></bean>

<!-- 配置切面bean -->
<bean id="loggingAspect" class="com.web.aop.impl.xml.LoggingAspect"></bean>

<bean id="validateAspect" class="com.web.aop.impl.xml.ValidateAspect"></bean>

<!-- ******************************AOP 配置******************************* -->
<aop:config>
   <!-- 配置切点表达式 -->
   <aop:pointcut id="pointcut" expression="execution(* com.web.aop.impl.xml.ArithmeticCalculatorImpl.*(int, int))" />

   <!-- 配置日志切面 -->
   <aop:aspect  ref="loggingAspect" order="1" >
       <aop:before method="beforMethod" pointcut-ref="pointcut"/>
       <aop:after method="afterMethod" pointcut-ref="pointcut"/>
       <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>
       <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="exception"/>
<!--            <aop:around method="aroundMethod" pointcut-ref="pointcut" />-->
   </aop:aspect>

   <!-- 配置验证切面 -->
   <aop:aspect  ref="validateAspect" order="2" >
       <aop:before method="beforMethod" pointcut-ref="pointcut"/>
   </aop:aspect>

</aop:config>

参考博文：
Java中的代理模式与动(静)态代理
Java中动态代理使用与原理详解
CGLIB动态代理使用与原理详解

流烟默
关注
专栏目录
Spring Boot入门(23)：记录接口日志再也不难！用AOP和自定义注解给Spring Boot加上日志拦截器！
**My Coding Family**
09-01 3224
基于AOP实现自定义注解拦截接口日志并入库，一文教会你。
AOP以及AOP的使用（日志）和事务
m0_53312145的博客
03-30 376
AOP面向切面编程AOP简介AOP的代理模式实现日志spring-aop实现日志信息 AOP简介 AOP（Aspect Oriented Programming 面向切面编程）通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。 AOP是对OOP（面向对象编程）的扩充，能够在不影响核心代码的前提下，可以在任意位置添加非核心代码。 本文通过计算器添加日志的实例描述动态代理和利用spring-aop完成代理 创建计算器的接口 Calculator /** * 加法 * @pa
关于AOP以及日志
m0_37839403的博客
09-09 64
首先aop是一种编程范式，是一种程序设计思想，别的语言也有。 添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 定义切面类：在类上添加@Aspect和@Component 注解即可将一个类定义为切面.
SpringBoot系列：通过AOP+注解优雅实现操作日志记录
最新发布
weixin_73588491的博客
07-16 8210
在企业应用开发中，操作日志记录是确保系统安全性、可追溯性以及调试分析的重要手段之一。通过记录用户的操作行为，不仅可以帮助开发者快速定位问题，还能满足审计和合规需求。本文旨在探讨如何在SpringBoot应用程序中通过AOP（面向切面编程）和自定义注解实现操作日志记录，并将日志存储到数据库中。我们将详细介绍实现这一功能的完整流程，包括项目环境搭建、数据库设计、代码实现及测试验证等步骤。操作日志在企业应用中扮演着至关重要的角色。
spring源码剖析AOP实现原理剖析
dxx707099957的博客
03-25 370
Spring的AOP实现原理，酝酿了一些日子，写博客之前信心不是很足，所以重新阅读了一边AOP的实现核心代码，而且又从网上找了一些Spring Aop剖析的例子，但是发现挂羊头买狗肉的太多，标题高大上，内容却大部分都是比较浅显的一些介绍，可能也是由于比较少人阅读这部分的核心代码逻辑把，然后写这部分介绍的人估计也是少之又少，不过说实话，Spring Aop的核心原理实现介绍确实不太好写，里面涉及的类...
简单日志aop和注解实现
卷心菜投手
08-30 254
前沿： 对于日志的aop可以不用自定义注解，但是为了爽一把自定义注解和aop，所以这里做了一个简单的demo 功能说明 在使用了自定义的注解的方法上，如果被调用则，会输出该方法的描述和执行时间 依赖 <dependency> <groupId>org.springframework.boot</groupId> ...
AOP结构图（术语图解）
qq_39773004的博客
09-29 910
AOP
Spring Boot学习入门之AOP处理请求详解
08-29
AOP允许我们定义横切关注点，如日志、事务管理或安全检查，并将这些关注点与核心业务逻辑解耦。在本篇文章中，我们将深入探讨如何在Spring Boot应用中使用AOP来处理请求。 首先，我们需要添加Spring Boot的AOP支持...
spring aop管理xml版
03-26
**Spring AOP 管理XML版详解** 在Spring框架中，面向切面编程（Aspect Oriented Programming，简称AOP）是一种重要的设计模式，它扩展了传统的面向对象编程（OOP），使得我们可以将关注点分离，特别是那些横切关注...
最简单的SpringAOP入门案例
05-16
本教程将通过一个简单的Spring AOP入门案例，帮助初学者理解这一概念。 ### 一、AOP基础 1. **切面（Aspect）**：切面是关注点的模块化，它封装了跨越多个对象的行为或数据。在Spring AOP中，切面可以由一个类定义...
spring入门学习-6、AOP几种配置方式详解.pdf
02-17
### Spring AOP 几种配置方式详解 #### 一、Spring AOP 概述 Spring AOP（面向切面编程）是一种强大的编程模式，用于在应用程序中管理横切关注点，如日志记录、安全控制等。Spring 提供了多种方式来支持 AOP 的...
图文详解 Spring AOP，看完必懂。。
wadfdhsajd的博客
06-13 116
学习一个模块的设计主要是看接口设计，通过接口设计我们就能够从整体知道模块怎么实现的，具体实现就是组装这些接口来进行实现的，知道了模块接口设计，实现也就变得很简单了。本文主要从aop背景出发点，来自己去想需要哪些接口，就能够描述一个模块的功能设计规则。使用面向对象编程 （ OOP ）有一些弊端，当需要为多个不具有继承关系的对象引人同一个公共行为时，例如日志、安全检测等，我们只有在每个对象里引用公共行为，这样程序中就产生了大量的重复代码，程序就不便于维护了，所以就有了一个对面向对象编程的补充，即面向方面编程 （
SpringAOP模型图解笔记
酒徒词客
12-31 1378
SpringAOP超详细图文解释（深入学习笔记可用于面试）
sakura的博客
09-23 2277
记录什么高频面径之SpringAOP底层原理以及对应的开发使用详细讲解；AOP 面向方面编程（Aspect-oriented Programming，151）通过提供关于程序结构的另一种思考方式，补充了面向对象编程。在 OOP 中，模块化的关键单元是类，而在 AOP 中，模块化的单元是方面。方面支持跨多个类型和对象的关注（例如事务管理）的模块化。
使用Spring AOP机制优雅的进行日志处理
Cxtztj的博客
11-11 253
本文采用spring aop机制，对方法进行日志记录与处理
java项目增加统一切面日志输出，对于项目调试问题排查还是很有必要的
qq_40393739的博客
04-11 865
java项目增加统一切面日志输出，对于项目调试问题排查还是很有必要的。
Java项目 日志框架+切面，完美记录
cat_book_milk的博客
07-22 1255
Java Spring Boot项目搭建日志框架，创建日志切面，方便追溯
Java切面的实现方式
weixin_49151141的博客
04-04 5115
是指在软件开发中，将某些横跨多个组件的功能，如日志记录、性能监控、权限控制等，抽象出来形成一个独立的模块，称之为切面。切面可以被应用到多个模块中，提供相同的功能。基于继承的切面实现 这种实现方式需要通过继承的方式实现，具体操作为：首先定义一个抽象类，实现该类时可以重写一些方法，从而达到切面的目的。以上是三种实现切面的方式，分别基于继承、代理和注解。其中，基于注解的方式是。的实现方式，而基于继承和代理的方式可以使用。中实现切面的技术有多种，下面分别介绍。
springboot方法日志切片_SpringBoot 切片做请求接口日志
weixin_36236774的博客
01-17 595
如何在 Spring Boot 2.0 中使用 AOP 切面统一处理请求日志，打印进出参相关参数。一：先看看日志输出效果 可以看到，每个对于每个请求，开始与结束一目了然，并且打印了以下参数：URL: 请求接口地址；HTTP Method: 请求的方法，是POST,GET, 还是DELETE等；Class Method: 对应 Controller 的全路径以及调用的哪个方法;IP: 请求 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

流烟默

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值