Spring Cloud Gateway 中 session 共享

背景

在进行 zuul 切换到 gateway 时，需要重新实现 session 共享，本文主要分享一下自己实现的方案。

zuul 中的 session 共享

在 zuul 中，是通过 spring-session-data-redis 这个组件，将 session 的信息存放到 redis 中实现的 session 共享。这次也简单说明下如何实现以及一些注意的点。

首先在网关 zuul 以及所有的微服务中添加 spring-session-data-redis 依赖：

<!-- session共享 -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.session</groupId>
  <artifactId>spring-session-data-redis</artifactId>
</dependency>

之后添加 redis 配置信息：

spring:
  redis:
    host: localhost
    port: 6379

添加 EnableRedisHttpSession 注解：

/**
 * 指定flushMode为IMMEDIATE 表示立即将session写入redis
 *
 * @author yuanzhihao
 * @since 2022/5/8
 */
@EnableRedisHttpSession(flushMode = FlushMode.IMMEDIATE)
@Configuration
public class RedisSessionConfig {
}

在网关 zuul 工程中，路由跳转到微服务时，需要添加 sensitiveHeaders，设置为空，表示将敏感信息透传到下游微服务，这边需要将 cookie 的信息传下去，session 共享保存到 redis 里面需要用到：

zuul:
  routes:
    portal:
      path: /portal/**
      sensitiveHeaders: # 将敏感信息传到下游服务
      serviceId: portal

指定 server.servlet.context-path 路径：

server.servlet.context-path=/gateway

zuul 测试工程

在我的代码库中，我提交了一个简单的 demo，主要有四个工程，分别是网关 zuul、主页 portal、两个客户端 client-1、server-1。

网关 zuul 中添加路由信息：

spring:
  application:
    name: zuul
  redis:
    host: localhost
    port: 6379
server:
  servlet:
    context-path: /gateway
zuul:
  routes:
    portal:
      path: /portal/**
      sensitiveHeaders:
      serviceId: portal
    client-1:
      path: /client1/**
      sensitiveHeaders:
      serviceId: eureka-client1
    server-1:
      path: /server1/**
      sensitiveHeaders:
      serviceId: eureka-server1

添加登录过滤器，对所有的请求进行拦截，对于没有登录的请求会自动跳转到登录页面：

/**
 * 登录过滤器
 *
 * @author yuanzhihao
 * @since 2022/5/8
 */
@Component
@Slf4j
public class LoginFilter extends ZuulFilter {
    private static final List<String> white_List = Arrays.asList("/login", "/logout");

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

    @Override
    public int filterOrder() {
        return -1;
    }

    @Override
    public boolean shouldFilter() {
        HttpServletRequest request = RequestContext.getCurrentContext().getRequest();
        String requestURI = request.getRequestURI();
        for (String uri : white_List) {
            if (requestURI.endsWith(uri)) {
                return false;
            }
        }
        return true;
    }

    @SneakyThrows
    @Override
    public Object run() throws ZuulException {
        RequestContext currentContext = RequestContext.getCurrentContext();
        HttpServletRequest request = currentContext.getRequest();
        HttpSession session = request.getSession();
        UserInfo userInfo = (UserInfo) session.getAttribute("userInfo");
        if (userInfo == null) {
            HttpServletResponse response = currentContext.getResponse();
            response.sendRedirect("/gateway/portal/login");
        }
        return null;
    }
}

portal 中简单实现了登录逻辑：

/**
 * @author yuanzhihao
 * @since 2022/5/8
 */
@Controller
public class LoginController {
    @GetMapping(value = "/login")
    public String login(HttpServletRequest request, HashMap<String, Object> map) {
        UserInfo userInfo = (UserInfo) request.getSession().getAttribute("userInfo");
        if (userInfo != null) {
            map.put("userInfo", userInfo);
            return "index";
        }
        return "login";
    }

    @PostMapping("/login")
    public String login(UserInfo userInfo, HashMap<String, Object> map, HttpServletRequest request) {
        // 设置session
        request.getSession().setAttribute("userInfo", userInfo);
        map.put("userInfo", userInfo);
        return "index";
    }

    @GetMapping("/logout")
    public String logout(HttpServletRequest request) {
        request.getSession().invalidate();
        return "logout";
    }
}

在客户端 client-1 和 server-1 中可以请求到当前 session 中的用户信息：

@GetMapping("/hello")
public String hello(HttpServletRequest request) {
  UserInfo userInfo = (UserInfo) request.getSession().getAttribute("userInfo");
  return "Client1 Hello " + userInfo.getUsername();
}

未登录时，通过网关访问其他微服务页面会重定向：

登录后，可以正常访问，并且在其他微服务中可以获取到 session 中的用户信息：

client-1：

server-1：

spring cloud gateway 中 session 共享

在 spring cloud gateway 中，和 zuul 有一些区别，下面整理了这些区别以及要如何修改。

httpSession 和 webSession

首先 spring cloud gateway 是基于 webflux，是非阻塞的，zuul 是基于 servlet 的，是阻塞的（这部分差异大家可以自行了解一下，我也不是很熟~）。他们的 session 是两种实现，在 zuul 中是 httpSession，而到了 gateway 中是 webSession。

