定制软件基于JWT实现简单的用户登陆验证（超详细）

一. 什么是

JSON Web Token（JWT）定制软件是目前最流行的定制软件跨域身份验证解决方案。

二.JWT定制软件一般用于做什么

  • 授权 

定制软件即在用户登录成功以后，定制软件为用户颁发一个token(令牌)，定制软件用户便可以使用这个token定制软件令牌访问后台的接口

  • 加密

使用JWT定制软件可以对接口的参数进行加密，定制软件在后台验证成功以后才定制软件能真正进行处理

三.为什么要使用JWT进行认证，而不使用session、cookie?

基于cookie的认证，存在如下问题：

  • CSRF：session基于cookie，如果cookie被截获，用户很容易收到跨站请求伪造的攻击。

基于session的认证，存在如下问题：

  • 开销大：每个用户在认证之后，都要在服务端做一次记录，以方便该用户下次请求的鉴别。通常session保存在内存中，随着认证用户的增多，服务端存储session的开销显著增大。
  • 扩展性低：用户认证记录存储在认证服务器的内存中，这意味着用户下次请求仍要访问这台服务器才能拿到授权。在分布式应用上，这限制了负载均衡的能力，进而限制了整个应用的扩展能力。

JWT是一种基于token的认证机制，它类似于HTTP协议一样是无状态的，不需要在服务端保留用户的认证信息或者会话信息。除此之外，基于token的鉴权机制不需要考虑用户在哪一台服务器登录，为应用扩展提供了便利。

       说了这么多，那我们就通过一个小案例来实战一下~

环境准备：

      一个简单的springboot工程：

      基本的user实体类：

  1. package com.example.mybatixtest.pojo;
  2.  
  3. import com.baomidou.mybatisplus.annotation.IdType;
  4. import com.baomidou.mybatisplus.annotation.TableField;
  5. import com.baomidou.mybatisplus.annotation.TableId;
  6. import com.baomidou.mybatisplus.annotation.TableName;
  7. import java.io.Serializable;
  8.  
  9. import com.sun.xml.internal.ws.developer.Serialization;
  10. import lombok.Data;
  11.  
  12. /**
  13.  * 
  14.  * @TableName user
  15.  */
  16. @TableName(value ="user")
  17. @Data
  18. @Serialization
  19. public class User implements Serializable {
  20.     /**
  21.      * 
  22.      */
  23.     private String userId;
  24.  
  25.     /**
  26.      * 
  27.      */
  28.     private String username;
  29.  
  30.     /**
  31.      * 
  32.      */
  33.     private String password;
  34.  
  35.     @TableField(exist = false)
  36.     private static final long serialVersionUID = 1L;
  37. }

 1.我们先在pom.xml文件中导入jwt依赖

  1.         <!--引入jwt-->
  2.         <dependency>
  3.             <groupId>com.auth0</groupId>
  4.             <artifactId>java-jwt</artifactId>
  5.             <version>3.9.0</version>
  6.         </dependency>

2.创建一个JWT工具类，封装JWT的相关操作（加密、验证、解密）

  1. package com.canrio.onlinemusic.utils;
  2.  
  3. import com.auth0.jwt.JWT;
  4. import com.auth0.jwt.JWTVerifier;
  5. import com.auth0.jwt.algorithms.Algorithm;
  6. import com.auth0.jwt.interfaces.DecodedJWT;
  7. import org.springframework.stereotype.Component;
  8.  
  9. import java.util.Date;
  10.  
  11. @Component
  12. public class TokenUtil {
  13.  
  14.     private static final long EXPIRE_TIME= 15*60*1000;
  15.     private static final String TOKEN_SECRET="token123";  //密钥盐
  16.  
  17.     /**
  18.      * 签名生成
  19.      * @return
  20.      */
  21.     public static String sign(String name,String userId){
  22.  
  23.         String token = null;
  24.         try {
  25.             Date expiresAt = new Date(System.currentTimeMillis() + EXPIRE_TIME);
  26.             token = JWT.create()
  27.                     .withIssuer("auth0").withClaim("id","id")
  28.                     .withClaim("username", name)
  29.                     .withClaim("userId",userId)
  30.                     .withExpiresAt(expiresAt)
  31.                     // 使用了HMAC256加密算法。
  32.                     .sign(Algorithm.HMAC256(TOKEN_SECRET));
  33.         } catch (Exception e){
  34.             e.printStackTrace();
  35.         }
  36.         return token;
  37.  
  38.     }
  39.     /**
  40.      * 签名验证
  41.      * @param token
  42.      * @return
  43.      */
  44.     public static boolean verify(String token){
  45.  
  46.         try {
  47.             JWTVerifier verifier = JWT.require(Algorithm.HMAC256(TOKEN_SECRET)).withIssuer("auth0").build();
  48.             DecodedJWT jwt = verifier.verify(token);
  49.             System.out.println("认证通过：");
  50.             System.out.println("issuer: " + jwt.getIssuer());
  51.             System.out.println("username: " + jwt.getClaim("username").asString());
  52.             System.out.println("userId: " + jwt.getClaim("userId").asString());
  53.             System.out.println("id"+jwt.getClaim("id").asString());
  54.             System.out.println("过期时间：      " + jwt.getExpiresAt());
  55.             return true;
  56.         } catch (Exception e){
  57.             return false;
  58.         }
  59.     }
  60.  
  61.     public static String getId(String token){
  62.  
  63.  
  64.             JWTVerifier verifier = JWT.require(Algorithm.HMAC256(TOKEN_SECRET)).withIssuer("auth0").build();
  65.             DecodedJWT jwt = verifier.verify(token);
  66.             String id = jwt.getClaim("userId").asString();
  67.             return id;
  68.  
  69.         }
  70. }

