JWT开发简易教程：从入门到实践-原创手记-慕课网

概述

JWT开发涵盖了JWT的基础概念、工作原理及优势，介绍了如何搭建开发环境和生成JWT令牌，同时提供了验证和刷新令牌的方法，确保安全性和有效性。

JWT基础概念介绍

什么是JWT

JWT（JSON Web Token）是一种基于JSON的开放标准（RFC 7519），用于在各方之间安全地传输信息。它允许客户端和服务器之间传递声明（claims），确保数据的安全传输。JWT设计为紧凑，易于传输，并且支持多种编码格式，如URL安全，Base64编码等，这使其非常适合在HTTP头中传输。

JWT的主要组成部分包括Header、Payload和Signature。Header部分包含JWT的类型（如JWT）和加密算法（如HMAC，RSA等）。Payload部分包含了声明（claims），即关于主体（通常是用户）的信息。这些声明可以分为注册声明、公共声明和私有声明。Signature部分用于保证JWT的完整性和防篡改，它通过Header和Payload的哈希值（加上密钥）生成。

JWT的工作原理

JWT的工作流程可以分为几个步骤：

令牌生成：客户端向服务端发送请求，服务端根据请求生成JWT，包含所需的信息（例如用户ID、用户名等），并使用密钥和Header的算法对Payload进行签名，生成JWT。
令牌传输：服务端将生成的JWT返回给客户端，客户端可以选择将JWT存储在本地（如localStorage，sessionStorage）或者内存中。
令牌验证：每次客户端发送请求到服务端时，都会携带JWT（通常通过Authorization头）。服务端收到请求后，会验证Token的有效性：检查Token是否过期、验证Token的签名是否有效等。
合法性检查：服务端验证通过后，根据JWT中包含的用户信息执行相应操作（例如获取用户信息、执行权限控制等）。

JWT的优势和应用场景

JWT的主要优势包括：

安全性：JWT通过加密确保数据的数据完整性和真实性，防止篡改。
跨域认证：由于JWT是无状态的，因此没有存储服务器端的用户信息，这使得跨域认证变得简单。
简化客户端存储：JWT是轻量级的，可以存储在客户端的本地存储中，减少了客户端与服务器端之间的数据交互。
易于扩展：JWT支持自定义的声明，可以根据需要添加新的信息，易于扩展。

JWT的主要应用场景包括：

用户认证：通过JWT实现用户登录后的状态保持，确保用户身份的唯一性。
授权控制：控制用户对特定资源的访问权限。
跨域共享：在不同域之间共享用户信息和权限信息。
API访问控制：保护API接口，限制特定用户的访问权限。

JWT开发环境搭建

选择开发语言

JWT可以被多种编程语言支持，选择合适的语言要根据项目的实际需求和团队的技术栈。以下是几种常见的选择：

Java：适合大型企业应用、微服务架构等。
Python：适合快速开发、Web应用等。
Node.js：适合Web后端开发、实时应用等。

安装必要的库或框架

选择语言后，需要安装相应的库或框架，以下是一些示例：

Java：使用jjwt库。
Python：使用PyJWT。
Node.js：使用jsonwebtoken。

配置开发环境

配置开发环境通常包括安装开发工具并确保语言和库的正确安装。以下是示例：

Java：安装Java开发工具（IDE）如IntelliJ IDEA或Eclipse，安装maven或gradle作为构建工具，并在项目中添加jjwt依赖。

<!-- pom.xml for Maven -->
<dependencies>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>
</dependencies>

// build.gradle for Gradle
dependencies {
    implementation 'io.jsonwebtoken:jjwt:0.9.1'
}

Python：安装Python环境，建议使用虚拟环境（如virtualenv），并安装PyJWT库。
```
pip install pyjwt
```
Node.js：安装Node.js环境，使用npm或yarn安装jsonwebtoken库。
```
npm install jsonwebtoken
```

创建JWT令牌

生成JWT令牌的步骤

生成JWT令牌通常包括以下步骤：

创建Header。
创建Payload。
生成Signature。

分析JWT令牌组成部分

Header

Header部分包含令牌类型（Type）和加密算法（Algorithm）。通常Header格式如下：

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

Payload

Payload部分包含声明（Claims）。常见的声明包括：

