Spring Cloud GateWay实现token的校验和传输

最新推荐文章于 2024-06-06 14:29:28 发布

瓜瓜醒

最新推荐文章于 2024-06-06 14:29:28 发布

阅读量7.8k

点赞数 10

分类专栏： Spring Cloud Netflix 文章标签： filter 网关 gateway

本文链接：https://blog.csdn.net/xingxinggua9620/article/details/113402368

版权

Spring Cloud Netflix 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Spring Cloud GateWay实现token的校验和传输

1.1 SpringCloud Gateway 简介

Spring Cloud GateWay基于WebFlux框架实现的，而WebFlux框架底层则使用了高性能的Reactor模式通信框架Netty.

Spring Cloud Gateway 的目标，不仅提供统一的路由方式，并且基于 Filter 链的方式提供了网关基本的功能，例如：安全，监控/指标，和限流。

提前声明：Spring Cloud Gateway 底层使用了高性能的通信框架Netty

1.2 SpringCloud Gateway 特征

SpringCloud官方，对SpringCloud Gateway 特征介绍如下：

基于 Spring Framework 5，Project Reactor 和 Spring Boot 2.0
集成 Hystrix 断路器
集成 Spring Cloud DiscoveryClient
Predicates 和 Filters 作用于特定路由，易于编写的 Predicates 和 Filters
具备一些网关的高级功能：动态路由、限流、路径重写

从以上的特征来说，和Zuul的特征差别不大。SpringCloud Gateway和Zuul主要的区别，还是在底层的通信框架上。

简单说明一下上文中的三个术语：

**（**1） Filter（过滤器)：

和Zuul的过滤器在概念上类似，可以使用它拦截和修改请求，并且对上游的响应，进行二次处理。过滤器为org.springframework.cloud.gateway.filter.GatewayFilter类的实例。

（2）Route（路由）：

网关配置的基本组成模块，和Zuul的路由配置模块类似。一个Route模块由一个 ID，一个目标 URI，一组断言和一组过滤器定义。如果断言为真，则路由匹配，目标URI会被访问。

**（**3）Predicate（断言）：

这是一个 Java 8 的 Predicate，可以使用它来匹配来自 HTTP 请求的任何内容，例如 headers 或参数。断言的输入类型是一个 ServerWebExchange。

1.3 SpringCloud Zuul的IO模型/GateWay的IO模型

Zuul

Springcloud中所集成的Zuul版本，采用的是Tomcat容器，使用的是传统的Servlet IO处理模型。

大家知道，servlet由servlet container进行生命周期管理。container启动时构造servlet对象并调用servlet init()进行初始化；container关闭时调用servlet destory()销毁servlet；container运行时接受请求，并为每个请求分配一个线程（一般从线程池中获取空闲线程）然后调用service()。

弊端：servlet是一个简单的网络IO模型，当请求进入servlet container时，servlet container就会为其绑定一个线程，在并发不高的场景下这种模型是适用的，但是一旦并发上升，线程数量就会上涨，而线程资源代价是昂贵的（上线文切换，内存消耗大）严重影响请求的处理时间。在一些简单的业务场景下，不希望为每个request分配一个线程，只需要1个或几个线程就能应对极大并发的请求，这种业务场景下servlet模型没有优势。

所以Springcloud Zuul 是基于servlet之上的一个阻塞式处理模型，即spring实现了处理所有request请求的一个servlet（DispatcherServlet），并由该servlet阻塞式处理处理。所以Springcloud Zuul无法摆脱servlet模型的弊端。虽然Zuul 2.0开始，使用了Netty，并且已经有了大规模Zuul 2.0集群部署的成熟案例，但是，Springcloud官方已经没有集成改版本的计划了。

GateWay

Webflux模式替换了旧的Servlet线程模型。用少量的线程处理request和response io操作，这些线程称为Loop线程，而业务交给响应式编程框架处理，响应式编程是非常灵活的，用户可以将业务中阻塞的操作提交到响应式框架的work线程中执行，而不阻塞的操作依然可以在Loop线程中进行处理，大大提高了Loop线程的利用率。

Webflux虽然可以兼容多个底层的通信框架，但是一般情况下，底层使用的还是Netty，毕竟，Netty是目前业界认可的最高性能的通信框架。而Webflux的Loop线程，正好就是著名的Reactor 模式IO处理模型的Reactor线程，如果使用的是高性能的通信框架Netty，这就是Netty的EventLoop线程。

1.4 token传递以及存储

由于在网关层面拦截token之后,需要检验并且解析,并且将解析后的token(包含用户信息)传递给其他微服务,实现微服务之间的调用

