黑马商城（四）网关

一、网关介绍

二、快速入门

路由规则配置：

package com.hmall.gateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


@SpringBootApplication
public class GatewayApplication {
    public static void main(String[] args) {

        SpringApplication.run(GatewayApplication.class, args);
    }
}

server:
  port: 8080
spring:
  application:
    name: gateway
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.50.129:8848
    gateway:
      routes:
        - id: item-service
          uri: lb://item-service
          predicates:
            - Path=/items/**,/search/** #多controller情况
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/users/**,/addresses/** #多controller情况
        - id: trade-service
          uri: lb://trade-service
          predicates:
            - Path=/orders/**
        - id: cart-service
          uri: lb://cart-service
          predicates:
            - Path=/carts/** #多controller情况

三、路由属性 

路由断言：

路由过滤器：

想要在其他路由中同样生效（全局过滤器）

四、网关登录校验

自定义过滤器：

GlobalFilter：

@Component
public class MyGlobalFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //TODO 模拟登录校验逻辑
        ServerHttpRequest request = exchange.getRequest();
        HttpHeaders headers = request.getHeaders();
        System.out.println("Headers = "+headers );
        //放行
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        //设置过滤器的优先级
        return 0;
    }
}

GatewayFilter：

package com.hmall.gateway.filters;

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.OrderedGatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class PrintAnyGatewayFilterFactory extends AbstractGatewayFilterFactory<Object> {
    @Override
    public GatewayFilter apply(Object config) {
/*        //匿名内部类
        return new GatewayFilter() {
            //匿名内部类无法实现Ordered接口 来实现设置优先级
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                System.out.println("print any filter running");
                return chain.filter(exchange);
            }
        };*/
        //能够实现Ordered接口的装饰类 --OrderedGatewayFilter 
        return new OrderedGatewayFilter(new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                System.out.println("print any filter running");
                return chain.filter(exchange);
            }
        },1);
    }
}

server:
  port: 8080
spring:
  application:
    name: gateway
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.50.129:8848
    gateway:
      routes:
        - id: item-service
          uri: lb://item-service
          predicates:
            - Path=/items/**,/search/** #多controller情况
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/users/**,/addresses/** #多controller情况
        - id: trade-service
          uri: lb://trade-service
          predicates:
            - Path=/orders/**
        - id: cart-service
          uri: lb://cart-service
          predicates:
            - Path=/carts/** 
        - id: pay-service
          uri: lb://pay-service
          predicates:
            - Path=/pay-orders/** 
      default-filters:
        - PrintAny

实现登录校验:

package com.hmall.gateway.filters;


import com.hmall.common.exception.UnauthorizedException;
import com.hmall.gateway.config.AuthProperties;
import com.hmall.gateway.utils.JwtTool;
import lombok.RequiredArgsConstructor;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.List;

@Component
@RequiredArgsConstructor
public class AuthGlobalFilter implements GlobalFilter, Ordered {

    private final AuthProperties authProperties; //构造函数注入

    private final JwtTool jwtTool;

    private final AntPathMatcher antPathMatcher=new AntPathMatcher();

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //1.获取用户信息--request
        ServerHttpRequest request = exchange.getRequest();
        //2.判断是否需要登录拦截
        if(isExclude(request.getPath().toString())){
            //是排除路径中 --放行
            return chain.filter(exchange);
        }
        //3.获取token
        /* HttpHeaders headers = request.getHeaders();*/
        String token= null;
        List<String> headers = (List<String>) request.getHeaders().get("authorization");
        if(headers!=null && !headers.isEmpty()){
            token =headers.get(0);
        }
        //4.校验并解析token
        Long userId=null;
        try {
            userId = jwtTool.parseToken(token);
        } catch (UnauthorizedException e) {
            //拦截 设置响应状态码401
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        //TODO 5.传递用户信息
        System.out.println("userId = "+userId);
        //6.放行
        return chain.filter(exchange);
    }

    private boolean isExclude(String path) {
        for (String pathPattern : authProperties.getExcludePaths()){
            if(antPathMatcher.match(pathPattern,path)){
                //如果匹配上了
                return true;
            }
        }
        return false;
    }

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

网关传递用户：

package com.hmall.common.interceptors;

import cn.hutool.core.util.StrUtil;
import com.hmall.common.utils.UserContext;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


public class UserInfoInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.获取用户信息
        String userInfo = request.getHeader("user-info");

        //2.判断是否获取了用户，如果有，存入ThreadLocal
        if(StrUtil.isNotBlank(userInfo)){
            //不为空--存储信息到ThreadLocal中
            UserContext.setUser(Long.valueOf(userInfo));
        }
        //3.放行
        return true;
    }


    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //清理用户
        UserContext.removeUser();
    }
}

