java jwt生成token并在网关设置全局过滤器进行token的校验并在给请求头设置参数及在微服务中解析参数

jjw_zyfx

已于 2023-07-03 10:00:17 修改

阅读量2k

点赞数 2

分类专栏： Java 文章标签： java 网络算法

于 2023-07-02 19:43:35 首次发布

本文链接：https://blog.csdn.net/jjw_zyfx/article/details/131502490

版权

Java 专栏收录该内容

44 篇文章 1 订阅

订阅专栏

1、首先引入jjwt的依赖

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

2、编写生成token的工具类

package com.jjw.result.util;

import com.jjw.result.constants.SystemConstants;
import io.jsonwebtoken.*;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.*;

public class AppJwtUtil {

    // TOKEN的有效期一天（S）
    private static final int TOKEN_TIME_OUT = 3600;
    // 加密KEY
    private static final String TOKEN_ENCRY_KEY = "MDk4ZjZiY2Q0NjIxZDM3M2NhZGU0ZTgzMjYyN2I0ZjY";
    // 最小刷新间隔(S)
    private static final int REFRESH_TIME = 300;

    // 生产ID
    public static String createToken(Long id) {
        Map<String, Object> claimMaps = new HashMap<>();
        claimMaps.put("id", id);
        long currentTime = System.currentTimeMillis();
        return Jwts.builder()
                .setId(UUID.randomUUID().toString())
                .setIssuedAt(new Date(currentTime))  //签发时间
                .setSubject("system")  //说明
                .setIssuer("jjw") //签发者信息
                .setAudience("app")  //接收用户
                .compressWith(CompressionCodecs.GZIP)  //数据压缩方式
                .signWith(SignatureAlgorithm.HS512, generalKey()) //加密方式
                //过期一个小时
                .setExpiration(new Date(currentTime + TOKEN_TIME_OUT * 1000))  //过期时间戳
                .addClaims(claimMaps) //cla信息
                .compact();
    }

    /**
     * 获取token中的claims信息
     *
     * @param token
     * @return
     */
    private static Jws<Claims> getJws(String token) {
        return Jwts.parser()
                .setSigningKey(generalKey())
                .parseClaimsJws(token);
    }

    /**
     * 获取payload body信息
     *
     * @param token
     * @return
     */
    public static Claims getClaimsBody(String token) {
        try {
            return getJws(token).getBody();
        } catch (ExpiredJwtException e) {
            return null;
        }
    }

    /**
     * 获取hearder body信息
     *
     * @param token
     * @return
     */
    public static JwsHeader getHeaderBody(String token) {
        return getJws(token).getHeader();
    }

    /**
     * 是否过期
     *
     * @param token
     * @return 1 有效  0 无效  2 已过期
     */
    public static Integer verifyToken(String token) {

        try {
            Claims claims = AppJwtUtil.getClaimsBody(token);
            if (claims == null) {
                return SystemConstants.JWT_FAIL;
            }
            return SystemConstants.JWT_OK;
        } catch (ExpiredJwtException ex) {
            return SystemConstants.JWT_EXPIRE;
        } catch (Exception e) {
            return SystemConstants.JWT_FAIL;
        }
    }

    /**
     * 由字符串生成加密key
     *
     * @return
     */
    public static SecretKey generalKey() {
        byte[] encodedKey = Base64.getEncoder().encode(TOKEN_ENCRY_KEY.getBytes());
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }

    public static void main(String[] args) {
       /* Map map = new HashMap();
        map.put("id","11");*/
        String token = AppJwtUtil.createToken(1102L);
        System.out.println(token);	

        Claims claims = AppJwtUtil.getClaimsBody(token);
        //Integer integer = AppJwtUtil.verifyToken("dsafafsa");
        Integer integer = AppJwtUtil.verifyToken("eyJhbGciOiJIUzUxMiIsInppcCI6IkdaSVAifQ.H4sIAAAAAAAAAC2LywrDIBAA_2XP8aCrZs3frI-CQkFYQ1tK_z0b6G2GYb4wVocDMNuMXMhQfKDxJQXDuEcTk68tuFooBNig84LDRiJHO2HaQM6st3xktefdRVTHeCnzWZV5TuX2nv8vWX9_XZv7Xf0W2Rt-AAAA.srh9GIXr4ZqpXNfFb6vGIUxT12ve6Tu6xQ2KmdySsziP6AeCgP1h2GBhhx1g4rNbdsLozNI_WA-2FKsoR6-yPg");
        System.out.println(integer);
        System.out.println(claims);

    }
}

3、使用到的常量类：

package com.jjw.result.constants;

public class SystemConstants {
    //JWT TOKEN已过期
    public static final Integer JWT_EXPIRE = 2;
    //JWT TOKEN有效
    public static final Integer JWT_OK = 1;
    //JWT TOKEN无效
    public static final Integer JWT_FAIL = 0;

    public static final String USER_HEADER_NAME = "userId";

