【SpringBoot】集成JWT实现用户认证

最新推荐文章于 2024-08-13 22:37:59 发布
最新推荐文章于 2024-08-13 22:37:59 发布
阅读量5.1k 收藏 25
点赞数 2
分类专栏： SpringBoot 文章标签： springboot jwt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dh_chao/article/details/84109667
版权

初识JWT

1.什么是JWT

JSON Web Token (JWT) 是一个开放标准 (RFC 7519)，它定义了一种紧凑且独立的方式，可以在客户端与服务器之间作为JSON对象安全地传输信息。

2.JWT使用场景

  • 身份验证: 用户在登录以后，后续的每个请求都将包含JWT，允许用户访问该令牌允许的路由，服务和资源等。Session同样也可以实现这个功能，但是在使用Session的同时也会相应的增加服务器的压力；而JWT的开销则相对较小，因为其将存储的压力分布到各个客户端中，从而减轻了服务器的压力，并且能够在不同域的系统当中轻松的使用。单点登录(SSO)就广泛使用了JWT的功能。
  • 信息交换: JWT能够在客户端与服务器之间安全地传输信息，因为其可以签名，通过签名可以验证传输信息是否被修改。

3.JWT组成

JWT就是一个字符串，经过加密处理与校验处理的字符串，由 . 分割的三个部分组成，分别是头(Header)、有效荷载(Playload)、签名(Signature)，因此JWT的格式通常也是这样: header.playload.signature(header由JWT的表头信息经过加密后得到；playload由JWT用到的身份验证信息JSON数据加密得到；signature是由header和playload加密得到，这一部分作为校验部分)。

  • Header
    通常是由两部分组成的：一是令牌的类型，即JWT；二是哈希算法，比如SHA256。

例如：

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

然后这个JSON通过Base64加密形成JWT的第一个部分即header。

  • Playload
    JWT的第二个部分是有效荷载，其中包含了声明(Claim)。JWT提供了一组预定义的声明，这些声明都是可选的，并不是强制性的。当然你也可以自定义声明传输所需信息，比如系统用户ID。出于安全考虑，一般不会将用户的敏感信息存放在声明当中。
声明属性说明
iss发行人，JWT由谁签发
iatJWT创建时间，unix时间戳格式
expJWT过期时间，unix时间戳格式
subJWT所面向的用户
aud接收方，接收JWT的一方
nbf当前时间在nbf之前，JWT不能被接收处理
jtiJWT唯一ID

例如：

{
	"iss": "Hilox",
	"sub": "HiloxApiUser",
	"iat": "1542337107",
	"exp": "1542340707",
	"userId": "5"
}

将上述声明(Claim)通过Base64加密后得到payload。

  • Signature
    将表头经过Base64加密得到的header和Claim经过Base64加密得到的playload进行组合，形成一个新字符串header.playload，对新形成的字符串使用标头当中指定的算法(例如:上述Header例子中使用HS256算法)和自定义的密钥(例如:Hilox)进行加密得到signature。

最后，将字符串组合 header.playload.signature就是生成的token了。



图1 JWT生成流程图

JWT应用

1.JWT如何使用

博主为移动端app搭建服务器，所采用的方式是将token放到http请求的请求头部当中，通常使用的是Authorization属性字段。
移动端app使用cookie不太方便，所以暂不做考虑。

2.应用流程



图2 初次登录生成JWT流程图



图3 用户访问资源流程图

JWT应用代码实现

下面通过代码来实现用户认证的功能，博主这里主要采用Spring Boot与JWT整合的方式实现。
关于Spring Boot项目如何搭建与使用本章不做详细介绍。
代码当中针对异常自行做处理，我这里偷点懒直接用日志在控制台打印。

1.添加JWT依赖

<dependency>
	<groupId>io.jsonwebtoken</groupId>
	<artifactId>jjwt</artifactId>
	<version>0.9.1</version>
</dependency>

2.添加JWT相关配置

Base64在线加密

jwt:
 # 发行者
 name: Hilox
 # 密钥, 经过Base64加密, 可自行替换
 base64Secret: SGlsb3g=
 #jwt中过期时间设置(分)
 jwtExpires: 120

3.JWT配置实体类

/**
 * jwt 相关参数
 * Created by Hilox on 2018/11/16 0016.
 */
