Java之 Spring Cloud 微服务搭建网关 nginx，Zuul（第三个阶段）【一】【SpringBoot项目实现商品服务器端是调用】

转x33g5p2x  于2021-12-02 转载在 Java  
字(8.8k)|赞(0)|评价(0)|浏览(677)

一、微服务网关概述

在学习完前面的知识后，微服务架构已经初具雏形。但还有一些问题：不同的微服务一般会有不同的网络地址，客户端在访问这些微服务时必须记住几十甚至几百个地址，这对于客户端方来说太复杂也难以维护。如下图：

如果让客户端直接与各个微服务通讯，可能会有很多问题：

  • 客户端会请求多个不同的服务，需要维护不同的请求地址，增加开发难度
  • 在某些场景下存在跨域请求的问题
  • 加大身份认证的难度，每个微服务需要独立认证
    因此，我们需要一个微服务网关，介于客户端与服务器之间的中间层，所有的外部请求都会先经过微服务网关。客户端只需要与网关交互，只知道一个网关地址即可，这样简化了开发还有以下优点：
  1. 1、易于监控 
  2.   2、易于认证 
  3.   3、减少了客户端与各个微服务之间的交互次数

1、服务网关的概念

（1）什么是微服务网关

API网关是一个服务器，是系统对外的唯一入口。
API网关封装了系统内部架构，为每个客户端提供一个定制的API。

API网关方式的核心要点是，所有的客户端和消费端都通过统一的网关接入微服务，在网关层处理所有的非业务功能。

通常，网关也是提供REST/HTTP的访问API。服务端通过API-GW注册和管理服务。

（2）作用和应用场景

网关具有的职责，如身份验证、监控、负载均衡、缓存、请求分片与管理、静态响应处理。当然，最主要的职责还是与“外界联系”。

2、常见的API网关实现方式

  • Kong
    基于Nginx+Lua开发，性能高，稳定，有多个可用的插件(限流、鉴权等等)可以开箱即用。问题：只支持Http协议；二次开发，自由扩展困难；提供管理API，缺乏更易用的管控、配置方式。
  • Zuul
    Netflix开源，功能丰富，使用JAVA开发，易于二次开发；需要运行在web容器中，如Tomcat。
    问题：缺乏管控，无法动态配置；依赖组件较多；处理Http请求依赖的是Web容器，性能不如
    Nginx；
  • Traefik
    Go语言开发；轻量易用；提供大多数的功能：服务路由，负载均衡等等；提供WebUI
    问题：二进制文件部署，二次开发难度大；UI更多的是监控，缺乏配置、管理能力；
    Spring Cloud Gateway
    SpringCloud提供的网关服务
  • Nginx+lua实现
    使用Nginx的反向代理和负载均衡可实现对api服务器的负载均衡及高可用
    问题：自注册的问题和网关本身的扩展性

3、基于Nginx的网关实现

（1） Nginx介绍

（2） 正向/反向代理

1）正向代理

正向代理，“它代理的是客户端，代客户端发出请求”，是一个位于客户端和原始服务器(origin server)之间的服务器，

为了从原始服务器取得内容，客户端向代理发送一个请求并指定目标(原始服务器)，然后代理向原始服务器转交请求并将获得的内容返回给客户端。

客户端必须要进行一些特别的设置才能使用正向代理。

2）反向代理

多个客户端给服务器发送的请求，Nginx服务器接收到之后，按照一定的规则分发给了后端的业务处理服务器进行处理了。

此时~请求的来源也就是客户端是明确的，但是请求具体由哪台服务器处理的并不明确了，Nginx扮演的就是一个反向代理角色。

客户端是无感知代理的存在的，反向代理对外都是透明的，访问者并不知道自己访问的是一个代理。因为客户端不需要任何配置就可以访问。

反向代理，“它代理的是服务端，代服务端接收请求”，主要用于服务器集群分布式部署的情况下，反向代理隐藏了服务器的信息如果只是单纯的需要一个最基础的具备转发功能的网关，那么使用Ngnix是一个不错的选择。

（3） 准备工作

使用第一次的工程来练习项目
您可以直接下载并导入我的项目

源代码下载：https://download.csdn.net/download/qq_44757034/52708487

运行项目打开

访问：http://localhost:9002/order/buy/1

访问：http://localhost:9002/order/1

访问：http://localhost:9001/product/1