AuthLoginGlobalFilter全局认证过滤器,实现GlobalFilter接口,进行请求的过滤.

@Slf4j
@PropertySource(value = "classpath:loginfilter.properties")
@Component
public class AuthLoginGlobalFilter  implements GlobalFilter, Ordered {

    @Value("#{'${jwt.ignoreUrls}'.split(',')}")
    List<String> ignoreUrls;

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * @Description  全局校验过滤器
     * @author Liu_gx
     * @date 2021/1/8 17:29
     * @param exchange
     * @param chain
     * @return
     */
    /*@Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request=exchange.getRequest();
        if(ignoreUrls!=null&&ignoreUrls.contains(request.getURI().getPath())){
            return chain.filter(exchange);
        }
        //获取token
        String authoriztion=request.getHeaders().getFirst(Constants.LOGIN_TOKEN);
        //获取服务名称
        String serverName = getServerNameByPath(request.getURI().getPath());
        //获取具体的请求服务实例
        AbstractRequestUrlResolver serverInstance = AbstractRequestUrlResolver.getServerInstance(serverName);
        if(null == serverInstance){
            return onError(exchange,new ResponseEntity("fail", HttpStatus.BAD_REQUEST.value(), "暂不支持该登录类型", Collections.EMPTY_MAP));
        }
        serverInstance.setRedisTemplate(redisTemplate);
        //token如果为null,app端需要校验JwtUser,放行
        if(StringUtils.isEmpty(authoriztion)){
            //是否需要强制校验token
            if(serverInstance.tokenNullIsCheckToken()){
                return onError(exchange,serverInstance.setResponseEntity("fail", HttpStatus.UNAUTHORIZED.value(), "尚未登录", Collections.EMPTY_MAP));
            }else {
                ServerHttpRequest shr=request.mutate().header(Constants.JWT_USERINFO, JSON.toJSONString( new JwtUserInfo())).build();
                return chain.filter(exchange.mutate().request(shr).build());
            }
        }
        //校验token
        ResponseEntity responseEntity = serverInstance.checkAuthToken(authoriztion);
        if(null != responseEntity && responseEntity.getResult().equals("fail")){
            return onError(exchange,responseEntity);
        }

        ServerHttpRequest shr=request.mutate().header(Constants.JWT_USERINFO, JSON.toJSONString(responseEntity.getData())).build();
        return chain.filter(exchange.mutate().request(shr).build());
    }*/

    private static final String X_CLIENT_TOKEN_USER = "x-client-token-user";

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request=exchange.getRequest();
        if(ignoreUrls!=null&&ignoreUrls.contains(request.getURI().getPath())){
            return chain.filter(exchange);
        }
        //获取token
        String authoriztion=request.getHeaders().getFirst(Constants.LOGIN_TOKEN);
        //获取服务名称
        String serverName = getServerNameByPath(request.getURI().getPath());
        //获取具体的请求服务实例
        AbstractRequestUrlResolver serverInstance = AbstractRequestUrlResolver.getServerInstance(serverName);
        if(null == serverInstance){
            return onError(exchange,new ResponseEntity("fail", HttpStatus.BAD_REQUEST.value(), "暂不支持该登录类型", Collections.EMPTY_MAP));
        }
        serverInstance.setRedisTemplate(redisTemplate);
        //token如果为null,app端需要校验JwtUser,放行
        if(StringUtils.isEmpty(authoriztion)){
            //是否需要强制校验token
            if(serverInstance.tokenNullIsCheckToken()){
                return onError(exchange,serverInstance.setResponseEntity("fail", HttpStatus.UNAUTHORIZED.value(), "尚未登录", Collections.EMPTY_MAP));
            }else {
                ServerHttpRequest shr=request.mutate().header(X_CLIENT_TOKEN_USER, JSON.toJSONString( new JwtUserInfo())).build();
                return chain.filter(exchange.mutate().request(shr).build());
            }
        }
        //校验token
        ResponseEntity responseEntity = serverInstance.checkAuthToken(authoriztion);
        if(null != responseEntity && responseEntity.getResult().equals("fail")){
            return onError(exchange,responseEntity);
        }
        JSONObject jsonObject = (JSONObject) JSON.toJSON(responseEntity.getData());
        ServerHttpRequest shr=request.mutate().header(X_CLIENT_TOKEN_USER, JSON.toJSONString(responseEntity.getData())).build();
        return chain.filter(exchange.mutate().request(shr).build());
    }

    /**
     * @Description  获取请求的服务名称
     * @author Liu_gx
     * @date 2021/1/8 17:28
     * @param path  请求路径
     * @return
     */
    private String getServerNameByPath(String path){
        return   getServerNameByPath(path,
                    (pathUrl)->{
                        return pathUrl.replace("/api/", "");
                    },(pathUrl)->{
                        return pathUrl.substring(0, pathUrl.indexOf("/"));
                    });
    }

    private  String getServerNameByPath(String str, Function<String,String> fun1,Function<String,String> fun2){
        return fun1.andThen (fun2).apply (str);
    }

    /**
     * @Description  异常返回信息
     * @author Liu_gx
     * @date 2021/1/8 17:29
     * @param exchange
     * @param rd
     * @return
     */
    private Mono<Void> onError(ServerWebExchange exchange,ResponseEntity rd){
        ServerHttpResponse response=exchange.getResponse();
        response.setStatusCode(HttpStatus.valueOf(rd.getRescode()));
        response.getHeaders().add("Content-Type","application/json;charset=UTF-8");
        ObjectMapper objectMapper=new ObjectMapper();
        String rs="";
        try {
            rs=objectMapper.writeValueAsString(rd);
        } catch (JsonProcessingException e) {
            log.error("occur Exception:"+e);
        }
        DataBuffer buffer= response.bufferFactory().wrap(rs.getBytes());
        return response.writeWith(Flux.just(buffer));
    }

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

}

