springboot+JWT实现token认证

最新推荐文章于 2025-06-21 14:09:05 发布
原创 最新推荐文章于 2025-06-21 14:09:05 发布 · 2.9k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#JWT

本文介绍了一种基于JWT的用户认证方案，并通过Spring Boot实现了请求的拦截与验证流程。主要内容包括自定义注解、配置类、拦截器的实现及数据库操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

结构目录

在这里插入图片描述
在这里插入图片描述

一 annotation包

package com.gdqy.zhaosheng.demo.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface PassToken {
    boolean required() default true;
}

二 config包，拦截请求

package com.gdqy.zhaosheng.demo.config;

import com.gdqy.zhaosheng.demo.interceptor.AuthenticationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;


@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(authenticationInterceptor())
                .addPathPatterns("/**");    // 拦截所有请求，通过判断是否有 @LoginRequired 注解 决定是否需要登录
    }
    @Bean
    public AuthenticationInterceptor authenticationInterceptor() {
        return new AuthenticationInterceptor();
    }
}

三 interceptor包有两个类

第一个，AuthenticationInterceptor类，主要是验证token

package com.gdqy.zhaosheng.demo.interceptor;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.gdqy.zhaosheng.demo.annotation.PassToken;
import com.gdqy.zhaosheng.demo.annotation.UserLoginToken;
import com.gdqy.zhaosheng.demo.entity.User;
import com.gdqy.zhaosheng.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;


/**
 * @author jinbin
 * @date 2018-07-08 20:41
 */
public class AuthenticationInterceptor implements HandlerInterceptor {
    @Autowired
    UserService userService;
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object object) throws Exception {
        String token = httpServletRequest.getHeader("token");// 从 http 请求头中取出 token
        // 如果不是映射到方法直接通过
        if(!(object instanceof HandlerMethod)){
            return true;
        }
        HandlerMethod handlerMethod=(HandlerMethod)object;
        Method method=handlerMethod.getMethod();
        //检查是否有passtoken注释，有则跳过认证
        if (method.isAnnotationPresent(PassToken.class)) {
            PassToken passToken = method.getAnnotation(PassToken.class);
            if (passToken.required()) {
                return true;
            }
        }
        //检查有没有需要用户权限的注解
        if (method.isAnnotationPresent(UserLoginToken.class)) {
            UserLoginToken userLoginToken = method.getAnnotation(UserLoginToken.class);
            if (userLoginToken.required()) {
                // 执行认证
                if (token == null) {
                    throw new RuntimeException("无token，请重新登录");
                }
                // 获取 token 中的 user id
                String userId;
                try {
                    userId = JWT.decode(token).getAudience().get(0);
                } catch (JWTDecodeException j) {
                    throw new RuntimeException("401");
                }
                User user = userService.findUserById(userId);
                if (user == null) {
                    throw new RuntimeException("用户不存在，请重新登录");
                }
                // 验证 token
                JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(user.getPassword())).build();
                try {
                    jwtVerifier.verify(token);
                } catch (JWTVerificationException e) {
                    throw new RuntimeException("401");
                }
                return true;
            }
        }
        return true;
    }

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

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

    }
}

第二个是，GloablExceptionHandler类提示返回服务器出错

package com.gdqy.zhaosheng.demo.interceptor;

import com.alibaba.fastjson.JSONObject;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;


@ControllerAdvice
public class GloablExceptionHandler {
    @ResponseBody
    @ExceptionHandler(Exception.class)
    public Object handleException(Exception e) {
        String msg = e.getMessage();
        if (msg == null || msg.equals("")) {
            msg = "服务器出错";
        }
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("message", msg);
        return jsonObject;
    }
}

四 mapper包

package com.gdqy.zhaosheng.demo.mapper;

import com.gdqy.zhaosheng.demo.entity.User;
import org.apache.ibatis.annotations.Param;


public interface UserMapper {
    User findByUsername(@Param("username") String username);
    User findUserById(@Param("Id") String Id);
}

五 service包有两个类

第一个TokenService，封装token

package com.gdqy.zhaosheng.demo.service;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.gdqy.zhaosheng.demo.entity.User;
import org.springframework.stereotype.Service;



@Service("TokenService")
public class TokenService {
    public String getToken(User user) {
        String token="";
        token= JWT.create().withAudience(user.getId())// 将 user id 保存到 token 里面
                .sign(Algorithm.HMAC256(user.getPassword()));// 以 password 作为 token 的密钥
        return token;
    }
}

第二个UserService

package com.gdqy.zhaosheng.demo.service;

import com.gdqy.zhaosheng.demo.entity.User;
import com.gdqy.zhaosheng.demo.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


