SpringBoot2.1+SpringCloud（二）——网关路由（Zuul）

一、版本说明

SpringBoot：2.1.6.RELEASE

SpringCloud：Greenwich.RELEASE

二、功能说明

上一章节我们介绍了“注册中心”，下面我们将开始配置网关路由，个人理解网关路由是对“注册中心”的所有组件进行分发调用，在这里可以进行权限的验证、访问的分流与限流等操作；

Zuul大部分功能都是通过过滤器来实现的。Zuul中定义了四种标准过滤器类型，这些过滤器类型对应于请求的典型生命周期。

(1) PRE：这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试信息等。

(2) ROUTING：这种过滤器将请求路由到微服务。这种过滤器用于构建发送给微服务的请求，并使用Apache HttpClient或Netfilx Ribbon请求微服务。

(3) POST：这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。

(4) ERROR：在其他阶段发生错误时执行该过滤器。

三、Maven主要配置

<modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>【项目自定义】</groupId>
    <artifactId>【项目自定义】</artifactId>
    <version>【版本自定义】</version>
    <name>【名称自定义】</name>
    <packaging>jar</packaging>
    <description>路由控制中心——独立运行的服务</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--eureka客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!--流量限流-->
        <dependency>
            <groupId>com.marcosbarbero.cloud</groupId>
            <artifactId>spring-cloud-zuul-ratelimit</artifactId>
            <version>1.5.0.RELEASE</version>
        </dependency>
        <!--网关路由-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <!--spring cloud版本-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 打包spring boot应用 -->
    <build>
        <finalName>gateway-center-independent-service</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>    

四、配置文件（application.properties）

server.port=【服务端口号】

#服务名
spring.application.name=【服务名称】
#服务介绍
xinyan.server.message=这个是zuul组件
#远程SpringCloud配置
#eureka主机名，会在控制页面中显示
eureka.instance.hostname=【IP】
#eureka服务器页面中status的请求路径
eureka.instance.status-page-url=http://【IP】:【服务端口号】/index
eureka.instance.preferIpAddress=false
#eureka.instance.instance-id=${spring.application.name}:${spring.application.instance_id:${server.port}}
eureka.instance.appname=zuul-gateway
#eureka注册中心服务器地址
eureka.client.serviceUrl.defaultZone=http://【注册中心设置的用户名】:【注册中心设置的密码】@【注册中心IP】:【注册中心端口号】/eureka
#eureka.instance.instance-id=${spring.application.name}:${spring.application.instance_id:${server.port}}
eureka.instance.instance-id=${eureka.instance.hostname}:${server.port}
#新版配置，否则后面dashboard无法找到hystrix.stream
management.endpoints.web.exposure.include=*
ribbon.eureka.enabled=true

eureka.client.registerWithEureka=true
eureka.client.fetchRegistry=true

#忽略所有未配置的service,每一个微服务的路由配置都需要配置
zuul.ignored-services="*"
#需要忽略的头部信息，不在传播到其他服务
zuul.sensitive-headers=Access-Control-Allow-Origin
zuul.ignored-headers=Access-Control-Allow-Origin,H-APP-Id,Token,APPToken
zuul.routes.xinyan-test2-demo.path=/xinyan-test2-demo/**
zuul.routes.xinyan-test2-demo.serviceId=xinyan-test2-demo
zuul.routes.xinyan-test2-demo.sensitiveHeaders=true
zuul.routes.xinyan-test1-demo.path=/xinyan-test1-demo/**
zuul.routes.xinyan-test1-demo.serviceId=xinyan-test1-demo
zuul.routes.xinyan-test1-demo.sensitiveHeaders=true

zuul.ratelimit.enabled=true
zuul.ratelimit.repository=IN_MEMORY
zuul.ratelimit.behind-proxy=true

#每个刷新时间窗口对应的请求数量限制
zuul.ratelimit.policies.xinyan-test2-demo.limit=1
#每个刷新时间窗口对应的请求时间限制（秒）
zuul.ratelimit.policies.xinyan-test2-demo.quota=1
#刷新时间窗口的时间，默认值 (秒)
zuul.ratelimit.policies.【需要限制的组件名称】.refresh-interval=3
zuul.ratelimit.policies.【需要限制的组件名称】.type[0]=url
zuul.ratelimit.policies.【需要限制的组件名称】.type[1]=origin
zuul.ratelimit.policies.【需要限制的组件名称】.type[2]=user

这里特别说明：这里有个天坑，所有注册到“注册中心”的组件名称不能包含下划线，否则无法识别；

五、代码部分

5.1、重写异常交互

在调用网关发生异常或者限流异常等返回的信息不是非常友好，所以这里要对异常的交互Controller进行重写；

/**
 * 类描述:  重写系统/error接口
 *
 * @author xxsd
 * @version 1.0.0
 * @date 2019/6/20 0020 下午 8:56
 */
@RestController
@Slf4j
public class ErrorController extends AbstractErrorController {