3.创建一个登录拦截器LoginInterceptor，用于获取请求的Token并进行验证

  1. package com.example.mybatixtest.interceptor;
  2.  
  3. import com.example.mybatixtest.utils.TokenUtil;
  4. import org.springframework.http.HttpMethod;
  5. import org.springframework.stereotype.Component;
  6. import org.springframework.web.servlet.HandlerInterceptor;
  7.  
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10.  
  11. @Component   //在容器中进行注册
  12. public class LoginInterceptor implements HandlerInterceptor {
  13.  
  14.     @Override
  15.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  16.         if (HttpMethod.OPTIONS.toString().equals(request.getMethod())) {
  17.             System.out.println("OPTIONS请求，放行");
  18.             return true;
  19.         }
  20.         String token = request.getHeader("token");
  21.         if(TokenUtil.verify(token)){
  22.             return true;
  23.         }
  24.         // 失败我们跳转回登录页面
  25.         request.setAttribute("msg","登录出错");
  26.         request.getRemoteHost();
  27.         request.getRequestDispatcher("/login").forward(request,response);
  28.         return false;
  29.     }
  30.  
  31. }

4.修改web配置，添加一个配置类WebConfig对LoginInterceptor进行注册和制定拦截规则

  1. package com.example.mybatixtest.config;
  2.  
  3. import com.example.mybatixtest.interceptor.LoginInterceptor;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  7. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  8.  
  9. //@Configuration 告诉springboot这是一个配置类
  10. @Configuration
  11. public class WebConfig implements WebMvcConfigurer {
  12.  
  13.     @Autowired
  14.     LoginInterceptor loginInterceptor;
  15.     @Override
  16.     public void addInterceptors(InterceptorRegistry registry) {
  17.                 registry.addInterceptor(loginInterceptor)
  18.                         .addPathPatterns("/**")   //默认对所有请求进行拦截
  19.                         .excludePathPatterns("/userLogin","/static/**");     //对login页面和静态资源不拦截
  20.     }
  21. }

 5.我们编写简单的请求进行验证

  1.  @GetMapping(value = "/userLogin")
  2.     public String userLogin(@RequestParam("username") String username, @RequestParam("password") String password) {
  3.         //创建一个条件构造器
  4.         QueryWrapper<User> userQueryWrapper = new QueryWrapper<User>();
  5.         //传入查询条件
  6.  
  7.         userQueryWrapper.eq("username", username).eq("password", password);
  8.         User user = userService.getOne(userQueryWrapper);
  9.         if (user != null) {
  10.             String res = TokenUtil.sign(username, user.getUserid());
  11.             System.out.println(res);
  12.             return res;
  13.         }
  14.  
  15.         return "失败";
  16.  
  17.     }

6.使用postman进行验证，我们可以发现用户端得到了一串token字符串

 7.这里再用我之前做过的小项目对token进行验证

  1. /**
  2.      * 根据返回的token解析用户id并返回该用户的歌单列表
  3.      *
  4.      * @return
  5.      */
  6.     @GetMapping("/getUserFolderByUserId")
  7.     public List<UserFolder> getUserFolderByUserID() {
  8.         String token = request.getHeader("token");
  9.         System.out.println(token);
  10.         String id = TokenUtil.getId(token);
  11.         QueryWrapper<UserFolder> userFolderQueryWrapper = new QueryWrapper<>();
  12.         userFolderQueryWrapper.eq("user_userid", id);
  13.         List<UserFolder> list = userFolderService.list(userFolderQueryWrapper);
  14.         System.out.println(list);
  15.         return list;
  16.     }

当我们请求头不携带token时：

当我们携带时： 

 

至此，我们基于JWT实现简单的用户登陆验证教程就结束啦~

感谢您的阅读,希望我的文章能给你带来帮助！！！

网站建设定制开发 软件系统开发定制 定制软件开发 软件开发定制 定制app开发 app开发定制 app开发定制公司 电商商城定制开发 定制小程序开发 定制开发小程序 客户管理系统开发定制 定制网站 定制开发 crm开发定制 开发公司 小程序开发定制 定制软件 收款定制开发 企业网站定制开发 定制化开发 android系统定制开发 定制小程序开发费用 定制设计 专注app软件定制开发 软件开发定制定制 知名网站建设定制 软件定制开发供应商 应用系统定制开发 软件系统定制开发 企业管理系统定制开发 系统定制开发