Json web token 详解(三)

最新推荐文章于 2024-08-16 08:00:49 发布
最新推荐文章于 2024-08-16 08:00:49 发布
阅读量5.5k 收藏 6
点赞数 6
分类专栏： JsonWebToken
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zsg88/article/details/76892551
版权

下面我们用springmvc和jwt的类库来实现一个例子。

要使用jwt，需要pom.xml中添加如下依赖

        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.2.0</version>
        </dependency>

下面贴一个完整的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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.jstudioframework</groupId>
    <artifactId>jstudio-jwt</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <!-- 设置编码字符集 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- 集中定义依赖版本号 -->
        <junit.version>4.12</junit.version>
        <spring.version>4.3.7.RELEASE</spring.version>
        <jackson.version>2.8.4</jackson.version>
        <java.jwt.version>3.2.0</java.jwt.version>
        <jstl.version>1.2</jstl.version>
        <servlet-api.version>2.5</servlet-api.version>
        <jsp-api.version>2.2</jsp-api.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>${java.jwt.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- JSP相关 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>${jstl.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>${servlet-api.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>${jsp-api.version}</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <!-- 配置插件 -->
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <configuration>
                    <port>8080</port>
                    <path>/</path>
                    <url>http://127.0.0.1:8080/manager/text</url>
                    <username>tomcat</username>
                    <password>tomcat</password>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>


一。定义一个jwt的工具类，具有加密和解密token的功能

import java.util.HashMap;
import java.util.Map;

/**
 * JwtToken
 */
public class JwtToken {

    //密钥
    private static final String SECRET = "secret";

    //jackson
    private static ObjectMapper mapper = new ObjectMapper();

    /**
     * header数据
     * @return
     */
    private static Map<String, Object> createHead() {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("typ", "JWT");
        map.put("alg", "HS256");
        return map;
    }

    /**
     * 生成token
     *
     * @param obj    对象数据
     * @param maxAge 有效期
     * @param <T>
     * @return
     */
    public static <T> String sign(T obj, long maxAge) throws UnsupportedEncodingException, JsonProcessingException {
        JWTCreator.Builder builder = JWT.create();

        builder.withHeader(createHead())//header
                .withSubject(mapper.writeValueAsString(obj));  //payload

        if (maxAge >= 0) {
            long expMillis = System.currentTimeMillis() + maxAge;
            Date exp = new Date(expMillis);
            builder.withExpiresAt(exp);
        }

        return builder.sign(Algorithm.HMAC256(SECRET));
    }

    /**
     * 解密
     * @param token   token字符串
     * @param classT  解密后的类型
     * @param <T>
     * @return
     */
    public static <T> T unsign(String token, Class<T> classT) throws IOException {
        JWTVerifier verifier = JWT.require(Algorithm.HMAC256(SECRET)).build();
        DecodedJWT jwt = verifier.verify(token);

        Date exp = jwt.getExpiresAt();
        if(exp!=null&&exp.after(new Date())){
            String subject = jwt.getSubject();
            return mapper.readValue(subject, classT);
        }

        return null;
    }

}



二。 登录时根据用户传来的username和password验证身份，如果合法，便给该用户jwt加密生成token

package jwt.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import jwt.JwtToken;
import jwt.model.User;
import jwt.util.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import java.io.UnsupportedEncodingException;

/**
 * 用户登录
 */

@Controller
public class LoginController {

    @RequestMapping(value="login", produces = "application/json; charset=utf-8")
    @ResponseBody
    public ResponseEntity login(HttpServletRequest request, @RequestParam( "username") String username,
                                @RequestParam("password") String password) throws UnsupportedEncodingException, JsonProcessingException {
        ResponseEntity responseEntity = ResponseEntity.ok();

        if("admin".equals(username) && "admin".equals(password)) {
            //模拟用户数据，真实环境需要到数据库验证
            User user = new User();
            user.setId(123456);
            user.setUsername(username);
            //给用户jwt加密生成token
            String token = JwtToken.sign(user, 60L * 1000L * 30L);
            //封装成对象返回给客户端
            responseEntity.putDataValue("userId", user.getId());
            responseEntity.putDataValue("token", token);
            responseEntity.putDataValue("user", user);
        }
        else{
            responseEntity =  ResponseEntity.customerError();
        }
        return responseEntity;
    }

}


User用户类如下

package jwt.model;

/**
 * User bean
 */
public class User {
    private long id;
    private String username;
    private String password;

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}


返回给用户端的一个工具类


package jwt.util;

import java.util.HashMap;
import java.util.Map;

public class ResponseEntity {

    public static final String ERRORS_KEY = "errors";

    private final String message;
    private final int code;
    private final Map<String, Object> data = new HashMap();

    public String getMessage() {
        return message;
    }

    public int getCode() {
        return code;
    }

    public Map<String, Object> getData() {
        return data;
    }

    public ResponseEntity putDataValue(String key, Object value) {
        data.put(key, value);
        return this;
    }

    private ResponseEntity(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public static ResponseEntity ok() {
        return new ResponseEntity(200, "Ok");
    }

    public static ResponseEntity notFound() {
        return new ResponseEntity(404, "Not Found");
    }

    public static ResponseEntity badRequest() {
        return new ResponseEntity(400, "Bad Request");
    }

    public static ResponseEntity forbidden() {
        return new ResponseEntity(403, "Forbidden");
    }

    public static ResponseEntity unauthorized() {
        return new ResponseEntity(401, "unauthorized");
    }

    public static ResponseEntity serverInternalError() {
        return new ResponseEntity(500, "Server Internal Error");
    }

    public static ResponseEntity customerError() {
        return new ResponseEntity(1001, "Customer Error");
    }
}


三。在用户登录后获得userId和token，以后用户每次请求时，都得带上这两个参数，后台拿到token后解密出userId，与用户传递过来的userId比较，如果相同，则说明用户身份合法。这里用springmvc的拦截器实现验证。

注意:测试使用Params传递参数的，建议正式环境在header里添加参数


package jwt.interceptor;

import com.fasterxml.jackson.databind.ObjectMapper;
import jwt.JwtToken;
import jwt.model.User;
import jwt.util.ResponseEntity;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;

/**
 * Token验证拦截器
 */
public class UserTokenInterceptor implements HandlerInterceptor {

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {
        String token = request.getParameter("token");
        ResponseEntity responseData = ResponseEntity.ok();
        //token不存在
        if (token != null) {
            User user = JwtToken.unsign(token, User.class);
            String userId = request.getParameter("userId");
            //解密token后的userId与用户传来的userId不一致，大多是因为token过期
            if (user != null && userId != null && Integer.parseInt(userId) == user.getId()) {
                return true;
            }
        }

        responseData = ResponseEntity.forbidden();
        response.setContentType("application/json; charset=utf-8");
        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(responseData);
        PrintWriter out = response.getWriter();
        out.print(json);
        out.flush();
        out.close();
        return false;
    }

    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

    }

    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

    }
}

四。springmvc的配置 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="jwt.controller"/>

    <mvc:annotation-driven />

    <!-- 拦截器设置 -->
    <mvc:interceptors>
        <mvc:interceptor>
            <!-- 匹配的是url路径， 如果不配置或/**,将拦截所有的Controller -->
            <mvc:mapping path="/**" />
            <!-- /register 和 /login 不需要拦截-->
            <mvc:exclude-mapping path="/register" />
            <mvc:exclude-mapping path="/login" />
            <bean class="jwt.interceptor.UserTokenInterceptor"></bean>
        </mvc:interceptor>
        <!-- 当设置多个拦截器时，先按顺序调用preHandle方法，然后逆序调用每个拦截器的postHandle和afterCompletion方法 -->
    </mvc:interceptors>

    <!-- 默认的视图解析器 在上边的解析错误时使用 (默认使用html)- -->
    <bean id="defaultViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="contentType" value="text/html"/>
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
        <property name="order" value="1"/>
    </bean>

</beans>

五。 使用Chrome插件Postman进行简单的测试

1.登录，http://localhost:8080/login

、

记下 token和userId


2. 测试token鉴权  http://localhost:8080/info

输入正确的userId和token

注意:测试使用Params传递参数的，建议正式环境在header里添加参数


输入错误的userId或token，在拦截器那里就被拦截了


猪脚踏浪
关注
专栏目录
Json解析
h838245284的博客
05-19 1926
1.通过词法分析将json解析成token序列 有如下json { "key" : "value", } 通过词法解析将得到一组token { key : value , }罗列一下 JSON 所规定的数据类型： BEGIN_OBJECT（{） END_OBJECT（}） BEGIN_ARRAY（[） END_ARRAY（]） NULL（null） NUMBER（数字） STRING（字符串） BOOLEAN（true/false） SEP_C...
fastjson源码分析-JSON Token解析
qq_45946035的博客
09-11 1147
2021SC@SDUSC 简介 这个章节主要讨论关于对象&字段相关词法解析的api Int类型字段解析 当反序列化java对象遇到整型int.class字段会调用该方法解析： public int scanInt(char expectNext) { matchStat = UNKNOWN; int offset = 0; char chLocal = charAt(bp + (offset++)); /** 取整数第一个字符判断是
JSON Web Token (JWT): 理解与应用
yuanchun的知识整理
08-16 1231
JSON Web Token (JWT)
Json Web Token
weixin_51987441的博客
07-08 400
Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).定义了一种简洁的，自包含的方法用于通信双方之间以JSON对象的形式安全的传递信息。因为数字签名的存在，这些信息是可信的，JWT可以使用HMAC算法或者是RSA的公私秘钥对进行签名。传统用于身份验证的是session,session创建以后将sessionid以Cookie的方式返回给客户端。xxxx.xxxx.xxxx (Header 头部(标题包含了令牌的元数据，并且包含签名
JSON Web Token 的结构是什么
HONEY MOOSE
10-02 344
JSON Web Tokens 由使用 (.) 分开的 3 个部分组成的，这 3 个部分分别是： 头部（Header） 负载（Payload） 签名（Signature） 正是因为上面的组织形式，因此一个 JWT 通常看起如下面的表现形式。 xxxxx.yyyyy.zzzzz 让我们针对上面的形式来具体的分析下。 头部（Header） 在头部的数据中通常包含有 2 部分的内容：token 的类型，这里使用的是字符 JWT，和使用的的签名加密算法，例如 SHA256 或者 RSA。 例..
JSON Web Token
m0_54355172的博客
11-28 7463
JWT
详解JSON Web Token 入门教程
10-18
JSON Web Token（JWT）是网络上广泛使用的跨域认证解决方案。它是一种开放标准（RFC 7519），定义了一种紧凑的、自包含的方式，用于在各方之间以JSON对象的形式安全地传输信息。这些信息可以被验证和信任，因为它们...
php实现JWT(json web token)鉴权实例详解
01-03
JWT是json web token缩写。它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证token的正确性，只要正确即通过验证。基于token的身份验证可以替代传统的cookie+session身份验证方法...
JWT（JSON Web Token）：JWT签名算法详解.docx
最新发布
08-28
JWT（JSON Web Token）：JWT签名算法详解.docx
JSONWebToken(JWT)的Java实现
08-08
JSON Web Token (JWT)的Java实现
JSON Web Token 入门教程
未读代码
03-20 739
JSON Web Token（JWT）入门教程，介绍 JWT 原理，结构，应用场景以及优缺点，最后介绍最佳实践。
JsonWebToken Demo
dz45693的专栏
11-24 5081
直接上code： namespace TokenTest { using Newtonsoft.Json; using Newtonsoft.Json.Linq; using System; using System.Collections.Generic; using System.Security.Cryptography; using Sys
jsonwebtoken 详解！
qq_45135138的博客
05-28 3069
jsonwebtoken 详解！ 王一峰的网络日志 » 首页 » 档案 搜索 上一篇：每周分享第 14 期 下一篇：每周分享第 15 期 分类： 开发者手册 JSON Web Token 入门教程 作者： 王一峰 日期： 2018年7月23日 感谢 腾讯课堂NEXT学院 赞助本站，腾讯官方的前端培训 正在招生中。 腾讯课堂 NEXT 学院 JSON Web Token（缩写 JWT）是目前最流行的...
jwt(json web token)
prigilm的博客
11-04 450
Python之jwt(json web token) 一、什么是jwt 在用户注册或登录后，我们想记录用户的登录状态，或者为用户创建身份认证的凭证。我们不再使用Session认证机制，而使用Json Web Token（本质就是token）认证机制。 jwt全称json web token,是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准 （(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。 JWT的声明一般被用来在身份提供者和服务提供者间
JWT（JSON WEB TOKEN）
S_ZaiJiangHu的博客
08-26 873
（4）JWT 的最大缺点是，由于服务器不保存 session 状态，因此无法在使用过程中废止某个 token，或者更改 token 的权限。也就是说，一旦 JWT 签发了，在到期之前就会始终有效，除非服务器部署额外的逻辑。单机当然没有问题，如果是服务器集群，或者是跨域的服务导向架构，就要求 session 数据共享，每台服务器都能够读取 session。算出签名以后，把 Header、Payload、Signature 三个部分拼成一个字符串，每个部分之间用"点"（.）分隔，就可以返回给用户。......
JWT及使用方法：json web token
Ben_boba的博客
08-01 623
网络安全防护-JSON WEB TOKEN讲解与实战_jsonwebtoken 规范
m0_v648374的博客
04-12 848
然后，使用 Header 里面指定的签名算法（默认是 HMAC SHA256），按照下面的公式产生签名。算出签名以后，把 Header、Payload、Signature 三个部分拼成一个字符串，每个部分之间用"点"（.）分隔，就可以返回给用户。JWT 的原理是，服务器认证以后，生成一个 JSON 对象，发回给用户，就像下面这样。Header 部分是一个 JSON 对象，描述 JWT 的元数据，通常是下面的样子。注意，JWT 默认是不加密的，任何人都可以读到，所以不要把秘密信息放在这个部分。
JSONWeb令牌详解与实现
出版的关于 JSON Web Token (JWT) 的技术指南，版本0.10.1，发布于2016年。书中详细介绍了JWT的基础知识、实际应用以及技术实现。 JWT（JSON Web Token）是一种轻量级的身份验证和授权机制，用于在各方之间安全地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值