springboot全局异常处理

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量247 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangking407/article/details/89000968
版权

springboot全局异常处理

1、AOP日志和异常处理

  • pom.xml中添加
		<!--aop切面-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>
  • 切面类
package global_exception.global_exception.demo.config;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * Aop请求打日志
 */
@Aspect
@Component
public class WebLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(WebLogAspect.class);
    private static final ThreadLocal<Long> timeTreadLocal = new ThreadLocal<>();

        @Pointcut("execution(* global_exception.global_exception.demo..*.*(..)) && @annotation(org.springframework.web.bind.annotation.RequestMapping)")
//    @Pointcut("execution(* global_exception.global_exception.demo.timer..*(..))")
    public void log() {
    }

    @Before("log()")
    public void before(JoinPoint joinPoint) {
        timeTreadLocal.set(System.currentTimeMillis());
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        //获取请求的request
        HttpServletRequest request = attributes.getRequest();
        //获取所有请求的参数，封装为map对象
        // Map<String,Object> parameterMap = getParameterMap(request);
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        //获取被拦截的方法
        Method method = methodSignature.getMethod();
        //获取被拦截的方法名
        String methodName = method.getName();
        //被拦截的类
        String className = joinPoint.getTarget().getClass().getName();
        String[] classNames = className.split("\\.");
        className = classNames[classNames.length - 1];
        logger.info("请求方法：{}--开始", className + "-->" + methodName);
        //获取所有请求参数key和value
        String keyValue = getReqParameter(request);
        logger.info("请求url = {}", request.getRequestURL().toString());
        logger.info("请求方式 = {}", request.getMethod());
//        logger.info("请求资源uri = {}", request.getRequestURI());
//        logger.info("所有的请求参数 key：value = {}", keyValue);
    }


    @After("log()")
    public void after(JoinPoint joinPoint) {
//        logger.info("aop的after()方法");
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        //获取被拦截的方法
        Method method = methodSignature.getMethod();
        //获取被拦截的方法名
        String methodName = method.getName();
        //被拦截的类
        String className = joinPoint.getTarget().getClass().getName();
        String[] classNames = className.split("\\.");
        className = classNames[classNames.length - 1];
        long startTime = timeTreadLocal.get();
        double callTime = (System.currentTimeMillis() - startTime) / 1000.0;
        logger.info("请求方法：{}--结束；花费时间time = {}s", className + "-->" + methodName, callTime);
    }

    //controller请求结束返回时调用
    @AfterReturning(returning = "result", pointcut = "log()")
    public Object afterReturn(Object result) {
        logger.info("AOP afterReturn,返回值result = {}", result.toString());
        // System.out.println("返回值="+result.toString());
//        long startTime = timeTreadLocal.get();
//        double callTime = (System.currentTimeMillis() - startTime) / 1000.0;
//        logger.info("调用controller花费时间time = {}s", callTime);
        return result;
    }

    /**
     * 异常捕获
     *
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(pointcut = "log()", throwing = "e")
//    @AfterThrowing(pointcut = "execution(* global_exception.global_exception.demo.timer..*(..))", throwing = "e")
    public void handleThrowing(JoinPoint joinPoint, Exception e) {//controller类抛出的异常在这边捕获
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();
        String[] classNames = className.split("\\.");
        className = classNames[classNames.length - 1];
        //开始打log
        logger.info(className + "-->" + methodName + " 报错");
        logger.error(className + "-->" + methodName + " 报错", e);
    }

    /**
     * 获取所有请求参数，封装为map对象
     *
     * @return
     */
    public Map<String, Object> getParameterMap(HttpServletRequest request) {
        if (request == null) {
            return null;
        }
        Enumeration<String> enumeration = request.getParameterNames();
        Map<String, Object> parameterMap = new HashMap<String, Object>();
        StringBuilder stringBuilder = new StringBuilder();
        while (enumeration.hasMoreElements()) {
            String key = enumeration.nextElement();
            String value = request.getParameter(key);
            String keyValue = key + " : " + value + " ; ";
            stringBuilder.append(keyValue);
            parameterMap.put(key, value);
        }
        return parameterMap;
    }

    public String getReqParameter(HttpServletRequest request) {
        if (request == null) {
            return null;
        }
        Enumeration<String> enumeration = request.getParameterNames();
        //StringBuilder stringBuilder = new StringBuilder();
        JSONArray jsonArray = new JSONArray();
        while (enumeration.hasMoreElements()) {
            String key = enumeration.nextElement();
            String value = request.getParameter(key);
            JSONObject json = new JSONObject();
            //String keyValue = key+" : " +value+" ; ";
            json.put(key, value);
            //stringBuilder.append(keyValue);
            jsonArray.add(json);
        }
        //JSONObject jsonObject = new JSONObject();
        //jsonObject.put("请求参数为：",jsonArray.toString());
        return jsonArray.toString();
    }

}

