Spring Cloud Zuul Filter 和熔断

转一篇很不错的关于Spring Cloud Zuul 相关用法的文章，基本包含常用的一些场景，另外附上实际项目中的熔断、打印请求日志和登录验证的实例。

原文地址：https://www.cnblogs.com/shihaiming/p/8489006.html ，作者：https://www.cnblogs.com/shihaiming/

1.服务熔断

package com.ftk.hjs.zuul.server.hystrix;

import com.alibaba.fastjson.JSON;

import com.ftk.hjs.common.WebConstants;

import com.ftk.hjs.common.common.Response;

import com.netflix.zuul.context.RequestContext;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.springframework.cloud.netflix.zuul.filters.Route;

import org.springframework.cloud.netflix.zuul.filters.RouteLocator;

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 org.springframework.web.util.UrlPathHelper;

import javax.servlet.http.HttpServletRequest;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

@Component

public class ServiceFallbackProvider implements FallbackProvider {

    private static final Logger logger = LoggerFactory.getLogger(ServiceFallbackProvider.class);

    @Autowired

    private RouteLocator routeLocator;

    @Autowired

    private UrlPathHelper urlPathHelper;

    //服务id，可以用* 或者 null 代表所有服务都过滤

    @Override

    public String getRoute() {

        return null;

    }

    @Override

    public ClientHttpResponse fallbackResponse(String route, Throwable cause) {

        return new ClientHttpResponse() {

            @Override

            public HttpStatus getStatusCode() throws IOException {

                return HttpStatus.OK; //请求网关成功了，所以是ok

            }

            @Override

            public int getRawStatusCode() throws IOException {

                return HttpStatus.OK.value();

            }

            @Override

            public String getStatusText() throws IOException {

                return HttpStatus.OK.getReasonPhrase();

            }

            @Override

            public void close() {

            }

            @Override

            public InputStream getBody() throws IOException {

                RequestContext ctx = RequestContext.getCurrentContext();

                Route route = route(ctx.getRequest());

                logger.error(" >>>触发zuul-server断溶;zuulServletContextPath={{}}", route.getLocation());

                Response response = new Response(false);

                response.setMessage(WebConstants.SYSTEM_ERROR_MESSAGE);

                return new ByteArrayInputStream(JSON.toJSONString(response).getBytes("UTF-8")); //返回前端的内容

            }

            @Override

            public HttpHeaders getHeaders() {

                HttpHeaders httpHeaders = new HttpHeaders();

                httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8); //设置头

                return httpHeaders;

            }

        };

    }

    //核心逻辑，获取请求路径，利用RouteLocator返回路由信息

    protected Route route(HttpServletRequest request) {

        String requestURI = urlPathHelper.getPathWithinApplication(request);

        return routeLocator.getMatchingRoute(requestURI);

    }

}

2.打印日志的拦截器

package com.ftk.hjs.zuul.server.filter;

import com.alibaba.fastjson.JSONObject;

import com.ftk.framework.redis.clients.collections.builder.RedisStrutureBuilder;

import com.ftk.framework.redis.clients.collections.keyValueRedisStructure;

import com.ftk.hjs.common.WebConstants;

import com.ftk.hjs.common.constant.RedisConstants;

import com.ftk.hjs.common.data.LoginUserData;

import com.ftk.hjs.common.utils.StringUtil;

import com.netflix.zuul.ZuulFilter;

import com.netflix.zuul.context.RequestContext;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;

import org.springframework.util.StreamUtils;

import javax.servlet.http.HttpServletRequest;

import java.io.IOException;

import java.io.InputStream;

import java.nio.charset.Charset;

public class PrintRequestLogFilter extends ZuulFilter {

    private static Logger log = LoggerFactory.getLogger(PrintRequestLogFilter.class);

    @Override

    public String filterType() {

        return FilterConstants.POST_TYPE;//要打印返回信息，必须得用"post"

    }

    @Override

    public int filterOrder() {

        return 1;

    }

    @Override

    public boolean shouldFilter() {

        return true;

    }

    @Override

