一、网关介绍

API网关出现的原因是微服务架构的出现，不同的微服务一般会有不同的网络地址，而外部客户端可能需要调用多个服务的接口才能完成一个业务需求，如果让客户端直接与各个微服务通信，会有以下的问题：
（1）客户端会多次请求不同的微服务，增加了客户端的复杂性。
（2）存在跨域请求，在一定场景下处理相对复杂。
（3）认证复杂，每个服务都需要独立认证。
（4）难以重构，随着项目的迭代，可能需要重新划分微服务。例如，可能将多个服务合并成一个或者将一个服务拆分成多个。如果客户端直接与微服务通信，那么重构将会很难实施。
（5）某些微服务可能使用了防火墙 / 浏览器不友好的协议，直接访问会有一定的困难。
以上这些问题可以借助 API 网关解决。API 网关是介于客户端和服务器端之间的中间层，所有的外部请求都会先经过API 网关这一层。也就是说，API 的实现方面更多的考虑业务逻辑，而安全、性能、监控可以交由 API 网关来做，这样既提高业务灵活性又不缺安全性

二、Spring Cloud Gateway介绍

Spring cloud gateway是spring官方基于Spring 5.0、Spring Boot2.0和Project Reactor等技术开发的网关，Spring Cloud Gateway旨在为微服务架构提供简单、有效和统一的API路由管理方式，Spring Cloud Gateway作为Spring Cloud生态系统中的网关，目标是替代Netflix Zuul，其不仅提供统一的路由方式，并且还基于Filer链的方式提供了网关基本的功能，例如：安全、监控/埋点、限流等
image.png

三、搭建gateway模块

使用maven构建，构建gateway模块，该模块为项目的直接子模块。

配置pom.xml

  1. <dependencies>
  2.   <dependency>
  3.     <groupId>com.zhoujk</groupId>
  4.     <artifactId>common_util</artifactId>
  5.     <version>0.0.1-SNAPSHOT</version>
  6.   </dependency>
  7.   <!--网关-->
  8.   <dependency>
  9.     <groupId>org.springframework.cloud</groupId>
  10.     <artifactId>spring-cloud-starter-gateway</artifactId>
  11.   </dependency>
  13.   <!-- 服务注册 -->
  14.   <dependency>
  15.     <groupId>com.alibaba.cloud</groupId>
  16.     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  17.   </dependency>
  18.   <!-- 负载均衡 -->
  19.   <dependency>
  20.     <groupId>org.springframework.cloud</groupId>
  21.     <artifactId>spring-cloud-loadbalancer</artifactId>
  22.   </dependency>
  23. </dependencies>

配置application.yml

server:
  port: 80
spring:
  application:
    name: service-gateway
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true
      routes:
        - id: service-hosp
          predicates:
            - Path=/*/hosp/**,/*/hospital/**
          uri: lb://service-hosp
        - id: service-cmn
          predicates: Path=/*/cmn/**
          uri: lb://service-cmn
        - id: service-user
          predicates:
            - Path=/*/user/**,/*/ucenter/**
          uri: lb://service-user
        - id: service-msm
          predicates: Path=/*/msm/**
          uri: lb://service-msm
        - id: service-oss
          predicates: Path=/*/oss/**
          uri: lb://service-oss
        - id: service-order
          predicates: Path=/*/order/**
          uri: lb://service-order
        - id: service-task
          predicates: Path=/*/task/**
          uri: lb://service-task
        - id: service-statistics
          predicates: Path=/*/statistics/**
          uri: lb://service-statistics
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

添加启动类

@SpringBootApplication(exclude={DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
public class GatewayApplication
{
    public static void main(String[] args)
    {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

跨域配置类

@Slf4j
@Configuration
public class CorsConfig {
    @Bean
    public CorsWebFilter corsFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedMethod("*");
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
        source.registerCorsConfiguration("/**", config);
        log.info("跨域配置 finish...");
        return new CorsWebFilter(source);
    }
}

过滤配置类


/**
 * @author : zhoujiankang
 * @Desc:  全局Filter过滤器，统一处理会员登录与外部不允许访问的服务
 * @since : 2022/4/28 23:23
 */

@Component
public class AuthGlobalFilter implements GlobalFilter, Ordered {

    private final AntPathMatcher antPathMatcher = new AntPathMatcher();

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String path = request.getURI().getPath();
        System.out.println("===" + path);

        //内部服务接口，不允许外部访问
        if (antPathMatcher.match("/**/inner/**", path)) {
            ServerHttpResponse response = exchange.getResponse();
            return out(response, ResultCodeEnum.PERMISSION);
        }

        //api接口，异步请求，校验用户必须登录
        if (antPathMatcher.match("/api/**/auth/**", path)) {
            Long userId = this.getUserId(request);
            if (ObjectUtils.isEmpty(userId)) {
                ServerHttpResponse response = exchange.getResponse();
                return out(response, ResultCodeEnum.LOGIN_AUTH);
            }
        }
        return chain.filter(exchange);
    }

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

    /**
     * api接口鉴权失败返回数据
     *
     * @param response  响应
     * @return
     */
    private Mono<Void> out(ServerHttpResponse response, ResultCodeEnum resultCodeEnum) {
        Result result = Result.build(null, resultCodeEnum);
        byte[] bits = JSONObject.toJSONString(result).getBytes(StandardCharsets.UTF_8);
        DataBuffer buffer = response.bufferFactory().wrap(bits);
        //指定编码，否则在浏览器中会中文乱码
        response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        return response.writeWith(Mono.just(buffer));
    }

    /**
     * 获取当前登录用户id
     *
     * @param request 请求
     * @return token
     */
    private Long getUserId(ServerHttpRequest request) {
        String token = "";
        List<String> tokenList = request.getHeaders().get("token");
        if (null != tokenList) {
            token = tokenList.get(0);
        }
        if (!ObjectUtils.isEmpty(token)) {
            return JwtHelper.getUserId(token);
        }
        return null;
    }
}