    public ErrorController(ErrorAttributes errorAttributes) {
        super(new GlobalExceptionHandler());
    }

    @Override
    public String getErrorPath() {
        return null;
    }

    /**
     * 属性描述：路径
     *
     * @date : 2019/6/20 0020 下午 9:09
     */
    private static final String ERROR_PATH = "/error";
    /**
     * 属性描述：正常参数
     *
     * @date : 2019/6/20 0020 下午 9:09
     */
    private static final int OK = 200;
//    private static final String ERROR_MESSAGE = "系统内部错误,请联系管理员！";

    @RequestMapping(ERROR_PATH)
    public void exceptionHandler(HttpServletRequest request, HttpServletResponse response) {
        // 返回成功状态
        response.setStatus(OK);

        Map<String, Object> model = Collections.unmodifiableMap(getErrorAttributes(request, false));
        int status = Integer.valueOf(model.get("zuul_code").toString());
        String message = (String) model.get("zuul_manageMessage");

        // 判断请求类型
        String header = request.getHeader("X-Requested-With");
        //是否是Ajax提交
        boolean isAjax = "XMLHttpRequest".equalsIgnoreCase(header);

        Map<String, Object> error = new HashMap<>(2);
        error.put("code", status);
        error.put("manageMessage", message);

        if (isAjax) {
            log.info("Ajax交互");
        } else {
            log.info("非Ajax交互");
        }
        writeJson(response, error);
    }

