SpringCloud之一统天下-微服务网关Zuul

微服务网关Zuul

为什么需要微服务网关

不同的微服务一般有不同的网络地址，而外部的客户端可能需要调用多个服务的接口才能完成一个业务需求。比如一个电影购票的收集APP,可能回调用电影分类微服务，用户微服务，支付微服务等。如果客户端直接和微服务进行通信，会存在一下问题：
1）客户端会多次请求不同微服务，增加客户端的复杂性
2）存在跨域请求，在一定场景下处理相对复杂
3）认证复杂，每一个服务都需要独立认证
4）难以重构，随着项目的迭代，可能需要重新划分微服务，如果客户端直接和微服务通信，那么重构会难以实施
5）某些微服务可能使用了其他协议，直接访问有一定困难

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

什么是Zuul

Zuul是Netflix开源的微服务网关，他可以和Eureka,Ribbon,Hystrix等组件配合使用。Zuul组件的核心是一系列的过滤器，这些过滤器可以完成以下功能：
1）身份认证和安全: 识别每一个资源的验证要求，并拒绝那些不符的请求
2）审查与监控：
3）动态路由：动态将请求路由到不同后端集群
4）压力测试：逐渐增加指向集群的流量，以了解性能
5）负载分配：为每一种负载类型分配对应容量，并弃用超出限定值的请求
6）静态响应处理：边缘位置进行响应，避免转发到内部集群
7）多区域弹性：跨域AWS Region进行请求路由，旨在实现ELB(ElasticLoad Balancing)使用多样化Spring Cloud对Zuul进行了整合和增强。

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

Zuul路由转发

管理后台微服务网关

1）创建子模块tensquare_manager，pom.xml引入eureka-client 和zuul的依赖

        <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）创建application.yml

server:
  port: 9011
spring:
  application:
    name: tensquare-manager
  rabbitmq:
    host: 192.168.2.10
eureka:
  client:
    service-url:
      defaultZone: http://192.168.2.10:6868/eureka/
  instance:
    prefer-ip-address: true
