Spring Cloud之服务网关Zuul

Dear 丶 2022-02-13 10:55 166阅读 0赞

## 一.Zuul的简单介绍 ##

**1.zuul是什么**  
zuul 是netflix开源的一个API Gateway 服务器, 本质上是一个web servlet应用。Zuul是基于jvm路由和服务的负载均衡器，专为微服务而生的，认证，鉴权，限流，动态路由，监控，弹性，安全，负载均衡，协作单点压测。Zuul相当于外部环境和web网站后端所有请求的前门。  
**2.zuul的工作原理**  
zuul的核心是一系列的过滤器，大部分功能都是在过滤器中完成的。  
(1) PRE：这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试信息等。  
(2) ROUTING：这种过滤器将请求路由到微服务。这种过滤器用于构建发送给微服务的请求，并使用Apache HttpClient或Netfilx Ribbon请求微服务。  
(3) POST：这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。  
(4) ERROR：在其他阶段发生错误时执行该过滤器。  
**为什么需要zuul？**  
在微服务中，服务于服务之间的调用是很复杂的并且是调用的服务很多，如果服务与服务之间打交道的话又麻烦，还可能会导致系统问题。所以我们就设置一个网关，如果想调用服务的话就必须要经过这个网关，这个网关在进行请求的分发。前提是网关必须具备这些条件。

1.  稳定性，高可用
2.  安全性
3.  性能和并发
4.  扩展性

## 二.zuul的使用 ##

1.添加依赖

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
    </dependency>

2.配置文件  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTA1MTE1_size_16_color_FFFFFF_t_70]  
3，启动类上添加注解

@EnableZuulProxy

4，访问路径  
可以访问eureka上注册的所有服务，只不过要带上要访问的服务名称。

5，自定义路由，因为路由需要进行自定义，所以我们还要实现动态刷新