    /**
    * 功能描述：以Json的格式输出信息
    * @author : xxsd
    * @date : 2019/6/21 0021 下午 12:07
    */
    private void writeJson(HttpServletResponse response, Map<String, Object> error) {
        try {
            response.setContentType("text/html;charset=UTF-8");
            response.getWriter().write(JSONObject.fromObject(error).toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

 

全局异常拦截器：

/**
 * 类描述:  全局异常拦截器
 *
 * @author xxsd
 * @version 1.0.0
 * @date 2019/6/20 0020 下午 5:53
 */
public class GlobalExceptionHandler extends DefaultErrorAttributes {

    @Override
    public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) {
        Map<String, Object> errorAttributes = super.getErrorAttributes(webRequest, includeStackTrace);

        try {
            final Integer status = (Integer) errorAttributes.get("status");
            //TODO 下面还可以直接添加系统级别的异常码及说明
            ErrorCodeEntity errorCodeEntity = ErrorCodeEntity.valueOf("Code_" + status);
            assert errorCodeEntity != null;
            errorAttributes.put("zuul_code", errorCodeEntity.giveCodeNumber());
            errorAttributes.put("zuul_manageMessage", errorCodeEntity.giveCodeMessage());
        } catch (Exception e) {
            errorAttributes.put("zuul_code", 0);
            errorAttributes.put("zuul_manageMessage", "未知状态码");
        }
        return errorAttributes;
    }
}

 

5.2、定义Zuul过滤器抽象基类

/**
 * 类描述:  自定义过滤器
 *
 * @author xxsd
 * @version 1.0.0
 * @date 2019/6/19 0019 下午 3:59
 */
@Slf4j
public abstract class AbstractZuulFilter extends ZuulFilter {
    protected RequestContext context;

    @Override
    public boolean shouldFilter() {
        RequestContext ctx = RequestContext.getCurrentContext();
        return (boolean) (ctx.getOrDefault(ContantValue.NEXT_FILTER, true));
    }

    @Override
    public Object run() {
        context = RequestContext.getCurrentContext();
        return doRun();
    }

    public abstract Object doRun();

    /**
     * 功能描述：异常信息输出
     *
     * @param code    错误编码
     * @param message 错误信息
     * @return : java.lang.Object
     * @author : xxsd
     * @date : 2019/6/21 0021 上午 11:35
     */
    protected Object fail(Integer code, String message) {
        context.set(ContantValue.NEXT_FILTER, false);
        context.setSendZuulResponse(false);
        context.getResponse().setContentType("text/html;charset=UTF-8");
        context.setResponseStatusCode(code);
        context.setResponseBody(String.format("{\"result\":\"%s!\"}", message));
        return null;
    }

    /**
    * 功能描述：成功输出
    * @author : xxsd
    * @date : 2019/6/21 0021 上午 11:36
    */
    protected Object success() {
        context.set(ContantValue.NEXT_FILTER, true);
        return null;
    }

    /**
    * 功能描述：获取提交的数据内容及类型
    * @author : xxsd
    * @date : 2019/6/27 0027 下午 7:13
    */
    protected Map<String, Object> giveSubDataOrType(){

        Map<String, Object> returnMap = new HashMap<>(2);

        HttpServletRequest req = RequestContext.getCurrentContext().getRequest();
        System.err.println("REQUEST:: " + req.getScheme() + " " + req.getRemoteAddr() + ":" + req.getRemotePort());
        System.err.println("REQUEST:: " + req.getScheme() + " " + req.getRemoteAddr() + ":" + req.getRemotePort());
        StringBuilder params = new StringBuilder("?");
        Enumeration<String> names = req.getParameterNames();
        if(ContantValue.SUP_TYPE.equals(req.getMethod())) {
            while (names.hasMoreElements()) {
                String name = names.nextElement();
                params.append(name);
                params.append("=");
                params.append(req.getParameter(name));
                params.append("&");
            }
        }

        if (params.length() > 0) {
            params.delete(params.length()-1, params.length());
        }

        returnMap.put("method", req.getMethod());

        System.err.println("REQUEST:: > " + req.getMethod() + " " + req.getRequestURI() + params + " " + req.getProtocol());

        Enumeration<String> headers = req.getHeaderNames();

        while (headers.hasMoreElements()) {
            String name = headers.nextElement();
            String value = req.getHeader(name);
            System.err.println("REQUEST:: > " + name + ":" + value);
        }

        final RequestContext ctx = RequestContext.getCurrentContext();
        if (!ctx.isChunkedRequestBody()) {
            ServletInputStream inp;
            try {
                inp = ctx.getRequest().getInputStream();
                String body;
                if (inp != null) {
                    body = IOUtils.toString(inp);
                    System.err.println("REQUEST:: > " + body);
                    returnMap.put("inputStream", JSONObject.fromObject(body));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return returnMap;
    }
}

 

5.3、自定义Zuul异常拦截器

/**
* 类描述: 自定义异常拦截器
* @author : xxsd
* @date : 2019/6/21 0021 上午 11:38
*/
@Component
public class ErrorHandlerFilter extends AbstractZuulFilter {
    @Override
    public String filterType() {
        return ERROR_TYPE;
    }

    @Override
    public int filterOrder() {
        return SEND_RESPONSE_FILTER_ORDER + 1;
    }

    @Override
    public Object doRun() {
        return success();
    }

}

 

5.4、自定义请求PRE拦截器

/**
 * 类描述:  自定义PRE过滤器
 *
 * @author xxsd
 * @version 1.0.0
 * @date 2019/6/19 0019 下午 4:23
 */
@Slf4j
@Component
public class PreHandlerFilter extends AbstractZuulFilter {

    @Override
    public String filterType() {
        return PRE_TYPE;
    }

    /**
     * 每秒允许处理的量是50
     */
    RateLimiter rateLimiter = RateLimiter.create(50);

    @Override
    public int filterOrder() {
        return FilterOrder.RATE_LIMITER_ORDER;
    }

    private static String INPUT_STREAM = "inputStream";

    @Override
    public Object doRun() {
        HttpServletRequest request = context.getRequest();
        String url = request.getRequestURI();
        if (rateLimiter.tryAcquire()) {
            Map<String, Object> stringObjectMap = giveSubDataOrType();

            System.out.println(SystemAttribute.getDebugType());
            System.out.println(SystemAttribute.getSsoCodeId());
            if (SystemAttribute.getDebugType()) {
                System.out.println(stringObjectMap.get("method").toString());
                System.out.println(stringObjectMap.get("inputStream").toString());
            }

            if (stringObjectMap.get(INPUT_STREAM) != null && !"".equals(stringObjectMap.get(INPUT_STREAM).toString().trim())) {
                if (SystemAttribute.getSsoCodeId() != null && !"".equals(SystemAttribute.getSsoCodeId())) {
                    //TODO 这里开始验证逻辑
                }
            }

            return success();
        } else {
            log.info("rate limit:{}", url);
            return fail(401, String.format("rate limit:{}", url));
        }
    }
}

 

5.4、启动入口

/**
* 类描述: 路由控制中心启动入口
* @author : xxsd
* @date : 2019/6/27 0027 下午 6:19
*/
@SpringBootApplication
@EnableDiscoveryClient
@EnableZuulProxy
public class GatewayCenterIndependentServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(GatewayCenterIndependentServiceApplication.class, args);
    }

}

 

六、跨域处理

目前开发模式已经从原来的“一锅端”发展到现在的前后端分离，那么很多人都在问我跨域如何处理，目前我使用的方式没有发现有其他的问题出现，现在将这个代码发出来，大家一起看看；

/**
 * 类描述:  跨域配置
 *
 * @author xxsd
 * @version 1.0.0
 * @date 2019/6/19 0019 下午 5:08
 */
@Configuration
public class CorsConfig {
    @Bean
    public FilterRegistrationBean corsFilter() {
        final ResourceHttpRequestHandler resourceHttpRequestHandler = new ResourceHttpRequestHandler();
        final CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.setAllowCredentials(true);
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        //corsConfiguration.addExposedHeader("X-forwared-port, X-forwarded-host");
        resourceHttpRequestHandler.setCorsConfiguration(corsConfiguration);
        FilterRegistrationBean bean = new FilterRegistrationBean(new CorsFilter(resourceHttpRequestHandler));
        bean.setOrder(Ordered.HIGHEST_PRECEDENCE);
        return bean;
    }
}

 

七、项目开源地址

目前项目正在进行大规模调整，后期再进行开放；