GitHub源码地址：https://github.com/AngelSXD/springcloud
版本介绍：
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<spring-boot.version>2.0.4.RELEASE</spring-boot.version>
<spring-cloud.version>Finchley.SR1</spring-cloud.version>
<lcn.last.version>4.2.1</lcn.last.version>
</properties>
====================================================
参考地址：https://www.cnblogs.com/cralor/p/9234697.html
====================================================
一.简单介绍
Zuul作为微服务系统的网关组件，用于构建边界服务，致力于动态路由、过滤、监控、弹性伸缩和安全。
为什么需要Zuul
Zuul、Ribbon以及Eureka结合可以实现智能路由和负载均衡的功能；网关将所有服务的API接口统一聚合，统一对外暴露。外界调用API接口时，不需要知道微服务系统中各服务相互调用的复杂性，保护了内部微服务单元的API接口；网关可以做用户身份认证和权限认证，防止非法请求操作API接口；网关可以实现监控功能，实时日志输出，对请求进行记录；网关可以实现流量监控，在高流量的情况下，对服务降级；API接口从内部服务分离出来，方便做测试。
Zuul通过Servlet来实现，通过自定义的ZuulServlet来对请求进行控制。核心是一系列过滤器，可以在Http请求的发起和响应返回期间执行一系列过滤器。Zuul采取了动态读取、编译和运行这些过滤器。过滤器之间不能直接通信，而是通过RequestContext对象来共享数据，每个请求都会创建一个RequestContext对象。
Zuul生命周期如下图。 当一个客户端Request请求进入Zuul网关服务时，网关先进入”pre filter“，进行一系列的验证、操作或者判断。然后交给”routing filter“进行路由转发，转发到具体的服务实例进行逻辑处理、返回数据。当具体的服务处理完成后，最后由”post filter“进行处理，该类型的处理器处理完成之后，将Request信息返回客户端。
二.配置过程
1.pom依赖
<!--熔断器 健康检查-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
<!--zuul核心依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
2.配置application.properties
spring.application.name=springcloud-ms-gateway
server.port=8001
eureka.client.service-url.defaultZone=http://127.0.0.1:8000/eureka/ #因为parent的pom.xml中 添加了连接数据库的依赖,所以 需要配置数据库连接相关配置
spring.datasource.continue-on-error=false
spring.datasource.url=jdbc:mysql://localhost:3306/springcloudtest?useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root zuul.host.socket-timeout-millis=10000
#网关最大超时时间10s
zuul.host.connect-timeout-millis=10000
#网关最大连接数 默认200
zuul.host.max-total-connections=200 #给要路由的API请求加前缀 可加可不加
zuul.prefix=/v1
#需要忽略的服务 ,号分隔 配置后将不会被路由
zuul.ignored-services=spring-cloud-ms-eureka #配置了zuul之后,那么整个分布式系统，对外则只暴露http://zuul-IP:zuul-port/v1/服务自定义地址/具体API请求地址 #这一组配置后,访问http://localhost:8001/v1/ms-member/member/showMember 即相当于直接访问会员服务http://localhost:9000/member/showMember
#zuul.routes.xx xx随便写,zuul中唯一即可
#zuul.routes.xx.serviceId=eureka中注册的服务名 即各个服务配置文件中的spring.application.name
zuul.routes.member.serviceId=springcloud-ms-member
#zuul.routes.xx.path=/自定义的地址 /**表示下级也可以访问
zuul.routes.member.path=/ms-member/** #这一组配置后,所有访问积分服务的请求 即可直接访问网关地址http://localhost:8001/v1/ms-integral/具体接口地址 ,由zuul进行路由转发和负载均衡
zuul.routes.integral.serviceId=springcloud-ms-integral
zuul.routes.integral.path=/ms-integral/** #这一组配置后,所有访问商品服务的请求 即可直接访问网关地址http://localhost:8001/v1/ms-goods/具体接口地址 ,由zuul进行路由转发和负载均衡
zuul.routes.goods.serviceId=springcloud-ms-goods
zuul.routes.goods.path=/ms-goods/** #txmanager地址 必填
tm.manager.url=http://127.0.0.1:7000/tx/manager/
3.启动类注解
核心注解@EnableZuulProxy
同时需要添加注解，服务发现，注册eureka
package com.swapping.springcloud.ms.gateway; import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
import org.springframework.cloud.openfeign.EnableFeignClients; @EnableCircuitBreaker //Hystrix Dashboard必须加
@EnableHystrixDashboard//展示熔断器仪表盘 @EnableZuulProxy //网关映射 注解
@EnableFeignClients //feign调用注解
@EnableDiscoveryClient
@SpringBootApplication(scanBasePackages = "com.swapping")
public class SpringcloudMsGatewayApplication { public static void main(String[] args) {
SpringApplication.run(SpringcloudMsGatewayApplication.class, args);
}
}
>>>>>>>>>>>>>路由转发
4.启动网关服务
springcloud-ms-gateway 端口8001
启动ms-member服务，端口9000
那么现在访问
http://localhost:9000/member/showMember
即直接访问ms-member服务，的/member/showMember这个API
现在可以访问网关，通过zuul进行动态路由
http://localhost:8001/v1/ms-member/member/showMember
统一访问网关地址，由网关进行统一路由转发
至此，zuul实现路由转发！
>>>>>>>>>>>>>路由拦截
5.使用zuul进行路由拦截
现在既然所有的访问接口都是由zuul网关暴露出去的，那所有的请求都来找网关，这样的话在网关的过滤器中就可以做很多的事情。
Filter是Zuul的核心，用来实现对外服务的控制。Filter的生命周期有4个，分别是“PRE”、“ROUTING”、“POST”、“ERROR”，整个生命周期可以用下图来表示
5.1 Zuul大部分功能都是通过过滤器来实现的，这些过滤器类型对应于请求的典型生命周期。
- PRE： 这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试信息等。
- ROUTING：这种过滤器将请求路由到微服务。这种过滤器用于构建发送给微服务的请求，并使用Apache HttpClient或Netfilx Ribbon请求微服务。
- POST：这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。
- ERROR：在其他阶段发生错误时执行该过滤器。 除了默认的过滤器类型，Zuul还允许我们创建自定义的过滤器类型。例如，我们可以定制一种STATIC类型的过滤器，直接在Zuul中生成响应，而不将请求转发到后端的微服务。
5.2 在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 | 处理正常的请求响应 |
5.3 zuul还提供了一类特殊的过滤器，分别为：StaticResponseFilter和SurgicalDebugFilter
StaticResponseFilter：StaticResponseFilter允许从Zuul本身生成响应，而不是将请求转发到源。
SurgicalDebugFilter：SurgicalDebugFilter允许将特定请求路由到分隔的调试集群或主机
5.4 在zuul中定义自定义的过滤器
例如：自定义一个请求被路由之前的过滤器，用于验证请求中是否携带auth，如果携带安全验证，则成功路由；否则统一终止路由，返回响应
自定义filter需要继承ZuulFilter【注意，自定义Filter需要注入spring 使用注解@Component】
package com.swapping.springcloud.ms.gateway.filter; import com.alibaba.fastjson.JSON;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import com.swapping.springcloud.ms.core.response.UniVerResponse;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component; import javax.servlet.http.HttpServletRequest; /**
* 路由拦截
*
*
* >>>>>zuul的filter过滤器的生命周期有一下四个：
*
* PRE： 这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试信息等。
* ROUTING：这种过滤器将请求路由到微服务。这种过滤器用于构建发送给微服务的请求，并使用Apache HttpClient或Netfilx Ribbon请求微服务。
* POST：这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。
* ERROR：在其他阶段发生错误时执行该过滤器。 除了默认的过滤器类型，Zuul还允许我们创建自定义的过滤器类型。例如，我们可以定制一种STATIC类型的过滤器，直接在Zuul中生成响应，而不将请求转发到后端的微服务。
*
*
* Zuul中默认实现了很多Filter，也可以自己自定义过滤器
*
* 下面是自己自定义过滤器
* 实际使用中我们可以结合shiro、oauth2.0等技术去做鉴权、验证
*
*/
@Component
public class AuthFilter extends ZuulFilter{ @Override
public String filterType() {
return "pre";//可以在请求被路由之前调用
} @Override
public int filterOrder() {
return 0;//filter执行顺序，通过数字指定 ,优先级为0，数字越大，优先级越低
} @Override
public boolean shouldFilter() {
return true;// 是否执行该过滤器，此处为true，说明需要过滤
} /**
* filter需要执行的具体操作
*
* 例如：本filter实际执行的逻辑 是验证所有的访问请求中，是否包含安全信息auth
* @return
* @throws ZuulException
*/
@Override
public Object run() throws ZuulException { RequestContext ctx = RequestContext.getCurrentContext();
HttpServletRequest request = ctx.getRequest(); String auth = request.getParameter("auth");
//TODO 此处可以做日志记录
System.out.println("zuul拦截--请求前验证---auth："+auth); //成功的情况
if (StringUtils.isNotBlank(auth)){
ctx.setSendZuulResponse(true); //对请求进行路由
ctx.setResponseStatusCode(200);
ctx.set("isSuccess", true);
}else {
//失败的情况
UniVerResponse res = new UniVerResponse();
res.beFalse3("zuul拦截--请求前验证---没有auth登录验证",UniVerResponse.ERROR_BUSINESS); ctx.setSendZuulResponse(false); //不对请求进行路由
ctx.setResponseStatusCode(res.getCode());//设置返回状态码
ctx.setResponseBody(JSON.toJSONString(res));//设置返回响应体
ctx.set("isSuccess", false);
ctx.getResponse().setContentType("application/json;charset=UTF-8");//设置返回响应体格式，可能会乱码 } return null;
} }
5.5 测试自定义拦截
启动网关服务 ms-gateway 端口：8001
启动服务注册中心eureka
启动要被路由的服务ms-member 端口：9000
@RestController
@RequestMapping("/member")
public class MemberController { @Autowired
MemberService memberService; @RequestMapping(value = "/showMember")
public String showMember(){
return "会员服务正常,会员服务是服务消费者,也就是服务调用者,会调用商品服务进行商品购买,减少库存,增加销量;\n\r同时调用积分服务,增加积分";
}
访问地址：携带auth验证
http://localhost:8001/v1/ms-member/member/showMember?auth=111
访问地址：不携带auth
5.6 如果你想禁用 zuul中的filter，可以这么做：
如果你想禁用一个，只需设置zuul.<SimpleClassName>.<filterType> .disable = true。按照惯例，过滤器后面的包是Zuul过滤器类型。例如，要禁用org.springframework.cloud.netflix.zuul.filters.post.SendResponseFilter 需设置 zuul.SendResponseFilter.post.disable = true
>>>>>>>>>>>>>路由熔断
6.使用zuul进行路由熔断
类似与服务之间的feign调用熔断器设定，网关路由各个服务的请求也可以做路由熔断，在不能成功路由到具体服务上的请求时，进行降级处理，定制返回内容【也就是设置统一响应体】
目前路由熔断仅能 支持服务级别的熔断，不支持具体到某个URL进行熔断
自定义熔断类需要实现FallbackProvider接口【注意，自定义熔断类需要注入spring 使用注解@Component】
package com.swapping.springcloud.ms.gateway.fallback; import com.alibaba.fastjson.JSON;
import com.swapping.springcloud.ms.core.response.UniVerResponse;
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; /**
* 路由熔断
*
* 类似与服务之间的feign调用熔断器设定，网关路由各个服务的请求也可以做路由熔断，
* 在不能成功路由到具体服务上的请求时，进行降级处理，定制返回内容【也就是设置统一响应体】
*
* 目前路由熔断仅能 支持服务级别的熔断，不支持具体到某个URL进行熔断
*
*/
@Component
public class UniVerFallback implements FallbackProvider { /**
* 指定 可以熔断拦截 哪些服务
* @return
*/
@Override
public String getRoute() {
// return "springcloud-ms-member";//指定 可熔断某个服务 服务名是配置文件中配置的各服务的serviceId
return "*"; //指定 可熔断所有服务
} /**
* 指定 熔断后返回的定制化内容
* @param route
* @param cause
* @return
*/
@Override
public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
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() { } /**
* 设置响应体
* @return
* @throws IOException
*/
@Override
public InputStream getBody() throws IOException {
//TODO 此处可以做日志记录
UniVerResponse uniVerResponse = new UniVerResponse();
uniVerResponse.beFalse3(route+"服务凉凉了",UniVerResponse.ERROR_BUSINESS);
return new ByteArrayInputStream(JSON.toJSONString(uniVerResponse).getBytes());
} /**
* 设置响应头信息
* @return
*/
@Override
public HttpHeaders getHeaders() {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON_UTF8);//指定响应体 格式+编码方式
return headers;
}
};
}
}
保证eureka启动，
然后重启网关服务ms-gateway，端口：8001
关闭ms-member服务，端口：9000
然后访问地址：来访问ms-member的接口
http://localhost:8001/v1/ms-member/member/showMember?auth=111
就可以对指定的服务进行熔断！！！
>>>>>>>>>>>>>路由重试
7.使用zuul进行路由重试【慎用】
在服务暂时不可用的情况下，可能是服务重启正被注册中心扫描或者其他原因，我们想要对发起的请求进行重试，zuul结合Spring Retry实现路由重试
7.1 网关服务添加依赖
<!--路由重试 依赖-->
<dependency>
<groupId>org.springframework.retry</groupId>
<artifactId>spring-retry</artifactId>
</dependency>
7.2 application.properties添加配置
#路由重试
#是否开启路由重试,针对于 查询接口可以使用,但是对于非幂等的新增或更新接口,使用路由重试会出现很大的问题,应该注意 #是否开启重试功能
zuul.retryable=true
#对当前服务的重试次数[不包含首次访问]，也就是说实际访问接口的次数是3+1次
ribbon.MaxAutoRetries=3
#切换相同Server的次数
ribbon.MaxAutoRetriesNextServer=0
7.3 重启网关服务，更改一下ms-member的测试接口
@RequestMapping(value = "/showMember")
public String showMember(){
System.out.println("请求到达！！！！"); try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "会员服务正常,会员服务是服务消费者,也就是服务调用者,会调用商品服务进行商品购买,减少库存,增加销量;\n\r同时调用积分服务,增加积分";
}
可以看到，要访问的接口 休眠10s，而网关配置的超时时间设置为2s
结合上面的重试次数的配置，请求到达的次数应该是3+1次。
启动ms-member服务，访问地址：
http://localhost:8001/v1/ms-member/member/showMember?auth=111
可以看到，请求总共到达了4次，首次+重试3次
。
请求结果可以看到，最终服务被熔断。
7.4 路由重试注意
是否开启路由重试,针对于 查询接口可以使用,但是对于非幂等的新增或更新接口,使用路由重试会出现很大的问题,应该注意
开启重试在某些情况下是有问题的，比如当压力过大，一个实例停止响应时，路由将流量转到另一个实例，很有可能导致最终所有的实例全被压垮。说到底，断路器的其中一个作用就是防止故障或者压力扩散。用了retry，断路器就只有在该服务的所有实例都无法运作的情况下才能起作用。这种时候，断路器的形式更像是提供一种友好的错误信息，或者假装服务正常运行的假象给使用者。 不用retry，仅使用负载均衡和熔断，就必须考虑到是否能够接受单个服务实例关闭和eureka刷新服务列表之间带来的短时间的熔断。如果可以接受，就无需使用retry。
=============结束================
参考：http://www.ityouknow.com/springcloud/2018/01/20/spring-cloud-zuul.html
参考：https://www.cnblogs.com/cralor/p/9234697.html