微服务SpringCloud之服务网关zuul二

Zuul的核心

Filter是Zuul的核心，用来实现对外服务的控制。Filter的生命周期有4个，分别是“PRE”、“ROUTING”、“POST”、“ERROR”，整个生命周期可以用下图来表示。

 

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

• PRE： 这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试信息等。
• ROUTING：这种过滤器将请求路由到微服务。这种过滤器用于构建发送给微服务的请求，并使用Apache HttpClient或Netfilx Ribbon请求微服务。
• POST：这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。
• ERROR：在其他阶段发生错误时执行该过滤器。 除了默认的过滤器类型，Zuul还允许我们创建自定义的过滤器类型。例如，我们可以定制一种STATIC类型的过滤器，直接在Zuul中生成响应，而不将请求转发到后端的微服务。

Zuul中默认实现的Filter

类型	顺序	过滤器	功能
pre	-3	ServletDetectionFilter	标记处理Servlet的类型
pre	-2	Servlet30WrapperFilter	包装HttpServletRequest请求
pre	-1	FormBodyWrapperFilter	包装请求体
route	1	DebugFilter	标记调试标志
route	5	PreDecorationFilter	处理请求上下文供后续使用
route	10	RibbonRoutingFilter	serviceId请求转发
route	100	SimpleHostRoutingFilter	url请求转发
route	500	SendForwardFilter	forward请求转发
post	0	SendErrorFilter	处理有错误的请求响应
post	1000	SendResponseFilter	处理正常的请求响应

自定义Filter

 实现自定义Filter，需要继承ZuulFilter的类，并覆盖其中的4个方法。

我们假设有这样一个场景，因为服务网关应对的是外部的所有请求，为了避免产生安全隐患，我们需要对请求做一定的限制，比如请求中含有Token便让请求继续往下走，如果请求不带Token就直接返回并给出提示。

首先自定义一个Filter，在run()方法中验证参数是否含有Token。

package com.example.demo;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang.StringUtils;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;

public class CusFilter extends ZuulFilter {
    @Override
    public String filterType() {
        return "pre"; //定义filter的类型，有pre、route、post、error四种
    }

    @Override
    public int filterOrder() {
        return 10; //定义filter的顺序，数字越小表示顺序越高，越先执行
    }

    @Override
    public boolean shouldFilter() {
        return true; //表示是否需要执行该filter，true表示执行，false表示不执行
    }

    @Override
    public Object run() {
       // return null; //filter需要执行的具体操作
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();

       // logger.info("--->>> TokenFilter {},{}", request.getMethod(), request.getRequestURL().toString());

        String token = request.getParameter("token");// 获取请求的参数

        if (StringUtils.isNotBlank(token)) {
            ctx.setSendZuulResponse(true); //对请求进行路由
            ctx.setResponseStatusCode(200);
            ctx.set("isSuccess", true);
            return null;
        } else {
            ctx.setSendZuulResponse(false); //不对其进行路由
            ctx.setResponseStatusCode(400);
            ctx.setResponseBody("token is empty");
            ctx.set("isSuccess", false);
            return null;
        }
    }
    
}

View Code

将CusFilter加入到请求拦截队列，在启动类中添加以下代码：

    @Bean
    public CusFilter tokenFilter() {
        return new CusFilter();
    }

测试

分别启动EurekaServer、EurekaClient、SpringColudZuulSimple。输入http://localhost:8890/producer/hello?name=cuiyw时页面显示如下。

 

输入url带token时输出正常。

 

 

 

路由熔断

 

当我们的后端服务出现异常的时候，我们不希望将异常抛出给最外层，期望服务可以自动进行一降级。Zuul给我们提供了这样的支持。当某个服务出现异常时，直接返回我们预设的信息。

我们通过自定义的fallback方法，并且将其指定给某个route来实现该route访问出问题的熔断处理。主要继承ZuulFallbackProvider接口来实现，ZuulFallbackProvider默认有两个方法，一个用来指明熔断拦截哪个服务，一个定制返回内容。