zuul:
      routes:
      #/myProduct/list -> /product/list自定义路由
    #    myProduct:
    #      path: /myProduct/**
    #      serviceId: product
    #简单的写法
        product: /myProduct/**
    #排除某些路由
      ignored-patterns:
        - /product/list
        - /myProduct/list

6，动态路由和动态刷新配置  
远端git配置,我这里配置了动态刷新  
Apigateway.yml

spring:
      cloud:
        bus:
          refresh:
            enabled: true
      rabbitmq:
        host: 10.64.1.127
        port: 5672
        username: guest
        password: guest
    zuul:
      routes:
      #忽略全部服务的敏感头（全部服务都可以获取token）
      sensitive-headers: 
      #/myProduct/list -> /product/list自定义路由
    #    myProduct:
    #      path: /myProduct/**
    #      serviceId: product
    #简单的写法
        product: /myProduct/**
    #排除某些路由
      ignored-patterns:
        - /product/list
    # - /myProduct/list

代码扫描，如果使用自动刷新配置必须要有这个。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTA1MTE1_size_16_color_FFFFFF_t_70 1]

## 过滤器 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTA1MTE1_size_16_color_FFFFFF_t_70 2]  
**限流**  
限流就是很多请求来的时候，zuul可以把他们给挡回去。  
限流是zuul的其中一个功能，限流是在请求被转发之前，即使有权限拦截的情况下，依然要把限流放到权限拦截的前边。  
在限流的时候会有一个令牌桶算法，以固定的速度去令牌桶放令牌，然后获取的时候在令牌桶获取令牌，如果获取到的话就进行下一步，获取不到的话就进行拦截。  
谷歌用RateLimiter封装了这种令牌桶的算法。  
直接定义一个过滤器

@Component
    public class RateLimitFilter extends ZuulFilter {
    	//设置100个令牌
        private static final RateLimiter RATE_LIMITER = RateLimiter.create(100);
    
        @Override
        public String filterType() {
            return PRE_TYPE;
        }
    
        @Override
        public int filterOrder() {
            return SERVLET_DETECTION_FILTER_ORDER-1;
        }
    
        @Override
        public boolean shouldFilter() {
            return true;
        }
    
        @Override
        public Object run() throws ZuulException {
            if (!RATE_LIMITER.tryAcquire()){
                throw new RateLimitException();
            }
            return null;
        }
    }

下面是FilterConstants的部分源码，里面定义了请求类型和请求的数字，数字越小，优先级越高。

public static final int DEBUG_FILTER_ORDER = 1;
        public static final int FORM_BODY_WRAPPER_FILTER_ORDER = -1;
        public static final int PRE_DECORATION_FILTER_ORDER = 5;
        public static final int RIBBON_ROUTING_FILTER_ORDER = 10;
        public static final int SEND_ERROR_FILTER_ORDER = 0;
        public static final int SEND_FORWARD_FILTER_ORDER = 500;
        public static final int SEND_RESPONSE_FILTER_ORDER = 1000;
        public static final int SIMPLE_HOST_ROUTING_FILTER_ORDER = 100;
        public static final int SERVLET_30_WRAPPER_FILTER_ORDER = -2;
        public static final int SERVLET_DETECTION_FILTER_ORDER = -3;
        public static final String ERROR_TYPE = "error";
        public static final String POST_TYPE = "post";
        public static final String PRE_TYPE = "pre";
        public static final String ROUTE_TYPE = "route";

**添加报头**

@Component
    public class addResponseHeaderFilter extends ZuulFilter {
        @Override
        public String filterType() {
            return POST_TYPE;
        }
    
        @Override
        public int filterOrder() {
            return SEND_RESPONSE_FILTER_ORDER - 1;
        }
    
        @Override
        public boolean shouldFilter() {
            return true;
        }
    
        @Override
        public Object run() throws ZuulException {
            RequestContext requestContext = RequestContext.getCurrentContext();
            HttpServletResponse response = requestContext.getResponse();
            response.setHeader("X-Foo", UUID.randomUUID().toString());
            return null;
        }
    }

**验证token**

@Component
    public class TokenFilter extends ZuulFilter {
        //验证过滤器，就是设置权限的过滤器
        @Override
        public String filterType() {
            return PRE_TYPE;
        }
    
        @Override
        public int filterOrder() {
            return PRE_DECORATION_FILTER_ORDER - 1;
        }
    
        @Override
        public boolean shouldFilter() {
            return true;
        }
    
        @Override
        public Object run() throws ZuulException {
            RequestContext requestContext = RequestContext.getCurrentContext();
            HttpServletRequest request = requestContext.getRequest();
    
            //这个只是模拟加上token
            String token = request.getParameter("token");
            if (StringUtils.isEmpty(token)){
                requestContext.setSendZuulResponse(false);
                requestContext.setResponseStatusCode(HttpStatus.SC_UNAUTHORIZED);
            }
            return null;
        }
    }

**权限拦截验证**

@Component
    public class AuthBuyerFilter extends ZuulFilter {
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
        //验证过滤器，就是设置权限的过滤器
        @Override
        public String filterType() {
            return PRE_TYPE;
        }
    
        @Override
        public int filterOrder() {
            return PRE_DECORATION_FILTER_ORDER - 1;
        }
    
        @Override
        public boolean shouldFilter() {
            RequestContext requestContext = RequestContext.getCurrentContext();
            HttpServletRequest request = requestContext.getRequest();
            if ("/order/order/create".equals(request.getRequestURI())){
                return true;
            }
            return false;
        }
    
        @Override
        public Object run() throws ZuulException {
            RequestContext requestContext = RequestContext.getCurrentContext();
            HttpServletRequest request = requestContext.getRequest();
            /**
             * order/create创建订单只能买家访问（cookie中有openid）
             */
    
            Cookie cookie = CookieUtil.get(request,"openid");
            if (cookie == null||StringUtils.isEmpty(cookie.getValue())){
                requestContext.setSendZuulResponse(false);
                requestContext.setResponseStatusCode(HttpStatus.SC_UNAUTHORIZED);
            }
            return null;
        }
    }

**跨域**  
一般跨域有两种解决方式，一种是咋子类或者方法上添加@CrossOrigin注解，这个是基于方法的，放在哪个方法上，哪个方法生效。一种是增加CorsFilter过滤器，看下面代码。

@Component
    public class CorsConfig {
    
        @Bean
        public CorsFilter corsFilter(){
            final UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    
            final CorsConfiguration configuration = new CorsConfiguration();
    
            configuration.setAllowCredentials(true);
            configuration.setAllowedOrigins(Arrays.asList("*"));    //http://www.a.com
            configuration.setAllowedHeaders(Arrays.asList("*"));
            configuration.setAllowedMethods(Arrays.asList("*"));
            //在这个时间段里，相同的跨域请求就不再进行检查
            configuration.setMaxAge(300l);
            
            source.registerCorsConfiguration("/**",configuration);
            return new CorsFilter(source);
        }
    }

**注意**  
zuul必须要保证高可用，zuul的高可用就是把多个zuul节点注册到Eurekaserver上面去。  
还有一种方法就是Nginx和Zuul混合使用的方式，Nginx做负载均衡，把请求转发到多个zuul上，这样的话就把Nginx和Zuul的优点发挥出来。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTA1MTE1_size_16_color_FFFFFF_t_70]: /images/20220213/48393832a3cd420aae33917d76d50075.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTA1MTE1_size_16_color_FFFFFF_t_70 1]: /images/20220213/755dc10ecbca4893bf6f484f2ffddcb8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM4MTA1MTE1_size_16_color_FFFFFF_t_70 2]: /images/20220213/65e4df51c33446bf97f5a3e5bd72b44d.png