@Component
@ConfigurationProperties(prefix = "jwt")
public class JwtParam {

    /**
     * 发行者名
     */
    private String name;

    /**
     * base64加密密钥
     */
    private String base64Secret;

    /**
     * jwt中过期时间设置(分)
     */
    private int jwtExpires;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getBase64Secret() {
        return base64Secret;
    }

    public void setBase64Secret(String base64Secret) {
        this.base64Secret = base64Secret;
    }

    public int getJwtExpires() {
        return jwtExpires;
    }

    public void setJwtExpires(int jwtExpires) {
        this.jwtExpires = jwtExpires;
    }
}

4.配置JWT拦截器

/**
 * jwt 拦截器
 * Created by Hilox on 2018/11/16 0016.
 */
@Slf4j
public class JwtInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtParam jwtParam;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, 
    					Object handler) throws Exception {

        // 忽略带JwtIgnore注解的请求, 不做后续token认证校验
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            JwtIgnore jwtIgnore = handlerMethod.getMethodAnnotation(JwtIgnore.class);
            if (jwtIgnore != null) {
                return true;
            }
        }

        if (HttpMethod.OPTIONS.equals(request.getMethod())) {
            response.setStatus(HttpServletResponse.SC_OK);
            return true;
        }

        final String authHeader = request.getHeader(JwtConstant.AUTH_HEADER_KEY);

        if (StringUtils.isEmpty(authHeader)) {
            // TODO 这里自行抛出异常
            log.info("===== 用户未登录, 请先登录 =====");
            return false;
        }

        // 校验头格式校验
        if (!JwtUtils.validate(authHeader)) {
            // TODO 这里自行抛出异常
            log.info("===== token格式异常 =====");
            return false;
        }

        // token解析
        final String authToken = JwtUtils.getRawToken(authHeader);
        Claims claims = JwtUtils.parseToken(authToken, jwtParam.getBase64Secret());
        if (claims == null) {
            log.info("===== token解析异常 =====");
            return false;
        }

        // 传递所需信息
         request.setAttribute("CLAIMS", claims);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, 
    					Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
    					Object handler, Exception ex) throws Exception {

    }
}

5.配置MVC拦截器

/**
 * mvc 配置
 * Created by Hilox on 2018/11/15 0015.
 */
@Configuration
public class MyWebConfigurer extends WebMvcConfigurerAdapter {

    // 这里这么做是为了提前加载, 防止过滤器中@AutoWired注入为空
    @Bean
    public JwtInterceptor jwtInterceptor() {
        return new JwtInterceptor();
    }

    // 自定义过滤规则
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtInterceptor()).addPathPatterns("/**");
    }
}

6.自定义忽略token验证注解

/**
 * JWT请求忽略注解
 * Created by Hilox on 2018/11/20 0020.
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface JwtIgnore {
}

7.JWT工具类

/**
 * JWT工具类
 * Created by Hilox on 2018/11/16 0016.
 */
@Slf4j
public class JwtUtils {

    private static final String AUTHORIZATION_HEADER_PREFIX = "Bearer ";

    // 构造私有
    private JwtUtils() {}

    /**
     * 获取原始token信息
     * @param authorizationHeader 授权头部信息
     * @return
     */
    public static String getRawToken(String authorizationHeader) {
        return authorizationHeader.substring(AUTHORIZATION_HEADER_PREFIX.length());
    }

    /**
     * 获取授权头部信息
     * @param rawToken token信息
     * @return
     */
    public static String getAuthorizationHeader(String rawToken) {
        return AUTHORIZATION_HEADER_PREFIX + rawToken;
    }

    /**
     * 校验授权头部信息格式合法性
     * @param authorizationHeader 授权头部信息
     * @return
     */
    public static boolean validate(String authorizationHeader) {
        return StringUtils.hasText(authorizationHeader) 
        	&& authorizationHeader.startsWith(AUTHORIZATION_HEADER_PREFIX);
    }

    /**
     * 生成token, 只在用户登录成功以后调用
     * @param userId 用户id
     * @param jwtParam JWT加密所需信息
     * @return
     */
    public static String createToken(String userId, JwtParam jwtParam) {
        return createToken(userId, null, jwtParam);
    }

