网关实现登陆校验（Spring Cloud Gateway）

已于 2025-04-09 21:50:07 修改
阅读量1.1k 收藏 10
点赞数 8
分类专栏： 微服务 文章标签： 微服务 网关 登陆校验
于 2025-04-09 21:47:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/FAQEW/article/details/147084484
版权

完整实现步骤：JWT 网关校验 + 微服务信息传递

JWT网关校验：在网关层使用全局过滤器进行拦截
微服务信息传递：在微服务里面用拦截器拦截到信息，然后统一使用

![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/10c5eb2f83ad4272bd0a0f70a11a4148.png![

一、技术选型说明
  • JWT 解析库推荐：
    推荐使用 jjwt（Java JWT），它是 Java 生态中最流行的 JWT 库，具有以下优势：
    1. API 简洁：生成、解析 JWT 仅需几行代码。
    2. 安全性高：支持多种签名算法（如 HS512、RS256）。
    3. 社区活跃：长期维护，文档完善，与 Spring 兼容性好。

二、网关层实现 JWT 校验

1. 添加依赖

在网关模块的 pom.xml 中添加 jjwt 和必要依赖：

<!-- JJWT -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>
2. 实现 JWT 工具类
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.security.Key;
import java.util.Date;

@Component
public class JwtUtils {

    @Value("${jwt.secret}")  // 从配置文件中读取密钥
    private String secret;

    @Value("${jwt.expiration}")
    private long expiration;

    private Key key;

    // 初始化密钥
    @PostConstruct
    public void init() {
        this.key = Keys.hmacShaKeyFor(secret.getBytes());
    }

    // 生成 JWT
    public String generateToken(String username, String roles) {
        return Jwts.builder()
                .setSubject(username)
                .claim("roles", roles)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + expiration))
                .signWith(key)
                .compact();
    }

    // 解析 JWT
    public Claims parseToken(String token) {
        return Jwts.parserBuilder()
                .setSigningKey(key)
                .build()
                .parseClaimsJws(token)
                .getBody();
    }

    // 验证 Token 是否过期
    public boolean isTokenExpired(String token) {
        return parseToken(token).getExpiration().before(new Date());
    }
}
3. 全局过滤器实现 JWT 校验
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class JwtAuthGlobalFilter implements GlobalFilter, Ordered {

    private final JwtUtils jwtUtils;

    public JwtAuthGlobalFilter(JwtUtils jwtUtils) {
        this.jwtUtils = jwtUtils;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1. 排除登录接口
        String path = exchange.getRequest().getPath().value();
        if (path.startsWith("/api/auth/login")) {
            return chain.filter(exchange);
        }

        // 2. 获取 Token
        String token = extractToken(exchange.getRequest().getHeaders());

        // 3. 验证 Token
        if (token == null) {
            return buildUnauthorizedResponse(exchange, "Missing token");
        }
        try {
            Claims claims = jwtUtils.parseToken(token);
            if (jwtUtils.isTokenExpired(token)) {
                return buildUnauthorizedResponse(exchange, "Token expired");
            }

            // 4. 传递用户信息到下游服务
            ServerHttpRequest mutatedRequest = exchange.getRequest().mutate()
                    .header("X-User-Name", claims.getSubject())
                    .header("X-User-Roles", claims.get("roles", String.class))
                    .build();
            return chain.filter(exchange.mutate().request(mutatedRequest).build());
        } catch (Exception e) {
            return buildUnauthorizedResponse(exchange, "Invalid token");
        }
    }

    private String extractToken(HttpHeaders headers) {
        String authHeader = headers.getFirst(HttpHeaders.AUTHORIZATION);
        return (authHeader != null && authHeader.startsWith("Bearer ")) ? authHeader.substring(7) : null;
    }

    private Mono<Void> buildUnauthorizedResponse(ServerWebExchange exchange, String message) {
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        exchange.getResponse().getHeaders().add("Content-Type", "application/json");
        String body = String.format("{\"code\": 401, \"msg\": \"%s\"}", message);
        return exchange.getResponse().writeWith(Mono.just(exchange.getResponse().bufferFactory().wrap(body.getBytes())));
    }

    @Override
    public int getOrder() {
        return -1;  // 设置过滤器优先级（数字越小优先级越高）
    }
}
4. 配置文件 application.yml
jwt:
  secret: "my-ultra-secure-jwt-secret-key-1234567890"  # 密钥（至少 32 位）
  expiration: 3600000  # Token 有效期（1小时）

