NetflixZuul、SpringCloudConfig、SpringCloudBus

为什么需要微服务网关 ？

不同的微服务一般有不同的网络地址，而外部的客户端可能需要调用多个服务的接口才能完成一个业务需求。

比如一个电影购票的收集APP,可能会调用电影分类微服务，用户 微服务，支付微服务等。
如果客户端直接和微服务进行通信，会存在以下问题：

1. 客户端会多次请求不同微服务，增加客户端的复杂性
2. 存在跨域请求，在一定场景下处理相对复杂
3. 认证复杂，每一个服务都需要独立认证
4. 难以重构，随着项目的迭代，可能需要重新划分微服务，如果客户端直接和微服务通 信，那么重构会难以实施
5. 某些微服务可能使用了其他协议(例如有些服务是用java以外的语言写的)，直接访问有一定困难

上述问题，都可以借助微服务网关解决。微服务网关是介于客户端和服务器端之间的中间层，所有的外部请求都会先经过微服务网关。

什么是zuul？

Zuul是Netflix开源的微服务网关，他可以和Eureka,Ribbon,Hystrix等组件配合使 用。

Zuul组件的核心是一系列的过滤器，这些过滤器可以完成以下功能：

1. 身份认证和安全: 识别每一个资源的验证要求，并拒绝那些不符的请求
2. 审查与监控： 所有的请求都经过网关，我们就可以审查和监控所有的请求
3. 动态路由：动态将请求路由到不同后端集群
4. 压力测试：逐渐增加指向集群的流量，以了解性能
5. 负载分配：为每一种负载类型分配对应容量，并弃用超出限定值的请求

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

使用Zuul后，架构图演变为以下形式

在这网关就可以做一个身份认证，所有的请求都经过网关，如果符合往后走，不符合网关就可以做一个拦截。

搭建后台微服务网关

依赖

<dependencies>
        <!--eureka客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <!--zuul网关-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>

        <!--添加公共工程依赖,需要使用JwtUtil-->
        <dependency>
            <groupId>com.tensquare</groupId>
            <artifactId>tensquare_common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

application.yml

server:
  port: 9011
spring:
  application:
    name: tensquare-manager
eureka:
  client:
    service-url:
      #Eureka客户端与Eureka服务端进行交互的地址
      defaultZone: http://127.0.0.1:6868/eureka/
  instance:
    prefer‐ip‐address: true
