精华内容
下载资源
问答
  • 服务网关是分布式架构中不可缺少的组成部分,是外部网络和内部服务之间的屏障。这篇文章主要介绍了SpringCloud实战之Zuul网关服务。一起跟随小编过来看看吧
  • zuul网关配置参考

    2018-11-23 08:57:19
    spring boot、zuul整合的微服务网关配置代码demo,供学习参考
  • zuul 企业级应用
  • Zuul网关

    千次阅读 2019-08-13 14:32:05
    一、Zuul网关简介 zuul是spring cloud中的微服务网关。 网关: 是一个网络整体系统中的前置门户入口。请求首先通过网关,进行路径的路由,定位到具体的服务节点上。 Zuul是一个微服务网关,首先是一个微服务。也是...

    一、Zuul网关简介

    1. zuul是spring cloud中的微服务网关。
      网关: 是一个网络整体系统中的前置门户入口。请求首先通过网关,进行路径的路由,定位到具体的服务节点上。
    2. Zuul是一个微服务网关,首先是一个微服务。也是会在Eureka注册中心中进行服务的注册和发现。也是一个网关,请求应该通过Zuul来进行路由。
    3. Zuul网关不是必要的。是推荐使用的。
      使用Zuul,一般在微服务数量较多(多于10个)的时候推荐使用,对服务的管理有严格要求的时候推荐使用,当微服务权限要求严格的时候推荐使用。

    二、网关的作用

    在这里插入图片描述

    三、网关的应用

    1. 添加依赖
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
            
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
     </dependency>
    
    1. 在main方法上添加@EnableZuulProxy
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
    
    @SpringBootApplication
    @EnableZuulProxy
    public class Application {
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }
    
    1. 修改application.yml配置文件
    server:
      port: 8000
    spring:
      application:
        name: zuul
    zuul:
      routes:
        # 标识你服务的名字,这里可以自己定义,一般方便和规范来讲还是跟自己服务的名字一样
        EUREKA-CLIENT-PRODUCER:
          #服务映射的路径,通过这路径就可以从外部访问你的服务了,目的是为了不爆露你机器的IP
          #这里zuul是自动依赖hystrix,ribbon的,不是面向单机
          path: /EUREKA-CLIENT-PROVIDER/**
          #这里一定要是你Eureka注册中心的服务的名称,是因为这里配置serviceId因为跟eureka结合了,
          serviceId: EUREKA-CLIENT-PROVIDER
    eureka:
      client:
        service-url:
          defaultZone: http://admin:123456@127.0.0.1:8761/eureka/
    
    1. 相关说明

    a. 通过zuul访问服务的,URL地址默认格式为:http://zuulHostIp:port/服务名称/服务中的URL

    例如:http://127.0.0.1:8000/EUREKA-CLIENT-PROVIDER/get?name=123
    b. 服务名称就是配置文件中的spring.application.name。
    c. 服务的URL,就是对应的服务对外提供的URL路径

    URL匹配 - URL pattern
    使用路径方式匹配路由规则。
    参数key结构: zuul.routes.customName.path=xxx
    用于配置路径匹配规则。
    其中customName自定义。通常使用要调用的服务名称,方便后期管理
    可使用的通配符有: * ** ?
    ? 单个字符
    * 任意多个字符,不包含多级路径
    ** 任意多个字符,包含多级路径
    zuul.routes.eureka-application-service.path=/api/**
    #参数key结构: zuul.routes.customName.url=xxx
    #用于配置符合path的请求路径路由到的服务地址。
    zuul.routes.eureka-application-service.url=http://127.0.0.1:8080/

    服务名称匹配 - service id pattern 通过服务名称路由
    key结构 : zuul.routes.customName.path=xxx
    #路径匹配规则
    zuul.routes.eureka-application-service.path=/api/**
    key结构 : zuul.routes.customName.serviceId=xxx
    #用于配置符合path的请求路径路由到的服务名称。
    zuul.routes.eureka-application-service.serviceId=eureka-application-service
    simple service id pattern 简化配置方案
    #如果只配置path,不配置serviceId。则customName相当于服务名称。
    #符合path的请求路径直接路由到customName对应的服务上。
    zuul.routes.eureka-application-service.path=/api/**

    路由排除设置 - ignored service id pattern
    #配置不被zuul管理的服务列表。多个服务名称使用逗号’,'分隔。
    #配置的服务将不被zuul代理。
    zuul.ignored-services=eureka-application-service
    #通配方式配置排除列表。
    zuul.ignored-services=*
    #使用服务名称匹配规则配置路由列表,相当于只对已配置的服务提供网关代理。
    zuul.routes.eureka-application-service.path=/api/**
    #通配方式配置排除网关代理路径。所有符合ignored-patterns的请求路径都不被zuul网关代理。
    zuul.ignored-patterns=//test/
    zuul.routes.eureka-application-service.path=/api/**

    路由前缀配置
    #prefix URL pattern 前缀路由匹配
    #配置请求路径前缀,所有基于此前缀的请求都由zuul网关提供代理。
    zuul.prefix=/api
    #使用服务名称匹配方式配置请求路径规则。
    #这里的配置将为:http://ip:port/api/appservice/**的请求提供zuul网关代理。
    #并将请求路由到服务eureka-application-service中。
    zuul.routes.eureka-application-service.path=/appservice/**

    zuul网关配置总结

    网关配置方式有多种,默认、URL、服务名称、排除|忽略、前缀。
    网关配置没有优劣好坏,应该在不同的情况下选择合适的配置方案。
    zuul网关其底层使用ribbon来实现请求的路由,并内置Hystrix,可选择性提供网关fallback逻辑。使用zuul的时候,并不推荐使用Feign作为application client端的开发实现。毕竟Feign技术是对ribbon的再封装,使用Feign本身会提高通讯消耗,降低通讯效率,只在服务相互调用的时候使用Feign来简化代码开发就够了。而且商业开发中,使用Ribbon+RestTemplate来开发的比例更高。

    展开全文
  • zuul网关

    2019-11-26 18:33:45
    文章目录1、Zuul路由网关简介及基本使用简介路由配置2、Zuul路由映射配置3、Zuul请求过滤配置结果图: 1、Zuul路由网关简介及基本使用 简介 Zuul API路由网关服务简介: 请看上图,这里的API 路由网关服务 由Zuul...

    1、Zuul路由网关简介及基本使用

    简介

    Zuul API路由网关服务简介:
    在这里插入图片描述
    请看上图,这里的API 路由网关服务 由Zuul实现,主要就是对外提供服务接口的时候,起到了请求的路由和过滤作用,也因此能够隐藏内部服务的接口细节,从来有利于保护系统的安全性;

    路由配置

    首先,hosts文件配置:

    127.0.0.1  zuul.yj.com
    

    新建一个项目microservice-zuul-3001,
    pom依赖:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>com.yj</groupId>
            <artifactId>springcloud</artifactId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <artifactId>microservice-zuul-3001</artifactId>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>com.yj</groupId>
                <artifactId>microservice-common</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka</artifactId>
            </dependency>
            <!-- actuator监控 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <!-- hystrix容错 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-hystrix</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-config</artifactId>
            </dependency>
            <!--zuul网关-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-zuul</artifactId>
            </dependency>
    
    
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    
    

    application.yml :

    server:
      port: 3001
      context-path: /
    spring:
      application:
        name: microservice-zuul
    eureka:
      instance:
        instance-id: microservice-zuul:3001
        prefer-ip-address: true
      client:
        service-url:
          defaultZone: http://eureka2001.yj.com:2001/eureka/,http://eureka2002.yj.com:2002/eureka/,http://eureka2003.yj.com:2003/eureka/
    info:
      groupId: com.yj.springcloud
      artifactId: microservice-zuul-3001
      version: 1.0-SNAPSHOT
      userName: http://yj.com
      phone: 123456
    
    

    启动类:

    package com.yj.microservicezuul3001;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
    import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
    
    @SpringBootApplication(exclude={DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
    @EnableZuulProxy
    public class MicroserviceZuul3001Application {
        public static void main(String[] args) {
            SpringApplication.run(MicroserviceZuul3001Application.class, args);
        }
    
    }
    
    

    然后就完事了!

    2、Zuul路由映射配置

    上面是zuul的简单使用,从接口地址很轻易的就暴露了服务提供者的唯一标识名microservice-student;有安全风险,我们需要将其隐藏;
    ignored-services的作用是将原来的服务提供者唯一标识名禁用;
    Prefix的作用是给服务加前缀
    yml文件中添加以下配置:

    zuul:
      routes:
        studentServer.serviceId: microservice-student
        studentServer.path: /studentServer/**
      ignored-services: "*"
      prefix: /yj
    

    然后就可以测试了。

    3、Zuul请求过滤配置

    Zuul通过ZuulFilter过滤器实现过滤非法请求。
    AccessFilter类:

    package com.yj.microservicezuul3001.filter;
    
    import com.netflix.zuul.ZuulFilter;
    import com.netflix.zuul.context.RequestContext;
    import com.netflix.zuul.exception.ZuulException;
    import org.apache.log4j.Logger;
    
    import javax.servlet.http.HttpServletRequest;
    
    
    public class AccessFilter extends ZuulFilter {
    
        Logger logger=Logger.getLogger(AccessFilter.class);
    
        /**
         * 判断该过滤器是否要被执行
         */
        @Override
        public boolean shouldFilter() {
            return true;
        }
    
        /**
         * 过滤器的具体执行逻辑
         */
        @Override
        public Object run() throws ZuulException {
            RequestContext ctx = RequestContext.getCurrentContext();
            HttpServletRequest request = ctx.getRequest();
            String parameter = request.getParameter("accessToken");
            logger.info(request.getRequestURL().toString()+" 请求访问");
            if(parameter==null){
                logger.error("accessToken为空!");
                ctx.setSendZuulResponse(false);
                ctx.setResponseStatusCode(401);
                ctx.setResponseBody("{\"result\":\"accessToken is empty!\"}");
                return null;
            }
            //  token判断逻辑
            logger.info(request.getRequestURL().toString()+" 请求成功");
            return null;
        }
    
        /**
         * 过滤器的类型 这里用pre,代表会再请求被路由之前执行
         */
        @Override
        public String filterType() {
            return "pre";
        }
    
        /**
         * 过滤器的执行顺序
         */
        @Override
        public int filterOrder() {
            return 0;
        }
    
    }
    
    

    开启Filter配置:

    package com.yj.microservicezuul3001.config;
    
    import com.yj.microservicezuul3001.filter.AccessFilter;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class ZuulConfig {
    
        @Bean
        public AccessFilter accessFilter(){
            return new AccessFilter();
        }
    }
    
    
    

    fallback:

    package com.yj.microservicezuul3001.fallback;
    
    import org.springframework.cloud.netflix.zuul.filters.route.ZuulFallbackProvider;
    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;
    
    @Component
    public class ZuulFallBack implements ZuulFallbackProvider {
    
        @Override
        public String getRoute() {
            return "*";
        }
    
        /**
         * 在给zuul整合回退功能时,只要类实现ZuulFallbackProvider接口,并且注册bean即可。
         *
         * 不过需要注意的时,这个回退只有服务掉线或者超时的情况下才会触发(Camden.SR4版本测试是这样),
         * 如果服务程序出现异常,此回退程序是不能处理的,异常会直接返回给调用者,比如页面。
         *
         * @return
         */
        @Override
        public ClientHttpResponse fallbackResponse() {
            return new ClientHttpResponse() {
                @Override
                public HttpHeaders getHeaders() {
                    HttpHeaders headers = new HttpHeaders();
                    headers.setContentType(MediaType.APPLICATION_JSON_UTF8);//application/json;charset=UTF-8
                    return headers;
                }
    
                @Override
                public InputStream getBody() throws IOException {
                    String msg = "服务繁忙,请稍后.....";
                    //new ByteArrayInputStream("{\"code\":-1,\"msg\":\"服务暂不可用\"}".getBytes(StandardCharsets.UTF_8))
                    return new ByteArrayInputStream(msg.getBytes());
                }
    
                @Override
                public String getStatusText() throws IOException {
                    return HttpStatus.BAD_REQUEST.getReasonPhrase();//400
                }
    
                @Override
                public HttpStatus getStatusCode() throws IOException {
                    return HttpStatus.BAD_REQUEST;
                }
    
                @Override
                public int getRawStatusCode() throws IOException {
                    return HttpStatus.BAD_REQUEST.value();//"Bad Request"
                }
    
                @Override
                public void close() {
    
                }
            };
        }
    }
    

    然后就可以测试了。

    结果图:

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • SpringCloud中集成Zuul网关。 添加相关依赖,编写路由地址,添加过滤器可以在过滤器中对请求做其他操作 如验证是否登录、解密请求中的数据等
  • 1. 在zuul网关服务中实现限流 1.1 为什么需要限流? 限流是为了保证服务器的负载量处于正常状态,因为如果太多的访问量可能会直接导致服务的崩溃。 1.2 如何实现限流 1.2.1 令牌桶算法简介 在zuul中实现限流是通过...
  • 主要介绍了SpringCLoud搭建Zuul网关集群过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了SpringCloud Zuul网关功能实现解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • SpringCloud之Zuul网关服务

    千次阅读 2020-03-05 17:33:08
    Zuul是spring cloud中的微服务网关。网关: 是一个网络整体系统中的前置门户入口。请求首先通过网关,进行路径的路由,定位到... Zuul网关不是必要的。是推荐使用的。  使用Zuul,一般在微服务数量较多(多于10...

    Zuul是spring cloud中的微服务网关。网关: 是一个网络整体系统中的前置门户入口。请求首先通过网关,进行路径的路由,定位到具体的服务节点上。

      Zuul是一个微服务网关,首先是一个微服务。也是会在Eureka注册中心中进行服务的注册和发现。也是一个网关,请求应该通过Zuul来进行路由。

      Zuul网关不是必要的。是推荐使用的。

      使用Zuul,一般在微服务数量较多(多于10个)的时候推荐使用,对服务的管理有严格要求的时候推荐使用,当微服务权限要求严格的时候推荐使用。

    一、Zuul网关的作用

      网关有以下几个作用:

    • 统一入口:未全部为服务提供一个唯一的入口,网关起到外部和内部隔离的作用,保障了后台服务的安全性。
    • 鉴权校验:识别每个请求的权限,拒绝不符合要求的请求。
    • 动态路由:动态的将请求路由到不同的后端集群中。
    • 减少客户端与服务端的耦合:服务可以独立发展,通过网关层来做映射。

        

    二、Zuul网关的应用

      1、网关访问方式

      通过zuul访问服务的,URL地址默认格式为:http://zuulHostIp:port/要访问的服务名称/服务中的URL

      服务名称:properties配置文件中的spring.application.name。

      服务的URL:就是对应的服务对外提供的URL路径监听。

      2、网关依赖注入

    <!-- spring cloud Eureka Client 启动器 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-zuul</artifactId>
    </dependency>
    <!-- zuul网关的重试机制,不是使用ribbon内置的重试机制
       是借助spring-retry组件实现的重试
       开启zuul网关重试机制需要增加下述依赖
     -->
    <dependency>
       <groupId>org.springframework.retry</groupId>
       <artifactId>spring-retry</artifactId>
    </dependency>

     

      3、网关启动器

    /**
     * @EnableZuulProxy - 开启Zuul网关。
     *  当前应用是一个Zuul微服务网关。会在Eureka注册中心中注册当前服务。并发现其他的服务。
     *  Zuul需要的必要依赖是spring-cloud-starter-zuul。
     */
    @SpringBootApplication
    @EnableZuulProxy
    public class ZuulApplication {
        public static void main(String[] args) {
            SpringApplication.run(ZuulApplication.class, args);
        }
    }

     

      4、网关全局变量配置

      4.1 URL路径匹配

    # URL pattern
    # 使用路径方式匹配路由规则。
    # 参数key结构: zuul.routes.customName.path=xxx
    # 用于配置路径匹配规则。
    # 其中customName自定义。通常使用要调用的服务名称,方便后期管理
    # 可使用的通配符有: * ** ?
    # ? 单个字符
    # * 任意多个字符,不包含多级路径
    # ** 任意多个字符,包含多级路径
    zuul.routes.eureka-application-service.path=/api/**
    # 参数key结构: zuul.routes.customName.url=xxx
    # url用于配置符合path的请求路径路由到的服务地址。
    zuul.routes.eureka-application-service.url=http://127.0.0.1:8080/

     

      4.2 服务名称匹配

    # service id pattern 通过服务名称路由
    # key结构 : zuul.routes.customName.path=xxx
    # 路径匹配规则
    zuul.routes.eureka-application-service.path=/api/**
    # key结构 : zuul.routes.customName.serviceId=xxx
    # serviceId用于配置符合path的请求路径路由到的服务名称。
    zuul.routes.eureka-application-service.serviceId=eureka-application-service

     

      服务名称匹配也可以使用简化的配置:

    # simple service id pattern 简化配置方案
    # 如果只配置path,不配置serviceId。则customName相当于服务名称。
    # 符合path的请求路径直接路由到customName对应的服务上。
    zuul.routes.eureka-application-service.path=/api/**

      4.3 路由排除配置

    # ignored service id pattern
    # 配置不被zuul管理的服务列表。多个服务名称使用逗号','分隔。
    # 配置的服务将不被zuul代理。
    zuul.ignored-services=eureka-application-service
    
    # 此方式相当于给所有新发现的服务默认排除zuul网关访问方式,只有配置了路由网关的服务才可以通过zuul网关访问
    # 通配方式配置排除列表。
    zuul.ignored-services=*
    # 使用服务名称匹配规则配置路由列表,相当于只对已配置的服务提供网关代理。
    zuul.routes.eureka-application-service.path=/api/**
    
    # 通配方式配置排除网关代理路径。所有符合ignored-patterns的请求路径都不被zuul网关代理。
    zuul.ignored-patterns=/**/test/**
    zuul.routes.eureka-application-service.path=/api/**

     

      4.4 路由前缀配置

    # prefix URL pattern 前缀路由匹配
    # 配置请求路径前缀,所有基于此前缀的请求都由zuul网关提供代理。
    zuul.prefix=/api
    # 使用服务名称匹配方式配置请求路径规则。
    # 这里的配置将为:http://ip:port/api/appservice/**的请求提供zuul网关代理,可以将要访问服务进行前缀分类。
    # 并将请求路由到服务eureka-application-service中。
    zuul.routes.eureka-application-service.path=/appservice/**

     

      5 Zuul网关配置总结

      网关配置方式有多种,默认、URL、服务名称、排除|忽略、前缀

      网关配置没有优劣好坏,应该在不同的情况下选择合适的配置方案。

      zuul网关其底层使用ribbon来实现请求的路由,并内置Hystrix,可选择性提供网关fallback逻辑。使用zuul的时候,并不推荐使用Feign作为application client端的开发实现。毕竟Feign技术是对ribbon的再封装,使用Feign本身会提高通讯消耗,降低通讯效率,只在服务相互调用的时候使用Feign来简化代码开发就够了。而且商业开发中,使用Ribbon+RestTemplate来开发的比例更高

    三、Zuul网关过滤器

      Zuul中提供了过滤器定义,可以用来过滤代理请求,提供额外功能逻辑。如:权限验证,日志记录等。

      Zuul提供的过滤器是一个父类。父类是ZuulFilter。通过父类中定义的抽象方法filterType,来决定当前的Filter种类是什么。有前置过滤、路由后过滤、后置过滤、异常过滤。

    • 前置过滤:是请求进入Zuul之后,立刻执行的过滤逻辑。
    • 路由后过滤:是请求进入Zuul之后,并Zuul实现了请求路由后执行的过滤逻辑,路由后过滤,是在远程服务调用之前过滤的逻辑。
    • 后置过滤:远程服务调用结束后执行的过滤逻辑。
    • 异常过滤:是任意一个过滤器发生异常或远程服务调用无结果反馈的时候执行的过滤逻辑。无结果反馈,就是远程服务调用超时。

      3.1 过滤器实现方式

    继承父类ZuulFilter。在父类中提供了4个抽象方法,分别是:filterType, filterOrder, shouldFilter, run。其功能分别是:

    • filterType:方法返回字符串数据,代表当前过滤器的类型。可选值有-pre, route, post, error。

    pre - 前置过滤器,在请求被路由前执行,通常用于处理身份认证,日志记录等;

    route - 在路由执行后,服务调用前被调用;

    error - 任意一个filter发生异常的时候执行或远程服务调用没有反馈的时候执行(超时),通常用于处理异常;

    post - 在route或error执行后被调用,一般用于收集服务信息,统计服务性能指标等,也可以对response结果做特殊处理。

    • filterOrder:返回int数据,用于为同filterType的多个过滤器定制执行顺序,返回值越小,执行顺序越优先
    • shouldFilter:返回boolean数据,代表当前filter是否生效
    • run:具体的过滤执行逻辑。如pre类型的过滤器,可以通过对请求的验证来决定是否将请求路由到服务上;如post类型的过滤器,可以对服务响应结果做加工处理(如为每个响应增加footer数据)。

      3.2 过滤器的生命周期

                

      3.3 代码示例

    /**
     * Zuul过滤器,必须继承ZuulFilter父类。
     * 当前类型的对象必须交由Spring容器管理。使用@Component注解描述。
     * 继承父类后,必须实现父类中定义的4个抽象方法。
     * shouldFilter、 run、 filterType、 filterOrder
     */
    @Component
    public class LoggerFilter extends ZuulFilter {
    
        private static final Logger logger = LoggerFactory.getLogger(LoggerFilter.class);
        
        /**
         * 返回boolean类型。代表当前filter是否生效。
         * 默认值为false。
         * 返回true代表开启filter。
         */
        @Override
        public boolean shouldFilter() {
            return true;
        }
    
        /**
         * run方法就是过滤器的具体逻辑。
         * return 可以返回任意的对象,当前实现忽略。(spring-cloud-zuul官方解释)
         * 直接返回null即可。
         */
        @Override
        public Object run() throws ZuulException {
            // 通过zuul,获取请求上下文
            RequestContext rc = RequestContext.getCurrentContext();
            HttpServletRequest request = rc.getRequest();
    
            logger.info("LogFilter1.....method={},url={}",
                    request.getMethod(),request.getRequestURL().toString());
            // 可以记录日志、鉴权,给维护人员记录提供定位协助、统计性能
            return null;
        }
    
        /**
         * 过滤器的类型。可选值有:
         * pre - 前置过滤
         * route - 路由后过滤
         * error - 异常过滤
         * post - 远程服务调用后过滤
         */
        @Override
        public String filterType() {
            return "pre";
        }
    
        /**
         * 同种类的过滤器的执行顺序。
         * 按照返回值的自然升序执行。
         */
        @Override
        public int filterOrder() {
            return 0;
        }
    }

     

    四、Zuul网关的容错(与Hystrix的无缝结合)

      在spring cloud中,Zuul启动器中包含了Hystrix相关依赖,在Zuul网关工程中,默认是提供了Hystrix Dashboard服务监控数据的(hystrix.stream),但是不会提供监控面板的界面展示。可以说,在spring cloud中,zuul和Hystrix是无缝结合的。

      4.1 Zuul中的服务降级处理

      在Edgware版本之前,Zuul提供了接口ZuulFallbackProvider用于实现fallback处理。从Edgware版本开始,Zuul提供了ZuulFallbackProvider的子接口FallbackProvider来提供fallback处理。
      Zuul的fallback容错处理逻辑,只针对timeout异常处理,当请求被Zuul路由后,只要服务有返回(包括异常),都不会触发Zuul的fallback容错逻辑。

      因为对于Zuul网关来说,做请求路由分发的时候,结果由远程服务运算的。那么远程服务反馈了异常信息,Zuul网关不会处理异常,因为无法确定这个错误是否是应用真实想要反馈给客户端的。

      4.2 代码示例

    /**
     * 如果需要在Zuul网关服务中增加容错处理fallback,需要实现接口ZuulFallbackProvider
     * spring-cloud框架,在Edgware版本(包括)之后,声明接口ZuulFallbackProvider过期失效,
     * 提供了新的ZuulFallbackProvider的子接口 - FallbackProvider
     * 在老版本中提供的ZuulFallbackProvider中,定义了两个方法。
     *  - String getRoute()
     *    当前的fallback容错处理逻辑处理的是哪一个服务。可以使用通配符‘*’代表为全部的服务提供容错处理。
     *    如果只为某一个服务提供容错,返回对应服务的spring.application.name值。
     *  - ClientHttpResponse fallbackResponse()
     *    当服务发生错误的时候,如何容错。
     * 新版本中提供的FallbackProvider提供了新的方法。
     *  - ClientHttpResponse fallbackResponse(Throwable cause)
     *    如果使用新版本中定义的接口来做容错处理,容错处理逻辑,只运行子接口中定义的新方法。也就是有参方法。
     *    是为远程服务发生异常的时候,通过异常的类型来运行不同的容错逻辑。
     */
    @Component
    public class TestFallBbackProvider implements FallbackProvider {
    
        /**
         * return - 返回fallback处理哪一个服务。返回的是服务的名称
         * 推荐 - 为指定的服务定义特性化的fallback逻辑。
         * 推荐 - 提供一个处理所有服务的fallback逻辑。
         * 好处 - 服务某个服务发生超时,那么指定的fallback逻辑执行。如果有新服务上线,未提供fallback逻辑,有一个通用的。
         */
        @Override
        public String getRoute() {
            return "eureka-application-service";
        }
    
        /**
         * fallback逻辑。在早期版本中使用。
         * Edgware版本之后,ZuulFallbackProvider接口过期,提供了新的子接口FallbackProvider
         * 子接口中提供了方法ClientHttpResponse fallbackResponse(Throwable cause)。
         * 优先调用子接口新定义的fallback处理逻辑。
         */
        @Override
        public ClientHttpResponse fallbackResponse() {
            System.out.println("ClientHttpResponse fallbackResponse()");
            
            List<Map<String, Object>> result = new ArrayList<>();
            Map<String, Object> data = new HashMap<>();
            data.put("message", "服务正忙,请稍后重试");
            result.add(data);
            
            ObjectMapper mapper = new ObjectMapper();
            
            String msg = "";
            try {
                msg = mapper.writeValueAsString(result);
            } catch (JsonProcessingException e) {
                msg = "";
            }
            
            return this.executeFallback(HttpStatus.OK, msg, 
                    "application", "json", "utf-8");
        }
    
        /**
         * fallback逻辑。优先调用。可以根据异常类型动态决定处理方式。
         */
        @Override
        public ClientHttpResponse fallbackResponse(Throwable cause) {
            System.out.println("ClientHttpResponse fallbackResponse(Throwable cause)");
            if(cause instanceof NullPointerException){
                
                List<Map<String, Object>> result = new ArrayList<>();
                Map<String, Object> data = new HashMap<>();
                data.put("message", "网关超时,请稍后重试");
                result.add(data);
                
                ObjectMapper mapper = new ObjectMapper();
                
                String msg = "";
                try {
                    msg = mapper.writeValueAsString(result);
                } catch (JsonProcessingException e) {
                    msg = "";
                }
                
                return this.executeFallback(HttpStatus.GATEWAY_TIMEOUT, 
                        msg, "application", "json", "utf-8");
            }else{
                return this.fallbackResponse();
            }
        }
        
        /**
         * 具体处理过程。
         * @param status 容错处理后的返回状态,如200正常GET请求结果,201正常POST请求结果,404资源找不到错误等。
         *  使用spring提供的枚举类型对象实现。HttpStatus
         * @param contentMsg 自定义的响应内容。就是反馈给客户端的数据。
         * @param mediaType 响应类型,是响应的主类型, 如: application、text、media。
         * @param subMediaType 响应类型,是响应的子类型, 如: json、stream、html、plain、jpeg、png等。
         * @param charsetName 响应结果的字符集。这里只传递字符集名称,如: utf-8、gbk、big5等。
         * @return ClientHttpResponse 就是响应的具体内容。
         *  相当于一个HttpServletResponse。
         */
        private final ClientHttpResponse executeFallback(final HttpStatus status, 
                String contentMsg, String mediaType, String subMediaType, String charsetName) {
            return new ClientHttpResponse() {
    
                /**
                 * 设置响应的头信息
                 */
                @Override
                public HttpHeaders getHeaders() {
                    HttpHeaders header = new HttpHeaders();
                    MediaType mt = new MediaType(mediaType, subMediaType, Charset.forName(charsetName));
                    header.setContentType(mt);
                    return header;
                }
    
                /**
                 * 设置响应体
                 * zuul会将本方法返回的输入流数据读取,并通过HttpServletResponse的输出流输出到客户端。
                 */
                @Override
                public InputStream getBody() throws IOException {
                    String content = contentMsg;
                    return new ByteArrayInputStream(content.getBytes());
                }
    
                /**
                 * ClientHttpResponse的fallback的状态码 返回String
                 */
                @Override
                public String getStatusText() throws IOException {
                    return this.getStatusCode().getReasonPhrase();
                }
    
                /**
                 * ClientHttpResponse的fallback的状态码 返回HttpStatus
                 */
                @Override
                public HttpStatus getStatusCode() throws IOException {
                    return status;
                }
    
                /**
                 * ClientHttpResponse的fallback的状态码 返回int
                 */
                @Override
                public int getRawStatusCode() throws IOException {
                    return this.getStatusCode().value();
                }
    
                /**
                 * 回收资源方法
                 * 用于回收当前fallback逻辑开启的资源对象的。
                 * 不要关闭getBody方法返回的那个输入流对象。
                 */
                @Override
                public void close() {
                }
            };
        }
    }

     

    五、Zuul网关的限流保护

      Zuul网关组件也提供了限流保护。当请求并发达到阀值,自动触发限流保护,返回错误结果。只要提供error错误处理机制即可。

      Zuul的限流保护需要额外依赖spring-cloud-zuul-ratelimit组件。

    <dependency>
        <groupId>com.marcosbarbero.cloud</groupId>
        <artifactId>spring-cloud-zuul-ratelimit</artifactId>
        <version>1.3.4.RELEASE</version>
    </dependency>

      5.1 全局限流配置

      使用全局限流配置,zuul会对代理的所有服务提供限流保护。

    # 开启限流保护
    zuul.ratelimit.enabled=true
    # 60s内请求超过3次,服务端就抛出异常,60s后可以恢复正常请求
    zuul.ratelimit.default-policy.limit=3
    zuul.ratelimit.default-policy.refresh-interval=60
    # 针对IP进行限流,不影响其他IP
    zuul.ratelimit.default-policy.type=origin

     

      5.2 局部限流配置

      使用局部限流配置,zuul仅针对配置的服务提供限流保护。

    # 开启限流保护
    zuul.ratelimit.enabled=true
    # hystrix-application-client服务60s内请求超过3次,服务抛出异常。
    zuul.ratelimit.policies.hystrix-application-client.limit=3
    zuul.ratelimit.policies.hystrix-application-client.refresh-interval=60
    # 针对IP限流。
    zuul.ratelimit.policies.hystrix-application-client.type=origin

     

      5.3 限流参数简介

                

    六、Zuul网关性能调优:网关的两层超时调优

      使用Zuul的spring cloud微服务结构图:

                  

      从上图中可以看出。整体请求逻辑还是比较复杂的,在没有zuul网关的情况下,app client请求app service的时候,也有请求超时的可能。那么当增加了zuul网关的时候,请求超时的可能就更明显了。

      当请求通过zuul网关路由到服务,并等待服务返回响应,这个过程中zuul也有超时控制。zuul的底层使用的是Hystrix+ribbon来实现请求路由。结构如下:

                    

      zuul中的Hystrix内部使用线程池隔离机制提供请求路由实现,其默认的超时时长为1000毫秒。ribbon底层默认超时时长为5000毫秒。如果Hystrix超时,直接返回超时异常。如果ribbon超时,同时Hystrix未超时,ribbon会自动进行服务集群轮询重试,直到Hystrix超时为止。如果Hystrix超时时长小于ribbon超时时长,ribbon不会进行服务集群轮询重试。

      那么在zuul中可配置的超时时长就有两个位置:Hystrix和ribbon。具体配置如下:

    # 开启zuul网关重试
    zuul.retryable=true
    # hystrix超时时间设置
    # 线程池隔离,默认超时时间1000ms
    hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=8000
    
    # ribbon超时时间设置:建议设置比Hystrix小
    # 请求连接的超时时间: 默认5000ms
    ribbon.ConnectTimeout=5000
    # 请求处理的超时时间: 默认5000ms
    ribbon.ReadTimeout=5000
    # 重试次数:MaxAutoRetries表示访问服务集群下原节点(同路径访问);MaxAutoRetriesNextServer表示访问服务集群下其余节点(换台服务器)
    ribbon.MaxAutoRetries=1
    ribbon.MaxAutoRetriesNextServer=1
    # 开启重试
    ribbon.OkToRetryOnAllOperations=true

      Spring-cloud中的zuul网关重试机制是使用spring-retry实现的。工程必须依赖下述资源:

    <dependency>
      <groupId>org.springframework.retry</groupId>
      <artifactId>spring-retry</artifactId>
    </dependency>

     

     

    参考:

    1、京东10亿级调用量背后的高可用网关系统架构实践

    http://www.yunweipai.com/archives/23653.html

    2、有赞API网关实践

    https://tech.youzan.com/api-gateway-in-practice/

    3、剖析唯品会API网关设计与实践

    https://mp.weixin.qq.com/s/gREMe-G7nqNJJLzbZ3ed3A

    4、聊聊 API Gateway 和 Netflix Zuul

    http://www.scienjus.com/api-gateway-and-netflix-zuul/

    5、Spring Security With JWT

    https://gitee.com/SnailClimb/spring-security-jwt-guide

     

     

     

    展开全文
  • SpringCloud Zuul 网关搭建及配置

    千次阅读 多人点赞 2019-12-25 11:04:11
    一.Zuul网关 二.Zuul服务的前期准备 2.1 注册中心EurekaServer的搭建 2.2 EurekaService的搭建 三.Zuul服务搭建 五.Zuul的访问 六.Zuul的更多功能 前言:博主一直力求做到写博客尽量的详细来减少大家花在踩坑...

     

    目录

    一.Zuul网关

    二.Zuul服务的前期准备

    2.1 注册中心EurekaServer的搭建

    2.2 EurekaService的搭建

    三.Zuul服务搭建

    五.Zuul的访问

    六.Zuul的更多功能


    前言:博主一直力求做到写博客尽量的详细来减少大家花在踩坑上的时间,若有写的不好或错误的地方,还需各方大佬指正。

    一.Zuul网关

        网关,是一种网络关口,既然是关口,就需要知道哪些东西能通过哪些东西不能通过。

        在微服务中,Zuul是SpringCloud众多组件中的一个,用于微服务的网关。在微服务中,各自服务之间的调用不可能都在各自服务中来实现安全与认证功能,因此需要一个专门的微服务来提供这些功能。当请求从客服端发到服务器,如果经过网关的一系列验证和过滤符合访问要求,那么在之后访问其他微服务或由网关路由转发之后的访问时,不需要再做同样的安全认证。这是网关的主要功能。

        实际上,Zuul给我们提供的网关服务种类是很多的。后面会介绍他的一些功能。如果你已经搭建了注册中心那么可以直接看第三节:Zuul服务搭建

    二.Zuul服务的前期准备

    2.1 注册中心EurekaServer的搭建

    为了搭建好网关后,能通过网关来访问各模块微服务来证明网关的搭建成功,因此这里需要提前搭建一些可用的微服务。第一步我们先新建一个Project

    选择Springboot作为启动器,微服务的标配。当然你用Maven的骨架来搭建也完全可以,构建项目并没有非要用哪一种方式搭建。重要的是后面你知道pom里应该引入那些依赖,application.yml怎么配置。这些才是搭建微服务需要主要的地方。这里我使用Spring Initializr

    idea给你默认的内容如下:

    Group和Artifact我们已经见得太多了,当我们指定这两个参数时,项目名和包名应该与之适配。不过当然可以不一样。

    比如默认值 Group为com.example,Artifact为demo,那么项目名应该为demo和Artifact一致,包名Package应该为com.example.demo,为Group和Artifact的合体 。当然这里不强制,只是一种规范,比如别人看见你的包名为com.example.demo时,立马可以知道他属于com.example组下的demo项目。一些使用语言,Java版本,项目类型啥的。

    在这里因为我是作为测试springcloud相关组件的目的,那么我这里设置如下:

    细心的朋友会发现,当我们改完1和2,idea会自动给我们修改3和4选项,既然是规范idea当然希望大家准守。改完1和2,我们点击Next。这一步相当于选择这个项目需要的一些组件,比如这个项目你需要用到springmvc?Mybatis?MySQL?那么在这里选择后,idea会去加载这些相关的依赖并在pom里为大家自动引入这些依赖。

    这里我们要搭建一些测试的微服务,首先搭建1个Eureka注册中心。 所有的微服务都需要在这里注册。微服务的注册与发现详细的搭建过程可以参考上一篇博文:https://blog.csdn.net/qq_29519041/article/details/85238270

    如上图选择Eureka Server,点Next,如下图,项目为zuul,而模组这里我们先搭建微服务的注册中心Eureka Server,所以这里我把模组名命名为eurekaserver,继续点Next。改了模组名,idea会默认在项目目录下建立模组的文件夹,因此可以看见第二个红框自动变化。继续点下一步。

    因为我之前有项目所以这里选择开启新的idea窗口。New Window

    点击import change之后等待idea加载依赖

    查看项目结构:

    此时我习惯把application.properties后缀改为yml。这样配置书写的格式符合yml的风格,比较好看。

    现在需要做下面几件事,由于我们开始构建项目时选择了Eureka Server,所以pom.xml中不需要手动添加依赖了。

    首先在启动类SpringcloudApplication中添加EurekaServer的注解: @EnableEurekaServer

    然后在application.yml中添加相关配置:

    server:
      port: 9000  #eureka注册中心服务端口
    
    eureka:
      instance:
        hostname: localhost
      client:
        register-with-eureka: false #不向eureka注册中心注册。也就是为了关闭自己向自己注册,eureka默认要向自己注册
        fetch-registry: false
        service-url:
          defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

    就可以启动服务了:

    访问注册中心:按照配置的端口号访问。我这里配了9000,端口随意,如下图代表Eureka注册中心部署成功了。

    显示没有实例在此中心注册。没事接下来我们开始配置zuul网关,它也是一个服务需要注册到此注册中心来。

     

    2.2 EurekaService的搭建

    有了注册中心,我们现在需要搭建服务的真正提供者,EurekaService,第四节我们建四个。

    eurekaservice01,eurekaservice02,eurekaservice03,eurekaservice04,第一个如下,第二三四个按着第一个的建,修改一下名字,端口号还有方法返回值。

    需要用到mvc

    服务提供者同样需要注册到注册中心。

    改名你懂得

     

    完成:

    接下来是同样的套路,改yml,启动类添加注解:@EnableEurekaClient

    yml配置如下(因为是测试所有很简陋):

    server:
      port: 8900 # 服务提供方
    
    # 指定当前eureka客户端的注册地址,
    eureka:
      client:
        service-url:
          defaultZone: http://${eureka.instance.hostname}:9000/eureka/
      instance:
        hostname: localhost
    
    #当前服务名称
    spring:
      application:
        name: eurekaservice1

    注意当前服务名称。这里用于注册到注册中心的名字,还可以启动很多同样为eurekaservice1的名字的微服务到注册中心,zuul从注册中心Eureka Server获取所有服务名为eurekaservice01的服务列表后,会采用负载均衡策略访问其中一台服务提供者获取资源。

    下图我们之前zuul中的配置serviceId就是指向这里的服务名称,这是微服务调用的精髓,通过服务名调用。

     

    既然是服务提供者 ,这里要编写controller类了:新建controller包,新建Test01类,编写REST的方法。返回服务1

    按照服务提供者1的搭建方式,现在搭建服务提供者2:

    同样是新建模组,名字改为...02,yml配置文件中端口号与服务1要不同,服务名称相同,为了测试负载均衡,REST方法返回值设为服务2。

    yml:

    server:
      port: 8901 # 服务提供方
    
    # 指定当前eureka客户端的注册地址,
    eureka:
      client:
        service-url:
          defaultZone: http://${eureka.instance.hostname}:9000/eureka/
      instance:
        hostname: localhost
    
    #当前服务名称
    spring:
      application:
        name: eurekaservice1

    同样的方法再建两个服务提供者3和4,服务名称都为eurekaservice2,端口号分别为8902,和8903。REST方法返回值分别为,服务3和服务4。

     

    三.Zuul服务搭建

    有了第二节的准备,搭建了注册中心,和服务的提供者,我们现在开始搭建Zuul网关服务,最后通过zuul访问注册中心获取服务列表,然后访问服务提供者。

    新建模组:

     这里模组名设为zuul。包名设置为zuul,等会生成的启动类就会是带有zuul了。EurekaServer也可以这样只是我开始搭的时候没有注意到。

    需要Eureka的客户端组件,和zuul组件,点next

     模组名设为zuul,不强制

     项目结构:

    在启动类配置注解 @EnableEurekaClient,@EnableZuulProxy,@EnableZuulProxy可以称为@EnableZuulServer的增强版,当Zuul与Eureka、Ribbon等组件配合使用时,我们使用@EnableZuulProxy。 

    配置pom文件:

    server:
       port: 9100
    
    spring:
      application:
        name: zuul
    
    eureka:
      client:
        service-url:
            defaultZone: http://localhost:9000/eureka/ #当前zuul网关想要注册到哪个注册中心这里注册到之前搭的9000上。
    
    #路由规则定义。这里定义两种路由规则route1和route2
    #,代表访问网关/test01/**或/test02/**时。
    #路由到服务名为 eurekaservice1或 eureka
    #service2中的服务集群去。
    zuul:
      routes:
        route1:
          path: /test01/**
          serviceId: eurekaservice1
        route2:
          path: /test02/**
          serviceId: eurekaservice2
    

    启动项目:

    聪明的你再去注册中心看就能看见zuul服务已经被注册到注册中心了

    有了网关,

    五.Zuul的访问

    我们有一个网关服务zuul,一个注册中心eurekaserver,4个服务提供者eurekaservice,4个服务提供者,其中两个提供

    服务名为eurekaservice1的服务,另外两个提供eurekaservice2的服务,现在我们来启动4个服务提供者,在注册中心查看,并通过网关访问测试网关的服务是否正常。

    总项目结构:

    启动后注册中心查看:

    如之前所想,两个服务名下各两台服务提供者。

    现在回想之前zuul的路由配置:

    那么我访问zuul网关的test01/**下的任何服务都会给我转发到服务名为eurekaservice1下的01和02服务下。我们来试试

    第一次访问:test01

    第二次访问:test01

    可以看见zuul网关做了转发和负载均衡,使用的是ribbon轮询的方式负载均衡。

    那么可以猜想到我们访问test02,zuul网关会在服务名为eurekaservice2的服务3和服务4之间去访问了。我们来看看:

    至此我们已经实践完成zuul网关的基本功能转发和负载均衡。第三节会在yml中继续配置一些参数,来实践zuul的更多功能。

    六.Zuul的功能介绍

    6.1 传统路由配置

    6.1.1 传统路由配置

     

    6.1.2 单实例配置

     

    6.1.3 多实例配置

     

    6.2 服务路由配置

    6.3 服务路由的默认规则

    6.4 自定义路由映射规则

    6.5 路径匹配

    6.6 忽略表达式

    6.7 路由前缀

     

     

     

     

    展开全文
  • SpringCloud 之 Zuul 网关搭建及配置

    千次阅读 2020-11-05 14:40:32
    作者:Anakkiblog.csdn.net/qq_29519041/article/details/103654564一.Zuul网关网关,是一种网络关口,既然是关口,就需要知道哪些东...
  •  Zuul网关不是必要的。是推荐使用的。  使用Zuul,一般在微服务数量较多(多于10个)的时候推荐使用,对服务的管理有严格要求的时候推荐使用,当微服务权限要求严格的时候推荐使用。 一、Zuul网
  • 作者:kosaminocnblogs.com/jing99/p/11696192.html 正文 Zuul是spring cloud中的微服务网关网关:是一个网络整...
  • Zuul网关使用步骤

    2021-08-06 22:58:15
    Zuul网关使用步骤 1.在父项目中导入依赖SpringCloud管理 <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>...
  • zuul网关的介绍

    2020-10-27 21:12:18
    首先我们要知道为什么要使用网关呢? 先复习一下之前说过的微服务的知识,最开始我们运行微服务就是三个重要部分 1.服务端 2.消费端 3.注册中心 首先用户在消费端发出消息,这个时候就需要负载均衡器Ribbon去调配...
  • >>号外:关注“Java精选”公众号,菜单栏->聚合->干货分享,回复关键词领取视频资料、开源项目。Zuul是spring cloud中的微服务网关网关:是一个...
  • 答:Zuul是Java语言实现的,主要为Java服务提供网关服务,尤其是在微服务架构中可以更加灵活的对网关进行操作。Nginx是使用C语言实现,性能高于Zuul,但是实现自定义操作需要熟悉Lua语言,对程序员要求较高,可以...
  • Zuul网关使用笔记

    2020-08-06 17:10:50
    文章目录Zuul介绍Pom 中引入包启动类中添加@EnableZuulProxy注解启用Zuul的API网关功能yml文件中配置相关属性信息路由映射规则传统路由实现方式面向服务的路由与传统路由相比,有外部请求到API网关的时候,面向服务...
  • 使用Zuul网关统一入口

    2021-07-26 19:43:02
    Zuul网关统一入口一、什么是Zuul二、代码实现三、配置路由原则① 使用指定地址代替微服务名称② 让用户不能通过微服务名称访问③忽略所有微服务名称④给访问路径添加统一前缀四、使用ZuulFilter拦截过滤请求 ...
  • Zuul网关请求拦截控制

    2021-08-31 15:13:59
    zuul网关拦截器的执行: a. 首先根据filterType决定顺序pre优先post执行,此时filterOrder没有作用; b. filterType相同情况下,filterOrder值越小,优先级越高,负数也一样; c. pre拦截器在请求被路由前执行,一般...
  • zuul网关整合swagger

    2020-09-24 16:15:07
    zuul整合swagger网关 maven依赖 <dependency> <groupId>com.spring4all</groupId> <artifactId>swagger-spring-boot-starter</artifactId> <version>1.7.0.RELEASE</...
  • 1.还是和SpringCloud Config配置中心动态刷新配置文件一样 了解配置中心... 2.在码云创建一个新的配置文件zuul-gateway-dynamic-dev.properties .内容为zuul网关配置信息 3.搭建动态zuul...
  • Zuul网关服务

    千次阅读 2019-06-15 00:21:40
    微服务调用过程 前面的博客文章已经介绍过spring cloud的服务的相关...这个就是spring cloud提供的网关网关维护着所有的微服务,客户端通过请求到网关,由网关分发到不同的微服务,这样客户端就只需要维护网关...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,045
精华内容 12,018
关键字:

zuul网关