Spring注解实现日志记录

最新推荐文章于 2024-07-16 11:12:33 发布
最新推荐文章于 2024-07-16 11:12:33 发布
阅读量1.2w 收藏 8
点赞数 1
分类专栏： SSH框架 文章标签： Spring AOP java LOG
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weiweiai123456/article/details/54943724
版权

之前总结写了一篇通过XML配置的方式，切面编程实现日志记录的功能demo

http://blog.csdn.net/weiweiai123456/article/details/38561085

可参考http://blog.csdn.net/heirenheiren/article/details/36634497 ，讲的是注解实现

现在实现一个通过注解方式实现的样例：

一：准备

xml中需要开启CGLIB动态代理

<!-- 启用CGliB -->
	<aop:aspectj-autoproxy proxy-target-class="true"/>
切面编程----AOP，依赖的是代理，即JDK代理和CGLIB代理，而代理的实现依靠的是反射。

maven配置省...


二：注解类

SaveSysLog.java

package com.cooya.partner.metadata.entity.baseConfig;

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

/**
 * 
 * Description: 保存系统日志注解接口
 *
 * @author suoww
 * @date 2017-2-8
 *
 */
@Retention(RetentionPolicy.RUNTIME)  //注解会在class中存在，运行时可通过反射获取
@Target(ElementType.METHOD) //注解到方法
public @interface SaveSysLog {

    //调用方      1：嗨赚客户端   2：支付宝   3：微信       4：钱宝     5：其他第三方
    int send() default 1; 
    
    //接口url（从二级目录记起）
    String url();
    
    //接口类型(前台,后台)
    int type();
}
定义三个成员，这里只能定义八种基本数据类型，分别是


byte-->Byte

short-->Short

int-->Integer

long-->Long

float-->Float

double-->Double

char-->Character

boolean-->Boolean

注意：只能是上述这些8种类型的变量


三：切面类

SysLogAspect.java

package com.cooya.partner.service.baseConfig;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.shiro.SecurityUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
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.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.alibaba.fastjson.JSONObject;
import com.cooya.partner.constant.InterfaceTypeConst;
import com.cooya.partner.metadata.entity.baseConfig.PartnerSystemLog;
import com.cooya.partner.metadata.entity.baseConfig.SaveSysLog;
import com.cooya.partner.metadata.entity.user.PartnerUser;
import com.cooya.partner.metadata.mapper.baseConfig.PartnerSystemLogMapper;
import com.cooya.partner.permission.dto.ShiroUser;

/**
 * 
 * Description: 切面类记录接口调用失败日志信息
 *
 * @author suoww
 * @date 2017-2-8
 *
 */
@Aspect
@Component
public class SysLogAspect {
    
    public static final int CODE_SUCCESS = 0;
    
    private Logger logger = LoggerFactory.getLogger(SysLogAspect.class);
    
    @Resource
    private PartnerSystemLogMapper partnerSystemLogMapper;
    
    /**
     * 
     * Description: 定义切点名controllerAspect，此方法需要为空，只是标识切点和切面关系
     *
     * @author suoww
     * @date 2017-2-8
     */
    @Pointcut("@annotation(com.cooya.partner.metadata.entity.baseConfig.SaveSysLog)")
    public void controllerAspect(){}
    
