Java中JWT（JSON Web Token）的运用

于 2024-10-04 15:11:43 发布
阅读量1.6k 收藏 19
点赞数 15
分类专栏： java修炼 文章标签： java json 前端 spring boot token
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80011650/article/details/142703170
版权

目录


JWT（JSON Web Token）是一种开放标准（RFC 7519），用于在网络应用环境间以紧凑的方式安全地传递信息。JWT可以被用作身份验证和信息交换的手段，特别适合用于前后端分离的应用程序。

1. JWT的结构

JWT由三部分组成：

  • Header（头部）: 通常包含令牌的类型（JWT）和所使用的签名算法（如HMAC SHA256或RSA）。

  • Payload（负载）: 包含声明（claims），即要传递的数据。其中可以包含注册声明（如 iss、exp、sub 等）和自定义声明。

  • Signature（签名）: 用于验证消息的完整性和发送者的身份。通过将编码后的header和payload与一个密钥结合，利用指定的算法生成。

JWT的格式如下：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

2. JWT的优点

  • 无状态: 不需要在服务器存储会话信息，减轻了服务器的负担。
  • 跨域: 可以在不同的域之间进行身份验证。
  • 自包含: 含有用户身份信息，避免频繁查询数据库。

3. JWT的流转过程

  1. 用户通过登录接口发送用户名和密码。
  2. 服务器验证用户信息，如果成功，则生成JWT并返回给用户。
  3. 用户在后续请求中带上JWT，通常放在HTTP请求的Authorization头中。
  4. 服务器解析JWT，验证其有效性，允许或拒绝请求。

4.具体案例

好的，让我们更详细地探讨如何在Java Spring Boot应用程序中实现JWT身份验证，包括每一步的代码和说明。

一、项目结构

Spring Boot项目结构如下：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── jwt
│   │               ├── JwtApplication.java
│   │               ├── config
│   │               │   └── SecurityConfig.java
│   │               ├── controller
│   │               │   └── AuthController.java
│   │               ├── model
│   │               │   └── User.java
│   │               ├── service
│   │               │   └── JwtUtil.java
│   │               └── filter
│   │                   └── JwtRequestFilter.java
│   └── resources
│       └── application.properties
└── test

二、依赖配置

在pom.xml中添加必要的依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>
</dependencies>

三、用户模型

创建一个简单的用户模型：

package com.example.jwt.model;

public class User {
    private String username;
    private String password;

    // Constructors, getters, and setters
    //也可以使用Lombok
    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }
}

四、JWT工具类

创建JWT工具类，负责生成和解析JWT：

package com.example.jwt.service;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
/**
*Jwt工具类
*/
@Component//加入Spring容器
public class JwtUtil {

    private String secret = "your_secret_key"; // 强密码
    private long expiration = 60 * 60 * 1000; // 1小时

	//这个方法用于生成 JWT。它接受用户名作为参数。
    public String generateToken(String username) {
        Map<String, Object> claims = new HashMap<>();
        return createToken(claims, username);
    }
	//私有方法，用于实际生成 JWT
    private String createToken(Map<String, Object> claims, String subject) {
        return Jwts.builder()//开始构建 JWT 的构建器
                .setClaims(claims)//设置 JWT 中的声明
                .setSubject(subject)//设置主题（通常是用户名）
                .setIssuedAt(new Date(System.currentTimeMillis()))//设置 JWT 的签发时间
                .setExpiration(new Date(System.currentTimeMillis() + expiration))//设置 JWT 的过期时间
                .signWith(SignatureAlgorithm.HS256, secret)//使用指定的算法（HS256）和密钥对 JWT 进行签名
                .compact();//生成最终的 JWT 字符串
    }
	//用于验证给定的 JWT 是否有效。
    public Boolean validateToken(String token, String username) {
        final String extractedUsername = extractUsername(token);//提取 JWT 中的用户名
        return (extractedUsername.equals(username) && !isTokenExpired(token));//检查提取的用户名与提供的用户名是否匹配，并且检查 JWT 是否未过期
    }
	//从 JWT 中提取用户名
    public String extractUsername(String token) {
        return extractAllClaims(token).getSubject();
    }
	//解析 JWT 并返回所有声明
    private Claims extractAllClaims(String token) {
        return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
    }//使用密钥解析 JWT 获取其主体部分（声明）
    
	//检查 JWT 是否已过期
    private Boolean isTokenExpired(String token) {
        return extractAllClaims(token).getExpiration().before(new Date());
    }
}

五、JWT请求过滤器

创建JWT请求过滤器，用于拦截请求并验证JWT：

