SpringBoot2.0集成JWT实现token验证-初体验

╰半夏微凉° 2023-02-14 13:03 27阅读 0赞

### 1.JWT的介绍 ###

**1）jwt出现的背景**

互联网服务离不开用户认证。一般流程是下面这样。

> 1、用户向服务器发送用户名和密码。
> 
> 2、服务器验证通过后，在当前对话（session）里面保存相关数据，比如用户角色、登录时间等等。
> 
> 3、服务器向用户返回一个 session\_id，写入用户的 Cookie。
> 
> 4、用户随后的每一次请求，都会通过 Cookie，将 session\_id 传回服务器。
> 
> 5、服务器收到 session\_id，找到前期保存的数据，由此得知用户的身份。

这种模式的问题在于，扩展性（scaling）不好。单机当然没有问题，如果是服务器集群，或者是跨域的服务导向架构，就要求 session 数据共享，每台服务器都能够读取 session。

举例来说，A 网站和 B 网站是同一家公司的关联服务。现在要求，用户只要在其中一个网站登录，再访问另一个网站就会自动登录，请问怎么实现？

一种解决方案是 session 数据持久化，写入数据库或别的持久层。各种服务收到请求后，都向持久层请求数据。这种方案的优点是架构清晰，缺点是工程量比较大。另外，持久层万一挂了，就会单点失败。

另一种方案是服务器索性不保存 session 数据了，所有数据都保存在客户端，每次请求都发回服务器。JWT 就是这种方案的一个代表。

**2）JWT的原理**

JWT 的原理是，服务器认证以后，生成一个 JSON 对象，发回给用户，就像下面这样。

>     {
>       "姓名": "张三",
>       "角色": "管理员",
>       "到期时间": "2018年7月1日0点0分"
>     }

以后，用户与服务端通信的时候，都要发回这个 JSON 对象。服务器完全只靠这个对象认定用户身份。为了防止用户篡改数据，服务器在生成这个对象的时候，会加上签名（详见后文）。

服务器就不保存任何 session 数据了，也就是说，服务器变成无状态了，从而比较容易实现扩展。

**3）JWT 的数据结构**

实际的 JWT 大概就像下面这样。

![format_png][]

它是一个很长的字符串，中间用点（`.`）分隔成三个部分。注意，JWT 内部是没有换行的，这里只是为了便于展示，将它写成了几行。

JWT 的三个部分依次如下。

>  *  Header（头部）
>  *  Payload（负载）
>  *  Signature（签名）

写成一行，就是下面的样子。

>     Header.Payload.Signature

![format_png 1][]

下面依次介绍这三个部分。

**3.1）Header**

Header 部分是一个 JSON 对象，描述 JWT 的元数据，通常是下面的样子。

>     {
>       "alg": "HS256",
>       "typ": "JWT"
>     }

上面代码中，`alg`属性表示签名的算法（algorithm），默认是 HMAC SHA256（写成 HS256）；`typ`属性表示这个令牌（token）的类型（type），JWT 令牌统一写为`JWT`。

最后，将上面的 JSON 对象使用 Base64URL 算法（详见后文）转成字符串。

**3.2）Payload**

Payload 部分也是一个 JSON 对象，用来存放实际需要传递的数据。JWT 规定了7个官方字段，供选用。

>  *  iss (issuer)：签发人
>  *  exp (expiration time)：过期时间
>  *  sub (subject)：主题
>  *  aud (audience)：受众
>  *  nbf (Not Before)：生效时间
>  *  iat (Issued At)：签发时间
>  *  jti (JWT ID)：编号

除了官方字段，你还可以在这个部分定义私有字段，下面就是一个例子。

>     {
>       "sub": "1234567890",
>       "name": "John Doe",
>       "admin": true
>     }

注意，JWT 默认是不加密的，任何人都可以读到，所以不要把秘密信息放在这个部分。

这个 JSON 对象也要使用 Base64URL 算法转成字符串。

**3.3）Signature**

Signature 部分是对前两部分的签名，防止数据篡改。

首先，需要指定一个密钥（secret）。这个密钥只有服务器才知道，不能泄露给用户。然后，使用 Header 里面指定的签名算法（默认是 HMAC SHA256），按照下面的公式产生签名。

