Spring Cloud Gateway 使用JWT工具类做用户登录校验功能

1. jwt测试

/**
 * @auther: csp1999
 * @date: 2021/01/24/19:29
 * @description: jwt测试
 */
public class jwttest {

 /**
  * 创建jwt令牌：
  *
  * jwt = 头部header + 载荷playload + 签名signature
  */
 @test
 public void testcreatejwt() {
  // 构建jwt令牌
  // 1.头部header: 描述关于该jwt的最基本的信息,例如其类型以及签名所用的算法等
  jwtbuilder builder = jwts.builder()
    .setid("8989")      // 设置令牌唯一编号
    .setissuer("csp1999")    // 设置令牌颁发者
    .setsubject("jwt加密测试")   // 设置令牌主题 可以是json数据
    .setissuedat(new date())   // 设置令牌签发日期
    .setexpiration(new date(system.currenttimemillis() + 1000 * 60 * 3));// 设置令牌过期时间 3分钟

  // 2.自定义载荷playload: 存放有效信息的地方
  map<string,object> userinfo = new hashmap<>();
  userinfo.put("username","csp");
  userinfo.put("password","123456");
  userinfo.put("school","河南科技大学");
  userinfo.put("age","22");
  // 将载荷添加到jwt令牌中
  builder.addclaims(userinfo);

  // 3.为令牌设置 签名signature
  builder.signwith(signaturealgorithm.hs256, "haust");// 设置令牌的签名 使用hs256算法，并设置secretkey密钥(字符串)

  // 构建 并返回一个字符串
  string jwtstr = builder.compact();
  system.out.println(jwtstr);
 }

 /**
  * 解析jwt令牌数据
  */
 @test
 public void testparsejwt() {
  // jwt字符串
  string jwtstr = "eyjhbgcioijiuzi1nij9.eyjqdgkioii4otg5iiwiaxnzijoiy3nwmtk5osisinn1yii6ikpxvowkoowvhua1i-ivlsisimlhdci6mtyxmtq4odc1mswizxhwijoxnjexndg4otmxlcjwyxnzd29yzci6ijeymzq1niisinnjag9vbci6iuays-wnl-enkeakgowkp-wtpiisimfnzsi6ijiyiiwidxnlcm5hbwuioijjc3aifq.uh28g9mshfzakbaoyr8adksylvvy8o5p8g7torziufy";

  // 解析jwt字符串
  claims claims = jwts.parser().
    setsigningkey("haust").  // 密钥（盐）
    parseclaimsjws(jwtstr).  // 要解析的令牌对象
    getbody();     // 获取解析后的结果

  // {jti=8989, iss=csp1999, sub=jwt加密测试, iat=1611488751, exp=1611488931, password=123456, school=河南科技大学, age=22, username=csp}
  system.out.println(claims);
 }
}

2. jwt工具类

/**
 * @auther: csp1999
 * @date: 2021/01/24/19:29
 * @description: jwt工具类
 */
public class jwtutil {
 // 有效期为
 public static final long jwt_ttl = 3600000l;// 60 * 60 * 1000 一个小时

 // jwt令牌信息
 public static final string jwt_key = "itcast";

 /**
  * 生成令牌
  * @param id
  * @param subject
  * @param ttlmillis
  * @return
  */
 public static string createjwt(string id, string subject, long ttlmillis) {
  // 指定算法
  signaturealgorithm signaturealgorithm = signaturealgorithm.hs256;

  // 当前系统时间
  long nowmillis = system.currenttimemillis();
  // 令牌签发时间
  date now = new date(nowmillis);

  // 如果令牌有效期为null，则默认设置有效期1小时
  if (ttlmillis == null) {
   ttlmillis = jwtutil.jwt_ttl;
  }

  // 令牌过期时间设置
  long expmillis = nowmillis + ttlmillis;
  date expdate = new date(expmillis);

  // 生成秘钥
  secretkey secretkey = generalkey();

  // 封装jwt令牌信息
  jwtbuilder builder = jwts.builder()
    .setid(id)         //唯一的id
    .setsubject(subject)      // 主题 可以是json数据
    .setissuer("admin")       // 签发者
    .setissuedat(now)       // 签发时间
    .signwith(signaturealgorithm, secretkey) // 签名算法以及密匙
    .setexpiration(expdate);     // 设置过期时间

  return builder.compact();
 }

