Json Web Token介绍与基本使用

最新推荐文章于 2024-09-23 09:00:00 发布
最新推荐文章于 2024-09-23 09:00:00 发布
阅读量8.6k 收藏 57
点赞数 10
分类专栏： # Java Web 文章标签： jwt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuanlaijike/article/details/80174327
版权

一、Session与JWT

1.1 传统Cookie+Session

Cookie+Session的存在主要是为了解决HTTP这一无状态协议下服务器如何识别用户的问题。

其原理就是在用户登录通过验证后，服务端将数据加密后存储在服务器Session中，同时服务器将Session的标识即SessionId存放在客户端Cookie中。

用户之后发起的请求都会携带Cookie信息，服务器根据SessionId寻回对应的Session，从而完成验证，确认这是之前登陆过的用户。其工作原理如下图所示：

1.2 JWT技术

JWT，即JSON Web Token，当用户使用它的认证信息登陆系统之后，会返回给用户一个JWT，用户只需要本地保存即可。

当用户希望访问一个受保护的路由或者资源的时候，在请求头部添加该JWT。后台获取请求头部的JWT并进行验证，如果合法，则允许用户的行为。

二、JWT的组成

一个JWT实际上就是一个字符串，它由三部分组成：头部、载荷(Payload)与签名。

2.1 头部

头部用于描述关于该JWT的最基本的信息，例如其类型以及签名所用的算法等。这也可以被表示成一个JSON对象。

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

注：指明了这是一个JWT，并且我们所用的签名算法（后面会提到）是HS256算法。

对JSON串进行Base64编码，得到了JWT的Header（头部）。

2.2 载荷

JWT主体内容主要包含以下三种类型：

  1. Reserved（保留声明），它的含义就像是编程语言的保留字一样，属于JWT规范中规定好的，这类声明不是必须的，但是是建议使用的。有以下几种：

  • iss: JWT的签发者

  • sub: 该JWT所面向的用户

  • aud:JWT的接收方

  • exp(expires): 过期时间，这里是一个Unix时间戳

  • iat(issued at): 签发时间，这里是一个Unix时间戳

  1. Public （公共声明）：这类声明需要在 IANA JSON Web Token Registry 中定义或者提供一个URI，因为要避免重名等冲突。

  2. Private（私有声明）：根据业务需要自己定义的数据了

例如下面这个JSON串，最后一项user_id就是我自定义的数据：

{
	"iss": "Jitwxs",
	"iat": 1441593502,
	"exp": 1441594722,
	"aud": "www.example.com",
	"sub": "wxs@example.com",
	"user_id":"10001"
}

对上面的JSON串进行Base64编码，得到了JWT的载荷

2.3 签名

将上面的两个编码后的字符串都用句号 .连接在一起（头部在前），形如：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJmcm9tX3VzZXIiOiJCIiwidGFyZ2V0X3VzZXIiOiJBIn0

最后，我们将上面拼接完的字符串用HS256算法进行加密。

在加密的时候，我们还需要提供一个密钥（secret）。如果我们用 mySecret作为密钥的话，那么得到结构如下：

rSWamyAYwuHCo7IFAgd1oRpSP7nzL7BF5t7ItqpKViM

这就是签名。

最后将这一部分签名也拼接在被签名的字符串后面，我们就得到了完整的JWT，形如：

我们就可以将这个传递给客户端了。

三、JWT在客户端的存储

3.1 HTML5 Web Storage

Web存储就是使用localStorage或sessionStorage进行存储，许多人使用这种方式存储，是因为能够防止CSRF(跨站请求伪造)。但是使用Web存储，反而会增加XSS(跨站脚本攻击)的风险。

XSS，简而言之是一种漏洞，攻击者可以注入在页面上运行的JavaScript。为了防止XSS，常见的反应是转义和编码所有不可信的数据。但是只要有一个漏洞存在，那么整个防护体系就完全失效。如果你使用的第三方脚本被攻击，你的Web存储仍然会收受到威胁。

3.2 Cookies

3.2.1 CSRF

CSRF(跨站请求伪造)是一种典型的利用cookie-session漏洞的攻击。

假设你经常使用bank.example.com进行网上转账，在你提交转账请求时bank.example.com的前端代码会提交一个HTTP请求:

POST /transfer HTTP/1.1
Host: bank.example.com
cookie: JsessionID=randomid; Domain=bank.example.com; Secure; HttpOnly
Content-Type: application/x-www-form-urlencoded

amount=100.00&routingNumber=1234&account=9876

你图方便没有登出bank.example.com，随后又访问了一个恶意网站，该网站的HTML页面包含了这样一个表单：

<form action="https://bank.example.com/transfer" method="post">
    <input type="hidden" name="amount" value="100.00"/>
    <input type="hidden" name="routingNumber" value="evilsRoutingNumber"/>
    <input type="hidden" name="account" value="evilsAccountNumber"/>
    <input type="submit" value="点击就送!"/>
</form>

