SpringCloud-技术专区-Gateway优雅的处理Filter抛出的异常__springcloud gateway filter

需要重写的方法

@Slf4j
public class GlobalExceptionHandler extends DefaultErrorWebExceptionHandler {
    public GlobalExceptionHandler(ErrorAttributes errorAttributes, ResourceProperties resourceProperties, ErrorProperties errorProperties, ApplicationContext applicationContext) {
        super(errorAttributes, resourceProperties, errorProperties, applicationContext);
    @Override
    protected Map<String, Object> getErrorAttributes(ServerRequest request, boolean includeStackTrace) {
        Throwable error = super.getError(request);
       // todo 添加自己处理异常的逻辑
        return null;
    // 指定响应处理方法为JSON处理的方法
    @Override
    protected RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes) {
        return RouterFunctions.route(RequestPredicates.all(), this::renderErrorResponse);
    //设置返回状态码，由于我的返回json里面已经包含状态码了，不用这里的状态码，所以这里直接设置200即可
    @Override
    protected HttpStatus getHttpStatus(Map<String, Object> errorAttributes) {
        return HttpStatus.valueOf(200);
配置类替换成自己的处理异常类
@Configuration
@EnableConfigurationProperties({ServerProperties.class, ResourceProperties.class})
public class ErrorHandlerConfiguration {
    private final ServerProperties serverProperties;
    private final ApplicationContext applicationContext;
    private final ResourceProperties resourceProperties;
    private final List<ViewResolver> viewResolvers;
    private final ServerCodecConfigurer serverCodecConfigurer;
    public ErrorHandlerConfiguration(ServerProperties serverProperties,
                                     ResourceProperties resourceProperties,
                                     ObjectProvider<List<ViewResolver>> viewResolversProvider,
                                     ServerCodecConfigurer serverCodecConfigurer,
                                     ApplicationContext applicationContext) {
        this.serverProperties = serverProperties;
        this.applicationContext = applicationContext;
        this.resourceProperties = resourceProperties;
        this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
        this.serverCodecConfigurer = serverCodecConfigurer;
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public ErrorWebExceptionHandler errorWebExceptionHandler(ErrorAttributes errorAttributes) {
        GlobalExceptionHandler exceptionHandler = new GlobalExceptionHandler(
                errorAttributes,
                this.resourceProperties,
                this.serverProperties.getError(),
                this.applicationContext);
        exceptionHandler.setViewResolvers(this.viewResolvers);
        exceptionHandler.setMessageWriters(this.serverCodecConfigurer.getWriters());
        exceptionHandler.setMessageReaders(this.serverCodecConfigurer.getReaders());
        return exceptionHandler;
    这样我们就将统一异常处理指向了我们自己写的处理类了，剩下的就是具体的处理逻辑。
     因为我们想延用SpringMVC处理异常的注解，所以我们需要解析SpringMVC的注解，然后做一些相应的逻辑处理即可。具体的思路是这样的。
获取Spring容器中所有的类上标注@RestControllerAdvice注解的所有实例
获取实例里面所有标注@ExceptionHandler的方法。
创建一个map,key是注解中的value（处理异常的类型），value是方法。这样我们就将我们可以处理的异常和处理异常的方法关联起来了。
解决异常时，先获取异常的class和他所有的父类class。依次遍历map，直到找到第一个对应的处理方法，然后通过反射调用该方法。
@Slf4j
@Configuration
public class ExceptionHandlerCore implements ApplicationRunner {
     * key是处理异常的类型
     * value是处理异常的方法
    private HashMap<Class<? extends Throwable>, Node> exceptionHandlerMap;
     * 解析类上的注解
     * 将处理异常的方法注册到map中
    private void register(Object exceptionAdvice) {
        Method[] methods = exceptionAdvice.getClass().getMethods();
        Arrays.stream(methods).forEach(method -> {
            ExceptionHandler exceptionHandler = method.getAnnotation(ExceptionHandler.class);
            if (Objects.isNull(exceptionHandler)) {
                return;
            Arrays.asList(exceptionHandler.value()).forEach(a -> exceptionHandlerMap.put(a, new Node(method, exceptionAdvice)));
     * 根据异常对象获取解决异常的方法
     * @param throwable 异常对象
     * @return handler method
    private Node getHandlerExceptionMethodNode(Throwable throwable) {
        ArrayList<Class<?>> superClass = this.getSuperClass(throwable.getClass());
        for (Class<?> aClass : superClass) {
            Node handlerNode = null;
            if ((handlerNode = exceptionHandlerMap.get(aClass)) != null) {
                return handlerNode;
        return null;
    @Override
    public void run(ApplicationArguments args) throws Exception {
        exceptionHandlerMap = new HashMap<>();
        log.info("-------------异常处理容器内存分配完毕-------------");
        Map<String, Object> beans = SpringContextHolder.getBeansWithAnnotation(RestControllerAdvice.class);
        log.info("-------------异常处理对象获取完毕-------------");
        beans.keySet()
                .stream()
                .map(beans::get)
                .forEach(this::register);
        log.info("-------------异常处理方法注册完毕-------------");
     * 对外暴露的处理异常的方法
     * @param throwable 处理的异常
     * @return 调用异常后的返回值
    public Object handlerException(Throwable throwable) {
        Node exceptionMethodNode = this.getHandlerExceptionMethodNode(throwable);
        if (Objects.isNull(exceptionMethodNode)) {
            throw new RuntimeException("没有处理异常的方法");
        Object returnResult = null;
        try {
            returnResult = exceptionMethodNode.method.invoke(exceptionMethodNode.thisObj, throwable);
        } catch (IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        return returnResult;
     * 用于存放方法和方法所在的实例
    private static class Node {
        Node(Method method, Object thisObj) {
            this.method = method;
            this.thisObj = thisObj;
        Method method;
        Object thisObj;
     * 获取该类的class以及所有父的class
     * @param clazz this.class
     * @return list
    public ArrayList<Class<?>> getSuperClass(Class<?> clazz) {
        ArrayList<Class<?>> classes = new ArrayList<>();
        classes.add(clazz);
        Class<?> suCl = clazz.getSuperclass();
        while (suCl != null) {
            classes.add(suCl);
            suCl = suCl.getSuperclass();
        return classes;
    @Override
    @SuppressWarnings(value = "unchecked")
    protected Map<String, Object> getErrorAttributes(ServerRequest request, boolean includeStackTrace) {
        Throwable error = super.getError(request);
        //调用处理异常的方法，并将对象转换成map
        Object o = handlerCore.handlerException(error);
        String json = JsonHelper.objectToJson(o);
        return JsonHelper.jsonToObject(json, HashMap.class);
   // ...
    public static String toPrettyFormat(String json) {
        JsonParser jsonParser = new JsonParser();
        JsonObject jsonObject = jsonParser.parse(json).getAsJsonObject();
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        return gson.toJson(jsonObject);
     * Json转换成对象
     * @param json json string
     * @param <T> 对象类型
     * @return T
    public static  <T> T jsonToObject(String json,Class<T> t){
        Gson gson = new Gson();
        return gson.fromJson(json,t);
     * 对象转换成Json字符串
     * @param object obj
     * @return json string
    public static String objectToJson(Object object){
        Gson gson = new Gson();
        return gson.toJson(object);
public class SpringContextHolder implements ApplicationContextAware {
    private static ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringContextHolder.applicationContext = applicationContext;
    public static ApplicationContext getApplicationContext() {
        assertApplicationContext();
        return applicationContext;
    public static <T> T getBean(Class<T> requiredType) {
        assertApplicationContext();
        return applicationContext.getBean(requiredType);
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String beanName) {
        assertApplicationContext();
        return (T) applicationContext.getBean(beanName);
     * 通过类上的注解获取类
     * @param annotation anno
     * @return map
    public static Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotation) {
        assertApplicationContext();
        return applicationContext.getBeansWithAnnotation(annotation);
    private static void assertApplicationContext() {
        if (SpringContextHolder.applicationContext == null) {
            throw new RuntimeException("application Context属性为null,请检查是否注入了SpringContextHolder!");