SpringBoot整合全局异常处理&SpringBoot整合定时任务Task&SpringBoot整合异步任务

============整合全局异常===========

1.整合web访问的全局异常

　　如果不做全局异常处理直接访问如果报错，页面会报错500错误，对于界面的显示非常不友好，因此需要做处理。

全局异常处理的类:

package cn.qlq.ExceptionHandler;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.web.bind.annotation.ControllerAdvice;

import org.springframework.web.bind.annotation.ExceptionHandler;

import org.springframework.web.servlet.ModelAndView;

@ControllerAdvice

public class WebExceptionHandler {

    public static final String ERROR_VIEW = "error";

    @ExceptionHandler(value = Exception.class)

    public Object errorHandler(HttpServletRequest reqest, HttpServletResponse response, Exception e) throws Exception {

        e.printStackTrace();

        ModelAndView mav = new ModelAndView();

        mav.addObject("exception", e);

        mav.addObject("url", reqest.getRequestURL());

        mav.setViewName(ERROR_VIEW);

        return mav;

    }

}

拦截到异常之后会跳转到error页面error.html:

目录结构：

内容如下:

<!DOCTYPE html>

<html>

<head lang="en">

    <meta charset="UTF-8" />

    <title>捕获全局异常</title>

</head>

<body>

    <h1 style="color: red">发生错误：</h1>

    <div th:text="${url}"></div>

    <div th:text="${exception.message}"></div>

</body>

</html>

测试:

2.整合ajax全局异常处理

　　ajax异常处理就是捕捉到异常之后返回一个封装的JSON实体，ajax请求根据返回的状态判断是否请求成功。

封装的工具类:

package cn.qlq.utils;

import java.io.Serializable;

public class JSONResultUtil<T> implements Serializable {

    private static final long serialVersionUID = 3637122497350396679L;

    private boolean success;

    private T data;

    private String msg;

    public boolean isSuccess() {

        return success;

    }

    public void setSuccess(boolean success) {

        this.success = success;

    }

    public T getData() {

        return data;

    }

    public void setData(T data) {

        this.data = data;

    }

    public String getMsg() {

        return msg;

    }

    public void setMsg(String msg) {

        this.msg = msg;

    }

    public JSONResultUtil(boolean success) {

        this.success = success;

    }

    public JSONResultUtil(boolean success, String msg) {

        super();

        this.success = success;

        this.msg = msg;

    }

    public JSONResultUtil(boolean success, T data, String msg) {

        super();

        this.success = success;

        this.data = data;

        this.msg = msg;

    }

    /**

     * 返回正确结果不带数据

     *

     * @return

     */

    public static JSONResultUtil ok() {

        return new JSONResultUtil(true);

    }

    /**

     * 返回错误的结果带错误信息

     *

     * @param msg

     * @return

     */

    public static JSONResultUtil error(String msg) {

        return new JSONResultUtil(false, msg);

    }

}

Ajax请求的错误处理器:

package cn.qlq.ExceptionHandler;

import javax.servlet.http.HttpServletRequest;

import org.springframework.web.bind.annotation.ExceptionHandler;

import org.springframework.web.bind.annotation.RestControllerAdvice;

import cn.qlq.utils.JSONResultUtil;

@RestControllerAdvice

public class AjaxExceptionHandler {

    @ExceptionHandler(value = Exception.class)

    public JSONResultUtil defaultErrorHandler(HttpServletRequest req, Exception e) throws Exception {

        e.printStackTrace();

        return JSONResultUtil.error(e.getMessage());

    }

}

测试:

前台JS:

$.ajax({

        url: "/MySpringboot/err/getAjaxerror",

        type: "POST",

        async: false,

        success: function(data) {

            if(data.success) {

                alert("success");

            } else {

                alert("发生异常：" + data.msg);

            }

        },

        error: function (response, ajaxOptions, thrownError) {

            alert("error");

        }

    });

后台制造除零异常:

    @RequestMapping("/getAjaxerror")

    @ResponseBody

    public JSONResultUtil getAjaxerror() {

        int a = 1 / 0;

        return JSONResultUtil.ok();

    }

结果:

3.一个通用的全局异常处理器

　　不管是web请求还是ajax请求都可以用它处理。内部根据是否是ajax请求返回对应的数据

package cn.qlq.ExceptionHandler;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.web.bind.annotation.ExceptionHandler;

import org.springframework.web.bind.annotation.RestControllerAdvice;

import org.springframework.web.servlet.ModelAndView;

import cn.qlq.utils.JSONResultUtil;

@RestControllerAdvice

public class MyExceptionHandler {

    public static final String ERROR_VIEW = "error";

    @ExceptionHandler(value = Exception.class)

    public Object errorHandler(HttpServletRequest reqest, HttpServletResponse response, Exception e) throws Exception {

        e.printStackTrace();

        if (isAjax(reqest)) {

            return JSONResultUtil.error(e.getMessage());

        } else {

            ModelAndView mav = new ModelAndView();

            mav.addObject("exception", e);

            mav.addObject("url", reqest.getRequestURL());

            mav.setViewName(ERROR_VIEW);

            return mav;

        }

    }