实现类通过实现getRoute方法，告诉Zuul它是负责哪个route定义的熔断。而fallbackResponse方法则是告诉 Zuul 断路出现时，它会提供一个什么返回值来处理请求。

后来Spring又扩展了此类，丰富了返回方式，在返回的内容中添加了异常信息，因此最新版本建议直接继承类FallbackProvider 。

测试

依次启动EurekaServer、EurekaClient(设置不同端口启动)、SpringColudZuulSimple，之后需要将EurekaClient断开一个，如果不知道断开哪个时可以使用进程id。

package com.example.demo;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

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;


@Component
public class ProducerFallback implements FallbackProvider{

    public ClientHttpResponse fallbackResponse() {
        // TODO Auto-generated method stub
        return new ClientHttpResponse() {
            @Override
            public HttpStatus getStatusCode() throws IOException {
                return HttpStatus.OK;
            }

            @Override
            public int getRawStatusCode() throws IOException {
                return 200;
            }

            @Override
            public String getStatusText() throws IOException {
                return "OK";
            }

            @Override
            public void close() {

            }

            @Override
            public InputStream getBody() throws IOException {
                return new ByteArrayInputStream("The service is unavailable.".getBytes());
            }

            @Override
            public HttpHeaders getHeaders() {
                HttpHeaders headers = new HttpHeaders();
                headers.setContentType(MediaType.APPLICATION_JSON);
                return headers;
            }
        };
    }
    
    @Override
    public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
        if (cause != null && cause.getCause() != null) {
            String reason = cause.getCause().getMessage();
           // logger.info("Excption {}",reason);
        }
        return fallbackResponse();
    }
    @Override
    public String getRoute() {
        
        return "spring-cloud-producer";
    }

}

View Code

当服务出现异常时，打印相关异常信息，并返回”The service is unavailable.”。

路由重试

有时候因为网络或者其它原因，服务可能会暂时的不可用，这个时候我们希望可以再次对服务进行重试，Zuul也帮我们实现了此功能，需要结合Spring Retry 一起来实现。下面我们以上面的项目为例做演示。

添加Spring Retry依赖

首先在spring-cloud-zuul项目中添加Spring Retry依赖。

<dependency>
    <groupId>org.springframework.retrygroupId>
    <artifactId>spring-retryartifactId>
    <version>1.2.4.RELEASEversion>
dependency>

开启Zuul Retry

再配置文件中配置启用Zuul Retry，在main方法中添加@EnableRetry注解

#是否开启重试功能
zuul.retryable=true
#对当前服务的重试次数
ribbon.MaxAutoRetries=2
#切换相同Server的次数
ribbon.MaxAutoRetriesNextServer=0

测试

在EurekaClient中增加支持日志功能，引入spring-boot-starter-log4j2，同时排除start-web中默认的日志。

        dependency>
                <dependency>
               <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-log4j2artifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
            <exclusions>
                <exclusion>
                    <artifactId>spring-boot-starter-loggingartifactId>
                    <groupId>org.springframework.bootgroupId>
                exclusion>
            exclusions>
        dependency>

在application.properties同级目录下增加log4j2.xml配置文件。

xml version="1.0" encoding="UTF-8"?>