方式一

HandlerMethodArgumentResolver是用来处理方法参数的解析器，包含以下2个方法：

supportsParameter（满足某种要求，返回true，方可进入resolveArgument做参数处理）
resolveArgument 解析操作

知识储备已到位，接下来着手实现，主要分为三步走：

自定义参数注解@LoginUser，添加至controller的方法参数userId之上；
自定义方法参数解析器LoginUserHandlerResolver，取出request中的userInfo，并赋值给添加了@LoginUser注解的参数userId。
将自定义参数解析器LoginUserHandlerResolver注册到spring容器中.

在Common公用模块自定义参数解析器LoginUserHandlerResolver实现HandlerMethodArgumentResolver(方法参数解析器)

@Configuration
public class LoginUserHandlerResolver implements HandlerMethodArgumentResolver
{
    private static final String CURRENT_ID = "jwtUserInfo";

    @Override
    public boolean supportsParameter(MethodParameter parameter)
    {
        return parameter.hasParameterAnnotation(LoginUser.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer container,
                                  NativeWebRequest nativeWebRequest, WebDataBinderFactory factory) throws Exception
    {
        HttpServletRequest request = nativeWebRequest.getNativeRequest(HttpServletRequest.class);
        // 获取用户ID
        String userid = String.valueOf(request.getHeader(CURRENT_ID));
        if (userid == null){
            return null;
        }
        return userid;
    }
}

定义@LoginUser注解,绑定用户信息

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginUser
{}

将自定义解析器注册到spring容器中

@Configuration
public class WebMvcConfig extends WebMvcConfigurationSupport {
 
    @Value("${file.userfiles-path}")
    private String filePath;
 
    /**
     * 登录校验拦截器
     *
     * @return
     */
    @Bean
    public AuthenticationInterceptor loginRequiredInterceptor() {
        return new AuthenticationInterceptor();
    }
 
    /**
     * CurrentUser 注解参数解析器
     *
     * @return
     */
    @Bean
    public CurrentUserMethodArgumentResolver currentUserMethodArgumentResolver() {
        return new CurrentUserMethodArgumentResolver();
    }
 
