Getway jwt 单点登录以及刷新token时间

超、凢脫俗 2023-01-01 01:57 240阅读 0赞

Getway jwt 单点登录以及刷新token时间

不用nosql或其他
1.集成jwt
pom依赖：

  1. <dependency>
  2.       <groupId>io.jsonwebtoken</groupId>
  3.       <artifactId>jjwt</artifactId>
  4.       <version>0.9.0</version>
  5.     </dependency>

2.jwt工具类

  1. package com.zkhx.uitls;
  3. import io.jsonwebtoken.Claims;
  4. import io.jsonwebtoken.Jws;
  5. import io.jsonwebtoken.Jwts;
  6. import io.jsonwebtoken.SignatureAlgorithm;
  7. import org.springframework.util.StringUtils;
  9. import javax.servlet.http.HttpServletRequest;
  10. import java.util.Date;
  12. /**
  13.  * @author kai
  14.  * @since 2020
  15.  */
  16. public class JwtUtils {
  18.     //设置token过期时间
  19. //    public static final long EXPIRE = 1000 * 60 * 60 * 24;
  20.     public static final long EXPIRE = 2000 * 60;
  21.     //加密秘钥,可以随便写
  22.     public static final String KAI_SECRET = "xxxxxxxxxxxxx";
  24.     //这个是生成token的方法，参数可多个
  25.     public static String getJwtToken(String id, String nickname){
  27.         String JwtToken = Jwts.builder()
  28.                 //这个是头信息
  29.                 .setHeaderParam("typ", "JWT")
  30.                 .setHeaderParam("alg", "HS256")
  32.                 //这里是设置过期时间
  33.                 .setSubject("kj-user")
  34.                 .setIssuedAt(new Date())
  35.                 .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
  37.                 //设置token的主体信息，存储用户信息
  38.                 .claim("id", id)
  39.                 .claim("nickname", nickname)
  40.                 //.claim("xxx", xxx)
  42.                 //签发hash  根据KAI_SECRET秘钥  HS256方式生成
  43.                 .signWith(SignatureAlgorithm.HS256, KAI_SECRET)
  44.                 .compact();
  46.         return JwtToken;
  47.     }
  49.     /**
  50.      * 判断token是否存在与有效
  51.      * @param jwtToken
  52.      * @return
  53.      */
  54.     public static boolean checkToken(String jwtToken) {
  55.         if(StringUtils.isEmpty(jwtToken)) return false;
  56.         try {
  57.             Jwts.parser().setSigningKey(KAI_SECRET).parseClaimsJws(jwtToken);
  58.         } catch (Exception e) {
  59.             e.printStackTrace();
  60.             return false;
  61.         }
  62.         return true;
  63.     }
  65.     /**
  66.      * 判断token是否存在与有效
  67.      * @param request
  68.      * @return
  69.      */
  70.     public static boolean checkToken(HttpServletRequest request) {
  71.         try {
  72.             String jwtToken = request.getHeader("token");
  73.             if(StringUtils.isEmpty(jwtToken)) return false;
  74.             Jwts.parser().setSigningKey(KAI_SECRET).parseClaimsJws(jwtToken);//根据秘钥解析，如果异常，则返回false
  75.         } catch (Exception e) {
  76.             e.printStackTrace();
  77.             return false;
  78.         }
  79.         return true;
  80.     }
  82.     /**
  83.      * 根据token获取会员id
  84.      * @param request
  85.      * @return
  86.      */
  87.     public static String getMemberIdByJwtToken(HttpServletRequest request) {
  88.         String jwtToken = request.getHeader("token");
  89.         if(StringUtils.isEmpty(jwtToken)) return "";
  90.         Jws<Claims> claimsJws = Jwts.parser().setSigningKey(KAI_SECRET).parseClaimsJws(jwtToken);
  91.         Claims claims = claimsJws.getBody();
  92.         return (String)claims.get("id");
  93.     }
  95.     /**
  96.      * 根据token获取nickname
  97.      * @param request
  98.      * @return
  99.      */
  100.     public static String getNameByJwtToken(HttpServletRequest request) {
  101.         String jwtToken = request.getHeader("token");
  102.         if(StringUtils.isEmpty(jwtToken)) return "";
  103.         Jws<Claims> claimsJws = Jwts.parser().setSigningKey(KAI_SECRET).parseClaimsJws(jwtToken);
  104.         Claims claims = claimsJws.getBody();
  105.         return (String)claims.get("nickname");
  106.     }
  109. }

