Spring Cloud Zuul统一异常处理

谁践踏了优雅 2023-07-12 14:45 38阅读 0赞

一、[在zuul的errorfilter中处理][zuul_errorfilter]（我使用的这种）

package com.mortals.iot.module.common.interceptor;
    
    import com.alibaba.fastjson.JSONObject;
    import com.mortals.iot.framework.config.InterceptorConfig;
    import com.mortals.iot.module.login.service.UserCookieInfo;
    import com.mortals.iot.module.login.service.UserCookieService;
    import com.mortals.iot.module.system.operLog.service.OperLogService;
    import com.netflix.zuul.ZuulFilter;
    import com.netflix.zuul.context.RequestContext;
    import com.netflix.zuul.exception.ZuulException;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;
    import org.springframework.stereotype.Component;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.PrintWriter;
    
    @Component
    public class ZuulErrorFilter extends ZuulFilter {
    
    
        private static Logger logger = LoggerFactory.getLogger(ZuulErrorFilter.class);
    
    
        @Autowired
        private OperLogService operLogService;
    
        @Autowired
        private InterceptorConfig config;
    
        @Override
        public String filterType() {
            return FilterConstants.ERROR_TYPE;
        }
    
        @Override
        public int filterOrder() {
            //需要在默认的 SendErrorFilter 之前
            return -1;
        }
    
        @Override
        public boolean shouldFilter() {
            // 只有在抛出异常时才会进行拦截
            return RequestContext.getCurrentContext().containsKey("throwable");
        }
    
        @Override
        public Object run() {
            try {
                RequestContext requestContext = RequestContext.getCurrentContext();
                Object e = requestContext.get("throwable");
                if (e != null && e instanceof ZuulException) {
    //                ZuulException zuulException = (ZuulException) e;
                    // 删除该异常信息,不然在下一个过滤器中还会被执行处理
                    requestContext.remove("throwable");
    
                    //响应信息
                    HttpServletResponse response = requestContext.getResponse();
                    response.setHeader("Content-type", "application/json;charset=UTF-8");
                    response.setCharacterEncoding("UTF-8");
                    int status = response.getStatus();
    
    
                    //数据库-记录操作日志
                    HttpServletRequest request = requestContext.getRequest();
                    UserCookieInfo cookie = UserCookieService.getLoginCookie(request, config.getSecurityKey());
                    logger.error("用户：{}，接口：{}；异常信息：{}",cookie.getUser().getLoginName(),request.getRequestURI(),((ZuulException) e).getMessage());
                    operLogService.saveOperLog(request, cookie.getUser(), "接口异常", null);
    
                    // 响应给客户端信息
                    PrintWriter pw = null;
                    pw = response.getWriter();
                    JSONObject ret = new JSONObject();
                    ret.put("code", -1);
                    if (status == 504) {
                        ret.put("msg", "请求超时，请稍后再试。");
                    } else {
                        ret.put("msg", "服务异常或升级中，请联系管理员。");
                    }
                    pw.write(ret.toJSONString());
                    pw.close();
                }
            } catch (Exception ex) {
                logger.error("请求路由异常：", ex);
            }
    
            return null;
        }
    }

二、[zuul会抛ZuulException，然后转发路径为/error的Controller][zuul_ZuulException_error_Controller]；（作为替补）

