Spring aop日志

最新推荐文章于 2024-07-16 11:12:33 发布
最新推荐文章于 2024-07-16 11:12:33 发布
阅读量414 收藏 3
点赞数 2
分类专栏： spring-mvc 文章标签： spring aop 日志模块
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32759985/article/details/75909755
版权

spring aop 日志

之前开发项目,一直都是在service 的方法里面增加日志,每次都要写,感觉繁琐,自己研究了spring aop来进行日志管理.
在这里就不扯理论知识了,这里讲四中aop的实现来进行日志管理.
四种方式,首先考虑的为第一种基于@Aspect方式
如果使用的为低版本的JDK,可以考虑
如果升级一个低版本的spring aop 那么可以使用<aop:advisor>复用已经存在的advice类
如果使用低版本的spring那么可以使用Advisor

1:基于@Aspect注解形式

注意,jdk要支持这个注解

@Aspect//切面
public class MyLog {

    protected Logger logger = Logger.getLogger(this.getClass());

    @Before("execution(* wsylp.service.UserService.*(..))")//定义切面
    public void logBegin(JoinPoint point) {

        logger.info("@Before：前置增强：" + point.getSignature().getDeclaringTypeName() + "." + point
            .getSignature().getName());
    }

    @AfterReturning("execution(* wsylp.service.UserService.*(..))")//定义切面
    public void logAfter(JoinPoint point) {

        logger.info(
            "@AfterReturning：后置增强：" + point.getSignature().getDeclaringTypeName() + "." + point
                .getSignature().getName());
    }

    @Around("execution(* wsylp.service.UserService.*(..))")//定义切面
    public void logAround(ProceedingJoinPoint point) throws Throwable {
        logger.info("环绕增强开始...........");
        logger.info(point.getTarget().getClass());
        point.proceed();
        logger.info("@Around：环绕增强方法：" + point.getSignature().getDeclaringTypeName() + "." + point
            .getSignature().getName());
        logger.info("环绕增强结束...........");
    }
}

配置文件

 <!-- 注解aspect-->
 <aop:aspectj-autoproxy/>
 <bean class="wsylp.log.MyLog"></bean>

测试以及结果

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath*:spring-*.xml")
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void getUser() {
        userService.getList();
    }
}

结果

[wsylp.log.MyLog] - @Around：环绕增强方法开始：wsylp.service.UserService.getList
[wsylp.log.MyLog] - @Before：前置增强：wsylp.service.UserService.getList
[wsylp.service.impl.UserServiceImpl] - getList方法开始
[wsylp.service.impl.UserServiceImpl] - getList方法结束
[wsylp.log.MyLog] - @Around：环绕增强方法结束：wsylp.service.UserService.getList
[wsylp.log.MyLog] - @AfterReturning：后置增强：wsylp.service.UserService.getList

2:基于aop:aspect方式

public class LogSchema {

    protected Logger logger = Logger.getLogger(this.getClass());

    public void logBefore(JoinPoint point) {

        logger.info(
            "前置增强：" + point.getSignature().getDeclaringTypeName() + "." + point.getSignature()
                .getName());
    }

    public void logAfter(JoinPoint point) {
        logger.info(
            "后置增强：" + point.getSignature().getDeclaringTypeName() + "." + point.getSignature()
                .getName());
    }

    //环绕增强对应方法
    public void logAround(ProceedingJoinPoint pjp) throws Throwable {
        logger.info("环绕增强开始:"+pjp.getSignature().getDeclaringTypeName()+"."+pjp.getSignature().getName());
        pjp.proceed();
        logger.info("环绕增强结束:"+pjp.getSignature().getDeclaringTypeName()+"."+pjp.getSignature().getName());
    }

    //抛出异常增强
    public void afterThrowingMethod(IllegalArgumentException iae) {
        System.out.println("----afterThrowingMethod()----");
        System.out.println("exception msg:" + iae.getMessage());
        System.out.println("----afterThrowingMethod()----");
    }

    //final增强
    public void afterMethod() {
        System.out.println("----afterMethod()----");
    }


}

配置文件