用户服务登录获取token

  1. package com.zkhx.dept.controller;
  3. import com.github.pagehelper.PageInfo;
  4. import com.zkhx.dept.service.UserService;
  5. import com.zkhx.entity.UnitEntity;
  6. import com.zkhx.entity.UserEntity;
  7. import com.zkhx.uitls.JwtUtils;
  8. import com.zkhx.uitls.MD5;
  9. import com.zkhx.uitls.ResultCode;
  10. import com.zkhx.uitls.ResultMsg;
  11. import io.swagger.annotations.Api;
  12. import lombok.extern.slf4j.Slf4j;
  13. import org.springframework.beans.factory.annotation.Autowired;
  14. import org.springframework.web.bind.annotation.*;
  16. /**
  17.  * @author qinKJ
  18.  * @version 1.0
  19.  * @date 2020.12.7 11:50
  20.  */
  21. @RestController
  22. @Slf4j
  23. @RequestMapping("/xxx/xxx")
  24. @Api(tags = "",description = "")
  25. public class UserController {
  26.     @Autowired
  27.     private UserService userService;
  28.     @GetMapping("/UserController/userLogin")
  29.     public ResultMsg userLogin(@RequestParam("username") String username,@RequestParam("password") String password){
  30.         try {
  31.             UserEntity userEntity=new UserEntity();
  32.             userEntity.setPassword(MD5.encrypt(password));
  33.             userEntity.setUsername(username);
  34.             UserEntity userEntity1 = userService.userLogin(userEntity);
  35.             if(userEntity1!=null&&!userEntity1.equals("")){
  36.                 String jwtToken = JwtUtils.getJwtToken(String.valueOf(userEntity1.getId()), userEntity1.getUsername());
  37.                 return ResultMsg.successMsg().data(jwtToken);
  38.             }else {
  39.                 return ResultMsg.failMsg(ResultCode.DATANULL,"登录失败,请检查用户名和密码是否正确");
  40.             }
  41.         }catch (Exception e){
  42.             return ResultMsg.failMsg(ResultCode.ERROR,"发生异常");
  43.         }
  44.     }
  45. }

在这里插入图片描述
getway服务
依赖

  1. <dependency>
  2.       <groupId>org.springframework.cloud</groupId>
  3.       <artifactId>spring-cloud-starter-gateway</artifactId>
  4.       <version>${boot-version}</version>
  5.     </dependency>
  7.     <dependency>
  8.       <groupId>org.springframework.boot</groupId>
  9.       <artifactId>spring-boot-starter-actuator</artifactId>
  10.       <version>${boot-version}</version>
  11.     </dependency>
  13.     <!--jwt-->
  14.     <dependency>
  15.       <groupId>io.jsonwebtoken</groupId>
  16.       <artifactId>jjwt</artifactId>
  17.       <version>0.9.0</version>
  18.     </dependency>

