利用Spring AOP统一处理日志和异常

最新推荐文章于 2024-04-30 11:49:15 发布
最新推荐文章于 2024-04-30 11:49:15 发布
阅读量477 收藏 1
点赞数 2
分类专栏： spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37771131/article/details/96431655
版权

第一步：

1. 增加spring AOP相关配置到spring-context.xml：

<!-- 启动对@AspectJ注解的支持 -->
<!-- proxy-target-class等于true是强制使用cglib代理，proxy-target-class默认是false，如果你的类实现了接口就走JDK代理，如果没有，走cglib代理 -->
<!-- 注：对于单利模式建议使用cglib代理，虽然JDK动态代理比cglib代理速度快，但性能不如cglib -->
<!--如果不写proxy-target-class="true"这句话也没问题 -->

<aop:aspectj-autoproxy proxy-target-class="true" />

2. pom.xml增加相关依赖：

<!-- AOP -->
<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjrt</artifactId>
	<version>1.6.11</version>
</dependency>
<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
	<version>1.6.11</version>
</dependency>
<dependency>
	<groupId>cglib</groupId>
	<artifactId>cglib</artifactId>
	<version>2.1_3</version>
</dependency>
<dependency>
	<groupId>javassist</groupId>
	<artifactId>javassist</artifactId>
	<version>3.12.1.GA</version>
</dependency>

第二布：

创建相关自定义注解类，InterfaceParam.java 和 JzInterface.java

package com.abc.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 自定义注解类(方法描述)
 */
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface JzInterface {
 
    /**
     * 方法描述:接口名称
     * 
     * @return String
     */
    String value() default "";
 
    /**
     * 方法描述:参数列表
     * 
     * @return InterfaceParam[]
     */
    InterfaceParam[] params() default {};
}
package com.abc.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 自定义注解类(接口描述信息)
 */
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InterfaceParam {
 
    /**
     * 方法描述:参数名称
     * 
     * @return String
     */
    String name() default "";
 
    /**
     * 方法描述:参数说明
     * 
     * @return String
     */
    String desc() default "";
 
}


第三步：

创建操作日志实体对象，属性字段如下：

// 请求状态
public static final int STATUS_FAIL = 0; // 失败
public static final int STATUS_SUCCESS = 1; // 成功
private ObjectId _id;
private String userId; // 用户ID
private String integerfaceDesc; // 接口描述
private String receptionParams; // 前台参数
private String backstageParams; // 后台参数
private int status; // 请求状态
private String menuKey; // 菜单key
private Boolean deleted; // 删除标记
private Date createdAt; // 创建时间
private Date updatedAt; // 更新时间


第四部：

编写AOP拦截类：

package com.abc.aop;
 
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
 
import javax.servlet.http.HttpServletRequest;
 
import org.apache.shiro.SecurityUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterThrowing;
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.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
 
import com.abc.annotation.InterfaceParam;
import com.abc.annotation.JzInterface;
import com.abc.entity.OperationLog;
import com.abc.entity.User;
import com.abc.service.OperationLogService;
 
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.Modifier;
import javassist.NotFoundException;
import javassist.bytecode.CodeAttribute;
import javassist.bytecode.LocalVariableAttribute;
import javassist.bytecode.MethodInfo;
 
/**
 * 采用AOP的方式处理日志和异常问题
 * 
 */
@Aspect
@Component
public class BindAop {
 
    @Autowired
    private OperationLogService operationLogService;
 
    private final Logger log = LoggerFactory.getLogger(this.getClass());
 
    // 接口描述
    private String interfaceDescribe = "";
 
    // 接口参数
    InterfaceParam[] param = null;
 
    // 接口详细参数字符串map
    Map<String, String> parameContentMap = null;
 
    OperationLog operationLog = null;
 
    @Pointcut("execution(* com.abc.controller.*.*(..))")
    public void aopMethod() {
    }
 
    /**
     * 环绕通知
     * 
     * @param joinPoint
     * @return Object
     * @throws Throwable
     */
    @Around("aopMethod()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("before method invoking!");
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        JzInterface jzInterface = method.getAnnotation(JzInterface.class);
        if (null != jzInterface) {
            String classType = joinPoint.getTarget().getClass().getName();// 接口所在的包名类名
            // Class<?> clazz = Class.forName(classType);
            // String clazzName = clazz.getName();// 接口所在的类名
            // String clazzSimpleName = clazz.getSimpleName();// 接口所在的类名
            String methodName = joinPoint.getSignature().getName();// 被请求的接口名
            String[] paramNames = getFieldsName(this.getClass(), classType, methodName);// 被请求的接口的参数的key
            parameContentMap = appendParameInfo(paramNames, joinPoint, jzInterface.params());
            interfaceDescribe = jzInterface.value();
        } else {
            interfaceDescribe = "";
        }
        return joinPoint.proceed();
    }
 