enter description here
设置切入点，前切、后切和异常切都已这个切点为入口
另外：方法内捕获了异常，全局就会再去捕获异常了
效果：
浏览器输入：http://localhost:8080/aopExceptionTest/test2

浏览器输入：http://localhost:8080/aopExceptionTest/test1

2、定时器AOP日志和异常

TimerLogAspect切面类

package global_exception.global_exception.demo.config;

import lombok.extern.log4j.Log4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;

/**
 * 定时器打日志
 */
@Aspect
@Component
public class TimerLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(TimerLogAspect.class);
    private static final ThreadLocal<Long> timeTreadLocal = new ThreadLocal<>();

    /**
     * 切入点
     */
    @Pointcut("execution(* global_exception.global_exception.demo.timer..*(..))")
    public void log() {
    }

    /**
     * 前切
     * @param joinPoint
     */
    @Before("log()")
    public void before(JoinPoint joinPoint) {
        timeTreadLocal.set(System.currentTimeMillis());

        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        //获取被拦截的方法
        Method method = methodSignature.getMethod();
        //获取被拦截的方法名
        String methodName = method.getName();
        //被拦截的类
        String className = joinPoint.getTarget().getClass().getName();
        String[] classNames = className.split("\\.");
        className = classNames[classNames.length - 1];
        logger.info("定期器：{}--开始", className + "-->" + methodName);
    }

    /**
     * 后切
     * @param joinPoint
     */
    @After("log()")
    public void after(JoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        //获取被拦截的方法
        Method method = methodSignature.getMethod();
        //获取被拦截的方法名
        String methodName = method.getName();
        //被拦截的类
        String className = joinPoint.getTarget().getClass().getName();
        String[] classNames = className.split("\\.");
        className = classNames[classNames.length - 1];
        long startTime = timeTreadLocal.get();
        double callTime = (System.currentTimeMillis() - startTime) / 1000.0;
        logger.info("定时器：{}--结束；花费时间time = {}s", className + "-->" + methodName, callTime);
    }

    /**
     * 异常切面
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(pointcut = "execution(* global_exception.global_exception.demo.timer..*(..))", throwing = "e")
    public void handleThrowing(JoinPoint joinPoint, Exception e) {//controller类抛出的异常在这边捕获
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();
        String[] classNames = className.split("\\.");
        className = classNames[classNames.length - 1];
        //开始打log
        logger.info("定时器" + className + "-->" + methodName + " 报错");
        logger.error("定时器" + className + "-->" + methodName + " 报错", e);
    }
}

效果：
enter description here

3、请求页面异常捕获

两个页面404.html、500.html
404.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>404页面</h1>
</body>
</html>

500.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>500啦</h1>
</body>
</html>

两个类
NotFoundException.java

package global_exception.global_exception.demo.config;

import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
 * 捕获404异常
 */
@Controller
public class NotFoundException implements ErrorController {

    @Override
    public String getErrorPath() {
        return "/error";
    }

    @RequestMapping(value = {"/error"})
//    @ResponseBody
    public String error(HttpServletRequest request) {
//        Map<String, Object> body = new HashMap<>();
//        body.put("error", "not found");
//        body.put("code", "404");
        return "/error/404.html";
    }
}

GlobalExceptionHandler.java

enter code herepackage global_exception.global_exception.demo.config;

import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
 * 统一异常处理
 */
@ControllerAdvice("global_exception.global_exception.demo")
public class GlobalExceptionHandler {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @ExceptionHandler(RuntimeException.class)
//    @ResponseBody
    public String errorMsg(HttpServletRequest request,Exception ex) {
        //可以返回页面或json数据
//        logger.error("错误链接" + request.getRequestURL().toString());
//        Map<String, Object> errorMsgResult = new HashMap<>();
//        errorMsgResult.put("code", 500);
//        errorMsgResult.put("msg", "系统抛出异常");
        return "/error/500.html";
    }

}

效果：

项目地址：https://gitee.com/BestErwin/utils