    /**
     * 参数解析器
     *
     * @param argumentResolvers
     */
    @Override
    protected void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        argumentResolvers.add(currentUserMethodArgumentResolver());
        super.addArgumentResolvers(argumentResolvers);
    }
 
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginRequiredInterceptor())
                .addPathPatterns(Constants.BASE_API_PATH + "/**")
                .excludePathPatterns(Constants.BASE_API_PATH + "/login");
        super.addInterceptors(registry);
    }
 
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/**")
                .addResourceLocations("classpath:/META-INF/resources/")
                .addResourceLocations("classpath:/static/page/")
                .addResourceLocations("classpath:/static/templates/")
                .addResourceLocations("file:" + filePath);
    }
 
    @Override
    protected void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setSerializerFeatures(SerializerFeature.QuoteFieldNames,
                SerializerFeature.WriteEnumUsingToString,
                SerializerFeature.WriteMapNullValue,
                SerializerFeature.WriteDateUseDateFormat,
                SerializerFeature.DisableCircularReferenceDetect);
        fastJsonConfig.setSerializeFilters((ValueFilter) (o, s, source) -> {
            if (null != source && (source instanceof Long || source instanceof BigInteger) && source.toString().length() > 15) {
                return source.toString();
            } else {
                return null == source ? EMPTY : source;
            }
        });
 
        //处理中文乱码问题
        List<MediaType> fastMediaTypes = new ArrayList<>();
        fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
        fastConverter.setSupportedMediaTypes(fastMediaTypes);
        fastConverter.setFastJsonConfig(fastJsonConfig);
        converters.add(fastConverter);
    }
}

获取用户id

ResponseEntity<CentreListResponse<EfficiencyNeedhandleVo>> queryListByDayTwo(@LoginUser String userId, @RequestBody @Valid EfficiencyNeedhandleQueryForm from) throws UserCenterException {
     System.out.println(userId);
}

方式二

主要分为三步走：

自定义用户上下文UserContextHolder,并且使用ThreadLocal进行存储;
用户请求拦截器UserInterceptor实现HandlerInterceptor，取出request中的userInfo，并添加到用户上下文中;
将自定义拦截器UserInterceptor注册到spring容器中。

定义用户上下文

public class UserContextHolder {

    private ThreadLocal<Map<String, String>> threadLocal;

    private UserContextHolder() {
        this.threadLocal = new ThreadLocal<>();
    }

    /**
     * 创建实例
     *
     * @return
     */
    public static UserContextHolder getInstance() {
        return SingletonHolder.sInstance;
    }

    /**
     * 静态内部类单例模式
     * 单例初使化
     */
    private static class SingletonHolder {
        private static final UserContextHolder sInstance = new UserContextHolder();
    }

    /**
     * 用户上下文中放入信息
     *
     * @param map
     */
    public void setContext(Map<String, String> map) {
        threadLocal.set(map);
    }

    /**
     * 获取上下文中的信息
     *
     * @return
     */
    public Map<String, String> getContext() {
        return threadLocal.get();
    }

    /**
     * 获取上下文中的用户名
     *
     * @return
     */
    public String getUsername() {
        return Optional.ofNullable(threadLocal.get()).orElse(Maps.newHashMap()).get("id");
    }

    /**
     * 清空上下文
     */
    public void clear() {
        threadLocal.remove();
    }

}

定义用户请求拦截器UserInterceptor实现HandlerInterceptor,并且将拿到的用户信息存储到上下文UserContextHolder中

@Slf4j
public class UserInterceptor implements HandlerInterceptor {
    /**
     * 服务间调用token用户信息,格式为json
     * {
     * "user_name":"必须有"
     * "自定义key:"value"
     * }
     */
    public static final String X_CLIENT_TOKEN_USER = "x-client-token-user";
    /**
     * 服务间调用的认证token
     */
    public static final String X_CLIENT_TOKEN = "x-client-token";

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //从网关获取并校验,通过校验就可信任x-client-token-user中的信息
        checkToken(request.getHeader(X_CLIENT_TOKEN));
        String userInfoString = StringUtils.defaultIfBlank(request.getHeader(X_CLIENT_TOKEN_USER), "{}");
        UserContextHolder.getInstance().setContext(new ObjectMapper().readValue(userInfoString, Map.class));
        return true;
    }

    private void checkToken(String token) {
        //TODO 从网关获取并校验,通过校验就可信任x-client-token-user中的信息
        log.debug("//TODO 校验token:{}", token);
    }

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

将自定义拦截器注册到spring容器中

@Configuration
public class WebServerMvcConfigurerAdapter implements WebMvcConfigurer {

    @Bean
    public HandlerInterceptor userInterceptor() {
        return new UserInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(userInterceptor());
    }
}

获取用户信息

ResponseEntity<CentreListResponse<EfficiencyNeedhandleVo>> queryListByDayTwo(@RequestBody @Valid EfficiencyNeedhandleQueryForm from) throws UserCenterException {
        String username = UserContextHolder.getInstance().getUsername();
        System.out.println(username);
}

瓜瓜醒

关注

10
点赞
踩
36

收藏

觉得还不错? 一键收藏
7
评论
Spring Cloud GateWay实现token的校验和传输

Spring Cloud GateWay实现token的校验和传输1.1 SpringCloud Gateway 简介Spring Cloud GateWay基于WebFlux框架实现的，而WebFlux框架底层则使用了高性能的Reactor模式通信框架Netty.Spring Cloud Gateway 的目标，不仅提供统一的路由方式，并且基于 Filter 链的方式提供了网关基本的功能，例如：安全，监控/指标，和限流。提前声明：Spring Cloud Gateway 底层使用了高性能的通
复制链接

扫一扫