<aop:config proxy-target-class="true">
    <aop:aspect ref="logSchema" >
      <aop:pointcut id="logPoint" expression="target(wsylp.service.impl.UserServiceImpl)"/>
      <aop:before method="logBefore" pointcut-ref="logPoint"></aop:before>
      <aop:after-returning method="logAfter" pointcut-ref="logPoint"></aop:after-returning>
      <aop:around method="logAround" pointcut-ref="logPoint"></aop:around>
    </aop:aspect>

  </aop:config>
  <bean id="logSchema" class="wsylp.log.schema.LogSchema"></bean>

测试以及结果

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath*:spring-*.xml")
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void getUser() {
        userService.getList();
    }
}

结果:

 [wsylp.log.schema.LogSchema] - 前置增强：wsylp.service.impl.UserServiceImpl.getList
 [wsylp.log.schema.LogSchema] - 环绕增强开始:wsylp.service.impl.UserServiceImpl.getList
 [wsylp.service.impl.UserServiceImpl] - getList方法开始
 [wsylp.service.impl.UserServiceImpl] - getList方法结束
 [wsylp.log.schema.LogSchema] - 环绕增强结束:wsylp.service.impl.UserServiceImpl.getList
 [wsylp.log.schema.LogSchema] - 后置增强：wsylp.service.impl.UserServiceImpl.getList

3:基于aop:advisor方式

前置增强

public class LogAdvisorBefore implements MethodBeforeAdvice {
    protected Logger logger = Logger.getLogger(this.getClass());

    public void before(Method method, Object[] args, Object target) throws Throwable {
        logger.info("前置增强:"+method.getDeclaringClass()+"."+method.getName());
    }
}

后置增强

public class LogAdvisorAfter implements AfterReturningAdvice {
    protected Logger logger = Logger.getLogger(this.getClass());

    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1)
        throws Throwable {
        logger.info("后置增强:"+method.getDeclaringClass()+"."+method.getName());
    }
}

环绕增强

public class LogAdvisorAround implements MethodInterceptor {

    protected Logger logger = Logger.getLogger(this.getClass());

    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        logger.info(
            "环绕增强开始=>" + methodInvocation.getMethod().getDeclaringClass() + "." + methodInvocation
                .getMethod().getName());
        Object obj = methodInvocation.proceed();

        //在目标执行后调用
        logger.info(
            "环绕增强结束=>" + methodInvocation.getMethod().getDeclaringClass() + "." + methodInvocation
                .getMethod().getName());
        return obj;
    }
}

配置文件

  <aop:config proxy-target-class="true">
    <aop:advisor advice-ref="logBefore" pointcut="execution(* wsylp..*.UserService.*(..))"  />
    <aop:advisor advice-ref="logAfter" pointcut="execution(* wsylp..*.UserService.*(..))"  />
    <aop:advisor advice-ref="logAround" pointcut="execution(* wsylp..*.UserService.*(..))"  />
  </aop:config>
  <bean id="logBefore" class="wsylp.log.advisor.LogAdvisorBefore"></bean>
  <bean id="logAfter" class="wsylp.log.advisor.LogAdvisorAfter"></bean>
  <bean id="logAround" class="wsylp.log.advisor.LogAdvisorAround"></bean>

测试以及结果

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath*:spring-*.xml")
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void getUser() {
        userService.getList();
    }
}

结果

  [wsylp.log.advisor.LogAdvisorBefore] - 前置增强:class wsylp.service.impl.UserServiceImpl.getList
  [wsylp.log.advisor.LogAdvisorAround] - 环绕增强开始=>class wsylp.service.impl.UserServiceImpl.getList
  [wsylp.service.impl.UserServiceImpl] - getList方法开始
  [wsylp.service.impl.UserServiceImpl] - getList方法结束
  [wsylp.log.advisor.LogAdvisorAround] - 环绕增强结束=>class wsylp.service.impl.UserServiceImpl.getList
  [wsylp.log.advisor.LogAdvisorAfter] - 后置增强:class wsylp.service.impl.UserServiceImpl.getList

4:基于advisor类

静态方法代理

public class LogAdvisor extends StaticMethodMatcherPointcutAdvisor{