 /**
  * 生成加密 secretkey
  *
  * @return
  */
 public static secretkey generalkey() {
  byte[] encodedkey = base64.getencoder().encode(jwtutil.jwt_key.getbytes());
  secretkey key = new secretkeyspec(encodedkey, 0, encodedkey.length, "aes");
  return key;
 }


 /**
  * 解析令牌数据
  *
  * @param jwt
  * @return
  * @throws exception
  */
 public static claims parsejwt(string jwt) throws exception {
  secretkey secretkey = generalkey();
  return jwts.parser()
    .setsigningkey(secretkey)
    .parseclaimsjws(jwt)
    .getbody();
 }

 public static void main(string[] args) {
  string jwt = jwtutil.createjwt("weiyibiaoshi", "aaaaaa", null);

  system.out.println(jwt);
  try {
   claims claims = jwtutil.parsejwt(jwt);
   system.out.println(claims);
  } catch (exception e) {
   e.printstacktrace();
  }
 }
}

3. 用户登录校验

3.1 网关过滤器

/**
 * @auther: csp1999
 * @date: 2021/01/24/20:17
 * @description: 授权过滤器
 */
@component
public class authorizefilter implements globalfilter, ordered {

 // 令牌头名字
 private static final string authorize_token = "authorization";

 /**
  * 全局过滤器
  *
  * @param exchange
  * @param chain
  * @return
  */
 @override
 public mono<void> filter(serverwebexchange exchange, gatewayfilterchain chain) {
  // 获取request、response对象
  serverhttprequest request = exchange.getrequest();
  serverhttpresponse response = exchange.getresponse();

  // 获取请求的uri
  string path = request.geturi().getpath();

  // 如果是登录、goods等开放的微服务[这里的goods部分开放],则直接放行,这里不做完整演示，完整演示需要设计一套权限系统
  // 未登录下只放行登录和搜索
  if (path.startswith("/api/user/login") || path.startswith("/api/brand/search/")) {
   // 放行
   mono<void> filter = chain.filter(exchange);

   return filter;
  }

  // 从头文件中获取的令牌信息
  string token = request.getheaders().getfirst(authorize_token);
  // 如果为true：说明令牌在头文件中， false：令牌不在头文件中，将令牌封装入头文件，再传递给其他微服务
  boolean hastoken = true;

  // 如果头文件中没有令牌信息，则从请求参数中获取
  if (stringutils.isempty(token)) {
   token = request.getqueryparams().getfirst(authorize_token);
   hastoken = false;
  }

  // 如果为空，则输出错误代码
  if (stringutils.isempty(token)) {
   // 设置方法不允许被访问，405错误代码
   response.setstatuscode(httpstatus.method_not_allowed);
   return response.setcomplete();
  }

  // 如果不为空，则解析令牌数据
  try {
   claims claims = jwtutil.parsejwt(token);
  } catch (exception e) {
   e.printstacktrace();
   // 解析失败，响应401错误
   response.setstatuscode(httpstatus.unauthorized);
   return response.setcomplete();
  }

  // 放行之前，将令牌封装到头文件中(这一步是为了方便auth2校验令牌)
  request.mutate().header(authorize_token,token);

  // 放行
  return chain.filter(exchange);
 }


 /**
  * 过滤器执行顺序
  *
  * @return
  */
 @override
 public int getorder() {
  // 首位
  return 0;
 }
}

3.2 网关微服务application.yml