package com.example.jwt.filter;

import com.example.jwt.service.JwtUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

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

@Component // 将该类标记为 Spring 组件，以便自动扫描和管理
public class JwtRequestFilter extends OncePerRequestFilter {

    @Autowired // 自动注入 JwtUtil 实例
    private JwtUtil jwtUtil;

    @Autowired // 自动注入 UserDetailsService 实例
    private UserDetailsService userDetailsService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        // 从请求中获取 Authorization 头部
        final String authorizationHeader = request.getHeader("Authorization");

        String username = null; // 初始化用户名
        String jwt = null; // 初始化 JWT 令牌

        // 检查 Authorization 头部是否存在且以 "Bearer " 开头
        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            // 提取 JWT 令牌（去掉 "Bearer " 前缀）
            jwt = authorizationHeader.substring(7);
            // 从 JWT 中提取用户名
            username = jwtUtil.extractUsername(jwt);
        }

        // 如果用户名不为空且当前 SecurityContext 没有身份验证信息
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            // 根据用户名加载用户详细信息
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            
            // 验证 JWT 是否有效
            if (jwtUtil.validateToken(jwt, userDetails.getUsername())) {
                // 创建身份验证令牌，并设置用户的权限
                UsernamePasswordAuthenticationToken authenticationToken =
                        new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                
                // 设置请求的详细信息
                authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                
                // 将身份验证信息存入 SecurityContext
                SecurityContextHolder.getContext().setAuthentication(authenticationToken);
            }
        }
        
        // 继续过滤器链
        chain.doFilter(request, response);
    }
}

六、安全配置

配置Spring Security，以保护API并使用JWT：

package com.example.jwt.config;

import com.example.jwt.filter.JwtRequestFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JwtRequestFilter jwtRequestFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/auth/login").permitAll() // 公开登录接口
            .anyRequest().authenticated() // 其他接口需要认证
            .and()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS); // 无状态会话

        // 添加JWT过滤器
        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password(passwordEncoder().encode("password")).roles("USER"); // 示例用户
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

七、身份验证控制器

创建一个控制器来处理登录请求并返回JWT：

package com.example.jwt.controller;

import com.example.jwt.model.User;
import com.example.jwt.service.JwtUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/auth")
public class AuthController {

    @Autowired
    private JwtUtil jwtUtil;

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private UserDetailsService userDetailsService;

    @PostMapping("/login")
    public String login(@RequestBody User user) {
        try {
            authenticationManager.authenticate(
                    new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword())
            );
        } catch (Exception e) {
            throw new RuntimeException("Invalid credentials");
        }

        final UserDetails userDetails = userDetailsService.loadUserByUsername(user.getUsername());
        return jwtUtil.generateToken(userDetails.getUsername());
    }
}

八、测试JWT

  1. 启动Spring Boot应用程序。
  2. 使用Postman或其他工具测试登录接口。

请求示例：

POST /auth/login
Content-Type: application/json

{
    "username": "user",
    "password": "password"
}

响应示例：

{
    "token": "eyJhbGciOiJIUzI1NiIsInR5c..."
}
  1. 使用返回的token访问受保护的资源：