<Configuration status="WARN" monitorInterval="30">
    <Properties>
        
        <Property name="instance">EurekaClientProperty>
        <Property name="log.dir">D:\log\logsProperty>
    Properties>
    
    <Appenders>

        
        
        
        

        
        <Console name="Console" target="SYSTEM_OUT">
            
            <ThresholdFilter level="DEBUG" onMatch="ACCEPT" onMismatch="NEUTRAL"/>
            
            <PatternLayout
                    pattern="[%date{yyyy-MM-dd HH:mm:ss.SSS}][%thread][%level][%class][%line]:%message%n"/>
        Console>
        
        <RollingRandomAccessFile name="infoLog"
                                 fileName="${log.dir}/${instance}-info.log"
                                 filePattern="${log.dir}/%d{yyyy-MM}/${instance}-info-%d{yyyy-MM-dd}-%i.log.gz"
                                 append="true">
            
            <PatternLayout
                    pattern="[%date{yyyy-MM-dd HH:mm:ss.SSS}][%thread][%level][%class][%line]:%message%n"/>
            
            <Filters>
                <ThresholdFilter level="info" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
            Filters>
            <Policies>
                
                <TimeBasedTriggeringPolicy interval="1"
                                           modulate="true"/>
                
                <SizeBasedTriggeringPolicy size="200MB"/>
                
            Policies>
            
            
            
            
            <DefaultRolloverStrategy>
                
                
                <Delete basePath="${log.dir}" maxDepth="2">
                    
                    <IfFileName glob="*/EurekaClient-*.log.gz"/>
                    
                    <IfLastModified age="90D"/>
                Delete>
            DefaultRolloverStrategy>
        RollingRandomAccessFile>

        
        <RollingRandomAccessFile name="warnLog"
                                 fileName="${log.dir}/${instance}-warn.log"
                                 filePattern="${log.dir}/%d{yyyy-MM}/${instance}-warn-%d{yyyy-MM-dd}-%i.log.gz"
                                 append="true">
            <Filters>
                <ThresholdFilter level="error" onMatch="DENY"
                                 onMismatch="NEUTRAL"/>
                <ThresholdFilter level="warn" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
            Filters>
            <PatternLayout
                    pattern="[%date{yyyy-MM-dd HH:mm:ss.SSS}][%thread][%level][%class][%line]:%message%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy interval="1"
                                           modulate="true"/>
                <SizeBasedTriggeringPolicy size="200MB"/>
            Policies>
        RollingRandomAccessFile>

        
        <RollingRandomAccessFile name="errorLog"
                                 fileName="${log.dir}/${instance}-error.log"
                                 filePattern="${log.dir}/%d{yyyy-MM}/${instance}-error-%d{yyyy-MM-dd}-%i.log.gz"
                                 append="true">
            <Filters>
                <ThresholdFilter level="ERROR" onMatch="ACCEPT"
                                 onMismatch="DENY"/>
            Filters>
            <PatternLayout
                    pattern="[%date{yyyy-MM-dd HH:mm:ss.SSS}][%thread][%level][%class][%line]:%message%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy interval="1"
                                           modulate="true"/>
                <SizeBasedTriggeringPolicy size="200MB"/>
            Policies>
        RollingRandomAccessFile>
    Appenders>

    
    
    <Loggers> 
        <logger name="org.springframework" level="info" additivity="true">
            <AppenderRef ref="Console"/>
            <AppenderRef ref="infoLog"/>
            <AppenderRef ref="warnLog"/>
            <AppenderRef ref="errorLog"/>
        logger>
        <logger name="java.sql.PreparedStatement" level="debug"
                additivity="true">
            <AppenderRef ref="Console"/>
            <AppenderRef ref="infoLog"/>
        logger>
        
        <Root level="debug" includeLocation="true">
            <AppenderRef ref="infoLog"/>
            <AppenderRef ref="Console"/>
            <AppenderRef ref="errorLog"/>
        Root>
        
        
    Loggers>
Configuration>

View Code

修改HelloController方法。

@RestController
public class HelloController {
    private  static final Logger logger = LoggerFactory
            .getLogger(HelloController.class);
    @RequestMapping("/hello")
    public String index(@RequestParam String name) {
       
         logger.info("request two name is "+name);
            try{
                Thread.sleep(1000000);
            }catch ( Exception e){
                logger.error(" hello two error",e);
            }
            return "hello "+name+"，this is two messge";
            //return "hello "+name+"，this is first messge";
        
    }
}

View Code

修改端口启动EurekaClient，在浏览器刷新http://localhost:8890/spring-cloud-producer/hello?name=cuiyw&token=123。

在页面输出The service is unavailable时，可发现下面日志，说明进行了3次请求。