    /**

     * 根据请求头是否携带X-Requested-With参数判断是否是ajax请求

     *

     * @param httpRequest

     * @return

     */

    public static boolean isAjax(HttpServletRequest httpRequest) {

        return (httpRequest.getHeader("X-Requested-With") != null

                && "XMLHttpRequest".equals(httpRequest.getHeader("X-Requested-With").toString()));

    }

}

============整合定时任务Task===========

　　在springmvc使用的时候使用到的定时任务一般是quartz，也研究过使用过SpringTask。SpringBoot整合Task非常简单。

(1)@EnableScheduling开启task

package cn.qlq.config;

import org.springframework.context.annotation.Configuration;

import org.springframework.scheduling.annotation.EnableScheduling;

@Configuration // 通过该注解来表明该类是一个Spring的配置，相当于一个xml文件

@EnableScheduling

public class SpringTask {

}

(2)通过注解的方式使用task即可。

package cn.qlq.task;

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Component;

@Component

public class FirstAnnotationJob {

    private static int count;

    @Scheduled(fixedRate = 10000)

    public void cron() {

        try {

            Thread.sleep(2000);

        } catch (InterruptedException e) {

            System.err.println("InterruptedException " + e);

        }

        System.out.println("spring anno task execute times " + count++);

    }

}

结果:

spring anno task execute times 0
spring anno task execute times 1
spring anno task execute times 2

....

关于springTask的使用参考:https://www.cnblogs.com/qlqwjy/p/9960706.html

============整合异步任务===========

　　开启异步任务的方式比较简单。异步任务的使用场景是:发布消息、发送短信等一些异步任务上，当然异步可以用线程池实现，发送消息可以用MQ框架实现。

(1)@EnableAsync声明开启异步任务

package cn.qlq.config;

import org.springframework.context.annotation.Configuration;

import org.springframework.scheduling.annotation.EnableAsync;

import org.springframework.scheduling.annotation.EnableScheduling;

@Configuration // 通过该注解来表明该类是一个Spring的配置，相当于一个xml文件

//开启Task

@EnableScheduling

//开启异步调用方法

@EnableAsync

public class SpringTask {

}

(2)编写异步任务，@Component注入spring，异步的方法加上@Async注解即可

package cn.qlq.task;

import java.util.concurrent.Future;

import org.springframework.scheduling.annotation.Async;

import org.springframework.scheduling.annotation.AsyncResult;

import org.springframework.stereotype.Component;

@Component

public class AsyncTask {

    @Async

    public Future<Boolean> doTask11() throws Exception {

        long start = System.currentTimeMillis();

        Thread.sleep(1000);

        long end = System.currentTimeMillis();

        System.out.println("任务1耗时:" + (end - start) + "毫秒,线程名字:" + Thread.currentThread().getName());

        return new AsyncResult<>(true);

    }

    @Async

    public Future<Boolean> doTask22() throws Exception {

        long start = System.currentTimeMillis();

        Thread.sleep(700);

        long end = System.currentTimeMillis();

        System.out.println("任务2耗时:" + (end - start) + "毫秒,线程名字:" + Thread.currentThread().getName());

        return new AsyncResult<>(true);

    }

    @Async

    public Future<Boolean> doTask33() throws Exception {

        long start = System.currentTimeMillis();

        Thread.sleep(600);

        long end = System.currentTimeMillis();

        System.out.println("任务3耗时:" + (end - start) + "毫秒,线程名字:" + Thread.currentThread().getName());

        return new AsyncResult<>(true);

    }

}

(3)Controller层调用异步方法:

package cn.qlq.action;

import java.util.concurrent.Future;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import cn.qlq.task.AsyncTask;

@RestController

@RequestMapping("tasks")

public class AsyncTaskController {

    @Autowired

    private AsyncTask asyncTask;

    @RequestMapping("test1")

    public String test1() throws Exception {

        long start = System.currentTimeMillis();

        Future<Boolean> a = asyncTask.doTask11();

        Future<Boolean> b = asyncTask.doTask22();

        Future<Boolean> c = asyncTask.doTask33();

        while (!a.isDone() || !b.isDone() || !c.isDone()) {

            if (a.isDone() && b.isDone() && c.isDone()) {

                break;

            }

        }

        long end = System.currentTimeMillis();

        String times = "任务全部完成，总耗时：" + (end - start) + "毫秒";

        System.out.println(times);

        return times;

    }

}

　　上面执行asyncTask.doTaskXX的时候是异步执行的，相当于三个方法异步执行，下面的while循环直到三个方法都执行完毕。

测试:

前台访问:

后台控制台:(发现是通过多线程执行)

如果去掉上面三个异步方法的@Async注解查看结果:

前台:

后台:(单条线程执行)