（4）配置Nginx的请求转发

  1. location /api-product{
  2.             proxy_pass http://127.0.0.1:9001/;
  3.         }
  4.         location /api-order  {
  5.            proxy_pass http://127.0.0.1:9002/;
  6.          }

（5）启动nginx进行测试

访问：http://localhost/api-product/product/1

http://localhost/api-order/order/1

访问：http://localhost/api-order/order/buy/1

二、微服务网关Zuul

1、 Zuul简介

ZUUL是Netflix开源的微服务网关，它可以和Eureka、Ribbon、Hystrix等组件配合使用，Zuul组件的核心是一系列的过滤器，这些过滤器可以完成以下功能：

  • 动态路由：动态将请求路由到不同后端集群
  • 压力测试：逐渐增加指向集群的流量，以了解性能
  • 负载分配：为每一种负载类型分配对应容量，并弃用超出限定值的请求
  • 静态响应处理：边缘位置进行响应，避免转发到内部集群
  • 身份认证和安全: 识别每一个资源的验证要求，并拒绝那些不符的请求。Spring Cloud对Zuul进行了整合和增强。

Spring Cloud对Zuul进行了整合和增强

2、 搭建Zuul网关服务器（了解）

（1）创建工程导入依赖

在IDEA中创建ZUUL网关工程 zuul_server ，并添加响应依赖

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
  5.         </dependency>
  6.     </dependencies>

（2）编写启动类

  1. package cn.itbluebox.zuul;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
  7. @SpringBootApplication
  8. //开启Zuul
  9. @EnableZuulProxy
  10. public class ZuulServerApplication {
  11.     public static void main(String[] args) {
  12.         SpringApplication.run(ZuulServerApplication.class,args);
  13.     }
  14. }

@EnableZuulProxy ： 通过 @EnableZuulProxy 注解开启Zuul网管功能

（3）编写配置文件

创建配置文件 application.yml ，并添加相应配置

  1. server:
  2.   port: 8080 #服务端口
  3. spring:
  4.   application:
  5.     name: server-zuul #指定服务名

3、 Zuul中的路由转发

最直观的理解：“路由”是指根据请求URL，将请求分配到对应的处理程序。在微服务体系中，Zuul负责接收所有的请求。