sub：主体（Subject），通常是用户ID。
iat：发行时间（Issued At）。
exp：过期时间（Expiration Time）。
jti：JWT的唯一标识符（JWT ID）。
自定义声明（例如用户名、权限等）。

Signature

Signature是通过Header和Payload的Base64编码后的字符串加上密钥，然后使用指定的算法（例如HMAC SHA-256）计算得出的。

实例代码演示

以下是不同语言的示例：

Java

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

public class JwtExample {
    public static void main(String[] args) {
        String secret = "secretKey";
        String jwt = Jwts.builder()
                .setSubject("user123")
                .claim("username", "John")
                .setIssuedAt(new java.util.Date(System.currentTimeMillis()))
                .setExpiration(new java.util.Date(System.currentTimeMillis() + (1000 * 60 * 60)))
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
        System.out.println(jwt);
    }
}

Python

import jwt
import datetime

def create_jwt():
    secret = 'secretKey'
    payload = {
        'sub': 'user123',
        'username': 'John',
        'iat': datetime.datetime.utcnow(),
        'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1)
    }
    token = jwt.encode(payload, secret, algorithm='HS256')
    print(token.decode('utf-8'))

create_jwt()

Node.js

const jwt = require('jsonwebtoken');

const secret = 'secretKey';
const payload = {
    sub: 'user123',
    username: 'John',
    iat: new Date().getTime(),
    exp: new Date().getTime() + 1000 * 60 * 60
};

const token = jwt.sign(payload, secret, { algorithm: 'HS256' });
console.log(token);

验证和刷新JWT令牌

验证JWT令牌的方法

验证JWT令牌通常需要以下步骤：

检查Token的签名。
检查Token的过期时间。
检查Token的有效性（例如是否有被篡改）。

示例代码

Java

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;

public class JwtValidator {
    public static boolean validateToken(String token, String secret) {
        try {
            Jws<Claims> claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token);
            return !claims.getBody().getExpiration().before(new java.util.Date());
        } catch (Exception e) {
            return false;
        }
    }

    public static void main(String[] args) {
        String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4";
        System.out.println(validateToken(token, "secretKey"));
    }
}

Python

import jwt

def validate_jwt(token, secret):
    try:
        payload = jwt.decode(token, secret, algorithms=['HS256'])
        return True
    except jwt.ExpiredSignatureError:
        return False
    except jwt.InvalidTokenError:
        return False

token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4"
print(validate_jwt(token, 'secretKey'))

Node.js

const jwt = require('jsonwebtoken');

function validateToken(token, secret) {
    try {
        const decoded = jwt.verify(token, secret);
        return true;
    } catch (error) {
        return false;
    }
}

const token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4";
console.log(validateToken(token, 'secretKey'));

如何处理过期令牌

过期令牌需要重新生成新的令牌。一种常见的方法是通过刷新令牌（refresh token）来获取新的访问令牌（access token）。

示例代码

Java

public class RefreshTokenExample {
    public static void main(String[] args) {
        String refreshToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4";
        String newAccessToken = generateNewAccessToken(refreshToken);
        System.out.println(newAccessToken);
    }

    public static String generateNewAccessToken(String refreshToken) {
        // 业务逻辑：验证refreshToken的有效性，如果有效，生成新的accessToken
        // 为了示范，直接返回一个有效的新的accessToken
        return "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTI0MjMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4";
    }
}

Python

import jwt
import datetime

def generate_new_access_token(refresh_token):
    # 业务逻辑：验证refresh_token的有效性，如果有效，生成新的access_token
    # 为了示范，直接返回一个有效的新的access_token
    payload = {
        'sub': 'user123',
        'username': 'John',
        'iat': datetime.datetime.utcnow(),
        'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1)
    }
    return jwt.encode(payload, 'secretKey', algorithm='HS256')

refresh_token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4"
new_access_token = generate_new_access_token(refresh_token)
print(new_access_token.decode('utf-8'))

Node.js

const jwt = require('jsonwebtoken');

function generateNewAccessToken(refreshToken) {
    // 业务逻辑：验证refreshToken的有效性，如果有效，生成新的accessToken
    // 为了示范，直接返回一个有效的新的accessToken
    const payload = {
        sub: 'user123',
        username: 'John',
        iat: new Date().getTime(),
        exp: new Date().getTime() + 1000 * 60 * 60
    };
    return jwt.sign(payload, 'secretKey', { algorithm: 'HS256' });
}

const refreshToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4";
const newAccessToken = generateNewAccessToken(refreshToken);
console.log(newAccessToken);

实现令牌刷新功能的示例

刷新令牌通常需要一个刷新流程，包括验证刷新令牌的有效性，然后生成新的访问令牌。

示例代码

Java

public class TokenRefreshExample {
    public static void main(String[] args) {
        String refreshToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4";
        String newAccessToken = refreshAccessToken(refreshToken);
        System.out.println(newAccessToken);
    }

    public static String refreshAccessToken(String refreshToken) {
        // 业务逻辑：验证refreshToken的有效性，如果有效，生成新的accessToken
        // 为了示范，直接返回一个有效的新的accessToken
        return "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTI0MjMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4";
    }
}

Python

import jwt
import datetime

def refresh_access_token(refresh_token):
    # 业务逻辑：验证refresh_token的有效性，如果有效，生成新的access_token
    # 为了示范，直接返回一个有效的新的access_token
    payload = {
        'sub': 'user123',
        'username': 'John',
        'iat': datetime.datetime.utcnow(),
        'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1)
    }
    return jwt.encode(payload, 'secretKey', algorithm='HS256')

refresh_token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4"
new_access_token = refresh_access_token(refresh_token)
print(new_access_token.decode('utf-8'))

Node.js

const jwt = require('jsonwebtoken');

function refreshAccessToken(refreshToken) {
    // 业务逻辑：验证refreshToken的有效性，如果有效，生成新的accessToken
    // 为了示范，直接返回一个有效的新的accessToken
    const payload = {
        sub: 'user123',
        username: 'John',
        iat: new Date().getTime(),
        exp: new Date().getTime() + 1000 * 60 * 60
    };
    return jwt.sign(payload, 'secretKey', { algorithm: 'HS256' });
}

const refreshToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4";
const newAccessToken = refreshAccessToken(refreshToken);
console.log(newAccessToken);

JWT安全注意事项

如何保护JWT密钥

密钥安全：密钥必须被安全地存储，防止泄露。
密钥轮换：定期更换密钥，以防止密钥被破解。
密钥长度：使用足够长的密钥（例如256位）。

防止常见的JWT攻击手段

中间人攻击：可以通过HTTPS协议（TLS）来防止中间人攻击。

# 一个简单的HTTPS配置示例
# 在Node.js中使用Express
const express = require('express');
const https = require('https');
const fs = require('fs');
const app = express();

const options = {
    key: fs.readFileSync('/path/to/privatekey.pem'),
    cert: fs.readFileSync('/path/to/certificate.pem')
};

const server = https.createServer(options, app);

server.listen(3000, () => {
    console.log('HTTPS server is running on port 3000');
});

重放攻击：防止重放攻击，可以通过在Payload中加入nonce或时间戳等随机值。
```
{
    "jti": "unique_id_for_token",
    "iat": 1234567890,
    "exp": 1234567890 + 3600
}
```
CSRF攻击：通过设置JWT密钥为复杂且不可预测，减少攻击面。
XSS攻击：通过前端代码验证JWT的有效性，防止XSS攻击。

解决JWT存储问题的建议

存储位置：存储JWT令牌的最佳位置是HttpOnly Cookie（防止XSS攻击）。
安全性：设置HttpOnly和Secure标志来增加安全性。
刷新机制：设计合理的刷新机制，避免频繁刷新令牌带来的风险。

实际项目中的JWT应用

JWT在用户认证中的应用

JWT在用户认证中的应用包括：

用户登录：用户登录系统时，服务器生成并返回JWT令牌。
用户注销：用户注销时，可以删除客户端存储的JWT令牌，并同时设置服务器端令牌黑名单。
权限验证：每次请求时，服务器端验证JWT令牌，确保用户权限。

示例代码

Java

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;

public class UserAuthenticationExample {
    public static boolean authenticate(String token, String secret) {
        try {
            Jws<Claims> claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token);
            return !claims.getBody().getExpiration().before(new java.util.Date());
        } catch (Exception e) {
            return false;
        }
    }

    public static void main(String[] args) {
        String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4";
        System.out.println(authenticate(token, "secretKey"));
    }
}

Python

import jwt

def authenticate(token, secret):
    try:
        payload = jwt.decode(token, secret, algorithms=['HS256'])
        return True
    except jwt.ExpiredSignatureError:
        return False
    except jwt.InvalidTokenError:
        return False

