SpringBoot全局异常处理之Web与RPC接口差异化兜底方案(微服务全覆盖)

import lombok.data;
/**
 * 全局统一响应体
 */
@data
public class result<t> {
    private integer code;
    private string msg;
    private t data;
    public static <t> result<t> success(t data) {
        result<t> result = new result<>();
        result.setcode(200);
        result.setmsg("操作成功");
        result.setdata(data);
        return result;
    }
    public static <t> result<t> success() {
        return success(null);
    }
    public static <t> result<t> error(integer code, string msg) {
        result<t> result = new result<>();
        result.setcode(code);
        result.setmsg(msg);
        return result;
    }
}

import lombok.allargsconstructor;
import lombok.getter;
/**
 * 全局统一错误码
 */
@getter
@allargsconstructor
public enum errorcodeenum {
    system_error(500, "系统内部异常，请稍后重试"),
    param_error(400, "请求参数非法"),
    auth_error(401, "登录认证失败"),
    permission_error(403, "权限不足"),
    user_not_exist(1001, "用户不存在"),
    password_error(1002, "密码错误"),
    balance_not_enough(1003, "账户余额不足");
    private final integer code;
    private final string msg;
}

import lombok.data;
/**
 * 自定义业务异常（web/rpc通用）
 */
@data
public class businessexception extends runtimeexception {
    private integer code;
    private string msg;
    public businessexception(errorcodeenum errorcode) {
        super(errorcode.getmsg());
        this.code = errorcode.getcode();
        this.msg = errorcode.getmsg();
    }
    public businessexception(integer code, string msg) {
        super(msg);
        this.code = code;
        this.msg = msg;
    }
}

import java.lang.annotation.*;
/**
 * 标记rpc服务接口
 * 被该注解标记的接口，执行rpc异常透传逻辑
 */
@target({elementtype.type, elementtype.method})
@retention(retentionpolicy.runtime)
@documented
public @interface rpcapi {
}

import lombok.extern.slf4j.slf4j;
import org.springframework.validation.bindexception;
import org.springframework.validation.fielderror;
import org.springframework.web.bind.methodargumentnotvalidexception;
import org.springframework.web.bind.annotation.exceptionhandler;
import org.springframework.web.bind.annotation.restcontrolleradvice;
import org.springframework.web.method.handlermethod;
import javax.servlet.http.httpservletrequest;
/**
 * 微服务全局异常处理器
 * 差异化处理：web接口友好兜底、rpc接口异常透传
 */
@slf4j
@restcontrolleradvice
public class globalexceptionhandler {
    /**
     * 判断当前是否为rpc接口请求
     */
    private boolean isrpcapi(handlermethod handlermethod) {
        if (handlermethod == null) {
            return false;
        }
        // 方法或类标记@rpcapi注解则判定为rpc接口
        return handlermethod.hasmethodannotation(rpcapi.class)
                || handlermethod.getbeantype().isannotationpresent(rpcapi.class);
    }
    // 1、自定义业务异常差异化处理
    @exceptionhandler(businessexception.class)
    public result<void> businessexceptionhandler(httpservletrequest request, handlermethod handlermethod, businessexception e) {
        // rpc接口：error日志、透传详情，不屏蔽信息
        if (isrpcapi(handlermethod)) {
            log.error("【rpc业务异常】code:{}, msg:{}", e.getcode(), e.getmsg());
            throw e;
        }
        // web接口：warn日志、友好提示
        log.warn("【web业务异常】code:{}, msg:{}", e.getcode(), e.getmsg());
        return result.error(e.getcode(), e.getmsg());
    }
    // 2、参数校验异常差异化处理
    @exceptionhandler(methodargumentnotvalidexception.class)
    public result<void> validexceptionhandler(httpservletrequest request, handlermethod handlermethod, methodargumentnotvalidexception e) {
        fielderror fielderror = e.getbindingresult().getfielderror();
        string msg = fielderror != null ? fielderror.getdefaultmessage() : "参数非法";
        if (isrpcapi(handlermethod)) {
            log.error("【rpc参数异常】{}", msg);
            throw new businessexception(errorcodeenum.param_error.getcode(), msg);
        }
        log.warn("【web参数异常】{}", msg);
        return result.error(errorcodeenum.param_error.getcode(), msg);
    }
    // 3、空指针系统异常差异化处理
    @exceptionhandler(nullpointerexception.class)
    public result<void> nullexceptionhandler(httpservletrequest request, handlermethod handlermethod, nullpointerexception e) {
        if (isrpcapi(handlermethod)) {
            log.error("【rpc系统异常-空指针】", e);
            throw e;
        }
        log.error("【web系统异常-空指针】", e);
        return result.error(errorcodeenum.system_error.getcode(), "数据加载异常，操作失败");
    }
    // 4、全局未知异常兜底
    @exceptionhandler(exception.class)
    public result<void> exceptionhandler(httpservletrequest request, handlermethod handlermethod, exception e) {
        // rpc接口不兜底，原样抛出保证链路透传
        if (isrpcapi(handlermethod)) {
            log.error("【rpc未知异常】", e);
            throw new businessexception(errorcodeenum.system_error);
        }
        // web接口统一友好兜底
        log.error("【web未知系统异常】", e);
        return result.error(errorcodeenum.system_error.getcode(), "系统繁忙，请稍后重试");
    }
}

/**
 * web接口：对外前端，友好兜底
 */
@restcontroller
@requestmapping("/web/user")
public class userwebcontroller {
    @getmapping("/login")
    public result<string> login(string username) {
        if (username == null) {
            throw new businessexception(errorcodeenum.param_error);
        }
        return result.success("登录成功");
    }
}
/**
 * rpc接口：对内服务调用，异常透传
 */
@restcontroller
@requestmapping("/rpc/user")
@rpcapi
public class userrpccontroller {
    @getmapping("/getbyid")
    public result<string> getuserbyid(long id) {
        if (id == null) {
            throw new businessexception(errorcodeenum.param_error);
        }
        return result.success("用户信息");
    }
}