根据不同的URL匹配规则，将不同的请求转发到不同的微服务处理。

  1. zuul:
  2. 	routes:
  3. 		product-service: # 这里是路由id，随意写
  4. 			path: /product-service/** # 这里是映射路径
  5. 			url: http://127.0.0.1:9001 # 映射路径对应的实际url地址

只需要在application.yml文件中配置路由规则即可：

  • product-service：配置路由id，可以随意取名
  • url：映射路径对应的实际url地址
  • path：配置映射路径，这里将所有请求前缀为/product-service/的请求，转发到http://127.0.0.1:9002处理

运行测试，运行测试前将nginx关闭掉

运行测试

访问：http://localhost:8080/product-service/product/1

（1） 面向服务的路由

微服务一般是由几十、上百个服务组成，对于一个URL请求，最终会确认一个服务实例进行处理。
如果对每个服务实例手动指定一个唯一访问地址，然后根据URL去手动实现请求匹配，这样做显然就不合理。

Zuul支持与Eureka整合开发，根据ServiceID自动的从注册中心中获取服务地址并转发请求，这样做的好处不仅可以通过单个端点来访问应用的所有服务，而且在添加或移除服务实例的时候不用修改Zuul的路由配置。

1）添加Eureka客户端依赖

  1. <dependency>
  2.             <groupId>org.springframework.cloud</groupId>
  3.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  4.         </dependency>
2）开启Eureka客户端发现功能

  1. @SpringBootApplication
  2. //开启Zuul
  3. @EnableZuulProxy
  4. //eureka的服务发现
  5. @EnableDiscoveryClient
  6. public class ZuulServerApplication {
  7.     public static void main(String[] args) {
  8.         SpringApplication.run(ZuulServerApplication.class,args);
  9.     }
  10. }
3）添加Eureka配置，获取服务信息，修改映射配置，通过服务名称获取

  1. server:
  2.   port: 8080 #服务端口
  3. spring:
  4.   application:
  5.     name: server-zuul #指定服务名
  6. zuul:
  7.   routes:
  8.     # 以商品微服务举例子
  9.     product-service: # 这里是路由id，随意写
  10.       path: /product-service/** # 这里是映射路径 localhost:8080/product-service/xxxx
  11.       #url: http://127.0.0.1:9001 # 映射路径对应的实际url地址
  12.       serviceId: service-product  # 配置转发的微服务的服务名称
  13. #配置Eureka
  14. eureka:
  15.   client:
  16.     service-url:
  17.       defaultZone: http://localhost:9000/eureka/
  18.   instance:
  19.     prefer-ip-address: true #使用ip地址注册
4）运行测试

访问：http://localhost:8080/product-service/product/1

（2） 简化的路由配置

在刚才的配置中，我们的规则是这样的：

  • zuul.routes.<route>.path=/xxx/** ： 来指定映射路径。 是自定义的路由名
  • zuul.routes.<route>.serviceId=/product-service ：来指定服务名。

而大多数情况下，我们的 路由名称往往和服务名会写成一样的。因此Zuul就提供了一种简化的配置语法： zuul.routes.<serviceId>=<path>上面的配置可以简化为一条：

  1. server:
  2.   port: 8080 #服务端口
  3. spring:
  4.   application:
  5.     name: server-zuul #指定服务名
  6. zuul:
  7.   routes:
  8.     #如果路由id和对应微服务的serviceid一致的话
  9.     service-product: /product-service/**
  10. #配置Eureka
  11. eureka:
  12.   client:
  13.     service-url:
  14.       defaultZone: http://localhost:9000/eureka/
  15.   instance:
  16.     prefer-ip-address: true #使用ip地址注册

运行测试

访问：http://localhost:8080/product-service/product/1

（3）默认的路由规则

在使用Zuul的过程中，上面讲述的规则已经大大的简化了配置项。但是当服务较多时，配置也是比较繁琐的。因此Zuul就指定了默认的路由规则：

  • 默认情况下，一切服务的映射路径就是服务名本身。

  • 例如服务名为： service-product ，则默认的映射路径就是： /service-product/**

  1. # zuul中默认的路由配置
  2. # 如果当前的微服务名称 service-order,默认的请求的映射路径/service-order/**

访问：http://localhost:8080/service-order/order/1

（4）Zuul加入后的架构

4、 Zuul中的过滤器

通过之前的学习，我们得知Zuul它包含了两个核心功能：对请求的路由和过滤。
其中路由功能负责将外部请求转发到具体的微服务实例上，是实现外部访问统一入口的基础；
而过滤器功能则负责对请求的处理过程进行干预，是实现请求校验、服务聚合等功能的基础。其实，路由功能在真正运行时，它的路由映射和请求转发同样也由几个不同的过滤器完成的。
所以，过滤器可以说是Zuul实现API网关功能最为核心的部件，每一个进入Zuul的HTTP请求都会经过一系列的过滤器处理链得到请求响应并返回给客户端。
那么接下来，我们重点学习的就是Zuul的第二个核心功能：过滤器。

（1）ZuulFilter简介

Zuul 中的过滤器跟我们之前使用的 javax.servlet.Filter 不一样，javax.servlet.Filter 只有一种类型，可以通过配置 urlPatterns 来拦截对应的请求。而 Zuul 中的过滤器总共有 4 种类型，且每种类型都有对应的使用场景。

  1. PRE：这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试信息等。
  2. ROUTING：这种过滤器将请求路由到微服务。这种过滤器用于构建发送给微服务的请求，并使用Apache HttpClient或Netfilx Ribbon请求微服务。
  3. POST：这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的HTTPHeader、收集统计信息和指标、将响应从微服务发送给客户端等。
  4. ERROR：在其他阶段发生错误时执行该过滤器。Zuul提供了自定义过滤器的功能实现起来也十分简单，只需要编写一个类去实现zuul提供的接口。

  • 正常流程：

  • 请求到达首先会经过pre类型过滤器，而后到达routing类型，进行路由，请求就到达真正的服务提供者，执行请求，返回结果后，会到达post过滤器。而后返回响应。

  • 异常流程：

  • 整个过程中，pre或者routing过滤器出现异常，都会直接进入error过滤器，再error处理完毕后，会将请求交给POST过滤器，最后返回给用户。

  • 如果是error过滤器自己出现异常，最终也会进入POST过滤器，而后返回。

  • 如果是POST过滤器出现异常，会跳转到error过滤器，但是与pre和routing不同的时，请求不会再到达POST过滤器了。

  • 不同过滤器的场景：

  • 请求鉴权：一般放在pre类型，如果发现没有访问权限，直接就拦截了

  • 异常处理：一般会在error类型和post类型过滤器中结合来处理。

  • 服务调用时长统计：pre和post结合使用。

  • ZuulFilter是过滤器的顶级父类。在这里我们看一下其中定义的4个最重要的方法

  • shouldFilter ：返回一个 Boolean 值，判断该过滤器是否需要执行。返回true执行，返回false不执行。

  • run ：过滤器的具体业务逻辑。

  • filterType ：返回字符串，代表过滤器的类型。包含以下4种：

  • pre ：请求在被路由之前执行

  • routing ：在路由请求时调用

  • post ：在routing和errror过滤器之后调用

  • error ：处理请求时发生错误调用

  • filterOrder ：通过返回的int值来定义过滤器的执行顺序，数字越小优先级越高。

  1. package cn.itbluebox.zuul.filter;
  3. import com.netflix.zuul.ZuulFilter;
  4. import com.netflix.zuul.exception.ZuulException;
  5. import org.springframework.stereotype.Component;
  6. /* 自定义的zull过滤器 继承抽象的父类 */
  7. @Component
  8. public class LoginFilter  extends ZuulFilter {
  9.     //定义过滤器类型 pre routing post error
  10.     @Override
  11.     public String filterType() {
  12.         return "pre";
  13.     }
  14.     //指定过滤器的执行顺序 返回值越小执行顺序越高
  15.     @Override
  16.     public int filterOrder() {
  17.         return 1;
  18.     }
  19.     //当前过滤器是否生效 true ：使用此过滤器 false：不使用此过滤器
  20.     @Override
  21.     public boolean shouldFilter() {
  22.         return true;
  23.     }
  24.     //执行过滤器当中业务逻辑
  25.     @Override
  26.     public Object run() throws ZuulException {
  27.         System.out.println("执行了过滤器！！！！！");
  28.         return null;
  29.     }
  30. }