spring:
  cloud:
    gateway:
      routes:
        - id: auth-service
          uri: lb://auth-service
          predicates:
            - Path=/api/auth/**
          filters:
            - StripPrefix=1
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/users/**
          filters:
            - StripPrefix=1

三、微服务信息传递

为了在微服务中统一处理JWT校验并使用UserContext传递用户信息，可以按照以下步骤实现：
public class UserContext {
    private static final ThreadLocal<Map<String, String>> context = new ThreadLocal<>();

    public static void setUserInfo(Map<String, String> userInfo) {
        context.set(userInfo);
    }

    public static Map<String, String> getUserInfo() {
        return context.get();
    }

    public static void clear() {
        context.remove();
    }

    // 获取具体字段（示例）
    public static String getUserId() {
        return getUserInfo() != null ? getUserInfo().get("userId") : null;
    }

    public static String getUsername() {
        return getUserInfo() != null ? getUserInfo().get("username") : null;
    }
}

2. 实现JWT校验拦截器

@Component
public class JwtInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtUtils jwtUtils; // 你的JWT工具类

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 从请求头获取token
        String token = request.getHeader("Authorization");
        if (StringUtils.isEmpty(token)) {
            throw new UnauthorizedException("缺少Token");
        }

        // 校验并解析Token
        Claims claims = jwtUtils.parseToken(token);
        if (claims == null) {
            throw new UnauthorizedException("Token无效或已过期");
        }

        // 提取用户信息存入UserContext
        Map<String, String> userInfo = new HashMap<>();
        userInfo.put("userId", claims.get("userId", String.class));
        userInfo.put("username", claims.getSubject());
        UserContext.setUserInfo(userInfo);

        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        // 请求完成后清理ThreadLocal，防止内存泄漏
        UserContext.clear();
    }
}

3. 注册拦截器

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private JwtInterceptor jwtInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtInterceptor)
                .addPathPatterns("/**") // 拦截所有路径
                .excludePathPatterns("/auth/login", "/swagger**"); // 排除登录和Swagger
    }
}

4. JWT工具类示例（JwtUtils）

@Component
public class JwtUtils {

    @Value("${jwt.secret}")
    private String secret;

    public Claims parseToken(String token) {
        try {
            return Jwts.parser()
                    .setSigningKey(secret.getBytes())
                    .parseClaimsJws(token.replace("Bearer ", ""))
                    .getBody();
        } catch (Exception e) {
            return null; // Token解析失败
        }
    }
}

5. 在微服务中使用UserContext

@RestController
@RequestMapping("/api/user")
public class UserController {

    @GetMapping("/profile")
    public ResponseEntity<?> getUserProfile() {
        String userId = UserContext.getUserId();
        String username = UserContext.getUsername();
        // 查询数据库或其他业务逻辑...
        return ResponseEntity.ok("用户信息: " + username);
    }
}

关键点说明：

  1. 拦截流程：

    • 拦截器从Authorization头提取JWT。
    • 使用JwtUtils验证并解析Token。
    • 将用户关键信息存入UserContext的ThreadLocal中。

  2. 线程安全：

    • UserContext使用ThreadLocal确保每个请求线程独立存储。
    • 拦截器afterCompletion方法中调用UserContext.clear()，避免内存泄漏。

  3. 异常处理：

    • 如果Token校验失败，直接抛出异常（需配合全局异常处理器返回401状态码）。

  4. 网关与微服务协作：

    • 网关负责路由转发和初步鉴权（如权限校验）。
    • 微服务拦截器做二次校验（可选，根据安全级别决定），确保请求合法性。

扩展优化建议：

  • Feign传递用户信息：如果微服务间调用需要传递用户身份，可以添加Feign拦截器：
    @Bean
public RequestInterceptor feignRequestInterceptor() {
    return requestTemplate -> {
        String userId = UserContext.getUserId();
        if (userId != null) {
            requestTemplate.header("X-User-Id", userId);
        }
    };
}
  • 更严格的校验：检查Token的签名、过期时间、黑名单等。
  • 结合Spring Security：如果需要更复杂的权限控制，可整合Spring Security + JWT。

四、OpenFeign 传递用户信息（如JWT令牌或用户ID）

根据你的实际业务调整UserContext存储的字段和校验逻辑即可。
为了在微服务间通过 OpenFeign 传递用户信息（如JWT令牌或用户ID），需通过 Feign拦截器 自动将上下文信息添加到请求头中。以下是完整步骤：

1. 添加Feign拦截器（传递用户信息）

@Component
public class FeignUserInterceptor implements RequestInterceptor {

    @Override
    public void apply(RequestTemplate template) {
        // 从UserContext获取用户信息
        String userId = UserContext.getUserId();
        String token = UserContext.getToken(); 

        // 将信息添加到Feign请求头
        if (userId != null) {
            template.header("X-User-Id", userId);
        }
        if (token != null) {
            template.header("Authorization", "Bearer " + token);
        }
    }
}

2. 确保UserContext包含所需字段

public class UserContext {
    private static final ThreadLocal<Map<String, String>> context = new ThreadLocal<>();

    // 其他方法...

    public static String getToken() {
        return getUserInfo() != null ? getUserInfo().get("token") : null;
    }

    // 网关过滤器或拦截器中存入Token
    public static void setToken(String token) {
        Map<String, String> userInfo = getUserInfo();
        if (userInfo == null) {
            userInfo = new HashMap<>();
        }
        userInfo.put("token", token);
        context.set(userInfo);
    }
}

3. 下游服务接收并校验信息

下游服务需通过拦截器或过滤器读取请求头中的用户信息，并存入本地上下文：

下游服务拦截器示例
@Component
public class DownstreamUserInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 从请求头获取信息
        String userId = request.getHeader("X-User-Id");
        String token = request.getHeader("Authorization");

        // 校验Token（可选）
        if (token != null) {
            Claims claims = jwtUtils.parseToken(token.replace("Bearer ", ""));
            if (claims == null) {
                throw new UnauthorizedException("Token无效");
            }
        }

        // 存入当前服务的UserContext
        Map<String, String> userInfo = new HashMap<>();
        userInfo.put("userId", userId);
        userInfo.put("token", token);
        UserContext.setUserInfo(userInfo);

        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        UserContext.clear();
    }
}

4. Feign客户端调用示例

在服务A中，通过Feign调用服务B的API，用户信息会自动传递：

@FeignClient(name = "service-b")
public interface ServiceBClient {

    @GetMapping("/api/data")
    ResponseEntity<String> getData();
}

// 业务代码中直接调用
public class ServiceA {
    @Autowired
    private ServiceBClient serviceBClient;

    public void doSomething() {
        // UserContext已在拦截器中填充
        ResponseEntity<String> response = serviceBClient.getData();
    }
}

关键配置说明

  1. 拦截器自动生效
    Spring会自动发现FeignUserInterceptor（因标注了@Component），无需手动注册到Feign客户端。

  2. 确保UserContext正确填充

    • 网关层需将JWT Token存入UserContext。
    • 微服务自身的拦截器（如JwtInterceptor）需在校验Token后，将信息存入UserContext。

  3. 下游服务校验（可选）

    • 如果下游服务需要严格校验Token，需配置相同的JWT密钥。
    • 如果仅需传递用户ID，可省略Token校验步骤。

扩展场景：仅传递必要字段

如果不想传递完整Token，可在网关将用户ID、角色等关键信息注入请求头，微服务直接读取：

网关过滤器添加自定义头
public class GatewayFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 从JWT解析用户信息
        String userId = ...;
        String role = ...;

        // 添加自定义请求头
        ServerHttpRequest request = exchange.getRequest().mutate()
                .header("X-User-Id", userId)
                .header("X-User-Role", role)
                .build();

        return chain.filter(exchange.mutate().request(request).build());
    }
}
Feign拦截器透传这些头
public class FeignUserInterceptor implements RequestInterceptor {
    @Override
    public void apply(RequestTemplate template) {
        // 从当前请求的上下文中获取头信息（需配合RequestContextHolder）
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes != null) {
            HttpServletRequest request = attributes.getRequest();
            String userId = request.getHeader("X-User-Id");
            String role = request.getHeader("X-User-Role");
            template.header("X-User-Id", userId);
            template.header("X-User-Role", role);
        }
    }
}

注意事项

  1. 线程池隔离问题
    如果使用Hystrix或异步线程，需通过HystrixRequestContext或自定义线程上下文传递数据。

  2. 敏感信息安全

    • 始终使用HTTPS加密传输。
    • 避免在请求头中传递敏感数据（如密码），必要时进行加密。

  3. 性能影响
    频繁解析JWT可能影响性能，可在网关层完成主要校验，微服务按需二次校验。

Spring Cloud Gateway构建的API网关服务 | Spring Cloud 12
gmHappy
03-07 2061
所谓的网关就是指系统的统一入口，它封装了运用程序的内部结构，为客户端提供统一的服务，一些与业务功能无关的公共逻辑可以在这里实现，诸如认证、鉴权、监控、路由转发等。
Spring Cloud Gateway（2）-网关登录校验流程-JWT
2301_78117253的博客
06-04 760
Spring Cloud Gateway-自定义过滤器-GlobalFilter-优快云博客。Spring Cloud Gateway-实现登录校验-JWT-优快云博客。【代码】Spring Cloud Gateway-实现登录校验-JWT。文章浏览阅读19次。
网关登录校验
m0_45253972的博客
01-29 1093
路由过滤器，就是之前33种过滤器，作用范围比较灵活，可以是任意指定的路由Route：全局过滤器，作用范围是所有路由，不可配置。其实和/*** 处理请求并将其传递给下一个过滤器* @param exchange 当前请求的上下文，其中包含request、response等各种共享数据* @param chain 过滤器链，当前过滤器执行完后，要调用过滤器链种的下一个过滤器。* @return 根据返回值标记当前请求是否被完成或拦截，chain.filter(exchange)就放行了。*/
Spring Cloud Gateway 权限认证指南
最新发布
Myqijiahai的博客
03-01 636
通过上述步骤，你可以在 Spring Cloud Gateway 中集成 Spring Security 和 JWT，实现集中式的权限认证。主要步骤包括
微服务架构-服务网关(Gateway)-权限认证(分布式session替代方案)
姜皓的博客
04-10 2674
这一节我们就探讨一下Gateway在分布式环境中的一个具体用例-用户鉴权
SpringCloud Gateway 实现自定义全局过滤器 + JWT权限验证
知道的越多 不知道的就越多
08-09 9807
1、gateway filter的生命周期Spring Cloud Gateway同zuul类似，有“pre”和“post”两种方式的filter。客户端的请求先经过“pre”类型的filter，然后将请求转发到具体的业务服务，收到业务服务的响应之后，再经过“post”类型的filter处理，最后返回响应到客户端pre类型的filter:在业务逻辑之前post类型的filter:在业务逻辑之后2、gateway filter的应用场景。...
微服务--熟练掌握网关（包括权限认证）
weixin_62432037的博客
07-29 2098
无论是还是都支持自定义，只不过编码方式、使用方式略有差别。自定义不是直接实现，而是实现。@Component@Override@Override// 获取请求// 编写过滤器逻辑System.out.println("过滤器执行了");// 放行注意：该类的名称一定要以为后缀！spring:cloud:gateway:- PrintAny # 此处直接以自定义的GatewayFilterFactory类名称前缀类声明过滤器@Component。
springcloud gateway 全局过滤器统一签名判定.doc
12-01
下面将详细介绍如何配置和使用Spring Cloud Gateway实现这一功能。 首先，我们需要了解Spring Cloud Gateway的基本结构。它是Spring Cloud生态中的一个API网关服务，提供路由、熔断、限流等能力，可以作为所有...
SpringCloudGateway — 网关登录校验
cyt涛的博客
11-06 963
单体架构时我们只需要完成一次用户登录、身份校验，就可以在所有业务中获取到用户信息。而微服务拆分后，每个微服务都独立部署，不再共享数据。也就意味着每个微服务都需要做登录校验，这显然不可取。 既然网关是所有微服务的入口，一切请求都需要先经过网关。我们完全可以把登录校验的工作放到网关去做。
Spring Cloud Gateway使用Token验证详解
08-26
主要介绍了Spring Cloud Gateway使用Token验证详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
微服务（四）之网关
jinkkkkkkk的博客
11-04 1943
无论是还是都支持自定义，只不过编码方式、使用方式略有差别。自定义不是直接实现，而是实现。最简单的方式是这样的：//该类的名称一定要以GatewayFilterFactory为后缀！@Component@Override@Override// 获取请求// 编写过滤器逻辑System.out.println("过滤器执行了");
Gateway权限认证方案分析实现网关层限流
Jerry的博客
01-02 3395
1. 权限认证方案分析 1.1. 传统单应用的用户鉴权 使用session保存登录状态，通过存放的key-value来进行鉴权，对于一台机器无法同步session到其他机器的时候，我们的问题就来了，如何进行服务应用的鉴权 1.2. 分布式环境下的解决方案 1.2.1. 同步session session复制是最容易先想到的解决方案，可以将一台机器中的session复制到集群中其他的机器里，比如Tomcat中也有内置的session的同步方案，但是这并不是一个非常优雅的解决方案，他会带来以下两个问题 Tim
gateway-统一权限-认证
热门推荐
JAVAMysql111的博客
04-10 1万+
基础名词概念 **权限：**属于系统的安全范畴，权限管理实现对用户访问系统的控制，按照安全规则或者安全控制策略用户可以访问而且只能访问自己被授权的资源，主要包括用户身份认证和请求鉴权两部分，简称认证鉴权 认证判断一个用户是否为合法用户的处理过程，最常用的简单身份认证是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确 鉴权：即访问控制，控制谁能访问那些资源；进行身份认证后需要分配权限可访问的系统资源，对于某些资源没有权限是无法访问的，如下图所示 权
8.Gateway服务网关
bugeiban001的博客
03-09 873
Gateway服务网关 Spring Cloud Gateway 是 Spring Cloud 的一个全新项目，该项目是基于 Spring 5.0，Spring Boot 2.0 和 Project Reactor 等响应式编程和事件流技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。 为什么需要网关 Gateway网关是我们服务的守门神，所有微服务的统一入口。 网关的核心功能特性： 身份认证和权限校验：网关作为微服务入口，需要校验用户是是否有请求资格，如果没有则进行拦截。
springcloud gateway集成RBAC模型——实现用户权限判断
tang_seven的博客
10-26 1988
springcloud gateway集成jwt token后，基于RBAC模型实现用户权限管理及判断
springcloudgateway权限验证_Spring Cloud Gateway 之 Filter
weixin_39853892的博客
11-26 2936
简介网关经常需要对路由请求进行过滤，进行一些操作，如鉴权之后构造头部之类的，过滤的种类很多，如增加请求头、增加请求 参数 、增加响应头和断路器等等功能，这就用到了Spring Cloud Gateway 的 Filter。作用当我们有很多个服务时，比如下图中的user-service、goods-service、sales-service等服务，客户端请求各个服务的Api时，每个服务都需要做相同的...
尚医通（十四）Spring Cloud GateWay网关 | 跨域 | 权限认证
Knight
02-15 1211
尚医通（十四）Spring Cloud GateWay网关 | 跨域 | 权限认证
微服务网关鉴权：gateway使用、网关限流使用 用户密码加密 JWT鉴权
Java_zhujia的博客
01-08 1210
不同的微服务一般会有不同的网络地址，而外部客户端可能需要调用多个服务的接口才能完成一个业务需求，如果让客户端直接与各个微服务通信，会有以下的问题：客户端会多次请求不同的微服务，增加了客户端的复杂性存在跨域请求，在一定场景下处理相对复杂认证复杂，每个服务都需要独立认证难以重构，随着项目的迭代，可能需要重新划分微服务。例如，可能将多个服务合并成一个或者将一个服务拆分成多个。如果客户端直接与微服务通信，那么重构将会很难实施某些微服务可能使用了防火墙 / 浏览器不友好的协议，直接访问会有一定的困难。
SpringCloud Gateway与Nacos整合实现服务网关和配置中心
资源摘要信息:"SpringCloud Gateway整合Nacos" 在现代微服务架构中，服务网关（Service Gateway）是不可或缺的一个组件，它起到了流量的统一入口、请求路由、权限校验、监控和熔断等重要作用。而Spring Cloud ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值