spring:
 cloud:
 gateway:
  globalcors:
  corsconfigurations:
   '[/**]': # 匹配所有请求
   allowedorigins: "*" # 跨域处理 允许所有的域
   allowedmethods: #支持的请求类型
    - get
    - post
    - put
    - delete
  routes:
  # 对接商品goods微服务路由相关配置
  - id: changgou_goods_route
   uri: lb://changgou-goods
   predicates:
   - path=/api/brand/**,/api/category/**
   filters:
   - stripprefix=1
   - name: requestratelimiter # 请求数限流 名字不能随便写 ，使用默认的facatory
    args:
    # 用于限流的键的解析器的 bean 对象的名字。它使用 spel 表达式根据#{@beanname}从 spring 容器中获取 bean 对象。
    key-resolver: "#{@ipkeyresolver}"
    # 令牌桶每秒填充平均速率
    redis-rate-limiter.replenishrate: 1
    # 令牌桶总容量
    redis-rate-limiter.burstcapacity: 1
    # 上面配置，表示1秒内，允许 1个请求通过，令牌桶的填充速率也是1秒钟添加1个令牌。
  # 对接用户user微服务路由相关配置
  - id: changgou_user_route
   uri: lb://changgou-user
   predicates:
   - path=/api/user/**,/api/address/**,/api/areas/**,/api/cities/**,/api/provinces/**
   filters:
   # user微服务真实请求中是没有/api的，所以这里stripprefix=1
   - stripprefix=1
 # 微服务名称
 application:
 name: changgou-gateway-web
 # redis配置
 redis:
 # redis数据库索引（默认为0）
 database: 0
 # redis服务器地址
 host: 8.131.66.136
 # redis服务器连接端口
 port: 6379
 # redis服务器连接密码（默认为空）
 password: csp19990129

server:
 port: 8001
eureka:
 client:
 service-url:
  defaultzone: http://127.0.0.1:7001/eureka
 instance:
 prefer-ip-address: true
management:
 endpoint:
 gateway:
  enabled: true
 web:
  exposure:
  include: true

3.3 网关微服务主启动类

/**
 * @auther: csp1999
 * @date: 2021/01/24/15:16
 * @description: 用户/前台微服务网关启动类
 */
@springbootapplication
@enableeurekaclient
public class gatewaywebapplication {

 public static void main(string[] args) {
  springapplication.run(gatewaywebapplication.class, args);
 }

 /**
  * ip限流：由用户请求的ip创建创建用户唯一标识，进而根据ip进行限流操作
  *
  * @return
  */
 @bean(name = "ipkeyresolver")
 public keyresolver userkeyresolver() {
  return new keyresolver() {
   @override
   public mono<string> resolve(serverwebexchange exchange) {
    // 获取远程客户端ip
    string hostname = exchange.getrequest().getremoteaddress().getaddress().gethostaddress();
    system.out.println("hostname:" + hostname);
    return mono.just(hostname);
   }
  };
 }
}

3.4 用户微服务编写登录代码

/**
 * @author: csp1999
 * @description: user 的controller
 * @date 2021/1/14 0:18
 */
@restcontroller
@requestmapping("/user")
@crossorigin
public class usercontroller {

 @autowired
 private userservice userservice;

	 /***
  * 修改user数据
  * @param user
  * @param id
  * @return
  */
 @putmapping(value = "/{id}")
 public result update(@requestbody user user, @pathvariable string id) {
  	 ...
 }

 /***
  * 新增user数据
  * @param user
  * @return
  */
 @postmapping
 public result add(@requestbody user user) {
  ...
 }

 /***
  * 根据id查询user数据
  * @param id
  * @return
  */
 @getmapping("/{id}")
 public result<user> findbyid(@pathvariable string id) {
  ...
 }

 /***
  * 查询user全部数据
  * @return
  */
 @getmapping
 public result<list<user>> findall() {
  ...
 }

 /***
  * 用户登录
  * @param username
  * @param password
  * @param response
  * @param request
  * @return
  */
 @requestmapping("/login")
 public result<user> login(string username, string password, httpservletresponse response, httpservletrequest request) {
  // 1.从数据库中查询用户名对应的用户的对象
  user user = userservice.findbyid(username);
  if (user == null) {
   // 2.判断用户是否为空 为空返回数据
   return new result<user>(false, statuscode.loginerror, "用户名或密码错误...");
  }

  // 3.如果不为空 判断密码是否正确 若正确 则登录成功
  if (bcrypt.checkpw(password, user.getpassword())) {
   // 登录成功,讲用户信息存入map
   map<string, object> info = new hashmap<string, object>();
   info.put("role", "user");
   info.put("success", "success");
   info.put("username", username);

   // 3.1生成令牌
   string jwt = jwtutil.createjwt(uuid.randomuuid().tostring(), json.tojsonstring(info), null);
   // 3.2设置jwt存入 cookie 中
   cookie cookie = new cookie("authorization", jwt);
   response.addcookie(cookie);
   // 3.3设置jwt存入头文件中
   response.setheader("authorization", jwt);

   return new result<user>(true, statuscode.ok, "登录成功", jwt);
  } else {
   // 登录失败
   return new result<user>(false, statuscode.loginerror, "用户名或密码错误");
  }
 }
}

到此这篇关于spring cloud gateway 使用jwt工具类做用户登录校验的示例代码的文章就介绍到这了,更多相关spring cloud gateway 用户登录校验内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！