    /**
     * 后置通知
     *
     * 
     * @param joinPoint
     */
    @After("aopMethod()")
    public void after(JoinPoint joinPoint) {
        if (!"".equals(interfaceDescribe)) {// 获取接口的描述
            String parame = parameContentMap.get("parame");
            String parameInfo = parameContentMap.get("parameInfo");
            // 接口访问成功(加入日志操作记录)
            operationLog = new OperationLog();
            // operationLog对象set相关属性值
            operationLog.setIntegerfaceDesc(interfaceDescribe);
            operationLog.setReceptionParams(parameInfo);
            operationLog.setBackstageParams(parame);
            operationLog.setStatus(OperationLog.STATUS_SUCCESS);// 成功
            operationLog.setUserId(((User) SecurityUtils.getSubject().getPrincipal()).get_id() + "");//此处用户id根据自己项目实际情况获取
            operationLog.setDeleted(false);
            operationLog.setMenuKey("-");
            // 操作日志入库
            operationLog = operationLogService.add(operationLog);
        }
    }
    /**
     * 异常通知
     * 
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(pointcut = "aopMethod()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Throwable e) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String url = request.getRequestURI();
        if (!"".equals(interfaceDescribe)) {
            String parame = parameContentMap.get("parame");
            String parameInfo = parameContentMap.get("parameInfo");
            // 接口访问失败(修改日志操作记录)
            operationLog.setIntegerfaceDesc(interfaceDescribe);
            operationLog.setReceptionParams(parameInfo);
            operationLog.setBackstageParams(parame);
            operationLog.setStatus(OperationLog.STATUS_FAIL);// 失败
            operationLog.setUserId(((User) SecurityUtils.getSubject().getPrincipal()).get_id() + "");
            operationLog.setDeleted(false);
            operationLog.setMenuKey("-");
            // 修改刚才插入数据库的数据
            operationLogService.edit(operationLog);
        }
        // 错误信息
        log.error("访问" + url + " 发生错误, 错误信息:" + e.getMessage());
        // TODO ... 错误信息保存数据库 ...
    }
 
    /**
     * 拼接参数key以及参数value
     * 
     * @param paramNames
     * @param joinPoint
     * @param param
     * @return String
     */
    private Map<String, String> appendParameInfo(String[] paramNames, JoinPoint joinPoint, InterfaceParam[] param) {
        Map<String, String> map = new HashMap<String, String>();
        Object[] args = joinPoint.getArgs();
        StringBuilder sb = new StringBuilder();
        StringBuilder sb1 = new StringBuilder();
        sb.append("{");
        sb1.append("{");
        int length = args.length;
        if (param.length == length) {
            int lastArgsNum = args.length - 1;
            for (int k = 0; k < length; k++) {
                Object arg = args[k];
                sb.append("\"" + paramNames[k] + "\"");
                sb1.append("\"" + param[k].desc() + "\"");
                if (k == lastArgsNum) {
                    sb.append(":\"" + arg + "\"");
                    sb1.append(":\"" + arg + "\"");
                } else {
                    sb.append(":\"" + arg + "\",");
                    sb1.append(":\"" + arg + "\",");
                }
            }
        }
        sb.append("}");
        sb1.append("}");
        map.put("parame", sb.toString());
        map.put("parameInfo", sb1.toString());
        return map;
    }
 
    /**
     * 得到方法参数的名称
     * 
     * @param cls
     * @param clazzName
     * @param methodName
     * @return String[]
     * @throws NotFoundException
     */
    @SuppressWarnings("rawtypes")
    private String[] getFieldsName(Class cls, String clazzName, String methodName) throws NotFoundException {
        ClassPool pool = ClassPool.getDefault();
        ClassClassPath classPath = new ClassClassPath(cls);
        pool.insertClassPath(classPath);
 
        CtClass cc = pool.get(clazzName);
        CtMethod cm = cc.getDeclaredMethod(methodName);
        MethodInfo methodInfo = cm.getMethodInfo();
        CodeAttribute codeAttribute = methodInfo.getCodeAttribute();
        LocalVariableAttribute attr = (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
        if (attr == null) {
            // exception
        }
        String[] paramNames = new String[cm.getParameterTypes().length];
        int pos = Modifier.isStatic(cm.getModifiers()) ? 0 : 1;
        for (int i = 0; i < paramNames.length; i++) {
            paramNames[i] = attr.variableName(i + pos); // paramNames即参数名
        }
        return paramNames;
    }
}


第五步：

使用：

1. eg，接口需要将调用日志添加到数据库，则如下：