package com.hmall.common.config;

import com.hmall.common.interceptors.UserInfoInterceptor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
@ConditionalOnClass(DispatcherServlet.class) 
//网关同样引用了hmall-common 而网关模块并不是基于springmvc导致报错
//通过SpringBoot自动装配的条件注解 来防止在网关中自动装配导致报错
public class MvcConfig implements WebMvcConfigurer {

    //拦截器的注册器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new UserInfoInterceptor());
    }
}

通过SpringBoot自动装配的原理将该配置类放到factories文件中实现自动装配（底层会读取该文件对文件中路径的类进行自动装配） 拦截器并没有注册成Bean而是在配置文件中直接new，区别：

OpenFeign传递用户： 

用户之间传递通过OpenFeign实现，OpenFeign内置了一个拦截器接口用于拦截各种请求，并对请求进行处理，可以将用户之间的请求拦截，并添加请求头依次来传递用户信息。

package com.hmall.api.config;

import com.hmall.common.utils.UserContext;
import feign.Logger;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.context.annotation.Bean;

public class DefaultFeignConfig {

    @Bean
    public Logger.Level feignLoggerLevel(){
        return Logger.Level.FULL;
    }

    @Bean
    public RequestInterceptor userInfoRequestInterceptor(){
        return new RequestInterceptor() {
            @Override
            public void apply(RequestTemplate requestTemplate) {
                Long userId = UserContext.getUser();
                if(userId!=null) {
                    requestTemplate.header("user-info", userId.toString());
                }
            }
        };
    }
}

五、配置管理

Nacos集成了配置管理服务的功能

配置共享：

配置热更新：

案例-实现购物车添加商品上限的配置热更新：

package com.hmall.cart.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@ConfigurationProperties(prefix = "hm.cart")
@Component //注册成bean才能让配置文件生效
@Data
public class CartProperties {
    private Integer maxItems;
}

动态路由：

NacosConfigManager是依赖中创建好的bean，已经实现了getConfigService方法

因此直接注入即可

新增依赖：

package com.hmall.gateway.routers;

import cn.hutool.json.JSONUtil;
import com.alibaba.cloud.nacos.NacosConfigManager;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;

import javax.annotation.PostConstruct;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Executor;

@Slf4j
@Component
@RequiredArgsConstructor
public class DynamicRouteLoader {

    private final NacosConfigManager nacosConfigManager;
    private final RouteDefinitionWriter routeDefinitionWriter;
    private final Set<String> routeIds = new HashSet<>();  //保存每次更新后的routeId

    private final String dataId ="gateway-routes.json";
    private final String group ="DEFAULT_GROUP";

    @PostConstruct//在 DynamicRouteLoader 这个bean初始化之后执行
    public void initRouteConfigListener() throws NacosException {
        //1.项目启动，先拉取一次配置，并且添加配置监听器
        String configInfo = nacosConfigManager.getConfigService()
                .getConfigAndSignListener(dataId, group, 5000, new Listener() {
                    @Override
                    public Executor getExecutor() {
                        return null;
                    }

                    @Override
                    public void receiveConfigInfo(String configInfo) {
                        //2.监听到配置更新，需要去更新路由表
                        updateConfigInfo(configInfo);
                    }
                });
        //3.第一次读取到配置表，也需要更新到路由表
        updateConfigInfo(configInfo);
    }

    public void updateConfigInfo(String configInfo){
        log.debug("监听到路由配置信息: {}",configInfo);
        // 1 解析配置信息，转化为RouteDefinition类型
        List<RouteDefinition> routeDefinitions = JSONUtil.toList(configInfo, RouteDefinition.class);
        // 2 删除旧的路由表
        for (String routeId : routeIds) {
            routeDefinitionWriter.delete(Mono.just(routeId)).subscribe();
        }
        routeIds.clear(); //清空id表
        // 3 更新路由表
        for (RouteDefinition routeDefinition : routeDefinitions) {
            //3.1 更新路由表
            routeDefinitionWriter.save(Mono.just(routeDefinition)).subscribe();
            //3.2 记录路由id，便于下一次更新删除
            routeIds.add(routeDefinition.getId());
        }
    }
}

bootstrap.yaml文件 

spring:
  application:
    name: gateway-service #微服务名称
  profiles:
    active: dev
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.50.129:8848
      config:
        server-addr: 192.168.50.129:8848
        file-extension: yaml
        shared-configs:
          - data-id: shared-log.yaml