getway与web是有冲突的，servlet不能用，用 的ServerHttpRequest ServerHttpResponse
原jwt工具类是涉及到servlet的，复制改造jwt工具类到网关服务

  1. package com.zkhx.utils;
  3. import io.jsonwebtoken.Claims;
  4. import io.jsonwebtoken.Jws;
  5. import io.jsonwebtoken.Jwts;
  6. import io.jsonwebtoken.SignatureAlgorithm;
  7. import org.springframework.util.StringUtils;
  9. import java.util.Date;
  11. /**
  12.  * @author qinKJ
  13.  * @version 1.0
  14.  * @date 2020.12.30 10:55
  15.  */
  16. public class JwtUtil {
  17.     public static final String KAI_SECRET = "xxxxx";
  19.     //设置token过期时间
  20.     //    public static final long EXPIRE = 1000 * 60 * 60 * 24;
  21.     public static final long EXPIRE = 2000 * 60;
  23.     //这个是生成token的方法，参数可多个
  24.     public static String getJwtToken(String id, String nickname){
  26.         String JwtToken = Jwts.builder()
  27.                 //这个是头信息
  28.                 .setHeaderParam("typ", "JWT")
  29.                 .setHeaderParam("alg", "HS256")
  31.                 //这里是设置过期时间
  32.                 .setSubject("kj-user")
  33.                 .setIssuedAt(new Date())
  34.                 .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
  36.                 //设置token的主体信息，存储用户信息
  37.                 .claim("id", id)
  38.                 .claim("nickname", nickname)
  39.                 //.claim("xxx", xxx)
  41.                 //签发hash  根据KAI_SECRET秘钥  HS256方式生成
  42.                 .signWith(SignatureAlgorithm.HS256, KAI_SECRET)
  43.                 .compact();
  45.         return JwtToken;
  46.     }
  48.     /**
  49.      * 判断token是否存在与有效
  50.      * @param jwtToken
  51.      * @return
  52.      */
  53.     public static boolean checkToken(String jwtToken) {
  54.         if(StringUtils.isEmpty(jwtToken)) return false;
  55.         try {
  56.             Jwts.parser().setSigningKey(KAI_SECRET).parseClaimsJws(jwtToken);
  57.         } catch (Exception e) {
  58.             e.printStackTrace();
  59.             return false;
  60.         }
  61.         return true;
  62.     }
  64.     /**
  65.      * 根据token获取nickname
  66.      * @param jwtToken
  67.      * @return
  68.      */
  69.     public static String getNameByJwtToken(String jwtToken) {
  70.         if(StringUtils.isEmpty(jwtToken)) return "";
  71.         Jws<Claims> claimsJws = Jwts.parser().setSigningKey(KAI_SECRET).parseClaimsJws(jwtToken);
  72.         Claims claims = claimsJws.getBody();
  73.         return (String)claims.get("nickname");
  74.     }
  76.     /**
  77.      * 根据token获取会员id
  78.      * @param jwtToken
  79.      * @return
  80.      */
  81.     public static String getMemberIdByJwtToken(String jwtToken) {
  82.         if(StringUtils.isEmpty(jwtToken)) return "";
  83.         Jws<Claims> claimsJws = Jwts.parser().setSigningKey(KAI_SECRET).parseClaimsJws(jwtToken);
  84.         Claims claims = claimsJws.getBody();
  85.         return (String)claims.get("id");
  86.     }
  88.     /**
  89.      * 判断是可以刷新token，根据自己的业务来
  90.      * @param token
  91.      * @param lastPasswordReset
  92.      * @return
  93.      */
  94.     public static Boolean canTokenBeRefreshed(String token, Date xxx) {
  95.         Claims claims;
  96.         try {
  97.             claims = Jwts.parser()
  98.                     .setSigningKey(KAI_SECRET)
  99.                     .parseClaimsJws(token)
  100.                     .getBody();
  101.             final Date iat = claims.getIssuedAt();
  102.             final Date exp = claims.getExpiration();
  103.             if (iat.before(xxx) || exp.before(new Date())) {
  104.                 return false;
  105.             }
  106.             return true;
  107.         } catch (Exception e) {
  108.             return false;
  109.         }
  110.     }
  112.     /**
  113.      * 刷新token
  114.      * @param token
  115.      * @param id
  116.      * @param nickname
  117.      * @return
  118.      */
  119.     public static String refreshToken(String token,String id, String nickname) {
  120.         String refreshedToken;
  121.         try {
  122.             final Claims claims = Jwts.parser()
  123.                     .setSigningKey(KAI_SECRET)
  124.                     .parseClaimsJws(token)
  125.                     .getBody();
  126.             refreshedToken = getJwtToken(id, nickname);
  127.         } catch (Exception e) {
  128.             refreshedToken = null;
  129.         }
  130.         return refreshedToken;
  131.     }
  132. }