import com.alibaba.fastjson.JSONObject;
    import com.mortals.iot.framework.config.InterceptorConfig;
    import com.mortals.iot.module.login.service.UserCookieInfo;
    import com.mortals.iot.module.login.service.UserCookieService;
    import com.mortals.iot.module.system.operLog.service.OperLogService;
    import com.netflix.client.ClientException;
    import com.netflix.zuul.exception.ZuulException;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.web.servlet.error.ErrorController;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.servlet.http.HttpServletRequest;
    
    /**
     * @Description Zuul全局错误信息封装（路由失败，子服务异常）
     * @Author gg
     * @Date 2020/2/20 15:23
     * @Version 1.0
     */
    @RestController
    public class ZuulGlobalException implements ErrorController {
    
    
        private static Logger logger = LoggerFactory.getLogger(ZuulGlobalException.class);
    
        private static final String ERROR_PATH = "/error";
    
    
        @Autowired
        private OperLogService operLogService;
    
        @Autowired
        private InterceptorConfig config;
    
        @Override
        public String getErrorPath() {
            return ERROR_PATH;
        }
    
        @RequestMapping(value = ERROR_PATH)
        @ExceptionHandler(value = {ZuulException.class, ClientException.class})
        public String zuulRrror(HttpServletRequest request, final Exception e) {
            JSONObject result = new JSONObject();
    
            Integer code = (Integer) request.getAttribute("javax.servlet.error.status_code");
            Exception exception = (Exception) request.getAttribute("javax.servlet.error.exception");
    
    
    //        logger.error("异常信息code:"+code);
            //记录数据库操作日志
            UserCookieInfo cookie = UserCookieService.getLoginCookie(request, config.getSecurityKey());
    
            String errorMsg = "接口访问异常：用户：" + cookie.getUser().getLoginName()+"；异常信息msg:"+exception.getMessage();
            logger.error(errorMsg);
    
            operLogService.saveOperLog(request, cookie.getUser(), errorMsg, null);
    
            result.put("code", "-1");
            result.put("msg", "请求失败，服务异常!请联系管理员或稍后再试");
            return result.toJSONString();
        }
    
    
    }

三、FallbackProvider统一封装处理（暂未使用）

package com.mortals.iot.module.common.interceptor;
    
    import com.alibaba.fastjson.JSONObject;
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.springframework.cloud.netflix.zuul.filters.route.FallbackProvider;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.MediaType;
    import org.springframework.http.client.ClientHttpResponse;
    import org.springframework.stereotype.Component;
    
    import java.io.ByteArrayInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.nio.charset.Charset;
    
    /**
     * @Description 微服务不可以，统一反馈
     * TODO 说明：为了记录日志，让zuul自己抛异常，转发给/error处理
     * @Author hgg
     * @Date 2020/3/9 15:23
     * @Version 1.0
     */
    @Component
    public class UserFallbackProvider implements FallbackProvider {
    
      private static Log logger = LogFactory.getLog(UserFallbackProvider.class);
    
      @Override
      public String getRoute() {
        // 表明是为哪个微服务提供回退,如果需要所有调用都支持回退，则return "*"或return null
        return "*";
      }
    
      @Override
      public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
        logger.error("路由回退："+route+"；"+cause.getMessage());
        return new ClientHttpResponse() {
          @Override
          public HttpStatus getStatusCode() throws IOException {
            // fallback时的状态码
            return HttpStatus.OK;
          }
     
          @Override
          public int getRawStatusCode() throws IOException {
            // 数字类型的状态码，本例返回的其实就是200，详见HttpStatus
            return this.getStatusCode().value();
          }
     
          @Override
          public String getStatusText() throws IOException {
            // 状态文本，本例返回的其实就是OK，详见HttpStatus
            JSONObject ret = new JSONObject();
            ret.put("code", -1);
            //请求失败，服务异常!请联系管理员或稍后再试
            ret.put("msg", "服务异常或升级中，请稍后再试。");
            return ret.toJSONString();
          }
     
          @Override
          public void close() {
          }
    
          /**
           * 封装统一响应
           * @return
           * @throws IOException
           */
          @Override
          public InputStream getBody() throws IOException {
            logger.info(route+"服务异常，调用失败");
            return new ByteArrayInputStream(getStatusText().getBytes());
            // 响应体
    //        return new ByteArrayInputStream("用户微服务不可用，请稍后再试。".getBytes());
          }
     
          @Override
          public HttpHeaders getHeaders() {
            // headers设定
            HttpHeaders headers = new HttpHeaders();
            MediaType mt = new MediaType("application","json", Charset.forName("UTF-8"));
            headers.setContentType(mt);
            return headers;
          }
        };
      }
    }

推荐文章一：[zuul统一异常处理][zuul]

[zuul_errorfilter]: https://blog.csdn.net/DearLC/article/details/102916468
[zuul_ZuulException_error_Controller]: https://blog.csdn.net/chengsu9797/article/details/100702401
[zuul]: https://www.cnblogs.com/duanxz/p/7543040.html