    /**
     * 生成token, 只在用户登录成功以后调用
     * @param userId 用户id
     * @param claim 声明
     * @param jwtParam JWT加密所需信息
     * @return
     */
    public static String createToken(String userId, Map<String, Object> claim, JwtParam jwtParam) {
        try {
            // 使用HS256加密算法
            SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

            long nowMillis = System.currentTimeMillis();
            Date now = new Date(nowMillis);

            // 生成签名密钥
            byte[] apiKeySecretBytes = 
            			DatatypeConverter.parseBase64Binary(jwtParam.getBase64Secret());
            SecretKeySpec signingKey = 
            			new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());

            // 添加构成JWT的参数
            JwtBuilder jwtBuilder = Jwts.builder().setHeaderParam("typ", "JWT")
                    .claim(JwtConstant.USER_ID_KEY, userId)
                    .addClaims(claim)
                    .setIssuer(jwtParam.getName())
                    .setIssuedAt(now)
                    .signWith(signatureAlgorithm, signingKey);

            // 添加token过期时间
            long TTLMillis = jwtParam.getJwtExpires() * 60 * 1000;
            if (TTLMillis >= 0) {
                long expMillis = nowMillis + TTLMillis;
                Date exp = new Date(expMillis);
                jwtBuilder.setExpiration(exp).setNotBefore(now);
            }

            return jwtBuilder.compact();
        } catch (Exception e) {
            // TODO 这里自行抛出异常
            log.error("签名失败", e);
            return null;
        }
    }

    /**
     * 解析token
     * @param authToken 授权头部信息
     * @param base64Secret base64加密密钥
     * @return
     */
    public static Claims parseToken(String authToken, String base64Secret) {
        try{
            Claims claims = Jwts.parser()
                    .setSigningKey(DatatypeConverter.parseBase64Binary(base64Secret))
                    .parseClaimsJws(authToken).getBody();
            return claims;
        } catch (SignatureException se) {
            // TODO 这里自行抛出异常
            log.error("===== 密钥不匹配 =====", se);
        } catch (ExpiredJwtException ejw) {
            // TODO 这里自行抛出异常
            log.error("===== token过期 =====", ejw);
        } catch (Exception e){
            // TODO 这里自行抛出异常
            log.error("===== token解析异常 =====", e);
        }
        return null;
    }
}

8.编写登录验证Controller

/**
 * 登录验证Controller
 * Created by Hilox on 2018/11/16 0016.
 */
@Slf4j
@RestController
public class LoginController {

    @Autowired
    private JwtParam jwtParam;

    // 登录
    @PostMapping("/login")
    @JwtIgnore // 加此注解, 请求不做token验证
    public String login() {
        // 1.用户密码验证我这里忽略, 假设用户验证成功, 取得用户id为5
        Integer userId = 5;
        // 2.验证通过生成token
        String token = JwtUtils.createToken(userId + "", jwtParam);
        if (token == null) {
            log.error("===== 用户签名失败 =====");
            return null;
        }
        log.info("===== 用户{}生成签名{} =====", userId, token);
        return JwtUtils.getAuthorizationHeader(token);
    }

    // 验证
    @PostMapping("/hilox")
    public String hilox() {
        return "Hello World!";
    }
}

源码传送门

【源码地址】：springboot-jwt

JWT代码测试效果

启动以上项目，博主这里使用工具Postman来模拟http请求。

1.未登录情况请求测试接口/hilox




图4 未登录情况请求测试接口效果图

2.请求登录接口/login




图5 请求登录接口效果图

3.登录情况请求测试接口/hilox

这里我们需要将请求登录接口时返回的token放入请求头的Authorization当中。



图6 登录情况请求测试接口效果图

