SpringBoot项目基于JWT网络信息传输标准实现单点登录案例以及与传统Session认证的优缺点分析

最新推荐文章于 2022-06-06 17:33:47 发布

置顶 NotFoundObject.

最新推荐文章于 2022-06-06 17:33:47 发布

阅读量298

点赞数 1

分类专栏： SpringBoot JWT 文章标签： java jwt

本文链接：https://blog.csdn.net/weixin_45973634/article/details/105573395

版权

SpringBoot 同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

JWT

1 篇文章 0 订阅

订阅专栏

               ***SpringBoot项目中基于JWT实现单点登录案例***

JWT是什么？
Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。具体文字叙述请参考相关博文，此篇注重于应用。
为什么使用JWT,它与传统的Session认证有什么区别？
我们知道，http协议本身是一种无状态的协议，而这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证，那么下一次请求时，用户还要再一次进行用户认证才行，因为根据http协议，我们并不能知道是哪个用户发出的请求，所以为了让我们的应用能识别是哪个用户发出的请求，我们只能在服务器存储一份用户登录的信息，这份登录信息会在响应时传递给浏览器，告诉其保存为cookie,以便下次请求时发送给我们的应用，这样我们的应用就能识别请求来自哪个用户了,这就是传统的基于session认证。但是这种基于session的认证使应用本身很难得到扩展，随着不同客户端用户的增加，独立的服务器已无法承载更多的用户，而这时候基于session认证应用的问题就会暴露出来.
基于session认证所显露的问题，Session: 每个用户经过我们的应用认证之后，我们的应用都要在服务端做一次记录，以方便用户下次请求的鉴别，通常而言session都是保存在内存中，而随着认证用户的增多，服务端的开销会明显增大。扩展性: 用户认证之后，服务端做认证记录，如果认证的记录被保存在内存中的话，这意味着用户下次请求还必须要请求在这台服务器上,这样才能拿到授权的资源，这样在分布式的应用上，相应的限制了负载均衡器的能力。这也意味着限制了应用的扩展能力。CSRF: 因为是基于cookie来进行用户识别的, cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。
基于token的鉴权机制
基于token的鉴权机制类似于http协议也是无状态的，它不需要在服务端去保留用户的认证信息或者会话信息。这就意味着基于token认证机制的应用不需要去考虑用户在哪一台服务器登录了，这就为应用的扩展提供了便利。
流程上是这样的：
a.用户使用用户名密码来请求服务器。
b.服务器进行验证用户的信息。
c.服务器通过验证发送给用户一个token。
d.客户端存储token，并在每次请求时附送上这个token值。
e.服务端验证token值，并返回数据。
这个token必须要在每次请求时传递给服务端，它应该保存在请求头里，另外，服务端要支持CORS(跨来源资源共享)策略，一般我们在服务端这么做就可以了。
实例：
1、导入POM文件

 <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.7.0</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>

        </dependency>
        <!--JWT-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.4.0</version>
        </dependency>

2、封装JWT工具类

package com.ss.jwt.utils;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @version V1.0
 * @Package com.ss.jwt.utils
 * @author: Liu
 * @Date: 14:59
 */
public class JwtUtils {
    /*设置密钥*/
    static final String SECRET = "ThisIsASecret";

    /*生成Token方法
     * */
    public static String generateToken(String username) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("username", username);
        /*设置令牌的有效时间
         * 令牌的加密*/
        String jwt = Jwts.builder()
                .setClaims(map)/*声明JWT*/
                /*JWT的第二部分payload，其中包含claims。claims是关于实体（常用的是用户信息）和其他数据的声明，
                claims有三种类型： registered, public, and private claims。*/
                .setExpiration(new Date(System.currentTimeMillis() + 3600_000_000L))/*设置过期时间为当前时间+10小时*/
                .signWith(SignatureAlgorithm.HS512, SECRET)/*设置签约算法*/
                .compact();
                System.out.println(jwt+"生成的");
        return "Bearer" + jwt;/*Bearer代表Authorization头定义的schema.官方规范*/
    }

    /*验证JWT中Token值
     * */
    public static void validateToken(String token) {
        try {
            Map<String, Object> body = Jwts.parser()/*JWTs底层方法，用来分析解构JWT*/
                    .setSigningKey(SECRET)/*配对密钥，parser接口的方法*/
                    .parseClaimsJws(token.replace("Bearer", ""))/*先替换掉Token中头部的Bearer,再解构TOKEN中声明实体的信息*/
                    .getBody();/*取出*/

        } catch (Exception e) {
            throw new IllegalStateException("Invalid Token. " + e.getMessage());
        }


    }

}