在 gateway 中需要将 EnableRedisHttpSession 注解换成 EnableRedisWebSession：

/**
 * 指定saveMode为ALWAYS 功能和flushMode类似
 *
 * @author yuanzhihao
 * @since 2022/5/6
 */
@EnableRedisWebSession(saveMode = SaveMode.ALWAYS)
@Configuration
@Slf4j
public class RedisSessionConfig {}

同时需要覆盖 webSession 中读取 sessionId 的写法，将 SESSION 信息进行 base64 解码，默认实现中是没有 base64 解码的，sessionId 传到下游时不一致，会导致 session 不共享：

// 覆盖默认实现
@Bean
public WebSessionIdResolver webSessionIdResolver() {
    return new CustomWebSessionIdResolver();
}

private static class CustomWebSessionIdResolver extends CookieWebSessionIdResolver {
    // 重写resolve方法 对SESSION进行base64解码
    @Override
    public List<String> resolveSessionIds(ServerWebExchange exchange) {
        MultiValueMap<String, HttpCookie> cookieMap = exchange.getRequest().getCookies();
        // 获取SESSION
        List<HttpCookie> cookies = cookieMap.get(getCookieName());
        if (cookies == null) {
            return Collections.emptyList();
        }
        return cookies.stream().map(HttpCookie::getValue).map(this::base64Decode).collect(Collectors.toList());
    }

    private String base64Decode(String base64Value) {
        try {
            byte[] decodedCookieBytes = Base64.getDecoder().decode(base64Value);
            return new String(decodedCookieBytes);
        } catch (Exception ex) {
            log.debug("Unable to Base64 decode value: " + base64Value);
            return null;
        }
    }
}

这边可以参考下具体的源码。httpSession 在读取的时候，会进行解码，具体方法地址 org.springframework.session.web.http.DefaultCookieSerializer#readCookieValues

添加 context-path

spring-cloud-gateway 不是基于 servlet 的，所以设置了 server.servlet.context-path 属性并不生效，这边参考其他人的方案使用了另一种方法添加了 context-path。使用 StripPrefix 的方式。StripPrefix 的参数表示在进行路由转发到下游服务之前，剥离掉请求中 StripPrefix 参数个数的路径参数。比如 StripPrefix 为 2，像网关发起的请求是 / gateway/client1/name，转发到下游时，请求路径会变成 / name，这样就添加完成了 context-path。

具体路由的配置信息如下：

spring:
  application:
    name: gateway
  cloud:
    gateway:
      routes:
       - id: client1
         uri: lb://eureka-client1
         predicates:
           - Path=/gateway/client1/**
         filters:
           - StripPrefix=2
       - id: server1Session
         uri: lb://eureka-server1
         predicates:
           - Path=/gateway/server1/**
         filters:
           - StripPrefix=2
       - id: portal
         uri: lb://portal
         predicates:
           - Path=/gateway/portal/**
         filters:
           - StripPrefix=2

到现在差不多就完成了 gateway 的 session 共享。

gateway 测试工程

这边测试工程和上面一致，只是将网关换成了 gateway。

我们在 gateway 中添加一个登录过滤器拦截所有的请求，对于没有登录的请求跳转到登录页面：

/**
 * 登录过滤器
 *
 * @author yuanzhihao
 * @since 2022/5/6
 */
@Component
@Slf4j
public class LoginGlobalFilter implements GlobalFilter, Ordered {
    private static final List<String> white_List = Arrays.asList("/login", "/logout");

    // 登录地址
    private static final String PORTAL_URL = "https://localhost:7885/gateway/portal/login";

    @SneakyThrows
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        System.err.println("login filter starter");
        // 判断是否登录
        AtomicBoolean isLogin = new AtomicBoolean(false);
        exchange.getSession().subscribe(webSession -> {
            UserInfo userInfo = webSession.getAttribute("userInfo");
            System.err.println("userInfo is " + userInfo);
            if (userInfo != null) {
                isLogin.set(true);
            }
        });
        // 这边添加一个延时， 等待获取到session
        Thread.sleep(200);

        // url白名单
        String path = exchange.getRequest().getURI().getPath();
        boolean isWhiteUrl = white_List.stream().anyMatch(path::endsWith);

        // 登录状态或者在url白名单中 放行
        if (isLogin.get() || isWhiteUrl) {
            return chain.filter(exchange);
        }

        ServerHttpResponse response = exchange.getResponse();
        response.setStatusCode(HttpStatus.SEE_OTHER);
        response.getHeaders().set(HttpHeaders.LOCATION, PORTAL_URL);
        response.getHeaders().add("Content-Type", "text/plain;charset=UTF-8");
        return response.setComplete();
    }

    @Override
    public int getOrder() {
        return -1;
    }
}

这边我添加了一个 200ms 的睡眠，因为测试验证的时候，当请求进入这个过滤器时，获取到的 webSession 是空，导致逻辑异常。猜测是由于 spring-cloud-gateway 是基于 netty 实现的非阻塞 IO，所以获取 session 有一定的延迟，所有添加了一个 sleep 阻塞。后续会考虑修改。

之前也尝试过使用 block() 方法修改为阻塞的，但是抛异常了，具体原因没有分析出来。

这边通过 gateway 访问和 zuul 的结果一致：