你被“点击就送”吸引了，当你点了提交按钮时你已经向攻击者的账号转了100元。

现实中的攻击可能更隐蔽，恶意网站的页面可能使用Javascript自动完成提交。尽管恶意网站没有办法盗取你的session cookie（从而假冒你的身份），但恶意网站向bank.example.com发起请求时，你的cookie会被自动发送过去。

很多人用JWT+Web存储的本心是为了防护CRSF。这样做的原因是——因为Cookie的发送是完全由浏览器控制的，不受网页本身的控制。所以最简单直接的办法，就是不用Cookie，不让自动发送认证信息成为可能。问题在于，这么干是有XSS风险的。那么怎么在使用Cookie的同时，还能防范CSRF呢？

3.2.1 CSRF的防护
3.2.1.1 传统页面网站

在传统页面Web网站中，一般会使用CSRF Token。这是个非常流行的做法。像Tomcat这类的容器都会自带CSRF Token的产生和检查Filter。

CSRF Token是这样工作的。客户端要首先向服务器请求一个带有提交表单的页面，服务器返回的页面中会嵌入一个CSRF Token。当用户提交表单时，CSRF Token会被一起携带发给服务器做验证。所以当服务器看到CSRF Token，就可以放心大胆的确认用户的的确确是看看到了提交前的表单界面，从而避免了用户稀里糊涂提交一个被伪造的表单的可能性。

3.2.1.2 SPA应用

在SPA中，客户端与服务器之间的交互主要是通过接口完成的，没有页面的概念。此时，你的确可以照猫画虎的做一个接口让用户拿到CSRF Token，但这样什么也确认不了。因为攻击者可以调用同样的接口，拿到合法的CSRF Token。

这时有几种办法：

  1. 给所有接口都添加一个请求secret，来标记其来自于合法的客户端。这个secrect可以是固定的随机字符串，也可以通过某些动态算法产生。对于CSRF，浏览器只会做自动传Cookie而已，并不能帮助传入secret。这样一来，就可以确定消除CSRF的风险。但注意，这个机制仅能防范CSRF，而不能防范人为的攻击。黑客只要拿得到客户端，就一定能找到生成secret的办法。

  2. 用Same-Site Cookie。当用户看到了B站点伪造的表单，点击了提交，向站点A发出请求时，被标记了Same-Site=strict的Cookie是不会被携带的，因为当时的主站点域名B和提交的站点域名A不一样。这是Same-Site=strict标记是个相对较新的标准。目前大部分浏览器都已经支持了。

  3. 总是用JSON格式提交。CSRF可能发生的一个前提条件是必须用传统表单提交。这是因为传统表单提交可以跨域——你在站点B，可以提交表单给站点A。而Ajax的请求除非开启CORS，是不允许跨域的，所以天然的屏蔽掉了这个问题。传统表单的提交的格式必然是application/x-www-form-urlencoded。因此只要保证服务器能够拒绝处理所有这种格式的POST请求，就能确保SPA不受CSRF的影响。

四、 JWT的优缺点与适用场景

4.1 优点

  1. 无状态。Token机制在服务端不需要存储session信息，因为Token 自身包含了所有登录用户的信息，只需要在客户端的cookie或本地介质存储状态信息.

  2. 去耦。不需要绑定到一个特定的身份验证方案。Token可以在任何地方生成，只要在你的API被调用的时候，你可以进行Token生成调用即可.

  3. 更适用于移动应用。 当你的客户端是一个原生平台时，Cookie是不被支持的（你需要通过Cookie容器进行处理），这时采用Token认证机制就会简单得多。

  4. CSRF。因为不再依赖于Cookie，所以你就不需要考虑对CSRF的防范，但需要防范XSS。

4.2 缺点

  1. 占用太多空间。上面提到 JWT存储在Web存储中会导致XSS攻击，那就只能存储在 Cookie 里了。但是，Cookie 的存储容量是有限制的（通常为 4 KB）。而JWT 占用的空间又不是那么小，尤其是在使用无状态 JWT 时，所有的数据都被放到 JWT 里，数据大小很快就会超过 Cookie 的容量限制。

  2. **无法完全掌控JWT。**使用了JWT，无法实现在服务器端对用户请求进行管理——管理员没法统计多少个人登录了，一个人登录了多少次，登陆了什么设备；同时，也无法强行“踢”掉一个用户的登录——JWT一旦生成，在失效之前，总是有效的。如果实现了一个token黑名单之类的功能，就等价于实现了Session机制，无状态带来的好处就无从谈起。这个限制对于任何一个要认真做用户风险控制的网站来说都是不可能接受的。

  3. 数据实效性差。 JWT 一旦被生成，就不会再和服务端有任何瓜葛，一旦服务端中的相关数据更新，JWT 中存储的数据由于得不到更新，就变成了过期的数据。