    /**
     * 
     * Description:织入后增强 
     *
     * @param join
     * @author suoww
     * @throws Exception 
     * @date 2017-2-8
     */
    @AfterReturning(pointcut = "controllerAspect()", returning = "res")
    public void doAfter(JoinPoint joinPoint, Object res) throws Exception{
        //获取反射参数
        logger.debug("---------------AfterReturning开始--------------");
        if(null == res){
            return;
        }
        Map<String, Object> map = Obj2Map(res);
        int code = (Integer)map.get("code");
        if(code == CODE_SUCCESS){
            return;
        }
        String message = (String)map.get("message");
        //类名
        String targetName = joinPoint.getTarget().getClass().getSimpleName();
        //得到方法名
        String methodName = joinPoint.getSignature().getName();
        MethodSignature ms = (MethodSignature) joinPoint.getSignature();
        //入参key
        String[] parameterNames = ms.getParameterNames();
        //入参value
        Object[] arguments = joinPoint.getArgs();
        Method method = ms.getMethod();
        //方法的注解对象
        SaveSysLog logParam = method.getAnnotation(SaveSysLog.class);  
        /* logger.debug("SaveSysLog注解参数send：" + logParam.send());  
        logger.debug("SaveSysLog注解参数url：" + logParam.url()); 
        logger.debug("SaveSysLog注解参数type：" + logParam.type()); 
        logger.debug("targetName:" + targetName);
        logger.debug("methodName:" + methodName);
        logger.debug("ms:" + ms);
        logger.debug("arguments:" + JSONObject.toJSONString(arguments));
        logger.debug("parameterNames:" + JSONObject.toJSONString(parameterNames));
        logger.debug("method:" + JSONObject.toJSONString(method));*/
        
        //拼参数
        PartnerSystemLog sysLog = new PartnerSystemLog(); 
        //获取用户
        if(logParam.type() == InterfaceTypeConst.InterfaceType.APP){
            sysLog.setUserId(getAppUserId());
        }else{
            sysLog.setUserId(getMgrUserId());
        }
        sysLog.setSend(logParam.send());
        sysLog.setUrl(logParam.url());
        sysLog.setType(logParam.type());
        //入参字符串
        StringBuffer jsonParamSb = new StringBuffer();
        for(int i = 0;i < parameterNames.length;i++){
            jsonParamSb.append(parameterNames[i]).append("=").append(JSONObject.toJSONString(arguments[i]));
            if(i != (parameterNames.length - 1)){
                jsonParamSb.append("&");
            }
        }
        //截取返回json
        if(jsonParamSb.toString().length() <= 1000){
            sysLog.setJsonParam(jsonParamSb.toString());
        }else{
            sysLog.setJsonParam(jsonParamSb.toString().substring(0, 1000));
        }
        //出参
        sysLog.setJsonResult(JSONObject.toJSONString(res));
        StringBuffer remarkSb = new StringBuffer();
        remarkSb.append(targetName).append(".").append(methodName).append("报错信息：").append(message);
        //截取remark
        if(remarkSb.toString().length() <= 1000){
            sysLog.setRemark(remarkSb.toString());
        }else{
            sysLog.setRemark(remarkSb.toString().substring(0, 1000)); 
        }
        sysLog.setCreateTime(new Date());
        sysLog.setUpdateTime(new Date());
        handleLog(sysLog);
        logger.debug("---------------AfterReturning结束--------------");
    }
    
    /**
     * 
     * Description: 异步记录接口调用失败的日志
     *
     * @param systemLog
     * @author suoww
     * @date 2017-2-8
     */
    @Async
    public void handleLog(PartnerSystemLog sysLog){
        //写日志
        int row = partnerSystemLogMapper.insertSelective(sysLog);
        logger.debug("------日志写入行数：" + row);
    } 
    
    /**
     * 
     * Description: 对象转map
     *
     * @param obj
     * @return
     * @throws Exception
     * @author suoww
     * @date 2017-2-8
     */
    public Map<String,Object> Obj2Map(Object obj) throws Exception{
        Map<String,Object> map=new HashMap<String, Object>();
        Field[] fields = obj.getClass().getDeclaredFields();
        for(Field field:fields){
            field.setAccessible(true);
            map.put(field.getName(), field.get(obj));
        }
        return map;
    }
    
    /**
     * 
     * Description: 获取APP用户ID
     *
     * @return
     * @author suoww
     * @date 2017-2-8
     */
    protected Long getAppUserId() {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        if (null == session) {
            return null;
        }
        PartnerUser user = (PartnerUser) session.getAttribute("userInfo");
        if (null == user) {
            return null;
        }
        return user.getId();
    }
    
    /**
     * 
     * Description: 获取Mgr的用户ID
     *
     * @return
     * @author suoww
     * @date 2017-2-8
     */
    protected Long getMgrUserId(){
        ShiroUser user = (ShiroUser) SecurityUtils.getSubject().getPrincipal();
        return user.getId();
    }
}


@Aspect和@Component分别表示这是一个切面类、Spring要帮我实例化对象并管理



@Pointcut(XX) ：使用SaveSysLog作为注解（annotation）的将作为切点，对应切面controllerAspect