#配置zuul的路由转发
zuul:
  routes:
    tensquare-base: #路由的名字,任意填写
      #配置请求URL的请求规则,例如要访问基础微服务http://127.0.0.1:9011/base/.....
      path: /base/**
      serviceId: tensquare-base 
      #指定Eureka注册中心中的服务id
    tensquare-qa:
      path: /qa/**
      serviceId: tensquare-qa #指定Eureka注册中心中的服务id
    tensquare-user:
      path: /user/** #/user/user/1
      serviceId: tensquare-user #指定Eureka注册中心中的服务id
jwt:
  config:
    key: itcast

开启zuul网关

package com.tensquare.manager;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
import org.springframework.context.annotation.Bean;
import util.IdWorker;

@SpringBootApplication
// 开启使用zuul网关
@EnableZuulProxy
public class ManagerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ManagerApplication.class,args);
    }

    @Bean
    public IdWorker createIdWorker(){
        return new IdWorker(1,1);
    }
}

后台网关用户身份验证

package com.tensquare.manager.filter;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import util.JwtUtil;

import javax.servlet.http.HttpServletRequest;

@Component
public class MyFilter extends ZuulFilter {

    @Autowired
    private JwtUtil jwtUtil;

    @Override
    public String filterType() {
        return "pre";
    }

    @Override
    public int filterOrder() {
        return 0;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() throws ZuulException {
        //获取requestContext
        RequestContext requestContext = RequestContext.getCurrentContext();
        //获取原来的请求
        HttpServletRequest request = requestContext.getRequest();
        //获取请求头,token数据
        String header = request.getHeader("Authorization");


        //对请求头中的token数据进行规则校验
        if (header != null && !"".equals(header) && header.startsWith("Bearer ")) {
            try {
                //获取token
                String token = header.substring(7);

                //解析token,使用jwt工具类
                Claims claims = jwtUtil.parseJWT(token);

                if (claims != null) {
                    //判断用户是否是管理员
                    String roles = (String) claims.get("roles");

                    if ("admin".equals(roles)) {
                        //如果是管理员,把请求头信息转发
                        requestContext.addZuulRequestHeader("Authorization", header);

                        //放行
                        return null;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }

        //如果不是管理员
        //不能进行网关路由转发,参数为false就不会进行路由转发,相当于拦截
        requestContext.setSendZuulResponse(false);
        //设置相应状态码
        requestContext.setResponseStatusCode(401);
        //设置响应内容
        requestContext.setResponseBody("用户必须是管理员,身份校验失败!");

        //设置相应类型
        requestContext.getResponse().setContentType("text/html;charset=utf-8");

        return null;
    }
}

搭建前台网关

后台网关和前台网关是两个不同的服务，前台网关其他的作用暂时还没弄清楚

使用zuul过滤器解决请求路由转发头信息丢失的问题

package com.tensquare.web.filter;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

@Component
public class MyFilter extends ZuulFilter {
    @Override
    public String filterType() {
        //过滤器在网关进行路由转发之前,执行
        return "pre";
        //pre ：可以在请求被路由之前调用
        //route ：在路由请求时候被调用
        //post ：在route和error过滤器之后被调用
        //error ：处理请求时发生错误时被调用
    }

    @Override
    public int filterOrder() {
        //设置过滤器执行的优先级
        //如果为0,最高优先级,最先执行
        //数字越大,优先级越低
        return 0;
    }

    @Override
    public boolean shouldFilter() {
        //true:执行这个过滤器
        //false:不执行这个过滤器
        return true;
    }

    @Override
    public Object run() throws ZuulException {
        //过滤器执行的具体业务逻辑
        System.out.println("zuul过滤器执行了");

        RequestContext requestContext = RequestContext.getCurrentContext();
        //获取原来的请求
        HttpServletRequest request = requestContext.getRequest();
        //获取原来的请求头
        String header = request.getHeader("Authorization");

        //把原来的请求头设置到路由转发的请求头中
        requestContext.addZuulRequestHeader("Authorization", header);

        //方法结束,过滤器执行完成,放行
        return null;
    }
}

filterType：返回一个字符串代表过滤器的类型，在zuul中定义了四种不同生命周期的过 滤器类型，具体如下：

• pre ：可以在请求被路由之前调用
• route ：在路由请求时候被调用
• post ：在route和error过滤器之后被调用
• error ：处理请求时发生错误时被调用
• filterOrder ：通过int值来定义过滤器的执行顺序
• shouldFilter ：返回一个boolean类型来判断该过滤器是否要执行，所以通过此函数可 实现过滤器的开关。
  在上例中，我们直接返回true，所以该过滤器总是生效
• run ：过滤器的具体逻辑。

springCloudConfig简介

在分布式系统中，由于服务数量巨多，为了方便服务配置文件统一管理，实时更新，所 以需要分布式配置中心组件。

在Spring Cloud中，有分布式配置中心组件spring cloud config ，它支持配置服务放在配置服务的内存中（即本地），也支持放在远程Git仓库中。

在spring cloud config 组件中，分两个角色，一是config server，二是config client。

微服务在启动时会请求Config Server获取配置文件的内容，请求到后再启动容器。

git配置文件

server:
  port: 9001
spring:
  application:
    name: tensquare-base # 微服务的名字，springCloud会用到
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.190.0:3306/tensquare_base?characterEncoding=utf-8
    username: root
    password: root

mybatis:
  type-aliases-package: com.tensquare.recruit.pojo

eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:6868/eureka/
  instance:
    #获取服务相关的ip地址
    prefer-ip-address: true

搭建配置中心微服务

依赖

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-config-server</artifactId>
</dependency>

配置文件

application.yml

server:
  port: 12000
spring:
  application:
    name: tenquare-config
  cloud:
    config:
      server:
        git:
          #配置文件所在的仓库的地址
          uri: https://gitee.com/itcast_xu/tensquare-config336.git

开启配置中心

在springboot启动类上添加@EnableConfigServer

配置 配置中心客户端

依赖

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-config</artifactId>
</dependency>

编写配置文件

spring:
  cloud:
    config:
      #使用的配置文件名是base-dev.yml
      #配置文件名前半部分
      name: base
      #配置文件名后半部分
      profile: dev
      #git仓库的分支名称
      label: master
      #配置中心访问地址
      uri: http://127.0.0.1:12000

Spring Cloud Bus

如果我们更新码云中的配置文件，那客户端工程是不能及时接受新的配置信息。

修改服务器中的配置并没有更 新立刻到工程，只有重新启动程序才会读取配置。

那我们如果想在不重启微服务的情况 下更新配置如何来实现呢? 我们使用SpringCloudBus来实现配置的自动更新。

所以在这需要修改配置中心、添加mq和修改各微服务，

配置 配置中心服务

依赖

<!--配置中心,添加消息总线的依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-bus</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
</dependency>

更新配置中心服务 配置文件

application.yml

server:
  port: 12000
spring:
  application:
    name: tenquare-config
  cloud:
    config:
      server:
        git:
          #配置文件所在的仓库的地址
          uri: https://gitee.com/itcast_xu/tensquare-config336.git
  #配置消息总线使用的RabbitMQ服务的地址
  rabbitmq:
    host: 192.168.72.131
#配置如何通知配置中心
management:
  endpoints:
    web:
      exposure:
        include: bus-refresh

配置中心客户端 也就是各微服务

依赖

<!--添加使用配置中心的依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>

        <!--添加消息总线微服务客户端的依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-bus</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

git文件配置rabbitMQ的地址

就添加个rabbitmq的主机地址就好

刷新配置文件

请求这个地址就会刷新微服务读取新的配置文件

http://127.0.0.1:12000/actuator/bus-refresh

但是我们不能每次更新git中的配置文件就请求一次这个地址，太麻烦了

@RefershScope：当消息总线通知配置文件变更，需要加载内容的部分也需要刷新

知青的活不太重，因为这地方靠山吃山，农作物种得不多。夏天的晚上我们轮流去田里看庄稼----怕庄稼被野兽啃了，所以每天晚上得有一两个人在庄稼地里过夜。

鬼吹灯
天下霸唱