以上这些缺点都只针对无状态 JWT。如果使用有状态 JWT（JWT 中存储认证授权信息的 ID，具体数据存储在服务端），就可以规避这些缺点。不过，有状态 JWT 基本上等同于 Session / Cookie，没有存在价值。

4.3 适用场景

JWT 的最佳用途是「一次性授权 Token」，这种场景下的 Token 的特性如下：

  • 有效期短

  • 只希望被使用一次

例如使用邮箱注册时，需要发一封注册邮件进行验证，只需验证一次，并且超过一定时间后失效。

五、提高安全性

5.1 使用https

http是明文传输的。在http下，用户输入的任何信息，从他的电脑到服务器之间的每个链路节点都是明文的。在这里个链路中的任何地方，都可以截取到完整的数据，包含你的密码，认证token……

这就是为什么https是必须的。https主要提供三个保证：

  • 端端加密。通过https交互的原始数据，只有用户的浏览器和最终的服务器可以看到。其他中间节点无法获）。

  • 客户端可以认定要访问的服务器就是那个服务器。这是被证书体系所支撑的。一旦浏览器的地址栏出现了网址的证书信息，并且是绿色的提示，那么用户的心里就可以稳了。（当然国内其实也不完全是这样，讲多了查水表，懂者自懂）。

  • 服务器可以认定访问的客户端就是合法的客户端。这种模式被称为“2-Way SSL”或者“Mutal SSL”。这种模式是可选的，需要多配置一个客户端证书，一般场景用不到，多见于企业Web服务。

使用了https后，为了进一步保证安全，将Cookie设置为Secure。这样，浏览器就可以只在访问https网址时才会携带Cookie。如果不做这样的设置，通过https站点设置的Cookie，仍然会向http站点发送。当这个站点的域名解析被劫持，就可能造成向一个伪造的服务器发出你的认证信息。

5.2 认证信息不应该永久有效

很多人为了“用户体验”，选择让一个登录永久有效。这样做是非常危险的。因为一旦用户的认证信息被别人获取了，就永久性的失去了防御的机会。

因此，总是要保证认证信息的有效期是有限的。一般根据业务场景的安全级别不同，可以设为若干分钟～若干天。就算是社交娱乐类的应用，有效期最好也不要超过两周。

5.3 设计安全的secret

JWT唯一存储在服务端的只有一个 secret，个人认为这个 secret 应该设计成和用户相关的，而不是一个所有用户公用的统一值。这样可以有效的提高安全性。

例如用户修改密码时，需要重新生成jwt，密码就需要和secret存在一定的联系。

六、总结

注意：这里的总结是在Web开发中

  1. 可以使用Session也可以使用Token做认证，但是总是要保证服务器端可以管理Session，通过Session是否存在来最终确定认证的有效性

  2. 将认证信息存放在标记为HttpOnly，Secure，Same-Site=strict的Cookie中，从而避免XSS和CSRF

  3. 如果是传统的页面网站，请使用CSRF Token机制

  4. 总是使用https，只要你的网络链路经过了公网

  5. 保证token/session 必须有一个有效期

  6. 不要用 JWT 来做 Web 应用的会话管理，请用 Session / Cookie

七、示例程序

源码地址：https://github.com/jitwxs/blog_sample

7.1 HelloWorld

光说不练假把式，下面只用三步来实现一个JWT的HelloWorld程序（注意我是在SpringBoot的环境下）。

导入JJWT包简化操作：

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

第一步：JWT工具类，直接使用即可

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

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

/**
 * JWT工具类
 * @author jitwxs
 * @since 2018/5/2 18:49
 */
public class JwtUtils {
    // 签名密钥（高度保密）
    private static final String SECRET = "qYYjXt7s1C*nEC%9RCwQGFA$YwPr$Jrj";
    // 签名算法
    private static final SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS512;
    // token前缀
    private static final String TOKEN_PREFIX = "Bearer ";

    /**
     * 生成JWT token
     * @param map 传入数据
     * @param maxAge 有效期（单位：ms）
     * @author jitwxs
     * @since 2018/5/3 23:19
     */
    public static String sign(Map<String,Object> map, long maxAge) {
        return sign(map, null, null, maxAge);
    }

    /**
     * 生成JWT token
     * @param map 传入数据
     * @param issuer 签发者
     * @param subject 面向用户
     * @param maxAge 有效期（单位：ms）
     * @author jitwxs
     * @since 2018/5/3 23:19
     */
    public static String sign(Map<String,Object> map, String issuer, String subject, long maxAge) {
        Date now  = new Date(System.currentTimeMillis());
        String jwt = Jwts.builder()
                .setClaims(map) // 设置自定义数据
                .setIssuedAt(now) // 设置签发时间
                .setExpiration(new Date(now.getTime() + maxAge)) // 设置过期时间
                .setIssuer(issuer) // 设置签发者
                .setSubject(subject) // 设置面向用户
                .signWith(signatureAlgorithm, SECRET)
                .compact();
        return TOKEN_PREFIX + jwt;
    }