    /**
     * 新建角色
     *
     * @param name
     * @param desc
     * @param menuKeys
     * @return Result
     */
    @JzInterface(value = "新建角色", params = { @InterfaceParam(name = "name", desc = "角色名称"), @InterfaceParam(name = "desc", desc = "备注"),
            @InterfaceParam(name = "menuKeys", desc = "角色权限") })
    @RequestMapping(value = "add.do")
    public @ResponseBody Result add(String name, String desc, String menuKeys) {
        // TODO ...
        // ...
        // ...
        return null;
    }


2. eg，接口不需要将调用日志添加到数据库，则如下：

    /**
     * 新建角色
     *
     * @param name
     * @param desc
     * @param menuKeys
     * @return Result
     */
    @RequestMapping(value = "add.do")
    public @ResponseBody Result add(String name, String desc, String menuKeys) {
        // TODO ...
        // ...
        // ...
        return null;
    }


3. 说明，当需要添加日志，但是接口中又没有参数时，注解中的 params 直接 = {} 即可。当接口参数中包含有request、response、session或其他对象时，注解中的params也同样需要写入该参数，eg：

    @JzInterface(value = "获取人员数据列表", params = { @InterfaceParam(name = "page", desc = "页码"), @InterfaceParam(name = "limit", desc = "条数"),
            @InterfaceParam(name = "temp", desc = "0:初始化页面,不是0说明不是初始化页面"), @InterfaceParam(name = "session", desc = "HttpSession对象") })
    @RequestMapping(value = "IMOS_page_list.do")
    public @ResponseBody Map<String, Object> person_page_list(Integer page, Integer limit, String temp, HttpSession session) {
        Map<String, Object> map = new HashMap<String, Object>();
        // TODO ...
        // ... ...
        // ... ...
        return map;
    }


最后一点，要注意：params 里面的参数顺序必须和接口参数顺序保持一致！！！
 

驰暝烟两岸
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring AOP实现全局日志记录
柱子pg的博客
01-27 934
Spring AOP实现全局日志记录 一 前言： 在java开发中日志的管理有很多种， 在这里推荐Spring 的Aop思想将每一次请求记录 ，并且保存到数据库表中。 通常情况下，我们将项目部署到服务器后，如果接口出现了bug，那么我们就可以通过查看数据库表中记录的信息来判断这次请求是哪个用户操作的 在公司内部办公软件可以很好的使用，但是对外的项目建议使用日志几率到文件中更加符合业务场景。 二、代码详情： ps： 涉及公司隐私信息 添加数据库代码（被修改）就不对外暴露啦 谢谢大家 import o
spring boot aop 统一处理日志
10-18
本教程将深入探讨如何利用Spring Boot的AOP特性来实现日志的统一处理。 首先，我们需要了解AOP的基本概念。AOP允许程序员定义“切面”，它是一个包含业务逻辑和元数据的模块，可以跨越多个对象进行分布。在Spring中...
SpringBoot开发详解（六）-- 异常统一管理以及AOP的使用
尼斯湖水鬼的博客
05-07 2万+
AOP在SpringBoot中的使用使用切面管理异常的原因：今天的内容干货满满哦～并且是我自己在平时工作中的一些问题与解决途径，对实际开发的作用很大，好，闲言少叙，让我们开始吧～～我们先看一张错误信息在APP中的展示图： 是不是体验很差，整个后台错误信息都在APP上打印了。 作为后台开发人员，我们总是在不停的写各种接口提供给前端调用，然而不可避免的，当后台出现BUG时，前端总是丑陋的讲错
【Spring】解决aop日志切面时Post请求报Stream closed问题
fearless的博客
05-07 1398
spring boot项目，在过滤器、拦截器或自定义aop做统一处理时，获取了request中的inputstream来获取RequestBody里数据，获取之后在Controller里使用@RequestBody注解再获取就报错：Stream closed。这是因为HttpServletRequest中的inputstream是不可重复读的。 这块有个疑问：监听器、过滤器、 拦截器、 AOP的执行顺序是什么呢？？？ 如果监听器、过滤器、 拦截器、 AOP都存在，则它们的执行顺序为：监听器 => .
springaop实现相关功能（事务、异常处理、记录日志）
最新发布
唐昊
04-30 1139
当你的应用程序中的 com.example.myapp.service 包下的任意方法抛出异常时，ExceptionHandlingAspect 切面中的 handleException 方法将被自动调用，处理异常逻辑。事务管理器的类型取决于你使用的数据库和连接池。：虽然CGLIB代理在性能方面通常优于JDK动态代理，但由于它涉及到字节码操作，因此在创建代理类的过程中可能会存在一定的性能开销。：JDK动态代理要求目标对象必须实现至少一个接口，如果目标类没有实现任何接口，则无法使用JDK动态代理进行代理。
SpringAOP详解，使用SpringAop实现统一日志处理，异常处理
生而为人我很抱歉
08-03 3333
SpringAOP详解，使用SpringAop实现统一日志处理，异常处理
spring aop处理系统操作日志和异常日志，保存到数据库
shanger_1216的博客
07-06 7028
package com.env.web.zj;import java.text.SimpleDateFormat;import java.util.Arrays;import java.util.Date;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpSession;import org.apa...
利用Spring AOP记录方法的执行时间
09-01
总结来说，利用Spring AOP记录方法执行时间是一种优雅的解决方案，它有助于我们更好地理解和优化系统的性能瓶颈。通过切面和通知，我们可以轻松地插入监控代码，同时保持核心业务代码的清晰和整洁。在实际项目中，...
8_24_SpringAOP_springaop_
10-03
Spring AOP，全称Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为应用程序提供了...通过学习和掌握Spring AOP，开发者能够更好地利用面向切面编程的优势，提升软件工程的效率和质量。
Spring aop、jdbc和事务tx练习
11-08
- 包含@Transactional注解的服务层类，定义了业务逻辑，利用Spring自动管理事务。 - 测试类，通过JUnit或其他测试框架验证AOP、JDBC和事务功能的正确性。 通过这些练习，你可以深入理解Spring如何整合AOP、JDBC和...
spring-aop.rar_aop1270_spring_spring aop
09-23
Spring AOP，即Spring的面向切面编程，是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强或统一处理的方法。本文将围绕Spring AOP的源码分析，探讨其核心概念、工作原理以及在...
spring aop统一进行日常及异常的处理
呼延十
11-13 7147
什么是AOP 以下摘自百度百科： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程...
spring-boot使用AOP统一处理日志
weixin_34195546的博客
12-04 528
2019独角兽企业重金招聘Python工程师标准>>> ...
使用AOP统一处理日志
qq_36826506的博客
08-05 9947
AOP我想大家都很清楚,有时候我们需要处理一些请求日志,或者对某些方法进行一些监控,如果出现例外情况应该进行怎么样的处理,现在,我们从spring-boot中引入AOP. [开发环境:jdk版本号为1.8,spring boot的版本号为1.4.1]{style=”background-color:#FF0000”} 首先,我们先引入jar包, POM文件添加如下内容: ? 1 ...
spring boot AOP和spring boot统一异常处理
程序员养成日记
03-14 1795
一，spring AOP spring boot使用AOP，代码如下，代码比较简单就不细说了，直接上代码，可以使用AOP做日志处理 package com.qwrt.fire.sensor.aop; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import org.aspec...
SpringAOP详细配置与使用
热门推荐
青元子的博客
06-11 5万+
目录 SpringAOP简介 AOP概念 Spring AOP简单流程图 Spring AOP之Annotation 前置通知(Before advice) 返回后通知(After reurning advice) 抛出异常后通知(After throwing advice) 后置通知(After (finally) advice) 环绕通知(Around advice) 引入...
Spring统一日志处理(AOP)
XiChuan的博客
10-23 2366
来现在公司的缘故，公司大佬使用的AOP比较多，本来在校时候对AOP只是一知半解，在现在公司呆了半年，用到了各种拦截器，对AOP有了许多新的认识。此处用统一日志处理就是使用的是Spring AOP实现的。 定义统一日志表，用在将所有请求都记录在表中，方便以后查阅。 CREATE TABLE `t_union_log` ( `id` bigint(20) UNSIGNED NOT NULL...
SpringBoot全局异常捕获和使用自定义注解及AOP记录异常日志
FenG·的博客
05-02 3982
前言 由于项目中有的地方会出现异常，当出现次数多了之后，手写try-catch感觉十分的麻烦，于是查阅资料发现可以使用SpringBoot中的@ControllerAdivce注解来处理异常，并通过AOP的方式记录错误日志。 添加依赖 <dependency> <groupId>org.springframework.boot</groupId> ...
Java数据校验详解&springboot 统一异常处理（包含统一数据校验）
Rebirth 重生
05-17 1930
一切从元编程开始 一个健壮的系统都要对外部提交的数据进行完整性、合法性的校验。即使开发一个不面对最终用户的工具包，也需要对传入的数据进行缜密的校验来防止引发底层难以追踪的问题。各路大神当然也会注意到这个问题，所以在“元编程”（见JSR250与资源控制）提出之后相续提交了JSR-303、JSR-349以及JSR-380来完善使用注解进行数据校验的机制，这三个JSR也被称为Bean Validati...
Spring框架学习笔记：从IoC到AOP
8.1 Spring提供了统一的异常处理类型：Spring提供了统一的异常处理类型，可以处理不同的异常信息。 8.2 Spring提供了编写DAO的支持类：Spring提供了编写DAO的支持类，可以简化数据访问操作。 8.3 Spring提供了声明...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值