网关拦截器

  1. package com.zkhx.filter;
  3. import com.google.gson.JsonObject;
  4. import com.zkhx.utils.JwtUtil;
  5. import io.jsonwebtoken.Claims;
  6. import io.jsonwebtoken.Jwts;
  7. import org.springframework.cloud.gateway.filter.GatewayFilterChain;
  8. import org.springframework.cloud.gateway.filter.GlobalFilter;
  9. import org.springframework.core.Ordered;
  10. import org.springframework.core.io.buffer.DataBuffer;
  11. import org.springframework.http.HttpRequest;
  12. import org.springframework.http.server.reactive.ServerHttpRequest;
  13. import org.springframework.http.server.reactive.ServerHttpResponse;
  14. import org.springframework.stereotype.Component;
  15. import org.springframework.util.AntPathMatcher;
  16. import org.springframework.web.server.ServerWebExchange;
  17. import reactor.core.publisher.Mono;
  19. import java.nio.charset.StandardCharsets;
  20. import java.text.SimpleDateFormat;
  21. import java.util.Date;
  22. import java.util.List;
  24. /**
  25.  * @author qinKJ
  26.  * @version 1.0
  27.  * @date 2020.12.30 9:50
  28.  */
  29. @Component
  30. public class AuthGlobalFilter implements GlobalFilter, Ordered {
  32.     private AntPathMatcher antPathMatcher = new AntPathMatcher();
  34.     @Override
  35.     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
  36.         ServerHttpRequest request = exchange.getRequest();
  37.         String path = request.getURI().getPath();
  38.         ServerHttpResponse response = exchange.getResponse();
  39.         //校验用户必须登录
  40.         if(antPathMatcher.match("/phm/fault/**", path)) {
  41.             List<String> tokenList = request.getHeaders().get("token");
  42.             String tokenJwt=request.getHeaders().getFirst("token");
  43.             if(null == tokenList) {
  44. //                ServerHttpResponse response = exchange.getResponse();
  45.                 return out(response);
  46.             } else if(JwtUtil.checkToken(tokenJwt)) {
  47.                 String nameByJwtToken = JwtUtil.getNameByJwtToken(tokenJwt);
  48.                 String memberIdByJwtToken = JwtUtil.getMemberIdByJwtToken(tokenJwt);
  49. ****************************************************************测试用****************************************************************
  50.                 Claims claims1 = Jwts.parser()
  51.                         .setSigningKey("ukc8BDbRigUDaY6pZFfWus2jZWLPHO")
  52.                         .parseClaimsJws(tokenJwt)
  53.                         .getBody();
  55.                 Date d1 = claims1.getIssuedAt();
  56.                 Date d2 = claims1.getExpiration();
  57.                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
  58.                 System.out.println("username参数值：" + claims1.get("username"));
  59.                 System.out.println("登录用户的id：" + claims1.getId());
  60.                 System.out.println("登录用户的名称：" + claims1.getSubject());
  61.                 System.out.println("令牌签发时间：" + sdf.format(d1));
  62.                 System.out.println("令牌过期时间：" + sdf.format(d2));
  64.                 Boolean aBoolean = JwtUtil.canTokenBeRefreshed(tokenJwt, new Date());
  65.                 if (!aBoolean){
  66.                     tokenJwt=JwtUtil.refreshToken(tokenJwt,memberIdByJwtToken,nameByJwtToken);
  67.                     Claims claims2 = Jwts.parser()
  68.                             .setSigningKey(JwtUtil.KAI_SECRET)
  69.                             .parseClaimsJws(tokenJwt)
  70.                             .getBody();
  72.                     Date d3 = claims2.getIssuedAt();
  73.                     Date d4 = claims2.getExpiration();
  74.                     System.out.println("username参数值：" + claims2.get("username"));
  75.                     System.out.println("登录用户的id：" + claims2.getId());
  76.                     System.out.println("登录用户的名称：" + claims2.getSubject());
  77.                     System.out.println("令牌签发时间：" + sdf.format(d3));
  78.                     System.out.println("令牌过期时间：" + sdf.format(d4));
  80.                     // 获取响应Header，目前的实现中返回的是HttpHeaders实例，可以直接修改
  81.                     response.getHeaders().add("new_token",tokenJwt);
  82.                 }
  83. ****************************************************************测试用****************************************************************
  84.                 // TODO 将token信息存放在请求header中传递给下游业务
  85.                 ServerHttpRequest.Builder mutate = request.mutate();
  86.                 mutate.header("AuthToken", tokenJwt);
  87.                 ServerHttpRequest buildReuqest = mutate.build();
  88.                 return chain.filter(exchange.mutate()
  89.                         .request(buildReuqest)
  90.                         .response(response)
  91.                         .build());
  92.             }else {
  93. //                ServerHttpResponse response = exchange.getResponse();
  94.                 return out(response);
  95.             }
  96.         }
  97.         //内部服务接口，不允许外部访问
  98.         if(antPathMatcher.match("/**/knowledge/**", path)) {
  99. //            ServerHttpResponse response = exchange.getResponse();
  100.             return out(response);
  101.         }
  102.         return chain.filter(exchange);
  103.     }
  105.     @Override
  106.     public int getOrder() {
  107.         return 0;
  108.     }
  110.     private Mono<Void> out(ServerHttpResponse response) {
  111.         JsonObject message = new JsonObject();
  112.         message.addProperty("success", false);
  113.         message.addProperty("code", 28004);
  114.         message.addProperty("data", "鉴权失败");
  115.         byte[] bits = message.toString().getBytes(StandardCharsets.UTF_8);
  116.         DataBuffer buffer = response.bufferFactory().wrap(bits);
  117.         //response.setStatusCode(HttpStatus.UNAUTHORIZED);
  118.         //指定编码，否则在浏览器中会中文乱码
  119.         response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
  120.         return response.writeWith(Mono.just(buffer));
  121.     }
  122. }