1.@AfterReturning 表示切点后增强，即切入点的方法执行结束后，即执行切面中的增强代码，但是不会改变原切入点方法返回值。下面具体说明

2.pointcut="controllerAspect()" ，returning="res" 表示切点和切面对应关系，一个方法上可以有多个切面，指定顺序

参考：http://blog.csdn.net/rainbow702/article/details/52185827

3.下面的是反射获取的参数，类名，方法名，入参key,参数value，注解对象，方法返回值


四：调用

controller中调用

 /**
     * 
     * Description: 接口：查询场次下商品
     *
     * @param channelId
     * @return
     * @author suoww
     * @date 2017-1-13
     */
    @RequestMapping("/queryGoodsUnderChannel")
    @ResponseBody
    @SaveSysLog(send=InterfaceTypeConst.SendType.HZ, url="/goods/api/queryGoodsUnderChannel.html", type=InterfaceTypeConst.InterfaceType.APP)
    public AjaxResult queryGoodsUnderChannel(@RequestParam(value = "channelId", required = true)Long channelId){
        try{
            List<PartnerChannelGoodsDto> list = partnerGoods2ChannelService.getChannelGoodsDto(channelId);
            logger.info("根据channelId:" + channelId + "获取到的商品集合为" + JSONObject.toJSONString(list));
            return AjaxResult.success(list, "成功获取频道下商品");
        }catch(ResultCodeException e){
            e.printStackTrace();
            return AjaxResult.failed("校验失败：" + e.getMessage());
        }catch(Exception e){
            e.printStackTrace();
            return AjaxResult.failed("系统异常：" + e.getMessage());
        }
    }

@SaveSysLog(send=InterfaceTypeConst.SendType.HZ, url="/goods/api/queryGoodsUnderChannel.html", type=InterfaceTypeConst.InterfaceType.APP)

这里对应注解接口三个成员，send,url,type

queryGoodsUnderChannel 这个方法将整体作为一个切入点，结合@AfterReturning 在queryGoodsUnderChannel （）执行结束会，会进入到SysLogAspect.doAfter 执行一段代码，记录日志


五：测试

输入http://localhost:8080/partner-app/goods/api/queryGoodsUnderChannel.html?channelId=17


  入参中channelId=17


参数可以对应。


总结：权限控制，日志记录应该使用AOP，注解方式实际使用时候比XML配置方式要省事很多。











