【JWT】JSON Web Token 使用

　　JWT官网： https://jwt.io/

　　JWT(Java版)的github地址:https://github.com/jwtk/jjwt

什么是JWT

　　JWT 介绍参考：【JWT】JSON Web Token

　　Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).定义了一种简洁的，自包含的方法用于通信双方之间以JSON对象的形式安全的传递信息。因为数字签名的存在，这些信息是可信的，JWT可以使用HMAC算法或者是RSA的公私秘钥对进行签名。

JWT请求流程

　　

 

 

• 1. 用户使用账号和面发出post请求；

• 2. 服务器使用私钥创建一个jwt；

• 3. 服务器返回这个jwt给浏览器；

• 4. 浏览器将该jwt串在请求头中像服务器发送请求；

• 5. 服务器验证该jwt；

• 6. 返回响应的资源给浏览器。

JWT的主要应用场景

　　身份认证在这种场景下，一旦用户完成了登陆，在接下来的每个请求中包含JWT，可以用来验证用户身份以及对路由，服务和资源的访问权限进行验证。由于它的开销非常小，可以轻松的在不同域名的系统中传递，所有目前在单点登录（SSO）中比较广泛的使用了该技术。 信息交换在通信的双方之间使用JWT对数据进行编码是一种非常安全的方式，由于它的信息是经过签名的，可以确保发送者发送的信息是没有经过伪造的。

优点

• 1.简洁(Compact): 可以通过URL，POST参数或者在HTTP header

  发送，因为数据量小，传输速度也很快

• 2.自包含(Self-contained)：负载中包含了所有用户所需要的信息，避免了多次查询数据库

• 3.因为Token是以JSON加密的形式保存在客户端的，所以JWT是跨语言的，原则上任何web形式都支持。

• 4.不需要在服务端保存会话信息，特别适用于分布式微服务。

JWT的集成使用

　　新建SpringBoot项目，引入JWT依赖,由于是基于Java，所以需要的是java-jwt

<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.8.3</version>
</dependency>

自定义两个注解

　　用来跳过验证的PassToken

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

 　　需要登录才能进行操作的注解UserLoginToken

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

 简单自定义一个实体类User

package com.test.springboot.jwt.entity;

public class User {
    String Id;
    String username;
    String password;

    public User() {
    }

    public User(String id, String username, String password) {
        Id = id;
        this.username = username;
        this.password = password;
    }

    public String getId() {
        return Id;
    }

    public void setId(String id) {
        Id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "Id='" + Id + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

需要写token的生成方法

    /**
     * token的生成方法
     */
    public String getToken(User user) {
        String token="";
                // 创建JWT
        token= JWT.create()
                // 设置听众信息，也可以这是其他信息，如：withSubject主题
                .withAudience(user.getId())
                // 签名
                .sign(Algorithm.HMAC256(user.getPassword()));
        return token;
    }

　　Algorithm.HMAC256():使用HS256生成token,密钥则是用户的密码，唯一密钥的话可以保存在服务端。

　　withAudience()存入需要保存在token的信息，这里我把用户ID存入token中

拦截器去获取token并验证token

package com.test.springboot.jwt.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.test.springboot.jwt.annotation.PassToken;
import com.test.springboot.jwt.annotation.UserLoginToken;
import com.test.springboot.jwt.entity.User;
import com.test.springboot.jwt.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;

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 {
                    // 从jwt中获取信息
                    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 {
    }

}

配置拦截器

package com.test.springboot.jwt.config;

import com.test.springboot.jwt.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("/**");   
    }

    @Bean
    public AuthenticationInterceptor authenticationInterceptor() {
        return new AuthenticationInterceptor();
    }
}

 Controller

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    UserService userService;

    // 登录
    @PostMapping("/login")
    public Map<String, Object> login(@RequestBody User user) {
        Map<String, Object> result = new HashMap<>();

        User user1 = userService.findOne(user.getUsername(), user.getPassword());
        if (user1 != null) {
            String token = getToken(user1);
            result.put("token", token);
            result.put("user", user1);
            return result;
        } else {
            result.put("message", "登录失败");
            return result;
        }
    }

    @UserLoginToken
    @GetMapping("/getMessage")
    public Map<String, Object> getMessage() {
        Map<String, Object> result = new HashMap<>();
        result.put("content", "你已通过验证");
        return result;
    }

    @PassToken
    @GetMapping("/getPublicMessage")
    public Map<String, Object> getPublicMessage() {
        Map<String, Object> result = new HashMap<>();
        result.put("content", "公共信息");
        return result;
    }


    /**
     * token的生成方法
     */
    public String getToken(User user) {
        String token="";
                // 创建JWT
        token= JWT.create()
                // 设置听众信息，也可以这是其他信息，如：withSubject主题
                .withAudience(user.getId())
                // 签名
                .sign(Algorithm.HMAC256(user.getPassword()));
        return token;
    }
}

Service

package com.test.springboot.jwt.service;

import com.test.springboot.jwt.entity.User;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Service
public class UserService {

    private static Map<String, User> userMap = new ConcurrentHashMap<>();

    static {
        userMap.put("1001", new User("1001", "小白", "123456"));
        userMap.put("1002", new User("1002", "小黑", "123456"));
        userMap.put("1003", new User("1003", "小黄", "123456"));
    }

    public User findOne(String username, String password) {
        for (Map.Entry<String, User> entry : userMap.entrySet()) {
            User value = entry.getValue();
            if (value.getUsername().equals(username)
                    && value.getPassword().equals(password)) {
                return value;
            }
        }
        return null;
    }

    public User findUserById(String userId) {
        return userMap.get(userId);
    }
}

使用postman测试接口