zuul:
  routes:
    tensquare-article: #文章(名字随便取)
      path: /article/** #配置路由规则
      serviceId: tensquare-article #指定Eureka注册中心中的服务id
    tensquare-base:
      path: /base/**
      serviceId: tensquare-base
    tensquare-friend:
      path: /friend/**
      serviceId: tensquare-friend
    tensquare-gathering:
      path: /gathering/**
      serviceId: tensquare-gathering
    tensquare-qa:
      path: /qa/**
      serviceId: tensquare-qa
    tensquare-recruit:
      path: /recruit/**
      serviceId: tensquare-recruit
    tensquare-spit:
      path: /spit/**
      serviceId: tensquare-spit
    tensquare-user:
      path: /user/**
      serviceId: tensquare-user
jwt:
 config:
    key: youcan

3）编写启动类

package com.tensquare.manager;

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

@SpringBootApplication
@EnableEurekaClient
@EnableZuulProxy
public class ManagerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ManagerApplication.class);
    }
    @Bean
    public JwtUtil jwtUtil(){
        return new JwtUtil();
    }
}

网站前台的微服务网关

1）创建子模块tensquare_web，pom.xml引入依赖zuul

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

2）创建application.yml

server:
  port: 9012
spring:
  application:
    name: tensquare-web
  rabbitmq:
    host: 192.168.2.10
eureka:
  client:
    service-url:
      defaultZone: http://192.168.2.100:6868/eureka/
  instance:
    prefer-ip-address: true
zuul:
  routes:
    tensquare-search:
      path: /search/**
      serviceId: tensquare-search
    tensquare-article: #文章(名字随便取)
      path: /article/** #配置路由规则
      serviceId: tensquare-article #指定Eureka注册中心中的服务id
    tensquare-base:
      path: /base/**
      serviceId: tensquare-base
    tensquare-friend:
      path: /friend/**
      serviceId: tensquare-friend
    tensquare-gathering:
      path: /gathering/**
      serviceId: tensquare-gathering
    tensquare-qa:
      path: /qa/**
      serviceId: tensquare-qa
    tensquare-recruit:
      path: /recruit/**
      serviceId: tensquare-recruit
    tensquare-spit:
      path: /spit/**
      serviceId: tensquare-spit
    tensquare-user:
      path: /user/**
      serviceId: tensquare-user
jwt:
 config:
    key: youcan

3）编写启动类

package com.tensquare.manager;

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

@SpringBootApplication
@EnableEurekaClient
@EnableZuulProxy
public class ManagerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ManagerApplication.class);
    }

    @Bean
    public JwtUtil jwtUtil() {
        return new JwtUtil();
    }
}

Zuul过滤器

Zuul过滤器快速体验

我们现在在tensquare_web 创建一个简单的zuul过滤器

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 ManagerFilter extends ZuulFilter {

    @Autowired
    private JwtUtil jwtUtil;
    /**
     * 在请求前pre或者后post执行
     * @return
     */
    @Override
    public String filterType() {
        return "pre";
    }

    /**
     * 多个过滤器的执行顺序，数字越小，表示越先执行
     * @return
     */
    @Override
    public int filterOrder() {
        return 0;
    }

    /**
     * 当前过滤器是否开启true表示开启
     * @return
     */
    @Override
    public boolean shouldFilter() {
        return true;
    }

    /**
     * 过滤器内执行的操作 return 任何ojbect的值都表示继续执行
     * setsendzullRespponse(false)表示不再继续执行
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {
        System.out.println("经过后台过滤器了！");
        RequestContext requestContext = RequestContext.getCurrentContext();
        //request域
        HttpServletRequest request = requestContext.getRequest();

        if(request.getMethod().equals("OPTIONS")){
            return null;
        }

        if(request.getRequestURI().indexOf("login")>0){
            return null;
        }

        // 得到头信息
        String header = request.getHeader("Authorization");
        if(header!=null && !"".equals(header)){
            if(header.startsWith("Bearer ")){
                String token = header.substring(7);
                try {
                    Claims claims = jwtUtil.parseJWT(token);
                    String roles = (String) claims.get("roles");
                    if(roles.equals("admin")){
                        //把头信息转发下去，并且放行
                        requestContext.addZuulRequestHeader("Authorization", header);
                        return null;
                    }
                }catch (Exception e){
                    e.printStackTrace();
                    requestContext.setSendZuulResponse(false);//终止运行
                }
            }
        }
        requestContext.setSendZuulResponse(false);//终止运行
        requestContext.setResponseStatusCode(403);
        requestContext.setResponseBody("权限不足");
        requestContext.getResponse().setContentType("text/html;charset=utf-8");
        return null;
    }
}

说明：
启动tensquare_web会发现过滤器已经执行
1）filterType：返回一个字符串代表过滤器的类型，在zuul中定义了四种不同生命周期的过滤器类型，具体如下：
1.1）pre ：可以在请求被路由之前调用；
1.2）route ：在路由请求时候被调用；
1.3）post ：在route和error过滤器之后被调用；
1.4）error ：处理请求时发生错误时被调用；
2）filterOrder ：通过int值来定义过滤器的执行顺序；
3）shouldFilter ：返回一个boolean类型来判断该过滤器是否要执行，所以通过此函数可实现过滤器的开关。在上例中，我们直接返回true，所以该过滤器总是生效；
4）run ：过滤器的具体逻辑；

网站前台的token转发

我们现在在过滤器中接收header，转发给微服务，修改tensquare_web的过滤器。如果有token，直接转发。

    @Override
    public Object run() throws ZuulException {
        //得到request上下文
        RequestContext currentContext = RequestContext.getCurrentContext();
        //得到request域
        HttpServletRequest request = currentContext.getRequest();
        //得到头信息
        String header = request.getHeader("Authorization");
        //判断是否有头信息
        if(header!=null && !"".equals(header)){
            //把头信息继续向下传
            currentContext.addZuulRequestHeader("Authorization", header);
        }
        return null;
    }

管理后台过滤器实现token校验

修改tensquare_manager的过滤器, 因为是管理后台使用，所以需要在过滤器中对token进行验证。
1）tensquare_manager引入tensquare_common依赖 ，因为需要用到其中的JWT工具类

        <dependency>
            <groupId>com.tensquare</groupId>
            <artifactId>tensquare_common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

2）修改tensquare_manager配置文件application.yml

jwt:
 config:
    key: youcan

3）修改tensquare_manager的启动类,添加bean

    @Bean
    public JwtUtil jwtUtil(){
        return new JwtUtil();
    }

4）tensquare_manager编写过滤器类

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 ManagerFilter extends ZuulFilter {

    @Autowired
    private JwtUtil jwtUtil;
    /**
     * 在请求前pre或者后post执行
     * @return
     */
    @Override
    public String filterType() {
        return "pre";
    }

    /**
     * 多个过滤器的执行顺序，数字越小，表示越先执行
     * @return
     */
    @Override
    public int filterOrder() {
        return 0;
    }

    /**
     * 当前过滤器是否开启true表示开启
     * @return
     */
    @Override
    public boolean shouldFilter() {
        return true;
    }

    /**
     * 过滤器内执行的操作 return 任何ojbect的值都表示继续执行
     * setsendzullRespponse(false)表示不再继续执行
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {
        System.out.println("经过后台过滤器了！");
        RequestContext requestContext = RequestContext.getCurrentContext();
        //request域
        HttpServletRequest request = requestContext.getRequest();

        if(request.getMethod().equals("OPTIONS")){
            return null;
        }

        if(request.getRequestURI().indexOf("login")>0){
            return null;
        }

        //得到头信息
        String header = request.getHeader("Authorization");
        if(header!=null && !"".equals(header)){
            if(header.startsWith("Bearer ")){
                String token = header.substring(7);
                try {
                    Claims claims = jwtUtil.parseJWT(token);
                    String roles = (String) claims.get("roles");
                    if(roles.equals("admin")){
                        //把头信息转发下去，并且放行
                        requestContext.addZuulRequestHeader("Authorization", header);
                        return null;
                    }
                }catch (Exception e){
                    e.printStackTrace();
                    requestContext.setSendZuulResponse(false);//终止运行
                }
            }
        }
        requestContext.setSendZuulResponse(false);//终止运行
        requestContext.setResponseStatusCode(403);
        requestContext.setResponseBody("权限不足");
        requestContext.getResponse().setContentType("text/html;charset=utf-8");
        return null;
    }
}

说明：
1）需要注意，这里我们通过ctx.setSendZuulResponse(false) 令zuul过滤该请求，不对其进行路由，然后通过ctx.setResponseStatusCode(401) 设置了其返回的错误码；