    /**
     * 验证JWT token并返回数据。当验证失败时，抛出异常
     * @author jitwxs
     * @since 2018/5/3 23:20
     */
    public static Map unSign(String token) {
        try {
            return Jwts.parser()
                    .setSigningKey(SECRET)
                    .parseClaimsJws(token.replace(TOKEN_PREFIX,""))
                    .getBody();
        }catch (Exception e){
            throw new IllegalStateException("Token验证失败："+e.getMessage());
        }
    }

    public static void main(String[] args) {
        Map<String,Object> map = new HashMap<>();
        map.put("userName","admin");
        map.put("userId","001");

        String token = JwtUtils.sign(map, 3600_000);
//        String token = JwtUtils.sign(map, "jitwxs","普通用户",3600_000);
        System.out.println(JwtUtils.unSign(token));
    }
}

第二步：Controller类

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestAttribute;
import org.springframework.web.bind.annotation.RestController;

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

/**
 * @author jitwxs
 * @date 2018/5/2 21:03
 */
@RestController
public class SystemController {
    private final String USER_NAME_KEY = "USER_NAME";
    private final Long EXP_IMT = 3600_000L;

    @GetMapping("/api/test")
    public Object hellWorld(@RequestAttribute(value = USER_NAME_KEY)  String username) {
        return "Welcome! Your USER_NAME : " + username;
    }

    @PostMapping("/login")
    public Object login(String name, String password) {
        if(isValidPassword(name,password)) {
            // 将用户名传入并生成jwt
            Map<String,Object> map = new HashMap<>();
            map.put(USER_NAME_KEY, name);
            String jwt = JwtUtils.sign(map, EXP_IMT);

            // 将jwt返回给客户端
            return new HashMap<String,String>(){{
                put("token", jwt);
            }};
        }else {
            return new ResponseEntity(HttpStatus.UNAUTHORIZED);
        }
    }

    /**
     * 验证密码是否正确，模拟
     */
    private boolean isValidPassword(String name, String password) {
        return "admin".equals(name) && "admin".equals(password);
    }
}

主要就两个方法，一个用于登陆，一个用于测试JWT。

第三步：Filter类并在启动类中注册

import org.springframework.stereotype.Component;
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.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

/**
 * JWT过滤器
 * @author jitwxs
 * @date 2018/5/2 20:43
 */
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    private final String USER_NAME_KEY = "USER_NAME";

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        try {
            // 从用户请求头中取token，key一般为Authorization
            String token = request.getHeader("Authorization");
            Map map = JwtUtils.unSign(token);
            // 将用户名存入request属性
            request.setAttribute(USER_NAME_KEY, map.get(USER_NAME_KEY));
        } catch (Exception e) {
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, e.getMessage());
            return;
        }

        filterChain.doFilter(request, response);
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Application {

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

    @Bean
    public FilterRegistrationBean jwtAuthenticationFilterRegister() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        //注入过滤器
        registration.setFilter(new JwtAuthenticationFilter());
        //拦截规则
        registration.addUrlPatterns("/api/*");
        //过滤器名称
        registration.setName("jwtAuthenticationFilter");
        return registration;
    }
}

到此结束！也许你有点迷糊，我来解释下：

  1. 在Controller的login方法中，如果用户登陆成功，将会返回一个jwt token给用户，在这个token中，存放了用户的名称。
  2. 用户访问api/test，该url会被过滤器所拦截，在过滤器中，会取出jwt token并验证，如果验证失败（不存在或错误），抛出异常；如果验证成功，取出用户的名称并放入request的attribute中。
  3. 如果通过了过滤器，在api/test中，取出request attribute中的用户名称并输出。

是不是很简单，让我们运行下程序：

（1）当我们未携带或携带错误的jwt token访问/api/test时，抛出异常：
未携带JWT

（2）当我们成功登录后，返回jwt token：
登陆成功

（3）重新访问jwt token，并在请求头中携带jwt token：
携带JWT

7.2 与Spring Security结合

本节将带你体验下JWT 和 Spring Security 结合的实际应用。如果你还不了解Spring Security，可以参考我的《SpringBoot集成Spring Security》系列文章，从SpringBoot集成Spring Security（1）——入门程序看起。

首先我们先整理下思路，我们的程序对外提供一些api服务，使用这些服务用户需要验证身份，且根据用户的身份，只允许用户访问部分资源，使用到的技术为Spring Security + JWT。

有了思路，我们来想一下流程，Spring Security本身可以帮助我们鉴别用户身份和权限，那么流程大概如下：

  1. 用户登录，如果登录失败，返回错误信息；如果登录成功，返回一个JWT token给用户。
  2. 如果用户登录成功，用户携带着JWT token访问api服务，如果用户身份允许，则返回api结果；否则不允许获取。

为了实现这个流程，我们需要自定义两个过滤器，作用如下：

  • 过滤器1：当用户登录成功后，将JWT token 返回给用户

  • 过滤器2：当用户访问api服务验证时，验证携带的token