>     HMACSHA256(
>       base64UrlEncode(header) + "." +
>       base64UrlEncode(payload),
>       secret)

算出签名以后，把 Header、Payload、Signature 三个部分拼成一个字符串，每个部分之间用"点"（`.`）分隔，就可以返回给用户。

**3.4）Base64URL**

前面提到，Header 和 Payload 串型化的算法是 Base64URL。这个算法跟 Base64 算法基本类似，但有一些小的不同。

JWT 作为一个令牌（token），有些场合可能会放到 URL（比如 api.example.com/?token=xxx）。Base64 有三个字符`+`、`/`和`=`，在 URL 里面有特殊含义，所以要被替换掉：`=`被省略、`+`替换成`-`，`/`替换成`_` 。这就是 Base64URL 算法。

**4）.JWT 的使用方式**

客户端收到服务器返回的 JWT，可以储存在 Cookie 里面，也可以储存在 localStorage。

此后，客户端每次与服务器通信，都要带上这个 JWT。你可以把它放在 Cookie 里面自动发送，但是这样不能跨域，所以更好的做法是放在 HTTP 请求的头信息`Authorization`字段里面。

>     Authorization: Bearer <token>

另一种做法是，跨域的时候，JWT 就放在 POST 请求的数据体里面。

**5）.JWT 的几个特点**

（1）JWT 默认是不加密，但也是可以加密的。生成原始 Token 以后，可以用密钥再加密一次。

（2）JWT 不加密的情况下，不能将秘密数据写入 JWT。

（3）JWT 不仅可以用于认证，也可以用于交换信息。有效使用 JWT，可以降低服务器查询数据库的次数。

（4）JWT 的最大缺点是，由于服务器不保存 session 状态，因此无法在使用过程中废止某个 token，或者更改 token 的权限。也就是说，一旦 JWT 签发了，在到期之前就会始终有效，除非服务器部署额外的逻辑。

（5）JWT 本身包含了认证信息，一旦泄露，任何人都可以获得该令牌的所有权限。为了减少盗用，JWT 的有效期应该设置得比较短。对于一些比较重要的权限，使用时应该再次对用户进行认证。

（6）为了减少盗用，JWT 不应该使用 HTTP 协议明码传输，要使用 HTTPS 协议传输。

### 2.springboot集成JWT ###

**3.项目结构：项目主要介绍基本的集成，暂未连接数据库。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70][]

**4.pom.xml**

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.0.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.cxb</groupId>
        <artifactId>jwt</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>springboot-jwt</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
    
            <dependency>
                <groupId>com.auth0</groupId>
                <artifactId>java-jwt</artifactId>
                <version>3.5.0</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.68</version>
            </dependency>
    
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

**5.application.yml**

#项目配置
    server:
      port: 8089
      servlet:
        # 项目路径
        context-path: /cxb

**6.User**

package com.cxb.jwt.entity;
    
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class User {
    
        /**
         * 昵称
         */
        private String name;
        /**
         * 密码
         */
        private String password;
    }

**7.IUserService**

package com.cxb.jwt.service;
    
    import com.cxb.jwt.entity.User;
    
    public interface IUserService {
    
        /**
         * 校验用户信息
         * @param loginName
         * @param passWord
         * @return
         */
        boolean checkUser(String loginName, String passWord);
    
        /**
         * 查询用户信息
         * @param loginName
         * @return
         */
        User getUser(String loginName);
    }

**8.UserServiceImpl**

package com.cxb.jwt.service.impl;
    
    import com.cxb.jwt.entity.User;
    import com.cxb.jwt.service.IUserService;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserServiceImpl implements IUserService {
        @Override
        public boolean checkUser(String loginName, String passWord) {
            return true;
        }
    
        @Override
        public User getUser(String loginName) {
            User user = new User();
            user.setName("小石潭记");
            user.setPassword("123");
            return user;
        }
    }

**9.AjaxResult，返回结果的包装类**