黑豪Horace
关注
专栏目录
springboot集成JWT
weixin_50622066的博客
05-11 868
springboot集成JWT，jwt的简单使用
SpringBoot集成JWT实现用户注册、登录、鉴权功能
没有梦想何必远方#
01-09 1094
【代码】SpringBoot集成JWT实现用户注册、登录、鉴权功能。
SpringBoot使用JWT详解
最新发布
qq_41765777的博客
08-13 1251
son web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准.该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。
springboot 集成JWT
weixin_55384994的博客
03-13 265
jwt的请求流程 用户使用账号和面发出post请求； 服务器使用私钥创建一个jwt； 服务器返回这个jwt给浏览器； 浏览器将该jwt串在请求头中像服务器发送请求； 服务器验证该jwt； 返回响应的资源给浏览器。 优点 简洁(Compact):可以通过URL，POST参数或者在HTTP header发送，因为数据量小，传输速度也很快 自包含(Self-contained)：负载中包含了所有用户所需要的信息，避免了多次查询数据库 因为Token是以JSON加密的形式保存在客户端的，所以J..
史上最全面的基于JWT token登陆验证
SuperBins的博客
07-18 3568
介绍JWT 1、什么是JWT：JWT（Json web token）, 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519)。 2、JWT的组成： jwt由header（头部），playload（载荷）、signature（签名三部分组成） 头部部分header { “alg”: “HS256”, “typ”: “JWT” } alg描述的是签名算法。默认值是HS...
Spring Boot 集成 JWT
欲变世界，先变其身
09-24 562
JSON Web Token（JWT）是一个开放标准（RFC 7519），它定义了一种紧凑且独立的方式，用于在各方之间作为JSON对象安全地传输信息。因为数字签名的存在，这些信息是可信的，JWT可以使用HMAC算法或者是RSA的公私钥对进行签名。
springboot集成jwt
qq_43653436的博客
10-08 473
jwt
SpringBoot集成JWT实现token验证的流程
10-15
标题中的“SpringBoot集成JWT实现token验证的流程”是指在SpringBoot应用中使用JWT（Json Web Token）技术来实现用户身份验证的过程。JWT是一种开放标准（RFC 7519），它定义了一种紧凑的、自包含的方式来安全地在各...
SpringBoot集成JWT实现简单登录Demo认证
m0_55527867的博客
07-12 440
一. JWT简介 1. 什么是JWT？ JWT(JSONWeb Token)是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准。 它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证token的正确性，只要正确即通过验证；应用场景如用户登录。JWT详细讲解请见 github：https://github.com/jwtk/jjwt 2. 为什么使用JWT？ 随着技术的发展，分布式web应用的普及，通过session管理用户登录状态成本越来越高，因此.
SpringBoot 集成 JWT
wguo-up-site
03-30 1930
1. Jwt消息构成 1.1 组成 一个token 分为3 部分 头部（header） 载荷 （payload） 签证 （signature） 三部分之间用 . 号作为分隔 如： eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ
springboot整合jwt
letterss的博客
01-18 576
简介 Jwt全称是：json web token。它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证token的正确性，只要正确即通过验证。 优点 简洁: 可以通过URL、POST参数或者在HTTP header发送，因为数据量小，传输速度也很快； 自包含：负载中可以包含用户所需要的信息，避免了多次查询数据库； 因为Token是以JSON加密的形式保存...
SpringBoot集成JWT
SHENG_Z的博客
06-06 549
介绍SpringBoot集成JWT步骤及注意事项，干货满满
Springboot集成JWT
justleavel的博客
04-10 980
1：首先导入依赖： <!--JWT工具--> <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.10.3</version> </dependency> 2
SpringBoot：集成JWT
no1xiaoqianqian的博客
09-29 649
SpringBoot：集成JWT
SpringBoot整合JWT
m0_71467744的博客
04-17 2182
JWT 就是上述痛点的解决方案之一，客户端在请求服务端进行登录操作时，服务端验证用户的账号和密码，验证成功后生成 token 返回给客户端，之后浏览器的每一次操作都会在请求头中带上这个 token，服务器会验证该 token 信息，验证成功后才会返回资源给浏览器。JWT 的开销非常小，可以轻松在不同的域名中传递，所以在单点登录（SSO）中用到比较广泛，信息交换在通信的双方之间使用JWT对数据进行编码是一种非常安全的方式，由于它的信息是经过签名的，可以确保发送者发送的信息是没有经过伪造的。
SpringBoot集成jwt实现token认证
05-28
在Spring Boot中，可以使用以下步骤将JWT集成到应用程序中以实现token认证： 1. 添加依赖项 在pom.xml文件中添加以下依赖项： ``` <groupId>io.jsonwebtoken <artifactId>jjwt <version>0.9.1 ``` 2. 创建...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值