思路理的差不多了，下面开始实践吧！

7.2.1 准备数据库

数据库为Spring Security常规的三张表，即用户表、权限表、用户权限表。

CREATE TABLE `sys_role`  (
  `id` int(11) NOT NULL,
  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

INSERT INTO `sys_role` VALUES (1, 'ROLE_ADMIN');
INSERT INTO `sys_role` VALUES (2, 'ROLE_USER');

CREATE TABLE `sys_user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

INSERT INTO `sys_user` VALUES (1, 'admin', '123');
INSERT INTO `sys_user` VALUES (2, 'jitwxs', '123');

DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role`  (
  `user_id` int(11) NOT NULL,
  `role_id` int(11) NOT NULL,
  PRIMARY KEY (`user_id`, `role_id`) USING BTREE,
  INDEX `fk_role_id`(`role_id`) USING BTREE,
  CONSTRAINT `fk_role_id` FOREIGN KEY (`role_id`) REFERENCES `sys_role` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
  CONSTRAINT `fk_user_id` FOREIGN KEY (`user_id`) REFERENCES `sys_user` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

INSERT INTO `sys_user_role` VALUES (1, 1);
INSERT INTO `sys_user_role` VALUES (2, 2);

在配置文件中添加数据库信息：

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf-8&useSSL=true
spring.datasource.username=root
spring.datasource.password=root

mybatis.configuration.map-underscore-to-camel-case=true
7.2.2 导入依赖、准备实体、Mapper、Service

使用到的依赖包如下，主要就是spring security、mybatis和jjwt：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>

    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.1</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.7</version>
    </dependency>

    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.0</version>
    </dependency>
</dependencies>

（1）实体

public class SysUser implements Serializable{
    static final long serialVersionUID = 1L;

    private Integer id;

    private String username;

    private String password;

   // 省略getter/setter
}

public class SysRole implements Serializable {
    static final long serialVersionUID = 1L;

    private Integer id;

    private String name;

    // 省略getter/setter
}

public class SysUserRole implements Serializable {
    static final long serialVersionUID = 1L;

    private Integer userId;

    private Integer roleId;

    // 省略getter/setter
}

（2）Mapper

@Mapper
public interface SysUserMapper {
    @Select("SELECT * FROM sys_user WHERE id = #{id}")
    SysUser selectById(Integer id);

    @Select("SELECT * FROM sys_user WHERE username = #{username}")
    SysUser selectByUsername(String username);
}

@Mapper
public interface SysRoleMapper {
    @Select("SELECT * FROM sys_role WHERE id = #{id}")
    SysRole selectById(Integer id);
}

@Mapper
public interface SysUserRoleMapper {
    @Select("SELECT * FROM sys_user_role WHERE user_id = #{userId}")
    List<SysUserRole> listByUserId(Integer userId);
}

（3）Service

@Service
public class SysUserService {
    @Autowired
    private SysUserMapper userMapper;

    public SysUser selectById(Integer id) {
        return userMapper.selectById(id);
    }

    public SysUser selectByUsername(String username) {
        return userMapper.selectByUsername(username);
    }
}

@Service
public class SysRoleService {
    @Autowired
    private SysRoleMapper roleMapper;

    public SysRole selectById(Integer id){
        return roleMapper.selectById(id);
    }
}

@Service
public class SysUserRoleService {
    @Autowired
    private SysUserRoleMapper userRoleMapper;

    public List<SysUserRole> listByUserId(Integer userId) {
        return userRoleMapper.listByUserId(userId);
    }
}
7.2.3 编写Controller

Controller中，一个是登录失败的处理，剩下两个模拟api资源，一个需要ROLE_ADMIN身份，一个需要ROLE_USER身份。其中USER_ID_KEY 为从request中取出的值。

@Controller
public class LoginController {
    private final String USER_ID_KEY = "USER_ID";

    @RequestMapping("/login/error")
    @ResponseBody
    public String loginError(HttpServletRequest request, HttpServletResponse response) {
        AuthenticationException exception =
                (AuthenticationException)request.getSession().getAttribute("SPRING_SECURITY_LAST_EXCEPTION");
        return exception.toString();
    }

    @GetMapping("/api/admin")
    @ResponseBody
    @PreAuthorize("hasRole('ROLE_ADMIN')")
    public Object helloAdmin(@RequestAttribute(value = USER_ID_KEY)  Integer userId) {
        return "Welcome Admin! Your USER_ID : " + userId;
    }

    @GetMapping("/api/user")
    @ResponseBody
    @PreAuthorize("hasRole('ROLE_USER')")
    public Object helloUser(@RequestAttribute(value = USER_ID_KEY)  Integer userId) {
        return "Welcome User! Your USER_ID : " + userId;
    }
}
7.2.4 准备工具类

工具类除了上面使用的JwtUtils以外，还要加上一个用于获取Bean的工具类，因为我们要在过滤器中查询用户权限。

/**
 * @author jitwxs
 * @date 2018/3/20 14:22
 */
@Component
public class SpringBeanFactoryUtils implements ApplicationContextAware {
    private static ApplicationContext context = null;

    public static <T> T getBean(Class<T> type) {
        return context.getBean(type);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (SpringBeanFactoryUtils.context == null) {
            SpringBeanFactoryUtils.context = applicationContext;
        }
    }
}
7.2.5 编写登录的过滤器

前面说了那么多无关紧要的，下面开始重点了，现在编写第一个过滤器，用于登录成功后生成JWT token并返回给用户。

import jit.wxs.jwt.entity.SysUser;
import jit.wxs.jwt.service.SysUserService;
import jit.wxs.jwt.utils.JwtUtils;
import jit.wxs.jwt.utils.SpringBeanFactoryUtils;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * 该filter继承自UsernamePasswordAuthenticationFilter
 * 在验证用户名密码正确后，生成一个token，并将token返回给客户端
 * @author jitwxs
 * @since 2018/5/4 10:34
 */
public class JwtLoginFilter extends UsernamePasswordAuthenticationFilter {
    static final String USER_ID_KEY = "USER_ID";

    private AuthenticationManager authenticationManager;

    public JwtLoginFilter(AuthenticationManager authenticationManager) {
        this.authenticationManager = authenticationManager;
    }

    /**
     * 该方法在Spring Security验证前调用
     * 将用户信息从request中取出，并放入authenticationManager中
     * @author jitwxs
     * @since 2018/5/4 10:35
     */
    @Override
    public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse res) throws AuthenticationException {
        try {
            String username = req.getParameter("username");
            String password = req.getParameter("password");

            // 将用户信息放入authenticationManager
            return authenticationManager.authenticate(
                    new UsernamePasswordAuthenticationToken(
                            username,
                            password,
                            Collections.emptyList())
            );
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 该方法在Spring Security验证成功后调用
     * 在这个方法里生成JWT token，并返回给用户
     * @author jitwxs
     * @since 2018/5/4 10:37
     */
    @Override
    protected void successfulAuthentication(HttpServletRequest req, HttpServletResponse res, FilterChain chain, Authentication auth) throws IOException, ServletException {
        String username = ((User)auth.getPrincipal()).getUsername();

	    // 从数据库中取出用户信息
        SysUserService userService = SpringBeanFactoryUtils.getBean(SysUserService.class);
        SysUser user = userService.selectByUsername(username);;

        // 将用户id放入JWT token
        Map<String,Object> map = new HashMap<>();
        map.put(USER_ID_KEY, user.getId());
        String token = JwtUtils.sign(map, 3600_000);

	// 将token放入响应头中
        res.addHeader("Authorization", token);
    }
}
7.2.6 编写验证token的过滤器
  1. 在isProtectedUrl()方法中规定了只拦截/api下的所有请求
  2. 在getAuthentication()方法中验证token，验证失败，返回null；验证成功，返回的对象中包含用户的角色
  3. 在doFilterInternal()中，如果上面返回值为null，则抛出异常；否则将返回对象，也就是用户信息注入到框架中，并放行
import jit.wxs.jwt.entity.SysRole;
import jit.wxs.jwt.entity.SysUserRole;
import jit.wxs.jwt.service.SysRoleService;
import jit.wxs.jwt.service.SysUserRoleService;
import jit.wxs.jwt.utils.JwtUtils;
import jit.wxs.jwt.utils.SpringBeanFactoryUtils;
import org.springframework.security.authentication.AuthenticationCredentialsNotFoundException;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.PathMatcher;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * JWT过滤器
 * 在访问受限URL前，验证JWT token
 * @author jitwxs
 * @since 2018/5/2 20:43
 */
public class JwtAuthenticationFilter extends BasicAuthenticationFilter {
    private static final PathMatcher pathMatcher = new AntPathMatcher();

    static final String USER_ID_KEY = "USER_ID";

    public JwtAuthenticationFilter(AuthenticationManager authenticationManager) {
        super(authenticationManager);
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        if (isProtectedUrl(request)) {
            UsernamePasswordAuthenticationToken authentication = getAuthentication(request);

            // 如果验证失败，设置异常；否则将UsernamePasswordAuthenticationToken注入到框架中
            if (authentication == null) {
                //手动设置异常
                request.getSession().setAttribute("SPRING_SECURITY_LAST_EXCEPTION", new AuthenticationCredentialsNotFoundException("权限认证失败"));
                // 转发到错误Url
                request.getRequestDispatcher("/login/error").forward(request, response);
            } else {
                SecurityContextHolder.getContext().setAuthentication(authentication);
                filterChain.doFilter(request, response);
            }
        }
    }

    /**
     * 验证token
     * @return 成功返回包含角色的UsernamePasswordAuthenticationToken；失败返回null
     */
    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        String token = request.getHeader("Authorization");

        if (token != null) {
            Map map = JwtUtils.unSign(token);

            Integer userId = (Integer) map.get(USER_ID_KEY);
            if (userId != null) {
                // 将用户id放入request中
                request.setAttribute(USER_ID_KEY, userId);

                // 从数据库中获取用户角色
                SysUserRoleService userRoleService = SpringBeanFactoryUtils.getBean(SysUserRoleService.class);
                SysRoleService roleService = SpringBeanFactoryUtils.getBean(SysRoleService.class);
                List<SysUserRole> userRoles = userRoleService.listByUserId(userId);
                for (SysUserRole userRole : userRoles) {
                    SysRole role = roleService.selectById(userRole.getRoleId());
                    authorities.add(new SimpleGrantedAuthority(role.getName()));
                }

                // 这里直接注入角色，因为JWT已经验证了用户合法性，所以principal和credentials直接为null即可
                return new UsernamePasswordAuthenticationToken(null, null, authorities);
            }
            return null;
        }
        return null;
    }

    //只对/api/*下请求拦截
    private boolean isProtectedUrl(HttpServletRequest request) {
        return pathMatcher.match("/api/**", request.getServletPath());
    }
}
7.2.7 注入过滤器

完成了最关键的过滤器，下面只要将这两个过滤器注入到Spring Security中即可。

首先给出CustomUserDetailsService ，这是Spring Security的知识，不再赘述。

@Service("userDetailsService")
public class CustomUserDetailsService implements UserDetailsService {
    @Autowired
    private SysUserService userService;

    @Autowired
    private SysRoleService roleService;

    @Autowired
    private SysUserRoleService userRoleService;

    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        SysUser user = userService.selectByUsername(s);

        // 判断用户是否存在
        if(user == null) {
            throw new UsernameNotFoundException("用户名不存在");
        }

        // 添加权限
        List<SysUserRole> userRoles = userRoleService.listByUserId(user.getId());
        for (SysUserRole userRole : userRoles) {
            SysRole role = roleService.selectById(userRole.getRoleId());
            authorities.add(new SimpleGrantedAuthority(role.getName()));
        }

        // 返回UserDetails实现类
        return new User(user.getUsername(), user.getPassword(), authorities);
    }
}

在WebSecurityConfig中注入我们的过滤器，也就是addFilter()方法：

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private CustomUserDetailsService userDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(new PasswordEncoder() {
            @Override
            public String encode(CharSequence charSequence) {
                return charSequence.toString();
            }

            @Override
            public boolean matches(CharSequence charSequence, String s) {
                return s.equals(charSequence.toString());
            }
        });
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .anyRequest().authenticated()
                .and()
                // 设置登陆页
                .formLogin().loginPage("/login")
                // 设置登陆失败页
                .failureUrl("/login/error")
                // 设置登陆成功页
                .defaultSuccessUrl("/").permitAll()
                .and()
                .addFilter(new JwtLoginFilter(authenticationManager()))
                .addFilter(new JwtAuthenticationFilter(authenticationManager()))
                .logout().permitAll();

        http.csrf().disable();
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        // 设置拦截忽略文件夹，可以对静态资源放行
        web.ignoring().antMatchers("/css/**", "/js/**");
    }
}
7.2.8 运行程序