token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4"
print(authenticate(token, 'secretKey'))

Node.js

const jwt = require('jsonwebtoken');

function authenticate(token, secret) {
    try {
        const decoded = jwt.verify(token, secret);
        return true;
    } catch (error) {
        return false;
    }
}

const token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4";
console.log(authenticate(token, 'secretKey'));

JWT在授权控制中的作用

JWT在授权控制中的应用包括：

权限验证：根据JWT中的声明（例如roles）来控制用户的访问权限。
资源访问控制：根据资源的权限声明，决定用户能否访问特定资源。

示例代码

Java

import io.jsonwebtoken.Claims;

public class AuthorizationControlExample {
    public static boolean checkAuthorization(String token, String secret, String requiredRole) {
        try {
            Claims claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
            String role = claims.get("role", String.class);
            return role != null && role.equals(requiredRole);
        } catch (Exception e) {
            return false;
        }
    }

    public static void main(String[] args) {
        String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4";
        System.out.println(checkAuthorization(token, "secretKey", "admin"));
    }
}

Python

import jwt

def check_authorization(token, secret, required_role):
    try:
        payload = jwt.decode(token, secret, algorithms=['HS256'])
        role = payload.get('role')
        return role == required_role
    except jwt.ExpiredSignatureError:
        return False
    except jwt.InvalidTokenError:
        return False

token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4"
print(check_authorization(token, 'secretKey', 'admin'))

Node.js

const jwt = require('jsonwebtoken');

function checkAuthorization(token, secret, requiredRole) {
    try {
        const decoded = jwt.verify(token, secret);
        return decoded.role === requiredRole;
    } catch (error) {
        return false;
    }
}

const token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJKb2huIiwiaWF0IjoxNjM1NTIyOTMxLCJleHAiOjE2MzU1MjQ1MzF9.vjYpQKi6C428h8f8N4M1bBn5GpP0qX6o4j0a54b4";
console.log(checkAuthorization(token, 'secretKey', 'admin'));

JWT在前后端通信中的应用实例

JWT在前后端通信中的应用包括：

状态保持：JWT令牌可以用于保持会话状态，减少服务器端会话存储的负担。
跨域认证：JWT令牌可以跨域传递，实现不同域名之间的认证。
统一认证：通过JWT实现统一的用户认证流程，减少代码冗余。

示例代码

Java

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

public class JwtController {
    public void login(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        // 假设验证成功
        if ("user123".equals(username) && "password123".equals(password)) {
            String token = Jwts.builder()
                    .setSubject(username)
                    .claim("role", "user")
                    .setIssuedAt(new java.util.Date())
                    .setExpiration(new java.util.Date(System.currentTimeMillis() + (1000 * 60 * 60)))
                    .signWith(SignatureAlgorithm.HS256, "secretKey")
                    .compact();
            response.getWriter().println(token);
        } else {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        }
    }
}

Python

from flask import Flask, request, make_response

app = Flask(__name__)

@app.route('/login', methods=['POST'])
def login():
    username = request.form.get('username')
    password = request.form.get('password')
    # 假设验证成功
    if username == 'user123' and password == 'password123':
        token = jwt.encode(
            {
                'username': username,
                'role': 'user',
                'iat': datetime.datetime.utcnow(),
                'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1)
            },
            'secretKey',
            algorithm='HS256'
        )
        return make_response(token.decode('utf-8'))
    else:
        return make_response('Unauthorized', 401)

if __name__ == '__main__':
    app.run()

Node.js


const express = require('express');
const jwt = require('jsonwebtoken');

const app = express();

app.post('/login', (req, res) => {
    const { username, password } = req.body;
    // 假设验证成功
    if (username === 'user123' && password === 'password123') {
        const token = jwt.sign(
            {
                username: username,
                role: 'user',
                iat: new Date().getTime(),
                exp: new Date().getTime() + 1000 * 60 * 60
            },
            'secretKey',
            { algorithm: 'HS256' }
        );
        res.send(token);
    } else {
        res.status(401, 'Unauthorized');
    }
});

app.listen(3000, () => {
    console.log('Server is running on port 3000');
});
``

通过以上示例代码，可以看到JWT在用户认证、授权控制和前后端通信中的具体应用，这些示例可以帮助你更好地理解和实现JWT在实际项目中的应用。