运行测试

访问测试：http://localhost:8080/service-order/order/1

查看控制台

（2）身份验证

完善LoginFilter

  1. package cn.itbluebox.zuul.filter;
  3. import com.netflix.zuul.ZuulFilter;
  4. import com.netflix.zuul.context.RequestContext;
  5. import com.netflix.zuul.exception.ZuulException;
  6. import org.springframework.http.HttpStatus;
  7. import org.springframework.stereotype.Component;
  9. import javax.servlet.http.HttpServletRequest;
  11. /* 自定义的zull过滤器 继承抽象的父类 */
  12. @Component
  13. public class LoginFilter  extends ZuulFilter {
  14.     //定义过滤器类型 pre routing post error
  15.     @Override
  16.     public String filterType() {
  17.         return "pre";
  18.     }
  19.     //指定过滤器的执行顺序 返回值越小执行顺序越高
  20.     @Override
  21.     public int filterOrder() {
  22.         return 1;
  23.     }
  24.     //当前过滤器是否生效 true ：使用此过滤器 false：不使用此过滤器
  25.     @Override
  26.     public boolean shouldFilter() {
  27.         return true;
  28.     }
  29.     //执行过滤器当中业务逻辑
  30.     /* 身份认证： 1、所有的请求都需要携带参数：access-token 2、获取request请求 3、通过request获取参数：access-token 4、判断token是否为空 1 token == null ： 身份验证失败 2 token != null ： 执行后续操作 在Zuul网关当中，通过RequestContext的上下文对象，可以获取request对象 */
  31.     @Override
  32.     public Object run() throws ZuulException {
  33.         System.out.println("执行了过滤器！！！！！");
  34.         //1、获取Zuul提供上下文对象RequestContext
  35.         RequestContext ctx = RequestContext.getCurrentContext();
  36.         //2、从RequestContext当中获取request
  37.         HttpServletRequest request = ctx.getRequest();
  38.         //3、获取请求参数access
  39.         String token = request.getParameter("access-token");
  40.         //4、判断
  41.         //4.1 如果token==null ,拦截请求，返回认证失败
  42.         if(token == null){
  43.             ctx.setSendZuulResponse(false);//拦截请求
  44.             ctx.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());//设置状态码
  45.         }
  46.         //4.2 如果token!=null ，继续后续操作
  47.         return null;
  48.     }
  49. }

运行测试

不携带哦token直接访问：http://localhost:8080/product-service/product/1

写到token访问http://localhost:8080/product-service/product/1?access-token=1

5、服务网关Zuul的核心源码解析

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_44757034/article/details/121610837

内容来源于网络，如有侵权，请联系作者删除！

Java后端开发语言

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多

    目录

    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com