    @Override
    public boolean matches(Method method, Class<?> aClass) {
        return true;
    }
    public ClassFilter getClassFilter(){
        return new ClassFilter() {
            @Override
            public boolean matches(Class<?> aClass) {
                return UserServiceImpl.class.isAssignableFrom(aClass);
            }
        };
    }
}

前置增强

public class LogBeforeAdvice implements MethodBeforeAdvice {

    protected Logger logger = Logger.getLogger(this.getClass());

    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        logger.info("基于advisor->前置增强"+"方法名:" + o.getClass().getName() + "." + method.getName() + "()");
     }
}

后置增强

public class LogBeforeAdvice implements MethodBeforeAdvice {

    protected Logger logger = Logger.getLogger(this.getClass());

    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        logger.info("基于advisor->前置增强"+"方法名:" + o.getClass().getName() + "." + method.getName() + "()");
     }
}

配置文件

我采用的是ssm框架,大家把配置文件配好,日志写好,就可以直接使用

<!--低版本spring 基于advisor类-->
  <bean id="logBeforeAdvice" class="wsylp.log.advisorC.LogBeforeAdvice"></bean>
  <bean id="logAfterAdvice" class="wsylp.log.advisorC.LogAfterAdvice"></bean>
  <bean id="logAdvisorB" class="wsylp.log.advisorC.LogAdvisor"
   p:advice-ref="logBeforeAdvice" />
  <bean id="logAdvisorA" class="wsylp.log.advisorC.LogAdvisor"
    p:advice-ref="logAfterAdvice" />
    <bean id="parent" abstract="true" class="org.springframework.aop.framework.ProxyFactoryBean"
    p:interceptorNames="logAdvisorB,logAdvisorA"
    p:proxyTargetClass="true"
  ></bean>
  <bean id="userService1" parent="parent" p:target-ref="userService"></bean>

注意由于采用的是代理,bean的名字用userService1,而target-ref引用的为userService配置的bean,大家可以自己修改

测试代码以及结果

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath*:spring-*.xml")
public class UserServiceTest {

    @Autowired
    private UserService userService1;

    @Test
    public void getUser() {
        userService1.getList();
    }
}

结果