    public Object run() {

        try {

            RequestContext ctx = RequestContext.getCurrentContext();

            HttpServletRequest request = ctx.getRequest();

            InputStream in = request.getInputStream();

            String reqBbody = StreamUtils.copyToString(in, Charset.forName("UTF-8"));

            String principal = request.getHeader(WebConstants.TOKEN_KEY);

            if (StringUtil.isNotBlank(principal)) {

                String userToken = RedisConstants.UserNP.USER_TOKEN_KEY + principal;

                keyValueRedisStructure<String> structure = RedisStrutureBuilder.ofKeyValue(String.class)

                        .withNameSpace(RedisConstants.UserNP.USER_NAMESPACE)

                        .withttl(RedisConstants.UserNP.USER_TOKEN_EXPIRE).build();

                String token = structure.get(userToken);

                if (StringUtil.isNotBlank(token)) {

                    LoginUserData userData = JSONObject.parseObject(token, LoginUserData.class);

                    log.info("request token:{} , userNum:{} , mobilePhone:{} , channelNum:{}", principal, userData.getUserNum(), userData.getMobilePhone(), userData.getChannelNum());

                }

            }

            log.info("request url:{} , requestUrl:{}", request.getMethod(), request.getRequestURL().toString());

            if (reqBbody != null) {

                log.info("request body:{}", reqBbody);

            }

            String outBody = ctx.getResponseBody();

            if (outBody != null) {

                log.info("response body:{}", outBody);

            }

            ctx.getResponse().setContentType("text/html;charset=UTF-8");

            ctx.setResponseBody(outBody);

        } catch (IOException e) {

            log.error(e.getMessage(), e);

        }

        return null;

    }

}

3.登录验证

package com.ftk.hjs.zuul.server.filter;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONObject;

import com.ftk.framework.redis.clients.collections.MapStructure;

import com.ftk.framework.redis.clients.collections.builder.RedisStrutureBuilder;

import com.ftk.framework.redis.clients.collections.keyValueRedisStructure;

import com.ftk.hjs.common.WebConstants;

import com.ftk.hjs.common.common.Request;

import com.ftk.hjs.common.common.Response;

import com.ftk.hjs.common.constant.ErrCodeConstants;

import com.ftk.hjs.common.constant.RedisConstants;

import com.ftk.hjs.common.data.LoginUserData;

import com.ftk.hjs.common.utils.StringUtil;

import com.netflix.zuul.ZuulFilter;

import com.netflix.zuul.context.RequestContext;

import com.netflix.zuul.http.ServletInputStreamWrapper;

import lombok.Data;

import lombok.ToString;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.cloud.netflix.zuul.filters.Route;

import org.springframework.cloud.netflix.zuul.filters.RouteLocator;

import org.springframework.util.AntPathMatcher;

import org.springframework.util.PathMatcher;

import org.springframework.util.StreamUtils;

import org.springframework.web.util.UrlPathHelper;

import javax.servlet.ServletInputStream;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletRequestWrapper;

import java.nio.charset.Charset;

import java.util.*;

import static com.alibaba.fastjson.JSON.parseObject;

/**

 * 登录验证

 * Created by Frank on 2016/12/8.

 */

public class LoginFilter extends ZuulFilter {

    private static Logger log = LoggerFactory.getLogger(LoginFilter.class);

    private final RouteLocator routeLocator;

    private final UrlPathHelper urlPathHelper;

    private static List<String> oldServers = new ArrayList<>();

    private static List<String> newServers = new ArrayList<>();

    private List<String> excludeSuffixs = new ArrayList<>();

    public LoginFilter(RouteLocator routeLocator, UrlPathHelper urlPathHelper) {

        this.routeLocator = routeLocator;

        this.urlPathHelper = urlPathHelper;

        oldServers.add(RedisConstants.SystemNP.SYSTEM_SERVICE_METHOD_FINANCIAL);

        oldServers.add(RedisConstants.SystemNP.SYSTEM_SERVICE_METHOD_COMMON);

        oldServers.add(RedisConstants.SystemNP.SYSTEM_SERVICE_METHOD_FUND);

        oldServers.add(RedisConstants.SystemNP.SYSTEM_SERVICE_METHOD_INSURANCE);

        newServers.add(RedisConstants.SystemNP.SYSTEM_SERVICE_METHOD_BANK);

        newServers.add(RedisConstants.SystemNP.SYSTEM_SERVICE_METHOD_MESSAGE);

        newServers.add(RedisConstants.SystemNP.SYSTEM_SERVICE_METHOD_USER);

        newServers.add(RedisConstants.SystemNP.SYSTEM_SERVICE_METHOD_ROUT);

        excludeSuffixs.addAll(Arrays.asList(".png", ".js", ".css"));

    }

    //核心逻辑，获取请求路径，利用RouteLocator返回路由信息

    protected Route route(HttpServletRequest request) {

        String requestURI = urlPathHelper.getPathWithinApplication(request);

        return routeLocator.getMatchingRoute(requestURI);

    }

    @Override

    public String filterType() {

        return "pre";

    }

    @Override

    public int filterOrder() {

        return 0;

    }

    @Override

    public boolean shouldFilter() {

        return true;

    }

    @Override