爱你的小伟3
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用Spring AOP实现日志记录
小小渔夫
08-13 221
SpringAOP实现日志记录
SpringAop实现日志记录功能
weixin_45261485的博客
05-23 1994
AOP(面向切面编程) AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP术语 AOP 领域中的特性术语： 通知（Advice）: AOP 框架中的增强处理。通知描述了切面何时执行以及如何执行增强处理。 连接点（join point）: 连接点表示应用执行过程中能够插入切面的一个点，这个点可以是方法的调用
我使用Spring AOP实现了用户操作日志功能
Trouvailless的博客
05-21 792
我使用Spring AOP实现了用户操作日志功能 今天答辩完了，复盘了一下系统，发现还是有一些东西值得拿出来和大家分享一下。 需求分析 系统需要对用户的操作进行记录，方便未来溯源 首先想到的就是在每个方法中，去实现记录的逻辑，但是这样做肯定是不现实的，首先工作量大，其次违背了软件工程设计原则（开闭原则） 这种需求显然是对代码进行增强，首先想到的是使用 SpringBoot 提供的 AOP 结合注解的方式来实现 功能实现 1、 需要一张记录日志的 Log 表 导出的 sql 如下： -
爽！一个注解，搞定 SpringBoot 操作日志
m0_52987358的博客
02-23 974
来源：blog.csdn.net/weixin_43954303/article/details/113781801 使用方式 基本使用 源码 此组件解决的问题是：「谁」在「什么时间」对「什么」做了「什么事」 本组件目前针对 Spring-boot 做了 Autoconfig，如果是 SpringMVC，也可自己在 xml 初始化 bean 使用方式 基本使用 maven依赖添加SDK依赖 <dependency> <groupId>io.gi
SpringBoot系列：通过AOP+注解优雅实现操作日志记录
最新发布
weixin_73588491的博客
07-16 7446
在企业应用开发中，操作日志记录是确保系统安全性、可追溯性以及调试分析的重要手段之一。通过记录用户的操作行为，不仅可以帮助开发者快速定位问题，还能满足审计和合规需求。本文旨在探讨如何在SpringBoot应用程序中通过AOP（面向切面编程）和自定义注解实现操作日志记录，并将日志存储到数据库中。我们将详细介绍实现这一功能的完整流程，包括项目环境搭建、数据库设计、代码实现及测试验证等步骤。操作日志在企业应用中扮演着至关重要的角色。
Spring实现日志注解
qq_38345598的博客
05-22 2452
1、目的 写项目的时候经常会通过日志来排查原因，一种是通过log4j将日志收集出来，然后使用elk进行数据的分类与统计，这种是针对大量的请求日志进行记录。另一种就是通过自定义注解的方式写入数据库，这种是针对特定接口来处理，将重要的操作信息记录到数据库中。这篇博客就是说的第二种方式。 2、思路 首先，应该使用自定义注解来标记哪些接口需要记录操作日志。 然后, 使用切面来统一拦截参数和返回的结果，并将信息返回到数据库。 3、实现过程 4、实现效果 5、总结 ...
Spring-日志功能
吃土的柚的博客
04-20 760
当核心业务（保存）和增强业务（日志）同时出现时，我们可以在开发时对他们分别开发，运行时再组装在一起（使用动态代理的方式）。逻辑清晰：开发核心业务的时候，不必关注增强业务的代码代码复用性高：增强代码不用重复书写这就是一种 AOP ( 面向切面编程 ) 的思想，它的目的就是在不修改源代码的基础上，对原有功能进行增强。我的总结:开发阶段分别开发,运行阶段组装运行。
springboot 使用自定义注解实现aop切面日志
lp2388163的博客
12-26 732
平时我们在开发过程中，代码出现bug时为了更好的在服务器日志中寻找问题根源，会在接口的首尾打印日志，看下参数和返回值是否有问题。但是手动的logger.info() 去编写时工作量较大，这时我们可以使用AOP切面，为所有接口的首尾打印日志。 实现AOP切面日志一般有两种方式： 拦截所有接口controller，在首尾打印日志 拦截指定注解的接口，为有该注解的接口首尾打印日志 我们尝试用自定义...
Spring框架实现AOP添加日志记录功能过程详解
08-25
Spring框架实现AOP添加日志记录功能过程详解 本文主要介绍了使用Spring框架实现AOP添加日志记录功能的过程详解。通过示例代码，详细介绍了如何在业务方法的前面和后面添加日志记录功能。 首先，需要了解什么是AOP...
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
通过使用AspectJ注解，可以轻松地实现日志记录、性能监控、安全检查等功能。 知识点1: AspectJ注解 AspectJ是Java平台上最流行的AOP实现之一，提供了丰富的注解来实现切面编程。AspectJ注解可以用来定义切面、切入...
Spring Aop 实现日志功能
Tommyyug的博客
05-22 343
package com.netauth.api.aoplog; import java.lang.annotation.*; /** * * <p> * 自定义日志接口 * </p > * * @date 2022年5月13日 * @author Tommy * */ @Target(ElementType.METHOD) //注解放置的目标位置,METHOD是可注解在方法级别上 @Retention(RetentionPolicy.RUNTIME) //注...
spring aop实现日志功能
04-13
NULL 博文链接：https://zhaoshijie.iteye.com/blog/1733291
spring简单注解+log4j记录日志
12-30
简单的demo4初学者，用到spring注解，log4j记录日志到文件
Spring AOP实现简单的日志功能
秃头哥编程
07-15 3967
AOP对代码的侵入性非常的小，是一种可插拔的思想，大大降低了耦合度，AOP在许多地方都有应用，这篇文章就看看使用AOP实现日志的功能，也算是AOP思想的一种体现了。 主要是在用户访问一个URL前，记录用户的ip，访问方式，访问的URL，访问的哪个方法以及该方法的参数，访问URL后，记录访问返回的结果。 整个项目基于Spring Boot构建。 首先建立一个实体类Man，对应数据库中的一个...
Spring框架（十二）：实现日志功能通过SpringBean后处理器
futurn_hero的博客
12-05 482
痛定思痛，主要问题出现在自己雀氏不熟悉框架底层、一些面试题，以及sql的一些情况淡忘了。 本章节的开始是对于过去的重新回顾，当然，我也会深入基础，阅读源码，仔细熟悉开发过程，对问题进行整体学习， 后面会深入去做一些sql的题目来提升mysql能力 相关代码代码和笔记已经放到了gitee中去，喜欢的读者记得点赞下载 链接: BeanPostProcessor实现日志功能通过SpringBean后处理器 Proxy.newProxyInstance 通过反射机制用来动态生成代理类对象, 为接口创建一个代理类，这
Spring 使用注解集成Log
wangyan199366的博客
11-19 1270
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface WesLogable { } @Component @SuppressWarnings("serial") public class WesLogAdvisor extends AbstractPointcutAdv
SpringAop实现系统日志功能
myblogzz的博客
06-28 957
待完善。。。
SpringBoot AOP学习(二):Spring AOP实现日志功能
菜菜bu菜的博客
08-22 5675
Spring AOP实现日志功能代码示例
Spring之日志
一名在校大三学习JAVA
08-28 2598
关键节点上的关键数据日志记录举例：例如，比如咱们的教务系统，在注册时候不止要在教务系统添加一条用户记录，同时也会给比特论坛添加一条一模一样的用户记录，这样做的目的是为了实现一次注册，多处使用的目的。不需要用户在两边系统注册了，等于在程序中以极低的成本实现的用户数据的同步，但这样设计有一个致命的问题，用户在教务系统注册信息的时候，如果论坛挂了，那么用户的注册行为就会失败？因为用户在注册的时候需要同步注册到论坛系统，但论坛现在挂了，这个时候怎么办呢？...
springaop实现日志记录
03-28
Spring AOP是一个强大的框架，可以帮助我们实现各种切面，其中包括日志记录。下面是实现日志记录的步骤： 1. 添加Spring AOP依赖 在Maven或Gradle中添加Spring AOP依赖。 2. 创建日志切面 创建一个用于记录日志的切面。这个切面可以拦截所有需要记录日志的方法。在这个切面中，我们需要使用@Aspect注解来声明这是一个切面，并使用@Pointcut注解来定义哪些方法需要被拦截。 ```java @Aspect @Component public class LoggingAspect { @Pointcut("execution(* com.example.demo.service.*.*(..))") public void serviceMethods() {} @Around("serviceMethods()") public Object logServiceMethods(ProceedingJoinPoint joinPoint) throws Throwable { // 获取方法名，参数列表等信息 String methodName = joinPoint.getSignature().getName(); Object[] args = joinPoint.getArgs(); // 记录日志 System.out.println("Method " + methodName + " is called with args " + Arrays.toString(args)); // 执行方法 Object result = joinPoint.proceed(); // 记录返回值 System.out.println("Method " + methodName + " returns " + result); return result; } } ``` 在上面的代码中，我们使用了@Around注解来定义一个环绕通知，它会在拦截的方法执行前后执行。在方法执行前，我们记录了该方法的名称和参数列表，然后在方法执行后记录了该方法的返回值。 3. 配置AOP 在Spring的配置文件中配置AOP。首先，我们需要启用AOP： ```xml <aop:aspectj-autoproxy/> ``` 然后，我们需要将创建的日志切面添加到AOP中： ```xml <bean id="loggingAspect" class="com.example.demo.aspect.LoggingAspect"/> <aop:config> <aop:aspect ref="loggingAspect"> <aop:pointcut id="serviceMethods" expression="execution(* com.example.demo.service.*.*(..))"/> <aop:around method="logServiceMethods" pointcut-ref="serviceMethods"/> </aop:aspect> </aop:config> ``` 在上面的代码中，我们将创建的日志切面声明为一个bean，并将其添加到AOP中。我们还定义了一个切入点，并将其与日志切面的方法进行关联。 4. 测试 现在，我们可以测试我们的日志记录功能了。在我们的业务逻辑中，所有匹配切入点的方法都会被拦截，并记录它们的输入和输出。我们可以在控制台中看到这些日志信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值