下面来验证下，运行程序。

在未登录情况下，是无法访问api资源的：
未登录

未登录

我们使用一个角色为ROLE_USER的用户登录，登录成功后会返回一个token，在响应头：
登录成功

下面带着这个token再次访问api资源：
携带JWT

携带JWT

Jitwxs
关注
专栏目录
Json Web Token 介绍与基本使用完整源码
02-16
本文将深入介绍JWT的基本原理、结构以及如何在Java Web环境中使用JWT。 ### JWT基本原理 JWT由三部分组成，分别是头部（Header）、负载（Payload）和签名（Signature），它们之间用点（.）分隔。每部分都是Base64...
JWT(JSON Web Token )详解及实例
深圳市多克创新科技有限公司
10-31 5834
JSON Web Token (JWT)详解
Java中Json web token (JWT)的使用
热门推荐
UserGuan的博客
08-29 2万+
JWT是什么？ 使用JWT的好处 使用io.jsonwebtoken包的方式 pom.xml导入的jar包 User实体 JjwtUtil类 TestJjwt测试类 打印的结果 使用com.auth0包的方式 pom.xml文件 User实体使用上面的 JWTInterceptor拦截器 spring-context.xml配置文件 web.xml配置文件 JWTUti......
java JWT：JSON Web Token 详解
miracle的专栏
09-23 1051
JWT是一种灵活、轻量且跨平台的身份验证和授权方式。在现代 Web 应用中，尤其是分布式架构和微服务中，JWT 广泛用于处理用户身份验证和权限管理。通过本文的介绍，你不仅可以了解 JWT 的基本原理，还可以结合和Node.js实现 JWT 认证系统，并利用常用的调试工具提升开发效率。希望本文能帮助你更好地理解并运用 JWT。
JSON Web Token
m0_54355172的博客
11-28 7637
JWT
JSON Web Token (JWT)
lizsy的博客
04-10 879
JSON Web Token (JWT) 是一种开放标准 ()，我们常说的jwt token（令牌），其实就是按照jwt制定的标准生成的字符串令牌。
了解JWT（跨域）
weixin_50999696的博客
11-22 2058
什么是JWT呢？ 1、JWT(JSON Web Token) 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准。它定义了一种紧凑且独立的方式，可以在各方之间作为JSON对象安全地传输信息。此信息可以通过数字签名进行验证和信任。JWT可以使用秘密（使用HMAC算法）或使用RSA或ECDSA的公钥/私钥对进行签名。 简单的讲就是，JWT是一个带签名及用户相关的信息加密成串，页面请求校验登录接口时，请求头中携带JWT串到后端服务，后端通过签名加密串匹配校验，保证信息未被篡改。校验通过则认为是可靠的
Json Web Token（JWT）介绍与基本使用详解及完整源码示例
最新发布
11-05
本文将深入介绍JWT的基本原理、结构以及如何在Java Web环境中使用JWT。 ### JWT基本原理 JWT由三部分组成，分别是头部（Header）、负载（Payload）和签名（Signature），它们之间用点（.）分隔。每部分都是Base64...
JSON Web Token （前端与后端对话密钥生成文件）
06-28
token 生成文件，用于前后端数据传输时发送的密钥（暗语）。 直接解压后引用该文件即可 -- 后端在收到第一次请求的时候调用 私有的（p开头的） -- 前端发来密钥的时候调用 公用的进行判断是否正确 你也可以自己...
单点登录中的JSON WEB TOKEN的使用方法C#版
03-21
Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。本实例还原了整个的使用流程。建议...
详解JSON Web Token 入门教程
10-18
JSON Web Token（JWT）是网络上广泛使用的跨域认证解决方案。它是一种开放标准（RFC 7519），定义了一种紧凑的、自包含的方式，用于在各方之间以JSON对象的形式安全地传输信息。这些信息可以被验证和信任，因为它们...
JWT（Json Web Token）简介
crg18438610577的博客
04-01 1310
JWT（Json Web Token）简介～
JSON WEB TOKEN从原理到实战（基于java）
Java搜索工程技术栈
06-18 826
JSON Web Token（JWT）是一个非常轻巧的规范。这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息。简称JWT，在HTTP通信过程中，进行身份认证。我们知道HTTP通信是无状态的，因此客户端的请求到了服务端处理完之后是无法返回给原来的客户端。因此需要对访问的客户端进行识别，常用的做法是通过session机制：客户端在服务端登陆成功之后，服务端会生成一个sessionID，返回给客户端，客户端将sessionID保存到cookie中，再次发起请求的时候，携带cookie中的sessio
通过 JWT（JSON Web Token）实现令牌
q322359的博客
02-01 1634
令牌本质就是⼀个字符串,它的实现⽅式有很多,我们采⽤⼀个 JWT 令牌来实现.JWT全称:JSON Web Token官⽹:JSON Web Token(JWT)是⼀个开放的⾏业标准(RFC 7519),⽤于客户端和服务器之间传递安全可靠的信息.其本质是⼀个 token（令牌）,是⼀种紧凑的 URL 安全⽅法.
关于JWT（Json Web Token）
04-11 536
/</</</
JSON Web Token (JWT): 理解与应用
yuanchun的知识整理
08-16 1515
JSON Web Token (JWT)
解锁互联网安全的新钥匙：JWT（JSON Web Token）
weixin_74268571的博客
10-13 2027
JWT互联网安全，JWT的简介，并讲解了JWT的工作原理和JWT是如何工作的，JWT认证和session认证又有什么区别。介绍了JWT的结构和工具类的使用，以及案例的讲解
JWT的原理及实际应用
liaozhixiangjava的博客
10-13 771
定义：JSON Web Token（缩写 JWT）是目前最流行的跨域认证解决方案JWT官网由于HTTP协议是无状态的，这意味着如果我们想判定一个接口是否被认证后访问，就需要借助cookie或者session会话机制进行判定，但是由于现在的系统架构大部分都不止一台服务器，此时又要借助数据库或者全局缓存 做存储，这种方案显然受限太多。
网络安全防护-JSON WEB TOKEN讲解与实战_jsonwebtoken 规范
m0_v648374的博客
04-12 868
然后，使用 Header 里面指定的签名算法（默认是 HMAC SHA256），按照下面的公式产生签名。算出签名以后，把 Header、Payload、Signature 三个部分拼成一个字符串，每个部分之间用"点"（.）分隔，就可以返回给用户。JWT 的原理是，服务器认证以后，生成一个 JSON 对象，发回给用户，就像下面这样。Header 部分是一个 JSON 对象，描述 JWT 的元数据，通常是下面的样子。注意，JWT 默认是不加密的，任何人都可以读到，所以不要把秘密信息放在这个部分。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值