    public static final Integer TYPE_USER = 1; // 用户
    public static final Integer TYPE_E = 0; // 设备

}

4、在service的实现类中调用，生成token返回给前端

//4.生成令牌返回给前端
String token = AppJwtUtil.createToken(Long.valueOf(adUserFromDb.getId()));
Map<String, Object> info = new HashMap<>();
info.put("token",token);

5、在网关上进行校验，因此需要搭建网关服务。首先引人依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
    <groupId>com.jjw</groupId>
    <artifactId>result-content</artifactId>
    <version>1.0-SNAPSHOT</version>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </exclusion>
        <!--要排除spring-boot-starter-web这个依赖，但是result-content中包含的swagger-content这个
        依赖又依赖于spring-boot-starter-web，而我只需要result-content中的内容，所以将这两个依赖都排除了-->
        <exclusion>
            <groupId>com.jjw</groupId>
            <artifactId>swagger-content</artifactId>
        </exclusion>
    </exclusions>
</dependency>

6、启动类代码如下：

@SpringBootApplication
@EnableDiscoveryClient
public class GatewayAdminApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayAdminApplication.class,args);
    }
}

7、配置application.yml文件

spring:
  profiles:
    active: dev
---
server:
  port: 6001
spring:
  application:
    name: leadnews-admin-gateway
  profiles: dev
  cloud:
    nacos:
      server-addr: 192.168.211.136:8848
      discovery:
        server-addr: ${spring.cloud.nacos.server-addr}
    gateway:
      globalcors:
        add-to-simple-url-handler-mapping: true  #增加
        cors-configurations:
          '[/**]': # 匹配所有请求
            allowedOrigins: "*" #跨域处理 允许所有的域
            allowedHeaders: "*"
            allowedMethods: # 支持的方法
              - GET
              - POST
              - PUT
              - DELETE
            allowCredentials: true # 是否允许携带cookie
            maxAge: 360000 # 这次跨域检测的有效期
      routes:
        # 平台管理
        - id: admin
          uri: lb://leadnews-admin
          predicates:
            - Path=/admin/**
          filters:
            - StripPrefix= 1

8、添加网关模块、结构如下：

在这里插入图片描述

9、编写校验token的AuthorizeFilter类（全局过滤器），其内容如下：

package com.jjw.gatewayadmin.filter;

import com.jjw.result.constants.SystemConstants;
import com.jjw.result.util.AppJwtUtil;
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.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class AuthorizeFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //+ 1.先获取请求和响应对象
        ServerHttpRequest request = exchange.getRequest();

        ServerHttpResponse response = exchange.getResponse();
        // /get /a  post /a

        //+ 2.判断当前的请求 是否 是登录的请求 如果是 ，则放行
        String path = request.getURI().getPath();
        if(path.equals("/admin/admin/login")){
            return chain.filter(exchange);
        }

        //+ 3.获取页面传递过来的请求头中的令牌数据 如果获取不到 返回错误（401）
        String token = request.getHeaders().getFirst("token");
        if(StringUtils.isEmpty(token)){
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return  response.setComplete();//完成响应 返回 后面就不执行了
        }

        //+ 4.校验令牌 校验失败 返回错误401
        //通过jwt 来校验
        if(SystemConstants.JWT_OK!= AppJwtUtil.verifyToken(token)){
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return  response.setComplete();//完成响应 返回 后面就不执行了
        }
        //+ 5.校验成功 放行
        return chain.filter(exchange);
    }


    //过滤器的执行的优先级的设置 值越低 优先级越高
    @Override
    public int getOrder() {
        return 0;
    }
}

可在请求头中添加用户信息：

import com.alibaba.fastjson.JSON;

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.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.net.URLEncoder;

/**

 * 全局过滤器：所有的请求都需要经过此过滤器。可以自定义业务逻辑进行处理，在转发请求之前先处理
 * 步骤如下：
 * 1、创建一个类实现GlobalFilter, Ordered
 * 2、将此类交给spring容器进行管理  @Component
 * 3、重写方法，实现自定义的业务逻辑
 */
@Component
public class AuthorizeFilter implements GlobalFilter, Ordered {

    //获取用户携带的token令牌  解析校验 校验通过放行 不通过 返回错误
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //1.获取请求对象 和 响应对象
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();


        //1.5 如果请求的路径是 自媒体登录【白名单】 放行即可
        String path = request.getURI().getPath();
        if(path.startsWith("/user/app/login") ||path.startsWith("/user/app/refreshToken") || path.endsWith("v2/api-docs")){
            return chain.filter(exchange);
        }


        //2.从请求头中获取访问令牌数据
        String token = request.getHeaders().getFirst("token");
        //3.判断 是否为空 如果为空 返回错误 401
        if(StringUtils.isEmpty(token)){
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }

        //4.校验令牌是否正确了 如果不是  返回错误 401
        try {
            // 4.1 解析成功令牌有效
            UserTokenInfoExp userTokenInfoExp = JwtUtil.parseJwtUserToken(token);
            // 4.2 判断角色是否正确(网关是App网关， 来的令牌必须是APP或者是匿名用户的令牌)
            if(JwtUtil.isValidRole(userTokenInfoExp, TokenRole.ROLE_MEDIA)||JwtUtil.isValidRole(userTokenInfoExp, TokenRole.ROLE_ADMIN)){
                response.setStatusCode(HttpStatus.UNAUTHORIZED);
                return response.setComplete();
            }
            //直接返回 表示需要续约  判断是否过期
            if(JwtUtil.isExpire(userTokenInfoExp)){
                //403
                response.setStatusCode(HttpStatus.FORBIDDEN);
                return response.setComplete();
            }

            // 成功了将用户的令牌解析之后的所有的数据 放到请求头中 传递给下游 放行
            //URL编码 否则有乱码产生
            String encode = URLEncoder.encode(JSON.toJSONString(userTokenInfoExp), "UTF-8");
            //将信息传递给下游微服务
            request.mutate().header(SystemConstants.USER_HEADER_NAME, encode);

        } catch (Exception e) {
            e.printStackTrace();
            //直接错误
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        return chain.filter(exchange);
    }

    //值越低 优先级越高 优先被执行
    @Override
    public int getOrder() {
        return -10;
    }


     校验当前用户发送过来的请求是否有权限去访问，用户需要在请求头中携带之前生成颁发的令牌过来
    //@Override
    //public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    //    //+ 1.先获取请求和响应对象
    //    ServerHttpRequest request = exchange.getRequest();
    //
    //    ServerHttpResponse response = exchange.getResponse();
    //    // /get /a  post /a
    //
    //    //+ 2.判断当前的请求 是否 是登录的请求 如果是 ，则放行
    //    String path = request.getURI().getPath();
    //    if(path.equals("/media/wmUser/login")){
    //        return chain.filter(exchange);
    //    }
    //
    //    //+ 3.获取页面传递过来的请求头中的令牌数据 如果获取不到 返回错误（401）
    //    String token = request.getHeaders().getFirst("token");
    //    if(StringUtils.isEmpty(token)){
    //        response.setStatusCode(HttpStatus.UNAUTHORIZED);
    //        return  response.setComplete();//完成响应 返回 后面就不执行了
    //    }
    //
    //    //+ 4.校验令牌 校验失败 返回错误401
    //    //通过jwt 来校验
    //    if(SystemConstants.JWT_OK!= AppJwtUtil.verifyToken(token)){
    //        response.setStatusCode(HttpStatus.UNAUTHORIZED);
    //        return  response.setComplete();//完成响应 返回 后面就不执行了
    //    }
    //
    //    //在路由请求之前，将当前令牌中的用户id解析出来并添加到请求头中，传递给下游
    //    Claims claimsBody = AppJwtUtil.getClaimsBody(token);
    //    Object id = claimsBody.get("id"); // 这个id是claimMaps.put("id", id);的id
    //    //String id1 = claimsBody.getId(); // 这俩id是不一样的，这个id是Jwts.builder().setId
    //
    //    request.mutate().header(USER_HEADER_NAME, id.toString());
    //
    //    //+ 5.校验成功 放行
    //    return chain.filter(exchange);
    //}
    //
    //
    过滤器的执行的优先级的设置 值越低 优先级越高
    //@Override
    //public int getOrder() {
    //    return 0;
    //}




}

在服务端如何获取拦截器放在请求头中的信息：先定义一个获取的工具类

public class RequestContextUtil {
    /**
     * 获取登录的用户的ID 可以是自媒体账号 也可以是 平台账号 也可以是app账号
     * @return
     */
    public static String getUserInfo(){
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
        HttpServletRequest request = requestAttributes.getRequest();
        //获取路由转发的头信息
        String headerValue = request.getHeader(SystemConstants.USER_HEADER_NAME);
        return headerValue;
    }
}

在微服务中使用到的地方直接导包调用即可：

String userId = RequestContextUtil.getUserInfo();

jjw_zyfx

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
java jwt生成token并在网关设置全局过滤器进行token的校验并在给请求头设置参数及在微服务中解析参数

java jwt生成token并在网关设置全局过滤器进行token的校验
复制链接

扫一扫

专栏目录

java jwt生成token并在网关设置全局过滤器进行token的校验并在给请求头设置参数及在微服务中解析参数

1、首先引入jjwt的依赖

2、编写生成token的工具类

3、使用到的常量类：

4、在service的实现类中调用，生成token返回给前端

5、在网关上进行校验，因此需要搭建网关服务。首先引人依赖

6、启动类代码如下：

7、配置application.yml文件

8、添加网关模块、结构如下：

9、编写校验token的AuthorizeFilter类（全局过滤器），其内容如下：

可在请求头中添加用户信息：

在服务端如何获取拦截器放在请求头中的信息：先定义一个获取的工具类

在微服务中使用到的地方直接导包调用即可：

“相关推荐”对你有帮助么？