3、做一个拦截器，用来拦截请求，验证令牌。

package com.ss.jwt.config;

import com.ss.jwt.utils.JwtUtils;
import org.apache.catalina.connector.Request;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.PathMatcher;
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;

/**
 * @version V1.0
 * @Package com.ss.jwt.config
 * @author: Liu
 * @Date: 15:26
 */
/*拦截过滤器、当客户端发起请求，需要拦截处理请求信息，验证是否有授权信息的请求，验证授权信息的合法性*/
public class JwtAuthenticationFilter extends OncePerRequestFilter {
        /*创建一个预期路径适配器*/
    private static final PathMatcher pathMatcher = new AntPathMatcher();/*预期路径*/

         /*判断头部请求API是否合法，Login不需要身份验证*/
    private boolean isProtectedUrl(HttpServletRequest request) {
        /*请求路径是否与预期路径一致*/
        boolean matches = pathMatcher.match("/api/**", request.getServletPath());
        return matches;
    }
    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
        /*验证JWT令牌token是否合法或者过期，不合法直接抛出异常返回。*/
        try {
            if (isProtectedUrl(httpServletRequest)) {
                /*取出请求体中头部中授权签证信息，即基于JWt规范的Token*/
                String token = httpServletRequest.getHeader("Authorization");
                System.out.println(token);
               /*通过JWT工具类中验证Token信息*/
                JwtUtils.validateToken(token);
            }
        } catch (Exception e) {
            /*抛出未经授权请求的异常*/
            httpServletResponse.sendError(HttpServletResponse.SC_UNAUTHORIZED, e.getMessage());
        }
        /*验证合法的JWT令牌，就将request传递给后面的RestFul API，继续执行任务*/
        filterChain.doFilter(httpServletRequest, httpServletResponse);
    }
}

4、Controller层登陆业务

  @PostMapping("/login")
    public Object login(HttpServletResponse httpServletResponse, @RequestBody final User user) throws IOException {
        if (isValidUser(user)) {
            /*如果登陆用户信息 合法，用当前用户信息生成JWt规范的token*/
            String jwt = JwtUtils.generateToken(user.getUsername());
            /*  System.out.println("测试成功");*/
            //将生成的token返回客户端
            return new HashMap<String, String>() {{
                put("token", jwt);
            }};
        } else {
            /*如果用户信息不合法，返回自定义异常：用户信息错误状态码*/
            throw new StudentException(Renum.USER_NOT_EXIST);
        }
    }
     /*模拟判断登陆用户信息合法性*/
    private boolean isValidUser(User user) {
        boolean b = "admin".equals(user.getUsername()) && "admin".equals(user.getPassword());
        return b;
    }

5、controller测试接口

 /*模拟登陆后测试*/
    @GetMapping("/api/protected")
    public @ResponseBody
    Object hellWorld() {
        return "Hello World! This is a   api";
    }