    public Object run() {

        RequestContext ctx = RequestContext.getCurrentContext();

        HttpServletRequest request = ctx.getRequest();

        String userNum = null;

        String body = "";

        String principal = request.getHeader(WebConstants.TOKEN_KEY);

        String osTypeKey = request.getHeader(WebConstants.OSTYPE_KEY);

        String channelNum = request.getHeader(WebConstants.CHANNEL_NUM);

        ctx.addZuulRequestHeader(WebConstants.OSTYPE_KEY, osTypeKey);

        ctx.addZuulRequestHeader(WebConstants.CHANNEL_NUM, channelNum);

        try {

            body = StreamUtils.copyToString(request.getInputStream(), Charset.forName("UTF-8"));

//            log.info(">>> zuul LoginFilter body={}", body);

            if(StringUtil.isBlank(principal)){

                principal = request.getParameter(WebConstants.TOKEN_KEY);

            }

            if (StringUtil.isNotBlank(principal)) {

                String userToken = RedisConstants.UserNP.USER_TOKEN_KEY + principal;

                //如果用户token为空,则肯定是没有登录

                if (StringUtil.isBlank(userToken)) {

                    return null;

                }

                keyValueRedisStructure<String> structure = RedisStrutureBuilder.ofKeyValue(String.class)

                        .withNameSpace(RedisConstants.UserNP.USER_NAMESPACE)

                        .withttl(RedisConstants.UserNP.USER_TOKEN_EXPIRE).build();

                String token = structure.get(userToken);

                if (StringUtil.isNotBlank(token)) {

                    LoginUserData userData = JSONObject.parseObject(token, LoginUserData.class);

                    if (userData != null) {

                        userNum = userData.getUserNum();

                        channelNum = userData.getChannelNum();

                        //延长用户token登录时间

                        structure.set(userToken, token);

                        ctx.addZuulRequestHeader(WebConstants.USER_NUM, userNum);

                        ctx.addZuulRequestHeader(WebConstants.CHANNEL_NUM, channelNum);

                        JSONObject jsonObject = new JSONObject();

                        if (!StringUtil.isEmpty(body)) {

                            jsonObject = JSONObject.parseObject(body);

                        }

                        jsonObject.put("userNum", userNum);

                        request.setAttribute("userNum", userNum);

                        final byte[] reqBodyBytes = jsonObject.toJSONString().getBytes();

                        ctx.setRequest(new HttpServletRequestWrapper(request) {

                            @Override

                            public ServletInputStream getInputStream() {

                                return new ServletInputStreamWrapper(reqBodyBytes);

                            }

                            @Override

                            public int getContentLength() {

                                return reqBodyBytes.length;

                            }

                            @Override

                            public long getContentLengthLong() {

                                return reqBodyBytes.length;

                            }

                        });

                    }

                }

            }

//            log.info(" >>> gateWay url={}, userTokenKey={}, userNum={}", request.getRequestURI(), principal, userNum);

            Route route = route(ctx.getRequest());

            String requestURI = request.getRequestURI();

            String zuulServletContextPath = route.getLocation().replace("-server", "");

            //验证接口是否需要登录

            MapStructure<Boolean> structure = RedisStrutureBuilder.ofMap(Boolean.class).withNameSpace(RedisConstants.SystemNP.SYSTEM_NAMESPACE).build();

            Map<String, Boolean> serviceMethod = structure.get(RedisConstants.SystemNP.SYSTEM_SERVICE_METHOD.concat(zuulServletContextPath));

            NeedLoginBean needLoginBean = adaptServiceMethod(requestURI, body, serviceMethod, zuulServletContextPath);

            log.info(">>> zuul LoginFilter needLoginBean={}", needLoginBean);

            //static 静态资源不进行接口验证

            for (String suffix : excludeSuffixs) {

                if (requestURI.endsWith(suffix)) {

                    return null;

                }

            }

            //选判断此接口是否存在zuul网关中

            if (!needLoginBean.isHasMethod()) {

                log.error(">>> 未知接口。requestType={}", requestURI);

                ctx.setSendZuulResponse(false); //不进行路由

                ctx.getResponse().setContentType("text/html;charset=UTF-8");

                Response response = new Response(needLoginBean.getRequestURI(), false);

                response.setMessage(WebConstants.SYSTEM_ERROR_MESSAGE);

                ctx.setResponseBody(JSON.toJSONString(response));

                return null;

            }

            boolean needLogin = needLoginBean.needLogin;

            if (needLogin && StringUtil.isBlank(userNum)) {

                log.error(">>> 当前接口需要登录,请先登录。requestType={}", requestURI);

                ctx.setSendZuulResponse(false); //不进行路由

                ctx.getResponse().setContentType("text/html;charset=UTF-8");

                Response response = new Response(needLoginBean.getRequestURI(), false);

                response.setErrorCode(ErrCodeConstants.NEED_LOGIN.getCode());

                response.setMessage(ErrCodeConstants.NEED_LOGIN.getMessage());

                ctx.setResponseBody(JSON.toJSONString(response));

            }

        } catch ( Exception e) {

            log.error(e.getMessage(), e);

            ctx.setSendZuulResponse(false);

            ctx.setResponseStatusCode(401);

            Response response = new Response(request.getRequestURI(), false);

            response.setMessage(WebConstants.SYSTEM_ERROR_MESSAGE);

            ctx.setResponseBody(JSON.toJSONString(response));

            ctx.getResponse().setContentType("text/html;charset=UTF-8");

        }

        return null;

    }

