SpringBoot项目引入token设置

最新推荐文章于 2024-05-12 14:50:36 发布
最新推荐文章于 2024-05-12 14:50:36 发布
阅读量4.3k 收藏 12
点赞数 4
分类专栏： springboot 文章标签： java spring boot tokenization
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41107680/article/details/110221333
版权

一. 先了解熟悉JWT（JSON Web Token）

看这些介绍、结构之类的，确实挺无聊的；想直接进入主题的话，就跳过第一大步。望各位同仁给出相关意见，以备我来更加深入的学习。

1. JSON Web Token是什么鬼？

这个东西，反正理解成一个标准就行了，啥标准我也不知道。反正就是用于各种信息的安全性传输。

1. JSON Web令牌应用的场景

1.授权，在用户登录后会给用户一个token，在用户后续的所有请求后台资源的操作都将携带这个token，只有被token允许的操作才能执行。
2.信息交换，应用于各种数据信息交换的场景；目前这种场景我也没有涉及到过，嘿嘿！

2. JSON Web令牌结构

JSON Web Tokens由dot（.）分隔的三个部分组成：Header、Payload、Signature；
因此token的形式是：

xxxxx.yyyyy.zzzzz
2.1 Header

标头通常由两部分组成：令牌的类型，即JWT，以及正在使用的签名算法，例如HMAC SHA256或RSA。

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

然后，这个JSON被编码为Base64Url，形成JWT的第一部分

2.2 Payload

这一部分是声明，有三种类型：注册，公开和私有声明；

  1. 注册
    这些是一组预定义声明，不是强制性的，但建议使用，以提供一组有用的，可互操作的声明。其中一些是：iss (issuer), exp (expiration time), sub (subject), aud(audience)等
    注：请注意，声明名称只有三个字符，因为JWT意味着紧凑。
  2. 公开
    这些可以由使用JWT的人随意定义。但为避免冲突，应在 IANA JSON Web令牌注册表中定义它们，或者将其定义为包含防冲突命名空间的URI
  3. 私有
    私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息
    payload示例：
{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

然后，payload经过Base64Url编码，形成JSON Web令牌的第二部分
请注意：对于签名令牌，此信息虽然可以防止被篡改，但任何人都可以读取。除非加密，否则不要将秘密信息放在JWT的payload或header中。

2.3 Signature

要创建签名部分，必须采用 header, payload, secret，标头中指定的算法，并对其进行签名。
例如，如果要使用HMAC SHA256算法，将按以下方式创建签名：

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)
2.4 token

最后输出是三个由点分隔的Base64-URL字符串

3. JSON Web令牌工作原理
  1. 用户登陆的时候使用用户名和密码发送POST请求
  2. 服务器使用私钥创建一个jwt
  3. 服务器返回这个jwt到浏览器
  4. 浏览器将该jwt串加入请求头中向服务器发送请求
  5. 服务器验证jwt
  6. 返回相应的资源给客户端

二. 动手开始搞

1.引入依赖
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.4.0</version>
</dependency>
2. 定义注解
package com.example.fighting.config;

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