souwind南风
关注
专栏目录
SpringBoot项目统一异常处理方案（三）
bin-brother的博客
07-12 525
利用SpringAOP实现统一异常处理 集合文章： SpringBoot项目统一异常处理方案（一） SpringBoot项目统一异常处理方案（二）
SpringBoot全局异常处理
飞鸟的轨迹
02-23 787
网上看到的不错的全局异常处理教程：http://blog.csdn.net/JE_GE/article/details/53326516 项目中使用的注解在访问Controller方法之前拦截，对参数进行校验。 对方法级别的参数进行验证，需要加上如下配置： package com.redsoft.spirit.config; import org.springframework.boo...
Spring Boot 通过 AOP 实现全局异常处理
思苑
05-25 1826
一共有三种方式，这里详细介绍两种放弃，另外一种请自行百度 pom <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 一、使用 @Aspect 🌺这个类的前置准备需要，自定义的异常类（ClouduiBizException）、自定义返回结果处.
AOP实现全局异常处理SpringBoot
乾坤未定，你我皆是黑马
10-13 936
【AjaxResponse】响应类 package com.example.mytoken.model; import com.example.mytoken.config.exception.CustomException; import com.example.mytoken.config.exception.CustomExceptionType; import lombok.Data; ...
Springboot使用lombok,全局异常，aop统一处理web日志
qq_39380737的博客
10-27 916
全局异常是入门案例 背景： 比如我们代码里面出现重复的异常需要捕获，每次都要重复写代码，有没有可以解决的办法，就诞生了全局异常捕获。 首先对相关注解说明： /** * 1. ControllerAdvice 的一个辅助类，最常用的就是作为全局异常处理的切面类 * 2.可以指定扫描范围,是指扫描包的范围 * 3.约定了几种可行的返回值，如果是直接返回 model 类的话，需要使用 @Respo...
springboot 统一异常处理 + 日志记录
lgq2016的博客
04-13 2357
在项目的开发中，在某些情况下，比如非业务的操作，日志记录，权限认证和异常处理等。我们需要对客户端发出的请求进行拦截，常用的API拦截方式有Fliter，Interceptor，ControllerAdvice以及Aspect。先简单介绍一下不同的拦截方式。
SpringBoot 全局异常处理
weixin_44936599的博客
04-16 252
代码简单示例 SpringBoo t的项目已经对有一定的异常处理了，但是对于我们开发者而言可能就不太合适了，因此我们需要对这些异常进行统一的捕获并处理。SpringBoot 中有一个ControllerAdvice 的注解，使用该注解表示开启了全局异常的捕获，我们只需在自定义一个方法使用ExceptionHandler 注解然后定义捕获异常的类型即可对这些捕获的异常进行统一的处理。 我们根据下面的...
Springboot全局异常处理demo.zip
03-10
Springboot全局异常处理demo 项目的开发中，不管是对底层的数据库操作过程，还是业务层的处理过程，还是控制层的处理过程，都不可避免会遇到各种可预知的、不可预知的异常需要处理。每个过程都单独处理异常，系统的...
springboot全局异常处理代码实例
08-25
Spring Boot 全局异常处理代码实例 Spring Boot 全局异常处理代码实例是指在 Spring Boot 项目中，如何使用全局异常处理机制来捕捉和处理异常。全局异常处理机制可以避免项目中出现大量冗余的代码，提高代码的...
springboot 全局异常处理
05-29
springboot 全局异常统一处理
Springboot学习教程（四）使用AOP处理全局捕获异常和添加日志
10-16 5028
目录 1.Spring的AOP特性 2.使用AOP统一处理全局捕获异常 3.使用AOP统一处理Web请求日志 1.Spring的AOP特性 Spring有两大特性，IOC(控制反转)和AOP(面向切面编程), 我们可以利用aop特性处理全局捕获异常，添加日志，添加事物等。 2.使用AOP统一处理全局捕获异常 如果访问项目时出现异常，那么浏览器则会显示500或者别的...
springboot如何使用aop统一处理请求日志、异常日志、返回日志？
qq_20446879的博客
06-08 4129
springboot有很多方法处理日志，例如拦截器，aop切面，service中代码记录等。这里我们以aop切面为例： 这里要注意点是 AOP中@Pointcut切入点表达式的使用，不能使用execution(public * *(..)) ，这个代表切入全部请求，会在启动项目的时候报空指针异常，因为启动项目时候无法获取request。所以建议切入点表达式指定为controller包下的方法。 IpUtil.getIpAddr(request)方法为获取请求者的IP地址的方法，代码如下： 执行
SpringBoot教程（二十六） | SpringBoot集成AOP实现异常处理
qq_20236937的博客
08-31 1143
SpringBoot集成AOP实现异常处理
开启了全局异常处理，AOP日志处理中@AfterThrowing失效场景
qq_42102911的博客
05-12 3665
在实际业务场景中，我们通常会使用全局异常处理机制，也就是在业务代码发生异常的时候，拦截异常并进行统一的处理，然后以Json格式返回给前端。同时我们也会使用AOP进行操作日志记录，在不发生异常时，可以使用四种advice@After(“”)。当发生异常时，使用@AfterThrowing(value = “”,throwing = “e”)进行日志记录。
spring boot AOP和spring boot统一异常处理
wj903829182的专栏
10-20 8584
一，spring AOPspring boot使用AOP，代码如下，代码比较简单就不细说了，直接上代码，可以使用AOP做日志处理package com.qwrt.fire.sensor.aop; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import org.aspectj.lan
使用SpringBoot AOP记录操作日志和异常日志
YIYIYI
12-30 2132
使用SpringBoot AOP记录操作日志和异常日志
Java-网络
最新发布
2301_81543552的博客
09-14 703
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值