springboot全局异常处理方式@ControllerAdvice和@ExceptionHandler

import lombok.extern.slf4j.slf4j;
import org.springframework.util.stringutils;
import org.springframework.validation.bindexception;
import org.springframework.validation.bindingresult;
import org.springframework.validation.fielderror;
import org.springframework.web.bind.methodargumentnotvalidexception;
import org.springframework.web.bind.annotation.controlleradvice;
import org.springframework.web.bind.annotation.exceptionhandler;
import org.springframework.web.bind.annotation.responsebody;

@slf4j
@responsebody
@controlleradvice
public class globalexception {

	/**
	 * 系统异常处理
	 *
	 * @param ex 异常
	 * @return
	 */
	@exceptionhandler(value = throwable.class)
	public result defaulterrorhandler(exception ex) {
		log.error("系统异常:{}", ex);
		return result.error(statusenum.system_error);
	}

	/**
	 * bindexception
	 *
	 * @param e 异常
	 * @return
	 */
	@exceptionhandler(bindexception.class)
	public result handlebingexception(bindexception e) {
		fielderror fielderror = e.getfielderror();
		string message = fielderror.getdefaultmessage();
		return result.error(statusenum.system_error);
	}

	/**
	 * 处理 @requestbody参数校验异常
	 *
	 * @param e 异常信息
	 * @return
	 */
	@exceptionhandler(methodargumentnotvalidexception.class)
	public result handlemethodargumentnotvalidexception(methodargumentnotvalidexception e) {
		bindingresult bindingresult = e.getbindingresult();
		fielderror fielderror = bindingresult.getfielderror();
		string code = fielderror.getcode();
		string message = fielderror.getdefaultmessage();
		return result.error(errorcode, message);
	}
}

@data
public class result<t> {

	/**
	 * 状态值
	 */
	private boolean status;

	/**
	 * 状态码
	 */
	private string code;

	/**
	 * 状态信息
	 */
	private string message;

	/**
	 * 返回的结果
	 */
	private t result;

	/**
	 * 构造函数
	 *
	 * @param code    状态码
	 * @param message 提示信息
	 */
	public result(string code, string message) {
		this.status = false;
		this.code = code;
		this.message = message;
	}

	/**
	 * 构造函数
	 *
	 * @param status  状态
	 * @param code    状态码
	 * @param message 提示信息
	 */
	public result(boolean status, string code, string message) {
		this.status = status;
		this.code = code;
		this.message = message;
	}

	/**
	 * 构造函数
	 *
	 * @param status  状态
	 * @param code    状态码
	 * @param message 提示信息
	 * @param result  结果
	 */
	public result(boolean status, string code, string message, t result) {
		this.status = status;
		this.code = code;
		this.message = message;
		this.result = result;
	}

	// --------- 静态方法 ----------

	/**
	 * 枚举的状态码
	 */
	private static final string code;

	/**
	 * 枚举的提示信息
	 */
	private static final string message;

	/**
	 * 500
	 */
	private static final string error_code;

	/**
	 * 成功返回的状态码
	 */
	private static final string success_code;

	/**
	 * 成功返回的状态信息
	 */
	private static final string success_msg;

	/**
	 * 静态代码块初始化
	 */
	static {
		// 成功返回的状态码
		code = "getcode";
		// 枚举的提示信息
		message = "getmessage";
		// 异常码
		error_code = "500";
		// 成功返回的状态码
		success_code = "200";
		// 成功返回的状态信息
		success_msg = "操作成功";
	}

	/**
	 * 操作成功
	 *
	 * @return 返回结果
	 */
	public static result success() {
		return new result(true, success_code, success_msg);
	}

	/**
	 * 操作成功
	 *
	 * @return 返回结果
	 */
	public static <t> result success(t result) {
		return new result(true, success_code, success_msg, result);
	}

	/**
	 * 返回异常的
	 *
	 * @param t   泛型枚举
	 * @param <t> 泛型
	 * @return 返回 result
	 */
	public static <t extends enum> result error(t t) {
		return error(t, code, message, null);
	}

	/**
	 * 返回异常的
	 *
	 * @param t       泛型枚举
	 * @param message 提示信息
	 * @param <t>     泛型
	 * @return 返回 result
	 */
	public static <t extends enum> result error(t t, string message) {
		return error(t, code, message, message);
	}

	/**
	 * 返回异常的
	 *
	 * @param code 状态码
	 * @return 返回 result
	 */
	public static result error(string code) {
		return new result(code, null);
	}

	/**
	 * 返回异常的
	 *
	 * @param code    状态码
	 * @param message 提示信息
	 * @return 返回 result
	 */
	public static result error(string code, string message) {
		return new result(code, message);
	}

	/**
	 * 返回异常的
	 *
	 * @param t          返回的枚举
	 * @param codemethod 状态的方法
	 * @param msgmethod  提示信息的状态码
	 * @param <t>        泛型
	 * @return 返回 result 对象
	 */
	public static <t extends enum> result error(t t, string codemethod, string msgmethod, string message) {
		try {
			class<?> aclass = t.getclass();
			string code = aclass.getmethod(codemethod).invoke(t).tostring();
			message = stringutils.isempty(message) ? aclass.getmethod(msgmethod).invoke(t).tostring() : message;
			return new result(code, message);
		} catch (exception e) {
			return new result(error_code, e.getmessage());
		}
	}

	// ---- 重写的方法 ----

	/**
	 * 重写 tostring 方法
	 *
	 * @return 返回json字符串
	 */
	@override
	public string tostring() {
		return json.tojsonstring(this);
	}

	/**
	 * tojsonstring 方法
	 *
	 * @return 返回json字符串
	 */
	public string tojsonstring() {
		return json.tojsonstring(this);
	}
}

public enum statusenum {

	/**
	 * 操作成功
	 */
	ok("200", "操作成功"),

	/**
	 * 没有访问权限
	 */
	not_permission("403", "没有访问权限"),

	/**
	 * 没有登录或者登录已经过期
	 */
	not_login("405", "没有登录或者登录已经过期"),

	/**
	 * 系统繁忙，请稍后再试
	 */
	system_error("500", "系统繁忙，请稍后再试");

	/**
	 * 构造函数
	 *
	 * @param code    状态码
	 * @param message 提示信息
	 */
	statusenum(string code, string message) {
		this.code = code;
		this.message = message;
	}

	/**
	 * 状态码
	 */
	private string code;

	/**
	 * 提示信息
	 */
	private string message;

	/**
	 * 获取 状态码
	 *
	 * @return 状态码
	 */
	public string getcode() {
		return code;
	}

	/**
	 * 获取 提示信息
	 *
	 * @return 提示信息
	 */
	public string getmessage() {
		return message;
	}
}