SpringCloud — Zuul Api网关

pom.xml:

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.aaron</groupId>
    <artifactId>api-gateway</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>api-gateway</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- 不指定路径则从maven库中查找父级 -->
    </parent>

    <!-- 指定统一版本 -->
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.SR1</spring-cloud.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</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-netflix-eureka-client</artifactId>
        </dependency>

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

        <!-- Slf4j注解依赖包（日志） -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

application.yml配置文件:

#静态常量
static:
  ip: 127.0.0.1
  eurekaport: 8016
  username: root
  password: root
#端口
server:
  port: 8888

spring:
  application:
    name: zuul_api_gateway

#eureka注册
eureka:
  client:
    register-with-eureka: true
    service-url:
      defaultZone: http://${static.ip}:${static.eurekaport}/eureka
  instance:
    prefer-ip-address: true
    #设置心跳检测检测与续约时间
    lease-renewal-interval-in-seconds: 30
    lease-expiration-duration-in-seconds: 60

#zuul网关
zuul:
  ignoredServices: '*'
  #网关路由配置
  routes:
    basic:
      path: /aarontest/**
      serviceId: consumer

ribbon:
  #请求连接的超时时间
  ReadTimeout: 60000
  #请求处理的超时时间
  ConnectTimeout: 60000

hystrix:
  command:
    default:
      execution:
        timeout:
          enabled: true
        isolation:
          thread:
            #断路器的超时时间需要大于ribbon的超时时间，不然不会触发重试。
            timeoutInMilliseconds: 70000

application启动类:

package com.aaron.api;

import com.aaron.api.filter.AccessFilter;
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;

@EnableEurekaClient
@EnableZuulProxy
@SpringBootApplication
public class ApiGatewayApplication {

    @Bean
    public AccessFilter accessFilter() {
        return new AccessFilter();
    }

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

}

AccessFilter 路由过滤规则类：

package com.aaron.api.filter;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import lombok.extern.slf4j.Slf4j;
import javax.servlet.http.HttpServletRequest;

/**
 * 继承ZullFilter，用来进行请求过滤
 */
@Slf4j
public class AccessFilter extends ZuulFilter {
    /**
     * filterType 返回过滤器类型
     * 他决定了过滤器在请求的哪个生命周期中执行。这里定义为pre，代表会在请求被路由前执行。
     * pre:请求执行之前filter
     * route: 处理请求，进行路由
     * post: 请求处理完成后执行的filter
     * error:出现错误时执行的filter
     *
     * @return
     */
    @Override
    public String filterType() {
        return "pre";
    }

    /**
     * filterOrder 返回过滤器的执行顺序
     * 当请求在一个阶段有多个过滤器是，需要根据该方法的返回值来依次执行
     *
     * @return
     */
    @Override
    public int filterOrder() {
        return 0;
    }

    /**
     * shouldFilter 判断该过滤器是否需要被执行
     * 这里直接返回true，表示该过滤器对所有请求都会生效。
     * 实际运用中我们可以利用该函数指定过滤器的有效范围
     *
     * @return
     */
    @Override
    public boolean shouldFilter() {
        return true;
    }
    /**
     * 过滤器的具体逻辑
     *
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        try {
            HttpServletRequest request = ctx.getRequest();
            ctx.getResponse().setContentType("text/html;charset=UTF-8");
            log.info("send {} request to {}", request.getMethod(), request.getRequestURL().toString());
            String token = request.getHeader("token");
            //具体逻辑视需求而定
            if(token.isEmpty())
            {
                log.warn("访问令牌为空");
                routeBlocking(ctx);
                ctx.setResponseBody("访问令牌为空");
                return null;
            }

        } catch (Exception e) {
            e.printStackTrace();
            routeBlocking(ctx);
            log.warn("网关路由转化异常");
        }
        log.info("放行");
        return null;
    }

    // 这里我们通过RequestContext.setSendZuulResponse(false)让zuul过来请求，不对其进行路由
    // 然后通过RequestContext.setResponseStatusCode()设置了返回的错误码
    private void  routeBlocking(RequestContext ctx){
        ctx.setSendZuulResponse(false);
        ctx.setResponseStatusCode(401);
    }
}

Eureka注册中心：