接下来是给访问服务加过滤
在这里插入图片描述

  1. package com.zkhx.config;
  3. /**
  4.  * @author qinKJ
  5.  * @version 1.0
  6.  * @date 2020.12.30 14:13
  7.  */
  9. import com.zkhx.filter.TokenInterceptor;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.web.servlet.config.annotation.CorsRegistry;
  12. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  13. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  15. import java.util.ArrayList;
  16. import java.util.List;
  18. /**
  19.  * 拦截器配置
  20.  */
  21. @Configuration
  22. public class InterCepTerConfig implements WebMvcConfigurer {
  24.     private TokenInterceptor tokenInterceptor;
  26.     //构造方法
  27.     public InterCepTerConfig(TokenInterceptor tokenInterceptor){
  28.         this.tokenInterceptor = tokenInterceptor;
  29.     }
  31.     @Override
  32.     public void addInterceptors(InterceptorRegistry registry){
  33.         List<String> excludePath = new ArrayList<>();
  34. //        excludePath.add("/user_register"); //注册
  35. //        excludePath.add("/login"); //登录
  36. //        excludePath.add("/logout"); //登出
  37. //        excludePath.add("/static/**");  //静态资源
  38. //        excludePath.add("/swagger-ui.html/**");  //静态资源
  39. //        excludePath.add("/assets/**");  //静态资源
  41.         registry.addInterceptor(tokenInterceptor)
  42.                 .addPathPatterns("/**")
  43.                 .excludePathPatterns(excludePath);
  44.         WebMvcConfigurer.super.addInterceptors(registry);
  46.     }
  48.     /**
  49.      * 跨域支持
  50.      *
  51.      * @param registry
  52.      */
  53.     @Override
  54.     public void addCorsMappings(CorsRegistry registry) {
  55.         registry.addMapping("/**")
  56.                 .allowedOrigins("*")
  57.                 .allowCredentials(true)
  58.                 .allowedMethods("GET", "POST", "DELETE", "PUT", "PATCH", "OPTIONS", "HEAD")
  59.                 .maxAge(3600 * 24);
  60.     }
  63. }
  65. package com.zkhx.filter;
  67. import com.alibaba.fastjson.JSONObject;
  68. import com.zkhx.uitls.JwtUtils;
  69. import io.jsonwebtoken.Claims;
  70. import io.jsonwebtoken.Jwts;
  71. import org.springframework.stereotype.Component;
  72. import org.springframework.web.servlet.HandlerInterceptor;
  74. import javax.servlet.http.HttpServletRequest;
  75. import javax.servlet.http.HttpServletResponse;
  76. import java.io.PrintWriter;
  77. import java.text.SimpleDateFormat;
  78. import java.util.Date;
  80. /**
  81.  * @author qinKJ
  82.  * @version 1.0
  83.  * @date 2020.12.30 14:07
  84.  * 防止直接访问
  85.  */
  86. @Component
  87. public class TokenInterceptor implements HandlerInterceptor {
  91.     @Override
  92.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception{
  94.         if(request.getMethod().equals("OPTIONS")){
  95.             response.setStatus(HttpServletResponse.SC_OK);
  96.             return true;
  97.         }
  99.         response.setCharacterEncoding("utf-8");
  101.         String token = request.getHeader("AuthToken");
  102.         if(token != null){
  103.             boolean result = JwtUtils.checkToken(token);
  104.             if(result){
  105.                 return true;
  106.             }
  107.         }
  108.         response.setCharacterEncoding("UTF-8");
  109.         response.setContentType("application/json; charset=utf-8");
  110.         PrintWriter out = null;
  111.         try{
  112.             JSONObject json = new JSONObject();
  113.             json.put("success","false");
  114.             json.put("msg","不能从这里访问哟");
  115.             json.put("code","50000");
  116.             response.getWriter().append(json.toJSONString());
  117.             System.out.println("认证失败，未通过拦截器");
  118.             //        response.getWriter().write("50000");
  119.         }catch (Exception e){
  120.             e.printStackTrace();
  121.             response.sendError(500);
  122.             return false;
  123.         }
  125.         return false;
  127.     }
  128. }

完毕，不通过网关访问接口：
在这里插入图片描述
登录服务获取到token，通过postman调试
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
替换token后再次访问
在这里插入图片描述
刷新成功

发表评论

表情：
评论列表 （有 0 条评论，240人围观）

还没有评论，来说两句吧...

相关阅读