    public NeedLoginBean adaptServiceMethod(String requestURI, String req, Map<String, Boolean> serviceMethod, String zuulServletContextPath) {

        NeedLoginBean needLoginBean = new NeedLoginBean();//兼容老的服务调用方式

        if (oldServers.contains(zuulServletContextPath)) {

            Request bizRequest = parseObject(req, Request.class);

            needLoginBean.setRequestURI(bizRequest.getRequestType());

            Boolean needLogin = serviceMethod.get(bizRequest.getRequestType());

            if (needLogin == null) {

                //false说明此接口不在网关注册接口范围内

                needLoginBean.setHasMethod(false);

            } else {

                needLoginBean.setHasMethod(true);

                needLoginBean.setNeedLogin(needLogin);

            }

        } else if (newServers.contains(zuulServletContextPath)) {

            needLoginBean.setRequestURI(requestURI);

            //false说明此接口不在网关注册接口范围内

            PathMatcher matcher = new AntPathMatcher();

            Iterator it = serviceMethod.keySet().iterator();

            while (it.hasNext()) {

                String key = (String) it.next();

                boolean result = matcher.match(key, requestURI);

                if (result) {

                    needLoginBean.setHasMethod(true);

                    needLoginBean.setNeedLogin(serviceMethod.get(key));

                    break;

                }

            }

        } else {

            throw new RuntimeException(" >>>请求接口不存在");

        }

        return needLoginBean;

    }

    @ToString

    @Data

    private static class NeedLoginBean {

        String requestURI;

        boolean hasMethod;

        boolean needLogin;

    }

}

3.启动类

package com.ftk.hjs.zuul.server;

import com.ftk.framework.redis.clients.collections.factory.RedisConfig;

import com.ftk.framework.redis.clients.collections.factory.RedisConnection;

import com.ftk.hjs.zuul.server.filter.LoginFilter;

import com.ftk.hjs.zuul.server.filter.PrintRequestLogFilter;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.springframework.boot.CommandLineRunner;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cloud.client.SpringCloudApplication;

import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

import org.springframework.cloud.netflix.zuul.filters.RouteLocator;

import org.springframework.cloud.openfeign.EnableFeignClients;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.web.cors.CorsConfiguration;

import org.springframework.web.cors.UrlBasedCorsConfigurationSource;

import org.springframework.web.filter.CorsFilter;

import org.springframework.web.util.UrlPathHelper;

import java.util.ArrayList;

import java.util.List;

@SpringBootApplication

@EnableZuulProxy

@EnableEurekaClient

@SpringCloudApplication

@EnableFeignClients

@ComponentScan(basePackages = {"com.ftk.hjs","com.ftk.framework"})

public class ZuulServerLauncher implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(ZuulServerLauncher.class);

    @Autowired

    private RedisConfig redisConfig;

    public static void main(String[] args) {

        SpringApplication.run(ZuulServerLauncher.class, args);

    }

    @Override

    public void run(String... strings){

        //初始化redis

//        RedisConnection.init(redisConfig);

        logger.info("ZuulServerLauncher has run !!! {} ", strings);

    }

    @Bean

    public LoginFilter accessFilter(RouteLocator routeLocator) {

        return new LoginFilter(routeLocator,new UrlPathHelper());

    }

    @Bean

    public PrintRequestLogFilter printRequestLogFilter() {

        return new PrintRequestLogFilter();

    }

    private CorsConfiguration addcorsConfig() {

        CorsConfiguration corsConfiguration = new CorsConfiguration();

        List<String> list = new ArrayList<>();

        list.add("*");

        corsConfiguration.setAllowedOrigins(list);

        /*

        // 请求常用的三种配置，*代表允许所有，当时你也可以自定义属性（比如header只能带什么，只能是post方式等等）

        */

        corsConfiguration.addAllowedOrigin("*");

        corsConfiguration.addAllowedHeader("*");

        corsConfiguration.addAllowedMethod("*");

        corsConfiguration.setMaxAge(3600L);

        corsConfiguration.setAllowCredentials(true);

        return corsConfiguration;

    }

    @Bean

    public CorsFilter corsFilter() {

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();

        source.registerCorsConfiguration("/**", addcorsConfig());

        return new CorsFilter(source);

    }

}

最后，以上代码均为部分代码，参照转载文章的说明和实例即可实现自己的网关功能。