package com.cxb.jwt.util;
    
    import java.util.HashMap;
    
    public class AjaxResult extends HashMap<String, Object> {
        private static final long serialVersionUID = 1L;
    
        public static final String CODE_TAG = "code";
    
        public static final String MSG_TAG = "msg";
    
        public static final String DATA_TAG = "data";
    
        /**
         * 状态类型
         */
        public enum Type {
            /**
             * 成功
             */
            SUCCESS(0),
            /**
             * 失败
             */
            FAIL(1),
            /**
             * 警告
             */
            WARN(301),
            /**
             * 错误
             */
            ERROR(500);
            private final int value;
    
            Type(int value) {
                this.value = value;
            }
    
            public int value() {
                return this.value;
            }
        }
    
        /**
         * 状态类型
         */
        private Type type;
    
        /**
         * 状态码
         */
        private int code;
    
        /**
         * 返回内容
         */
        private String msg;
    
        /**
         * 数据对象
         */
        private Object data;
    
        /**
         * 初始化一个新创建的 AjaxResult 对象，使其表示一个空消息。
         */
        public AjaxResult() {
        }
    
        /**
         * 初始化一个新创建的 AjaxResult 对象
         *
         * @param type 状态类型
         * @param msg  返回内容
         */
        public AjaxResult(Type type, String msg) {
            super.put(CODE_TAG, type.value);
            super.put(MSG_TAG, msg);
        }
    
        /**
         * 初始化一个新创建的 AjaxResult 对象
         *
         * @param type 状态类型
         * @param msg  返回内容
         * @param data 数据对象
         */
        public AjaxResult(Type type, String msg, Object data) {
            super.put(CODE_TAG, type.value);
            super.put(MSG_TAG, msg);
            super.put(DATA_TAG, data);
        }
    
        /**
         * 返回成功消息
         *
         * @return 成功消息
         */
        public static AjaxResult success() {
            return AjaxResult.success("操作成功");
        }
    
        /**
         * 返回成功消息
         *
         * @param msg 返回内容
         * @return 成功消息
         */
        public static AjaxResult success(String msg) {
            return AjaxResult.success(msg, null);
        }
    
        /**
         * 返回成功消息
         *
         * @param msg  返回内容
         * @param data 数据对象
         * @return 成功消息
         */
        public static AjaxResult success(String msg, Object data) {
            return new AjaxResult(Type.SUCCESS, msg, data);
        }
    
        /**
         * 返回失败消息
         *
         * @return 成功消息
         */
        public static AjaxResult fail() {
            return AjaxResult.fail("操作失败");
        }
    
        /**
         * 返回失败消息
         *
         * @param msg 返回内容
         * @return 成功消息
         */
        public static AjaxResult fail(String msg) {
            return AjaxResult.fail(msg, null);
        }
    
        /**
         * 返回失败消息
         *
         * @param msg  返回内容
         * @param data 数据对象
         * @return 成功消息
         */
        public static AjaxResult fail(String msg, Object data) {
            return new AjaxResult(Type.FAIL, msg, data);
        }
    
        /**
         * 返回警告消息
         *
         * @param msg 返回内容
         * @return 警告消息
         */
        public static AjaxResult warn(String msg) {
            return AjaxResult.warn(msg, null);
        }
    
        /**
         * 返回警告消息
         *
         * @param msg  返回内容
         * @param data 数据对象
         * @return 警告消息
         */
        public static AjaxResult warn(String msg, Object data) {
            return new AjaxResult(Type.WARN, msg, data);
        }
    
        /**
         * 返回错误消息
         *
         * @return
         */
        public static AjaxResult error() {
            return AjaxResult.error("操作失败");
        }
    
        /**
         * 返回错误消息
         *
         * @param msg 返回内容
         * @return 警告消息
         */
        public static AjaxResult error(String msg) {
            return AjaxResult.error(msg, null);
        }
    
        /**
         * 返回错误消息
         *
         * @param msg  返回内容
         * @param data 数据对象
         * @return 警告消息
         */
        public static AjaxResult error(String msg, Object data) {
            return new AjaxResult(Type.ERROR, msg, data);
        }
    
        public Type getType() {
            return type;
        }
    
        public void setType(Type type) {
            this.type = type;
        }
    
        public int getCode() {
            return code;
        }
    
        public void setCode(int code) {
            this.code = code;
        }
    
        public String getMsg() {
            return msg;
        }
    
        public void setMsg(String msg) {
            this.msg = msg;
        }
    
        public Object getData() {
            return data;
        }
    
        public void setData(Object data) {
            this.data = data;
        }
    
    }

**10.JwtUtil，核心配置类**