public class UserToken {

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

//    需要验证
    @Target({ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface UserLoginToken {
        boolean required() default true;
    }
}
3.新增TokenService接口类和TokenServiceImpl实现类
package com.example.fighting.serviceImpl;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.example.fighting.bean.UserTest;
import com.example.fighting.service.TokenService;
import org.springframework.stereotype.Service;

@Service
public class TokenServiceImpl implements TokenService {

    @Override
    public String getToken(UserTest userTest) {
        String token="";
        token= JWT.create().withAudience(userTest.getId().toString())
                .sign(Algorithm.HMAC256(userTest.getPassword()));
        return token;
    }
}
4.新增拦截器
package com.example.fighting.config;

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.example.fighting.bean.UserTest;
import com.example.fighting.service.UserTestService;
import jdk.nashorn.internal.ir.annotations.Reference;
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;

public class AuthenticationInterceptor implements HandlerInterceptor {
    @Autowired
//    @Reference
    UserTestService userTestService;

    @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(UserToken.PassToken.class)) {
            UserToken.PassToken passToken = method.getAnnotation(UserToken.PassToken.class);
            if (passToken.required()) {
                return true;
            }
        }
        //检查有没有需要用户权限的注解
        if (method.isAnnotationPresent(UserToken.UserLoginToken.class)) {
            UserToken.UserLoginToken userLoginToken = method.getAnnotation(UserToken.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");
                }
                UserTest user = userTestService.findUserTestById(Long.parseLong(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 {
    }
}
5.添加拦截器配置
package com.example.fighting.interceptor;

import com.example.fighting.config.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("/**");
    }
    @Bean
    public AuthenticationInterceptor authenticationInterceptor() {
        return new AuthenticationInterceptor();
    }
}
6. 在controller中添加登录接口
//登录
    @ApiOperation(value="登录接口",notes ="验证登录后获取一个token")
    @ApiImplicitParams({
            @ApiImplicitParam(paramType="query",name="username",value="账号",required = true),
            @ApiImplicitParam(paramType="query",name="password",value="密码",required = true)
    })
    @PostMapping("/login")
    @ResponseBody
    public Map login(UserTest user) {
        Map<Object, Object> map = new HashMap<>();
        UserTest userForBase = userTestService.findUserTestByUserName(user.getUsername());
        if (userForBase == null) {
            map.put("message", "登录失败,用户不存在");
            return map;
        } else {
            if (!userForBase.getPassword().equals(user.getPassword())) {
                map.put("message", "登录失败,密码错误");
                return map;
            } else {
                String token = tokenService.getToken(userForBase);
                map.put("token", token);
                map.put("user", userForBase);
                return map;
            }
        }
    }
    @ApiOperation(value="测试token",notes ="测试token是否通过")
    @UserToken.UserLoginToken
    @GetMapping("/getMessage")
    public String getMessage() {
        return "你已通过验证";
    }
7.接口测试

1.用postman不加token访问
调接口：http://localhost:8014/userTest/getMessage
后台打印结果：
在这里插入图片描述
2.用postman添加错误的token访问
在这里插入图片描述
打印结果：
在这里插入图片描述
3.正常登录，使用登录后返回的token
登录接口：http://localhost:8014/userTest/login
在这里插入图片描述
调接口测试token是否生效：
在这里插入图片描述

陈厚伯
关注
  • 4
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
springboot+redis+token保持登录
08-03
在现代Web应用开发中，保持用户登录状态是一个常见的需求，"springboot+redis+token保持登录"的主题就涉及到了如何利用Spring Boot、Redis以及Token技术来实现这一功能。本文将详细探讨这一技术栈的实现原理和步骤。...
【SpringBoot】1、SpringBoot整合JWT实现Token验证
qq_24099547的博客
04-10 7900
单点登录
【三】springboot整合token
weixin_56995925的博客
09-03 1万+
springboot整合token
Spring Boot 集成 sa-token 实践教程
最新发布
05-12 606
通过以上步骤，我们已经成功地将sa-token集成到了Spring Boot项目中，实现了基本的登录和权限控制功能。sa-token的更多高级功能，如角色管理、权限细分等，可以通过阅读官方文档进一步学习。
SpringBoot（九）jwt + 拦截器实现token验证
zhaojun的博客
07-31 8142
前面两篇文章的过滤器和拦截器，我们都提到过可以做诸如权限验证的事情。http/https是无状态的协议，当用户访问一个后端接口时，如何判断该用户有没有权限？当然，可以使用账号+密码去验证。但是，如果使用账号和密码，需要频繁访问数据库，很明显，会带来一些额外的开销。本篇介绍下使用jwt和拦截器实现token权限验证。
springboot中使用token
Cidaren的博客
07-15 1万+
1. pom.xml文件中添加依赖 <!-- 引入操作JWT的相关依赖 --> <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.11.0</version> </dependency> 除此依赖之外还需要添加springbootweb的起步依赖，以及使用的数据库依赖 2. 定
SpringBoot集成JWT实现Token登录验证
Young_深情不及里子的博客
11-25 1万+
JSON Web令牌(JWT)是一种开放的标准(RFC 7519)，它定义了一种紧凑而独立的方式在各方之间安全地传输信息为JSON对象。学习总结一下SpringBoot整合JWT的登录token验证，简单易理解哦~
深入了解Token认证的来龙去脉
zyh568879280的博客
02-15 474
转载至：https://blog.csdn.net/niugang0920/article/details/80615137 Token 是在服务端产生的，如果前端使用用户名/密码向服务端请求认证，服务端认证成功，那么在服务端会返回 Token 给前端。前端可以在每次请求的时候带上 Token 证明自己的合法地位。     不久前，我在前后端分离实践中提到了基于 Token 的认证，现在我...
SpringBoot项目使用JWT+拦截器实现token验证
weixin_44320429的博客
10-18 1万+
上述流程当中token的具体实现方式为JWT，其全称是，官网地址：https://jwt.io/就是通过JSON形式作为Web应用中的令牌,用于在各方之间安全地将信息作为JSON对象传输。在数据传输过程中还可以完成数据加密、签名等相关处理。通俗地说，JWT的本质就是一个字符串，它是将用户信息保存到一个Json字符串中，然后进行编码后得到一个JWT token，并且这个JWT token带有签名信息，接收后可以校验是否被篡改，所以可以用于在各方之间安全地将信息作为Json对象传输。
springboot之token的用法总结
热门推荐
east123321的博客
04-03 1万+
一、 token的构造    token是又header（头）、payload（荷载）、sign（签名）三部分组成。    header：头部信息主要包括（参数的类型--JWT,签名的算法--HS256）    payload：存放自己想要的信息        sign：是为了防止恶意篡改数据二、JWT的生成和解析生成：String token=JavaWebTokenUtil.createJWT...
SpringBoot下token短信验证登入登出权限操作(token存放redis,ali短信接口)
08-25
同时，为了发送短信，我们需要阿里云的短信服务SDK，这可以通过`systemPath`方式引入到项目中，确保在构建时包含这个外部依赖： ```xml <groupId>ali <artifactId>taobao-sdk-java-auto <scope>system ${...
springboot整和jwt、shiro、redis实现token自动刷新
08-19
在Spring Boot项目中实现这一流程，首先需要引入相关的依赖，如Spring Security、Shiro、JWT库以及Redis相关库。然后配置Shiro的WebFilter，确保请求被Shiro拦截并执行认证。接着，我们需要创建一个JWTToken Realm，...
SpringBoot项目SSM+Redis整合
12-13
**SpringBoot项目SSM+Redis整合** 在现代Web开发中，SpringBoot因其便捷的配置、快速的开发体验而被广泛采用。本项目是基于SpringBoot框架进行构建的，旨在实现SSM（Spring、SpringMVC、Mybatis）的经典组合与Redis...
spring boot+jwt实现api的token认证详解
08-26
在Maven的`pom.xml`文件中，你需要引入`jjwt`库和`fastjson`库，如下所示： ```xml <!-- JWT 依赖 --> <groupId>io.jsonwebtoken <artifactId>jjwt <version>0.9.0 <!-- 阿里 FastJson 依赖 --> <groupId>...
Springboot集成JWT，用户名，密码生成token
administratop的博客
11-11 1981
基于标准化:你的API可以采用标准化的 JSON Web Token (JWT). 这个标准已经存在多个后端库（.NET, Ruby,更适用于移动应用: 当你的客户端是一个原生平台（iOS, Android，Windows 8等）时，Cookie是不被支持的。更适用CDN: 可以通过内容分发网络请求你服务端的所有资料（如：javascript，HTML,图片等），而你的服。支持跨域访问: Cookie是不允许垮域访问的，这一点对Token机制是不存在的，前提是传输的用户认证信息通。务端只要提供API即可.
springboot整合jwt实现token，简明笔记
学习，是熵减的最有效途径。
06-21 2576
一篇搞定springboot整合jwt实现token
springboot项目整合token，实现项目的认证与授权（提供代码）
一天不写代码难受的博客
05-21 3590
目录1 jwt验证流程2 token组成3 代码实现 1 jwt验证流程 首先，前端通过Web表单将自己的用户名和密码发送到后端的接口。这一过程- -般是一 个HTTP POST请求。建议的方式是通过SSL加密的传输(https协议) ，从而避免敏感信息被嗅探。 后端核对用户名和密码成功后，将用户的id等其他信息作为JWT Payload (负载)，将其与头部分别进行Base64编码拼接后签名，形成一个JWT(Token)。 形成的JWT就是一个形同11. zzz. xxx的字符串。token he
Springboot实现登录功能（token、redis、登录拦截器、全局异常处理）
qq_64680177的博客
10-06 3786
1、前端调用登录接口，往接口里传入账号，密码2、根据账号判断是否有这个用户，如果有则继续判断密码是否正确3、验证成功后，则是根据账号，登录时间生成token（用JWT）4、将token存入Redis当中，用于token过期策略5、将token和用户信息返回给前端6、此后调用后端任何接口都会先判断发来请求里token是否存在、有效(拦截器实现)7、然后继续接下来的正常调用。
SpringBoot基于token的请求验证
一路向北的博客
09-09 4647
SpringBoot实现基于Token的请求验证
springboot 项目实现 token 校验
05-29
在Spring Boot项目中实现Token校验，可以通过以下步骤： 1. 在项目中引入相应的依赖，如JWT库等。 2. 创建Token的生成和校验工具类，其中生成Token的方法可以使用JWT库中的方法，校验Token的方法可以解析Token中的信息并进行校验。 3. 在需要进行Token校验的接口中，添加一个拦截器，用于拦截请求并进行Token校验。在拦截器中获取请求头中的Token信息，然后调用Token校验工具类进行校验。 4. 如果Token校验通过，则放行请求；如果Token校验失败，则返回相应的错误信息。 以下是一个简单的示例代码： （1）pom.xml中添加JWT库的依赖： ```xml <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.0</version> </dependency> ``` （2）创建Token工具类： ```java import io.jsonwebtoken.Claims; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.SignatureAlgorithm; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; import java.util.Date; import java.util.HashMap; import java.util.Map; @Component public class JwtTokenUtil { private static final String CLAIM_KEY_USERNAME = "sub"; private static final String CLAIM_KEY_CREATED = "created"; @Value("${jwt.secret}") private String secret; @Value("${jwt.expiration}") private Long expiration; public String generateToken(String username) { Map<String, Object> claims = new HashMap<>(); claims.put(CLAIM_KEY_USERNAME, username); claims.put(CLAIM_KEY_CREATED, new Date()); return generateToken(claims); } private String generateToken(Map<String, Object> claims) { Date expirationDate = new Date(System.currentTimeMillis() + expiration * 1000); return Jwts.builder() .setClaims(claims) .setExpiration(expirationDate) .signWith(SignatureAlgorithm.HS512, secret) .compact(); } public String getUsernameFromToken(String token) { String username; try { Claims claims = getClaimsFromToken(token); username = claims.getSubject(); } catch (Exception e) { username = null; } return username; } public boolean validateToken(String token, String username) { String usernameFromToken = getUsernameFromToken(token); return usernameFromToken.equals(username) && !isTokenExpired(token); } private Claims getClaimsFromToken(String token) { Claims claims; try { claims = Jwts.parser() .setSigningKey(secret) .parseClaimsJws(token) .getBody(); } catch (Exception e) { claims = null; } return claims; } private boolean isTokenExpired(String token) { Date expirationDate = getExpirationDateFromToken(token); return expirationDate.before(new Date()); } private Date getExpirationDateFromToken(String token) { Claims claims = getClaimsFromToken(token); return claims.getExpiration(); } } ``` （3）创建Token拦截器： ```java import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.springframework.web.servlet.HandlerInterceptor; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @Component public class JwtTokenInterceptor implements HandlerInterceptor { @Autowired private JwtTokenUtil jwtTokenUtil; @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { String token = request.getHeader("Authorization"); String username = jwtTokenUtil.getUsernameFromToken(token); if (username != null && jwtTokenUtil.validateToken(token, username)) { return true; } else { response.getWriter().write("Token is invalid"); return false; } } } ``` （4）在需要进行Token校验的接口中添加拦截器： ```java import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController @RequestMapping("/api") public class MyController { @Autowired private JwtTokenInterceptor jwtTokenInterceptor; @RequestMapping("/test") public String test() { return "Hello, world!"; } @RequestMapping("/test2") public String test2() { return "Hello, world 2!"; } @RequestMapping("/test3") public String test3() { return "Hello, world 3!"; } @RequestMapping("/test4") public String test4() { return "Hello, world 4!"; } @RequestMapping("/test5") public String test5() { return "Hello, world 5!"; } } ``` 在Spring Boot项目中实现Token校验，可以通过以上步骤实现。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值