6、用来测试的登陆页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>JWT Spring Security Demo</title>

    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">

    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap-theme.min.css">
    <script src="https://code.jquery.com/jquery-2.2.2.js"></script>





    <script>
        $.ajaxSetup({
            contentType: "application/json; charset=utf-8"
        });
        var token = "";
        $(document).ready(function(){
            $("#btn-login").click(function(){
                var data = {username: $("#username").val(), password: $("#password").val()};
                $.ajax({
                    url: '/login',
                    method: 'POST',
                    data:JSON.stringify(data)
                }).always(function(data, status, xhr) {
                    if(status == "success"){
                        token = data.token;
                        $("#login").hide();
                        $("#logout").show();
                        $("#notLoggedIn").hide();
                        $("#loggedIn").show();
                    }else{
                        $("#response").text(JSON.stringify(data, null, 4));
                    }
                });
            });


            $("#btn-logout").click(function(){
                token = "";
                $("#login").show();
                $("#logout").hide();
                $("#notLoggedIn").show();
                $("#loggedIn").hide();
            });

            $("#exampleServiceBtn").click(function(){
                $.ajax({
                    url: '/api/protected',
                    headers: {'Authorization': token},
                    method: 'GET'
                }).always(function(data, status, xhr) {
                    if(data.responseJSON)
                        $("#response").text(JSON.stringify(data.responseJSON, null, 4));
                    else
                        $("#response").text(JSON.stringify(data));
                });
            });
            $("#exampleServiceBtn1").click(function(){
                $.ajax({
                    url: '/api/findById',
                    headers: {'Authorization': token},
                    method: 'GET'
                }).always(function(data, status, xhr) {
                    if(data.responseJSON)
                        $("#response1").text(JSON.stringify(data.responseJSON, null, 4));
                    else
                        $("#response1").text(JSON.stringify(data));
                });
            });
        });

    </script>
</head>
<body>
<div class="container">
    <h1>Spring Boot JWT Demo</h1>

    <div class="alert alert-danger" style="display:visible" id="notLoggedIn">Not logged in!</div>

    <div class="alert alert-info" style="display:none" id="loggedIn">Logged in</div>

    <div class="row">
        <div class="col-md-6">
            <div class="panel panel-default" id="login">
                <div class="panel-heading">
                    <h3 class="panel-title">Login</h3>
                </div>
                <div class="panel-body">
                    <input type="text" class="form-control" id="username" value="admin"
                           required>
                    <input type="password" class="form-control" id="password" value="admin"
                           required>
                    <button id="btn-login" class="btn btn-default">login</button>
                </div>
            </div>
        </div>

        <div class="col-md-6">
            <button type="button" class="btn btn-default" id="exampleServiceBtn" style="margin-bottom: 16px;">
                call example service
            </button>
            <div class="panel panel-default">
                <div class="panel-heading">
                    <h3 class="panel-title">Response:</h3>
                </div>
                <div class="panel-body">
                    <pre id="response"></pre>
                </div>
            </div>
        </div>
        <div class="col-md-7">
            <button type="button" class="btn btn-default" id="exampleServiceBtn1" style="margin-bottom: 16px;">
                call example service
            </button>
            <div class="panel panel-default">
                <div class="panel-heading">
                    <h3 class="panel-title">Response:</h3>
                </div>
                <div class="panel-body">
                    <pre id="response1"></pre>
                </div>
            </div>
        </div>

        <div class="col-md-6">
        </div>

        <div class="col-md-6">
            <div id="logout" style="display:none">
                <div class="panel panel-default">
                    <div class="panel-heading">
                        <h3 class="panel-title">Authenticated user</h3>
                    </div>
                    <div class="panel-body">
                        <div id="userInfoBody"></div>
                        <button id="btn-logout" type="button" class="btn btn-default">logout</button>
                    </div>
                </div>
            </div>
        </div>
    </div>
</div>
</body>
</html>

总结：JWT是当下分布式大趋势实现单点登录很好的方案。注释尽量多，底层方法我都有看过写的注释。欢迎指正交流。觉得还行，谢谢点赞哈

NotFoundObject.

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringBoot项目基于JWT网络信息传输标准实现单点登录案例以及与传统Session认证的优缺点分析

** SpringBoot项目中基于JWT实现单点登录案例**JWT是什么？Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份...
复制链接

扫一扫