package com.cxb.jwt.util;
    
    
    import com.auth0.jwt.JWT;
    import com.auth0.jwt.JWTVerifier;
    import com.auth0.jwt.algorithms.Algorithm;
    import com.auth0.jwt.exceptions.JWTVerificationException;
    import com.auth0.jwt.interfaces.DecodedJWT;
    
    import java.util.Date;
    import java.util.HashMap;
    
    public class JwtUtil {
    
        /**
         * 过期时间为15分钟
         */
        private static final long EXPIRE_TIME = 15*60*1000;
    
        /**
         * token私钥
         */
        private static final String TOKEN_SECRET = "frank_xbchen";
    
        /**
         * 生成签名,15分钟后过期
         * @param username
         * @param userId
         * @return
         */
        public static String sign(String username,String userId){
            //过期时间
            Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
            //私钥及加密算法
            Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
            //设置头信息
            HashMap<String, Object> header = new HashMap<>(2);
            header.put("typ", "JWT");
            header.put("alg", "HS256");
            //附带username和userID生成签名
            return JWT.create().withHeader(header).withClaim("username",username)
                    .withClaim("userId",userId).withExpiresAt(date).sign(algorithm);
        }
    
    
        public static boolean verity(String token){
            try {
                Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
                JWTVerifier verifier = JWT.require(algorithm).build();
                DecodedJWT jwt = verifier.verify(token);
                return true;
            } catch (IllegalArgumentException e) {
                return false;
            } catch (JWTVerificationException e) {
                return false;
            }
    
        }
    }

**11.LoginController**

package com.cxb.jwt.web;
    
    import com.alibaba.fastjson.JSONObject;
    import com.cxb.jwt.entity.User;
    import com.cxb.jwt.service.IUserService;
    import com.cxb.jwt.util.AjaxResult;
    import com.cxb.jwt.util.JwtUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.Map;
    
    @Controller
    @RequestMapping
    @Slf4j
    public class LoginController {
    
        @Autowired
        private IUserService userService;
    
    
        @PostMapping("login")
        @ResponseBody
        public AjaxResult login (@RequestBody Map<String,String> map){
            String username = map.get("username");
            String passWord = map.get("passWord");
            //身份验证
            boolean isSuccess =  userService.checkUser(username,passWord);
            if (isSuccess) {
                //模拟数据库查询
                User user = userService.getUser(username);
                if (user != null) {
                    //返回token
                    String token = JwtUtil.sign(username, passWord);
                    if (token != null) {
                        return AjaxResult.success("成功",token);
                    }
                }
            }
            return AjaxResult.fail();
        }
    
        @PostMapping("getUser")
        @ResponseBody
        public AjaxResult getUserInfo(HttpServletRequest request, @RequestBody Map<String, String> map){
            String username = map.get("username");
            String token = request.getHeader("token");
            boolean verity = JwtUtil.verity(token);
            if (verity) {
                User user = userService.getUser(username);
                if (user != null) {
                    return AjaxResult.success("成功", JSONObject.toJSONString(user));
                }
            }
            return AjaxResult.fail();
        }
    }

**12.SpringbootJwtApplication，不加载数据库**

package com.cxb.jwt;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    
    @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
    public class SpringbootJwtApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(SpringbootJwtApplication.class, args);
        }
    
    }

**13.测试**

**1）先获取token**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 2][]

这里的data就是获取到的token。

**2）使用token访问接口**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 4][]

**[文章参考1][1]、[文章参考2][2]、[项目代码下载][Link 1]**

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cud2FuZ2Jhc2UuY29tL2Jsb2dpbWcvYXNzZXQvMjAxODA3L2JnMjAxODA3MjMwNC5qcGc?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cud2FuZ2Jhc2UuY29tL2Jsb2dpbWcvYXNzZXQvMjAxODA3L2JnMjAxODA3MjMwMy5qcGc?x-oss-process=image/format,png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200602210758657.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020060221185348.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200602211907943.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200607110829543.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200602211955453.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2,size_16,color_FFFFFF,t_70
[1]: https://blog.csdn.net/milogenius/article/details/96425694
[2]: http://www.ruanyifeng.com/blog/2018/07/json_web_token-tutorial.html
[Link 1]: https://github.com/ChenXbFrank/springboot-jwt