[wsylp.log.advisorC.LogBeforeAdvice] - 基于advisor->前置增强方法名:wsylp.service.impl.UserServiceImpl.getList()
[wsylp.service.impl.UserServiceImpl] - getList方法开始
[wsylp.service.impl.UserServiceImpl] - getList方法结束
[wsylp.log.advisorC.LogAfterAdvice] - 基于advisor->后置增强方法名:wsylp.service.impl.UserServiceImpl.getList()
WeisyLP
关注
专栏目录
SpringAOP日志管理
01-06
采用SpringAOP拦截Controller，Service实现操作日志管理，统一处理异常，登陆日志管理，是SpringAOP的应用实践。通过SpringAOP的处理，可以方便移植日志管理功能，是个不错的学习demo
Spring AOP日志切面
06-28
结合logback和切面对参数名和参数值，方法运行时间，方法返回值记录日志，pom中需要添加ogback和切面依赖。
spring aop 日志
美好清新
08-28 128
import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.AfterThrowing; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.a...
SpringBoot系列：通过AOP+注解优雅实现操作日志记录
最新发布
weixin_73588491的博客
07-16 8056
在企业应用开发中，操作日志记录是确保系统安全性、可追溯性以及调试分析的重要手段之一。通过记录用户的操作行为，不仅可以帮助开发者快速定位问题，还能满足审计和合规需求。本文旨在探讨如何在SpringBoot应用程序中通过AOP（面向切面编程）和自定义注解实现操作日志记录，并将日志存储到数据库中。我们将详细介绍实现这一功能的完整流程，包括项目环境搭建、数据库设计、代码实现及测试验证等步骤。操作日志在企业应用中扮演着至关重要的角色。
Spring AOP日志记录
TechnicianWang的博客
01-10 219
@Slf4j @Aspect @Component public class AspectLogTools { // @Aspect 表明是一个切面类 // @Component 将当前类注入到Spring容器内 // @Pointcut 切入点，其中execution用于使用切面的连接点。使用方法：execution(方法修饰符(可选) 返回类型 方法名 参数 异常模式(可选)) ，可以使用通配符匹配字符，*可以匹配任意字符。 // @Before 在方法前执行 // @A.
SpringAop日志记录
热门推荐
轻描淡写
03-13 1万+
spring日志记录（使用切面方式记录） 1. 创建pojo类 @Data @Table(name = "tb_operate_record") public class OperateRecord { @Id private String id; //记录请求时间 @Column(name = "record_time") private Date rec...
spring aop 日志记录
stefshawn的专栏
07-06 1150
需要日志记录，将所有的web操作记录到数据库中，使用aop来记录日志，当然是一个好的选择，spring中集成aop记录日志的方式有多种（aop的配置方式有多种，注解、xml配置），这里只说一个xml配置的例子。    1、编写日志记录类    2、配置aop
Spring-AOP.rar_spring aop 日志
09-14
Spring AOP，全称为Aspect-Oriented Programming，是Spring框架中的一个重要组成部分，主要用来处理系统的横切关注点，如日志记录、事务管理、性能监控等。这些关注点通常会分散在应用程序的各个角落，而AOP就是为了...
swagger和spring Aop日志结合
08-09
另一方面，Spring AOP（面向切面编程）则是Spring框架的一个核心特性，用于实现跨切面的关注点，如日志记录。本篇文章将深入探讨如何将Swagger与Spring AOP结合起来，以实现优雅的日志记录功能。 首先，让我们了解...
spring AOP日志框架
06-25
总结来说，Spring AOP日志框架允许我们通过注解方式轻松地实现业务日志管理，提高代码的可读性和可维护性，同时减少了代码冗余。通过自定义切面和通知，我们可以灵活地控制日志记录的时机和内容，满足不同场景的需求...
Spring之AOP日志记录
积跬步，至千里。
10-17 1574
在Java中，可以使用注解和切面技术来实现AOP（Aspect Oriented Programming）。AOP是一种编程范式，它通过将应用程序分解为关注点的模块来提高代码的可维护性和重用性。注解可以用于标记程序元素，例如类、方法和字段，以便切面可以识别和操作这些元素。
spring aop 操作日志
06-04
本资源用来展示如何使用 spring aop 进行日志记录，例子里面通过aop的配置，把产生的日志存放到当前项目的根目录下，而且对方法执行过程中的参数进行了记录，对于aop如何记录日志不清楚的同学可以看看。
Spring AOP--日志管理
01-26
Spring AOP--日志管理，注释齐全，欢迎大家共同交流。
Spring aop记录日志
qq_33067315的博客
02-02 69
依赖包 spring 5.0.0 版本 <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>4.0.0</version> </dependency> 代码 private AopClass{ //定义一个切点 @Pointcut private void con
Spring：Aop记录日志
weixin_42914989的博客
01-15 233
Spring：Aop记录日志 本博客默认读者已经了解Aop原理，有spring基础，不在此详细描述。 AOP简介 AOP（Aspect Oriented Programming），即面向切面编程。 (OOP：Object 面向对象编程) 有了AOP，你写代码时不需要把这个验证用户步骤写进去，即完全不考虑验证用户。只写取款和显示余额的业务代码。而在另一个地方，写好验证用户的代码。这个验证用户的代码就是切面代码，以后在执行取款和显示余额的时候，利用代理模式。将验证用户的功能在执行取款和显示余额前调用。 代码在S
Spring Aop 日志管理
iteye_5095的博客
08-31 88
Spring Aop 日志管理 Spring 带给我们的另一个好处就是让我们可以“专心做事”，下面我们来看下面一个例子： public void doSameSomesing(int age,String  name){      // 记录日志      log.info("调用 doSameSomesing方法，参数是："+agfe+” ”+name);      // 输入合法性验...
spring Aop实现日志
weixin_41551987的博客
08-18 2147
这版讲到的日志是作用在方法的，通过aop来指定某些方法以完成在执行方法前后的一些操作，说是记录日志不如说是讲解aop的用法。
Spring aop日志怎么实现？
03-04
可以使用AspectJ或Spring AOP来实现Spring aop日志。可以通过定义切面和切点来捕获方法调用，并在方法执行前后记录日志。可以使用@Aspect注释来定义切面，使用@Before和@After注释来定义切点。在切面中，可以使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值