@Service("UserService")
public class UserService {
    @Autowired
    UserMapper userMapper;
    public User findByUsername(User user){
        return userMapper.findByUsername(user.getUsername());
    }
    public User findUserById(String userId) {
        return userMapper.findUserById(userId);
    }

}

DemoApplication 在启动程序记得添加

package com.gdqy.zhaosheng.demo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.gdqy.zhaosheng.demo.mapper")//写你mapper接口所在的路径
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

六 resources下的包

在这里插入图片描述
UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.gdqy.zhaosheng.demo.mapper.UserMapper">
    <select id="findByUsername" resultType="com.gdqy.zhaosheng.demo.entity.User">
      SELECT * FROM user
      where
      username=#{username}
    </select>
    <select id="findUserById" resultType="com.gdqy.zhaosheng.demo.entity.User">
        SELECT * FROM user
      where
      id=#{Id}
    </select>
</mapper>

application.properties

server.port=6379
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/booksystem?serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.max-idle=10
server.tomcat.uri-encoding=UTF-8
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
#指定全局配置文件
mybatis.config-location=classpath:mybatis.xml
#指定sql文件
mybatis.mapperLocations=classpath:mapper/*.xml

mybatis.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="logImpl" value="SLF4J"/>
        <!-- 开启驼峰命名转换 Table(create_time) -> Entity(createTime) -->
        <setting name="mapUnderscoreToCamelCase" value="true" />
    </settings>
</configuration>

附上sql语句



SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int(45) NOT NULL,
  `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, '张三', '123456');

SET FOREIGN_KEY_CHECKS = 1;

请求方式 我用的是postman接口测试工具

在这里插入图片描述

Springboot+Shiro+jwt+Redis+Mybatis 有效期内Token刷新方案.zip
02-04
本方案主要涉及Spring Boot、Apache Shiro、JSON Web Token (JWT)、Redis以及Mybatis等技术，它们共同构建了一个高效且灵活的身份验证和令牌刷新机制。下面我们将深入探讨这个方案的各个组件及其作用。 首先，...
基于springboot+oauth2.0+jwtToken鉴权认证开发的后台接口，整套架构采用restful风格，车牌识别，阿里云消息推送，短信接口等
04-04
内容只为接口开发，配合前端和移动app调用使用，不包含html页面，基于springboot+oauth2.0+jwttoken鉴权（内有怎么使用redistoken和数据库token注释）+restful风格+阿里短信+阿里消息推送+车牌识别等。该项目为工作...
spring boot+jwt实现api的token认证详解
08-26
主要给大家介绍了关于spring boot+jwt实现api的token认证的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一学习学习吧
基于SpringBoot使用JWT实现Token认证
Leopard锋的博客
03-11 1万+
目录 一、JWT的介绍 1、什么是JWT 2、、基于token的鉴权机制 3、JWT的构成 二、简单实战 1、新建一个简单的springboot项目 2、自定义登录异常处理 3、全局异常拦截处理输出 4、创建工具类 5、token的生成和拦截 三、参考文献 一、JWT的介绍 1、什么是JWT Json web token（JWT）是为了网络应用环境间传递声明而执...
SpringBoot 登录时使用 Token
最新发布
weixin_52578852的博客
06-21 579
Service@Override// 这里应该从数据库查询用户信息// 这里为了简单，使用硬编码的用户名和密码} else {这个教程展示了如何在 SpringBoot 中使用 JWT 实现基于 Token 的认证。实际应用中，你可能还需要：将用户信息存储在数据库中，添加刷新 token 的功能，实现更完善的错误处理，添加更多的安全配置。
Springboot +JWT
justlpf的专栏
06-05 1149
参考文章：Springboot +JWT
Springboot+JWT
while(life)++；
10-21 592
JWT（JSON WEB TOKEN）是一种标准，用来在前后端或者系统间以JSON对象安全的传输信息，该信息是可以被验证和信任的，因为它是数字签名的。可以使用HMAC或RSA或ECDSA的公钥/私钥进行签名。
SpringBoot——JWTtoken
逾越的博客
10-23 3917
1.JWT JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。 2.优点 1.无状态 2.有效避免了CSRF 攻击（跨站请求伪造，属于网络攻击领域范围） 3.适合移动端应用 4.单点登录友好（SSO的定义是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。） @Slf4j public class JwtUtil { //过期时
springboot + jwt + websocket + 拦截
09-02
在IT行业中，Spring Boot、JWT（JSON Web Token）和WebSocket是三个非常重要的技术概念，而“拦截”通常指的是在系统中实现的一种中间件机制，用于处理请求或响应。结合提供的标题和描述，我们可以深入探讨这四个...
springboot+springSecurity+jwt实现登录认证后令牌授权
09-12
在这个项目中，我们将探讨如何利用Spring Boot、Spring Security和JWT来实现登录认证后的令牌授权。 首先，让我们从Spring Boot开始。Spring Boot简化了Spring应用的初始搭建以及开发过程。通过提供默认配置，它极...
Springboot+SpringSecurity+JWT实现用户登录和权限认证示例
08-19
以下是实现Spring Boot + Spring Security + JWT登录和权限认证的主要步骤： 1. **项目初始化**：创建一个新的Spring Boot项目，添加`spring-boot-starter-web`、`spring-boot-starter-security`、`spring-security...
SpringBoot集成JWT
07-14 443
JWT（json web tokens）是目前比较流行的跨域认证解决方案；说通俗点就是比较流行的token生成和校验的方案。碰巧公司有个app的项目的token采用了jwt方案，因此记录下后端项目集成jwt的过程，方便后续查阅。一、jwt的简单介绍 jwt生成的token是一种无状态的token，服务端不需要对该token进行保存；它一般由客户端保存。客户端访问请求服务时，...
Springboot集成JWT
qq_63790285的博客
04-18 915
这里就是从数据库中根据用户名和密码查找用户，若能欧查到就生成token令牌，拿着这个令牌进行后续的操作。@ApiOperation("用户登录")if (user!= null) {// 查询到了用户的数据，将其封装到JWT令牌中//登录成功后，生成jwt令牌claims);return "";
【SpringBoot整合JWT】
蛋饼吧的博客
05-18 9945
1.认证方式我们知道，http协议本身是一种无状态的协议，而这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证，那么下一次请求时，用户还要再一次进行用户认证才行，因为根据http协议，我们并不能知道是哪个用户发出的请求，所以为了让我们的应用能识别是哪个用户发出的请求，我们只能在服务器存储一份用户登录的信息，这份登录信息会在响应时传递给浏览器，告诉其保存为cookie,以便下次请求时发送给我们的应用，这样我们的应用就能识别请求来自哪个用户了,这就是传统的基于session认证。
深入SpringBoot：JWT的集成与使用
~
04-05 2855
JSON Web Token（JWT）是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519)，它定义了一种紧凑且自包含的方式，用于在各方之间以JSON对象安全传输信息。这些信息可以通过数字签名进行验证和信任。可以使用秘密（使用HMAC算法）或使用RSA的公钥/私钥对对JWT进行签名。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，该token也可直接被用于认证，也可被加密。是目前最流行的跨域认证解决方案。
SpringBoot集成JWT实现Token
热门推荐
天道酬勤
05-20 1万+
SpringBoot 2.1.4集成JWT实现token验证 wRitchie2019-05-16 15:11:24 SpringBoot 2.1.4集成JWT实现token验证 编者： wRitchie（吴理琪） 来源：http://www.bj9420.com 什么是JWT：Json web token (JWT) 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(...
SpringBoot集成Jwt（详细步骤+图解）
wenjiangwang的专栏
12-21 3573
https://blog.youkuaiyun.com/weixin_67958017/article/details/128856282
Spring Boot与JWT深度整合：实现高效安全认证机制的详细指南
03-23 643
Spring Boot 是一个开源的 Java 基于 Spring 框架的快速开发平台，它极大地简化了 Spring 应用的开发过程。通过自动配置 Spring 和第三方库，Spring Boot 让开发者能够快速搭建出一个功能强大的应用。它提供了大量的 “Starters”（启动器），这些启动器封装了各种常用的功能，例如数据库访问、安全认证、Web 开发等，开发者只需在项目中引入相应的依赖即可。快速开发：通过自动配置，减少了大量的配置文件编写工作。独立运行。
SpringBoot使用JWT作为Token实现前后端分离登录
q438944209的博客
02-14 7481
JWT就不多介绍了 传统的shiro和SpringSecurity安全框架需要Session，重启后Session会丢失，或者将Session存入redis也行，但是相对比较繁琐。利用JWT可以很轻松的实现Token的认证，在前后端分离的情况下，JWT也显得非常的简易。 依赖 &lt;dependency&gt; &lt;groupId&gt;com.auth0&lt;/groupId&...
SpringBoot+JWT：实现Token登录权限认证详解
"本文详细介绍了如何使用SpringBoot结合JWT（JSON Web Token）实现用户登录权限认证。文中通过具体的示例代码，展示了JWT的登陆认证流程、JWT的构成以及其优势，并给出了项目的依赖配置。" 在现代Web应用中，安全性...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值