GET /protected/resource
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5c...
华农第一蒟蒻
关注
专栏目录
JWT（json web token）认证实现【Playload 存储自定义对象】
iOS逆向与安全
12-09 1394
会将空转为字符串“null”生成jwt：sign(
Java JWT：原理、机制及案例示范
J老熊
10-12 1156
在分布式系统中，安全性与用户身份的验证是至关重要的环节。在业务系统种，如何保证用户的身份在多个服务中得到安全验证是一个关键问题。JWT（JSON Web Token）是一种广泛使用的身份验证机制，它提供了一种无状态的、分布式的方式来验证用户的身份和权限。 本文将详细讲解JWT的原理和机制，分析为什么需要使用JWT，探讨它在电商交易系统中的具体应用，并提供一些常见问题的解决方案。我们还将展示前端如何使用HTML和JavaScript与后端进行JWT身份验证的交互。
java中使用JWT
男儿当自强
01-04 7183
JWT：JSON Web Token，是通过数字签名，以JSON对象为载体在服务间安全传输信息的方式。JWT由三部分组成：头信息、有效载体和签名。头信息包括：令牌类型和签名算法信息；有效载体是使用一个JSON对象作为数据内容，由于只是采用base64运算，并没有进行加密，因此通常存放一些非敏感数据；签名是采用不可逆签名算法对base64后的头信息拼接上点拼接上base64后的有效载体及签名秘钥进行运算得出，防止token信息被篡改，最后生成的Token是由base64后的头信息拼接上点拼接上base64后的
Java中JWT技术解析与实践：安全高效的身份认证
weixin_41245021的博客
07-26 2968
身份认证与授权是现代Web应用中至关重要的安全机制。JSON Web Token（JWT）作为一种轻量级的身份验证方案，已经成为Java开发中广泛使用的解决方案。本篇博客将深入解析JWT技术，探讨其在Java应用中的实践与应用。我们将了解JWT的基本原理，以及它如何实现安全高效的身份认证和授权。通过使用JWT，我们可以在无状态的分布式系统中实现简单且可扩展的用户身份验证，不再依赖传统的Session和Cookie。我们还将探讨如何在Java中集成JWT，以及如何将其应用于实际项目中。让我们一起深入探索JWT
Java使用JWT
热门推荐
cxmengxin的博客
07-31 1万+
JWT 一、简介 1、JWT JWT为 Json Web Token，是一种令牌生成算法。使用JWT能够保证Token的安全性，且能够进行Token时效性的检验。 2、JWT结构 JWT共由三部分组成，分别是数据头(Header)、Payload(数据体)、验证签名(Verify Signature)组成。其中，Header中的内容为加密信息以及Token的类别，Payload为用户数据、Verify Signature为校验数据。 二、依赖 JWT需要两个依赖java-jwt、jjwt <depe
java使用jwt
Linlietao0587的博客
01-27 1772
在一个标准项目，拦截器或者过滤器一定不会少了。有了这些，那必须使用令牌验证了。这里讲解的是jwt 可以去看一下我上一篇文章，使用token和redis验证 1、JWT 1️⃣什么是jwt jwt 全称是 json web token 在网络应用环境声明而执行的一种基于json的开发标准 jwt应用分布式的当点托登录系统，身份提供者和服务者提供者传递认证用户信息 2️⃣jwt认证流程 用户输入用户密码进行登录 服务判断用户登录是否正确 -如正确，则颁发给用户一个token 客户端存token,在以.
java jwt使用
alisande1的专栏
05-30 237
【代码】java jwt使用。
Java - JWT的简单介绍和使用
Zong_0915的博客
11-06 1万+
目前自己在做一个云直播个人项目，后端架构是微服务，目前准备用JWT来做Token的校验。借此机会来复习和学习一遍JWT的相关知识。
JWT-JSON Web Token實作分享1
08-08
JSON Web Token（JWT）是一种基于 token 的身份验证机制，它可以提供一种无状态、可扩展、安全的身份验证方式。下面将详细介绍 JWT 的实现和使用。 为什么需要 Web Token？ 在服务器端身份验证中，传统的基于...
Json Web Token（JWT）介绍与基本使用详解及完整源码示例
最新发布
11-05
Json Web Token（JWT）是一种轻量级的身份验证和授权机制，广泛应用于Web应用程序，特别是单页应用（SPA）和微服务架构中。JWT通过在客户端和服务器之间传递JSON编码的信息来实现用户认证，无需在服务器端存储会话...
JWT(java web Token)
01-22
token 去访问实现了jwt认证的web服务器。 token 可保存自定义信息，如用户基本信息， web服务器用解析token，解决跨域授权的问题
java-jwt：JSON Web令牌（JWT）的Java实现
02-03
Java JWT Java实现 。 如果您正在寻找JWT Decoder的Android版本，请查看我们的库。 该库当前支持Java7。从不久开始，它将需要Java 8作为最低支持的Java版本。 有关其他信息和时间表，请参。 安装 该库在Maven Central和Bintray上均可用，并且Javadoc发布。 Maven < dependency> < groupId>com.auth0</ groupId> < artifactId>java-jwt</ artifactId> < version>3.12.1</ version> </ d
JSONWebToken(JWT)的Java实现
08-08
JSON Web Token (JWT)的Java实现
JWT(Json Web Token)Java实现jar
04-18
压缩包中包jjwt.jar和源码包 JSON WEB Token（JWT，读作 [/dʒɒt/]），是一种基于JSON的、用于在网络上声明某种主张的令牌（token）
Java中使用JWT生成Token进行接口鉴权实现方法
08-25
JWT（JSON Web Token）是一种基于Token的身份验证方法。它可以在服务器和客户端之间安全地传输信息。JWT由三部分组成：头部、载荷和签名。头部包含了jwt的类型和加密算法，载荷包含了用户的信息，签名是对jwt的数字...
java使用JWT
weixin_45052750的博客
04-07 398
引入依赖 官网上面链接很多java实现，这里使用java-jwt <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.7.0</version> </dependency> ...
Java实现JWT认证的完整指南：如何从零开始构建安全认证系统
weixin_46372265的博客
07-09 1013
JWT是一种基于JSON的开放标准，用于在各方之间作为JSON对象安全地传输信息。它特别适合于在无状态环境中（如RESTful API）进行身份验证和信息交换。通过以上步骤，我们成功地在Java中实现了基于JWT的身份认证系统。这个系统具有高度的安全性和扩展性，适用于各种需要身份认证的应用场景。希望这篇文章对大家有所帮助，如果你觉得这篇文章对你有所帮助，欢迎关注我的博客。未来，我会继续分享更多关于Java开发的干货。让我们一起在技术的道路上不断探索，勇往直前！
java JWT：JSON Web Token 详解
miracle的专栏
09-23 1044
JWT是一种灵活、轻量且跨平台的身份验证和授权方式。在现代 Web 应用中，尤其是分布式架构和微服务中，JWT 广泛用于处理用户身份验证和权限管理。通过本文的介绍，你不仅可以了解 JWT 的基本原理，还可以结合和Node.js实现 JWT 认证系统，并利用常用的调试工具提升开发效率。希望本文能帮助你更好地理解并运用 JWT。
使用JSON Web Token 实现登录的Java代码
05-26
使用 JSON Web Token (JWT) 实现登录的 Java 代码如下： 首先，需要引入以下依赖： ```xml <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-api</artifactId> <version>0.11.2</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-impl</artifactId> <version>0.11.2</version> <scope>runtime</scope> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-jackson</artifactId> <version>0.11.2</version> <scope>runtime</scope> </dependency> ``` 然后，可以编写一个 `JwtUtil` 类来实现 JWT 的生成和解析： ```java import io.jsonwebtoken.Claims; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.SignatureAlgorithm; import io.jsonwebtoken.security.Keys; import java.security.Key; import java.util.Date; public class JwtUtil { private static final Key key = Keys.secretKeyFor(SignatureAlgorithm.HS256); public static String generateToken(String subject, long expirationTimeMillis) { Date now = new Date(); Date expirationDate = new Date(now.getTime() + expirationTimeMillis); return Jwts.builder() .setSubject(subject) .setIssuedAt(now) .setExpiration(expirationDate) .signWith(key) .compact(); } public static String parseToken(String token) { Claims claims = Jwts.parserBuilder() .setSigningKey(key) .build() .parseClaimsJws(token) .getBody(); return claims.getSubject(); } } ``` 在上面的代码中，`generateToken` 方法用于生成 JWT，接受一个 `subject` 参数表示用户 ID，和一个 `expirationTimeMillis` 参数表示过期时间（以毫秒为单位）。`parseToken` 方法用于解析 JWT，返回其中的用户 ID。 接下来，可以编写一个简单的登录接口： ```java import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RestController; @RestController public class LoginController { @PostMapping("/login") public ResponseEntity<String> login(@RequestBody User user) { if (authenticate(user)) { String token = JwtUtil.generateToken(user.getId(), 86400000); return ResponseEntity.ok(token); } else { return ResponseEntity.badRequest().build(); } } private boolean authenticate(User user) { // TODO: 实现验证逻辑 return true; } } ``` 在上面的代码中，`User` 是一个简单的 Java 类，包含一个字符串类型的 `id` 属性。`login` 方法接受一个 `User` 对象作为参数，调用 `authenticate` 方法进行验证。如果验证通过，则使用 `JwtUtil.generateToken` 方法生成 JWT 并返回；否则返回错误响应。 最后，可以编写一个使用 JWT 进行身份验证的接口： ```java import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestHeader; import org.springframework.web.bind.annotation.RestController; @RestController public class UserController { @GetMapping("/user") public ResponseEntity<String> getUser(@RequestHeader("Authorization") String authorizationHeader) { String token = authorizationHeader.substring(7); String userId = JwtUtil.parseToken(token); // TODO: 根据用户 ID 查询用户信息并返回 return ResponseEntity.ok("User ID: " + userId); } } ``` 在上面的代码中，`getUser` 方法接受一个名为 `Authorization` 的请求头，其中包含 JWT。首先从请求头中获取 JWT，并调用 `JwtUtil.parseToken` 方法解析其中的用户 ID。然后根据用户 ID 查询用户信息并返回。 注意，在实际应用中，需要对 JWT 进行安全性考虑，比如使用 HTTPS 协议传输、设置较短的过期时间、使用更复杂的密钥等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值