jwt认证入门并整合shiro

目录

什么是JWT

为什么使用JWT

基于token的鉴权机制

JWT的结构

JWT令牌的有点

jwt的签发和验证(jwt的入门)

SpringBoot下Shiro整合JWT实现权限校验

配置shiro

配置JWT

用postman测试工具测试程序

总结

参考文章

---

什么是JWT

Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。

简单来说就是 JWT(Json Web Token)是实现token技术的一种解决方案

为什么使用JWT

token验证和session认证的区别

传统的session认证

http协议本身是一种无状态的协议，而这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证，那么下一次请求时，用户还要再一次进行用户认证才行，因为根据http协议，我们并不能知道是哪个用户发出的请求，所以为了让我们的应用能识别是哪个用户发出的请求，我们只能在服务器存储一份用户登录的信息，这份登录信息会在响应时传递给浏览器，告诉其保存为cookie,以便下次请求时发送给我们的应用，这样我们的应用就能识别请求来自哪个用户了,这就是传统的基于session认证。

session缺点

基于session的认证使应用本身很难得到扩展，随着不同客户端用户的增加，独立的服务器已无法承载更多的用户

Session方式存储用户id的最大弊病在于要占用大量服务器内存，对于较大型应用而言可能还要保存许多的状态。

基于session认证暴露的问题

• Session需要在服务器保存，暂用资源
• 扩展性 session认证保存在内存中 ，无法扩展到其他机器中
• CSRF 基于cookie来进行用户识别的, cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。

基于token的鉴权机制

基于token的鉴权机制类似于http协议也是无状态的，它不需要在服务端去保留用户的认证信息或者会话信息。这就意味着基于token认证机制的应用不需要去考虑用户在哪一台服务器登录了，这就为应用的扩展提供了便利。

JWT方式将用户状态分散到了客户端中，可以明显减轻服务端的内存压力。除了用户id之外，还可以存储其他的和用户相关的信息，例如用户角色，用户性别等。

请求流程

1. 用户使用用户名密码来请求服务器
2. 服务器进行验证用户的信息
3. 服务器通过验证发送给用户一个token
4. 客户端存储token，并在每次请求时附送上这个token值
5. 服务端验证token值，并返回数据

这个token必须要在每次请求时传递给服务端，它应该保存在请求头里， 另外，服务端要支持 CORS(跨来源资源共享)策略，一般我们在服务端这么做就可以了 Access-Control-Allow-Origin: *。

JWT的结构

一个JWT是下面的结构

加密后jwt信息如下所示，是由.分割的三部分组成，分别为Header、Payload、Signature

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.

eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.

TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

 

JWT 的组成

Head -主要包含两个部分,alg指加密类型，可选值为HS256、RSA等等，typ=JWT为固定值，表示token的类型

Header:

{

 "alg": "HS256",

 "typ": "JWT"

}

Payload - Payload又被称为Claims包含您想要签署的任何信息

Claims:

{

 "sub": "1234567890",

 "name": "John Doe",

 "admin": true

}

JWT Payload的组成

Payload通常由三个部分组成，分别是 Registered Claims ; Public Claims ; Private Claims ;每个声明，都有各自的字段。

Registered Claims

iss 【issuer】发布者的url地址

sub 【subject】该JWT所面向的用户，用于处理特定应用，不是常用的字段

aud 【audience】接受者的url地址

exp 【expiration】 该jwt销毁的时间；unix时间戳

nbf 【not before】 该jwt的使用时间不能早于该时间；unix时间戳

iat 【issued at】 该jwt的发布时间；unix 时间戳

jti 【JWT ID】 该jwt的唯一ID编号

Signature 对 则为对Header、Payload的签名

Signature:

base64UrlEncode(Header) + "." + base64UrlEncode(Claims)

头部、声明、签名用 . 号连在一起就得到了我们要的JWT 也就是夏明这种类型的字符串

eyJhbGciOiJIUzI1NiJ9.

eyJleHAiOjE1MTUyOTgxNDEsImtleSI6InZhdWxlIn0.

orewTmil7YmIXKILHwFnw3Bq1Ox4maXEzp0NC5LRaFQ

其实这些事一行的，我只是让看的更直白点将其割开了。

JWT令牌的有点

jwt基于json，非常方便解析

1. 可以再令牌中自定义丰富的内容，易扩展（payload可以扩展）
2. 通过签名，让JWT防止被篡改，安全性高
3. 资源服务使用JWT可不依赖认证服务即可完成授权
4. 可以解决多机部署认证的问题
5. 支持单点登录

 

 

jwt的签发和验证(jwt的入门)

JAVA中使用JWT

使用Maven引入和Gradle引入

Maven

     

io.jsonwebtoken     

jjwt     

0.9.1

</dependency> 

Gradle

 dependencies { compile 'io.jsonwebtoken:jjwt:0.9.0' }

JWT依赖于Jackson，需要在程序中加入Jackson的jar包且版本大于2.x

签发JWT

public static String createJWT() {

        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        SecretKey secretKey = generalKey();

        JwtBuilder builder = Jwts.builder()

                .setId(id)                                      // JWT_ID

                .setAudience("")                                // 接受者

                .claims(null)                                // 自定义属性

                .setSubject("")                                 // 主题

                .setIssuer("")                                  // 签发者

                .setIssuedAt(new Date())                        // 签发时间

                .setNotBefore(new Date())                       // 失效时间

                .setExpiration(long)                                // 过期时间

                .signWith(signatureAlgorithm, secretKey);           // 签名算法以及密匙

        return builder.compact();

}

验证JWT

public static Claims parseJWT(String jwt) throws Exception {

    SecretKey secretKey = generalKey();

    return Jwts.parser()

        .setSigningKey(secretKey)

        .parseClaimsJws(jwt)

        .getBody();

}

完整示例

package com.exam

package com.example.bootandshiro;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.junit.jupiter.api.Test;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;

public class JwtTest {
    @Test
    public void CreateJwt(){
        JwtBuilder builder = Jwts.builder().setId("430681")//用户ID
                .setSubject("小白")//用户名
                .setIssuedAt(new Date())//生成时间
                .signWith(SignatureAlgorithm.HS256, "java")//前面算法，这里采用HS256加密算法盐值是java
                .setExpiration(new Date(new Date().getTime()+60000))//失效时间(毫秒为单位)这里是一分钟超过时间抛出io.jsonwebtoken.ExpiredJwtException
                .claim("role","admin")//claim方法可以自定义属性 根据键值对存放
                .claim("loginname","123");
        System.out.println(builder.compact());

    }
    @Test
    public void jx(){
        String token="eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiI0MzA2ODEiLCJzdWIiOiLlsI_nmb0iLCJpYXQiOjE1NzU3MTkyNzgsImV4cCI6MTU3NTcxOTMzOCwicm9sZSI6ImFkbWluIiwibG9naW5uYW1lIjoiYWRtaW4ifQ.rhj0anJQgU-PErpldv8krZo3WSzHvFdviKXhMs-V7do";
        Claims claims = Jwts.parser().setSigningKey("java").parseClaimsJws(token).getBody();
        System.out.println("用户名："+claims.getId());
        System.out.println("用户名："+claims.getSubject());
        System.out.println("claims:"+claims.get("role"));
        System.out.println("claims:"+claims.get("loginname"));
        System.out.println("tiam:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(claims.getIssuedAt()) );
        System.out.println("失效时间:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(claims.getExpiration()));
    }
}

 

SpringBoot下Shiro整合JWT实现权限校验

配置shiro

导包

因为整合shiro我们只需要shiro的部分功能所以我们只需要导入spring的包即可

    org.apache.shiro
    shiro-spring
    1.4.0

编写shiro的配置类

 

配置Realm

package com.example.bootandshiro.service.impl;

import com.example.bootandshiro.entity.Login;
import com.example.bootandshiro.entity.Permissions;
import com.example.bootandshiro.entity.Role;
import com.example.bootandshiro.service.LoginService;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;


public class CustomRealm extends AuthorizingRealm {

    @Autowired
    private LoginService loginService;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //获取登录用户名
        String name = (String) principalCollection.getPrimaryPrincipal();
        //根据用户名去数据库查询用户信息
        Login user = loginService.getUserByName(name);
        //添加角色和权限
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        for (Role role : user.getRoles()) {
            //添加角色
            simpleAuthorizationInfo.addRole(role.getRoleName());
            //添加权限
            for (Permissions permissions : role.getPermissions()) {
                simpleAuthorizationInfo.addStringPermission(permissions.getPermissionsName());
            }
        }
        return simpleAuthorizationInfo;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //加这一步的目的是在Post请求的时候会先进认证，然后在到请求
        if (authenticationToken.getPrincipal() == null) {
            return null;
        }
        //获取用户信息
        String name = authenticationToken.getPrincipal().toString();
        Login user = loginService.getUserByName(name);
            if (user == null) {
            //这里返回后会报出对应异常
            return null;
        } else {
            //这里验证authenticationToken和simpleAuthenticationInfo的信息
            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(name, user.getPwd().toString(),
            getName());
            return simpleAuthenticationInfo;
        }
    }
}

配置login的业务逻辑

package com.example.bootandshiro.service.impl;

import com.example.bootandshiro.dao.LoginMapper;
import com.example.bootandshiro.entity.Login;
import com.example.bootandshiro.entity.Permissions;
import com.example.bootandshiro.entity.Role;
import com.example.bootandshiro.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import sun.rmi.runtime.Log;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
 * 登录的业务逻辑类
 */
@Service
public class LoginServiceImpl implements LoginService {
    @Autowired
    private LoginMapper loginMapper;
    @Override
    public void saveLogin(Login login) {
        loginMapper.saveLogin(login);
    }

    @Override
    public Login getUserByName(String getMapByName) {
        //模拟数据库查询，正常情况此处是从数据库或者缓存查询。
        return getMapByName(getMapByName);
    }

    /**
     * 模拟数据库查询
     * @param userName
     * @return
     */
    private Login getMapByName(String userName){
        //共添加两个用户，两个用户都是admin一个角色，
        //wsl有query和add权限，zhangsan只有一个query权限
        Permissions permissions1 = new Permissions(1,"query");
        Permissions permissions2 = new Permissions(2,"add");
        Set permissionsSet = new HashSet<>();
        permissionsSet.add(permissions1);
        permissionsSet.add(permissions2);
        Role role = new Role(1,"admin",permissionsSet);
        Set roleSet = new HashSet<>();
        roleSet.add(role);
        Login user = new Login(1,"wsl","wsl","123456",roleSet);
        Map map = new HashMap<>();
        map.put(user.getLoginname(), user);

配置JWT

导包

因为是java项目所以是jjwt

    io.jsonwebtoken
    jjwt
    0.9.1

编写JWT的工具类JwtUtil

可以根据实际需要更改

package com.example.bootandshiro.util;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.ConfigurationPropertiesBinding;
import org.springframework.stereotype.Component;

import java.util.Date;
@Component
public class JwtUtil {
    private static String key;
    private static long ttl;

    public static String getKey() {
        return key;
    }

    public static void setKey(String key) {
        JwtUtil.key = key;
    }

    public static long getTtl() {
        return ttl;
    }

    public static void setTtl(long ttl) {
        JwtUtil.ttl = ttl;
    }

    /**
     * 生成Token
     * @param id
     * @param subject
     * @param roles
     * @return
     */
    public static String createJwt(String id,String subject,String roles){
        long nowMillis=System.currentTimeMillis();
        Date now=new Date(nowMillis);
        JwtBuilder builder = Jwts.builder().setId("430681")//用户ID
                .setSubject(subject)//用户名
                .setIssuedAt(now)//生成时间
                .signWith(SignatureAlgorithm.HS256, key)//前面算法，这里采用HS256加密算法盐值是java
                .setExpiration(new Date(new Date().getTime()+60000));//失效时间(毫秒为单位)这里是一分钟超过时间抛出io.jsonwebtoken
        return builder.compact();
    }

    /**
     * 解析Token
     * @param jwtstr Token
     * @return
     */
    public static Claims parseJWT(String jwtstr){
        return Jwts.parser()
                .setSigningKey(key)
                .parseClaimsJws(jwtstr)
                .getBody();
    }
}

 

配置拦截器

配置拦截器

package com.example.bootandshiro.filter;

import com.example.bootandshiro.ienum.StausEnum;
import com.example.bootandshiro.util.JwtUtil;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.AuthorizationException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.handler.HandlerExceptionResolverComposite;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class MyExceptionHandler extends HandlerInterceptorAdapter {
    @Autowired
    private JwtUtil jwtUtil;
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("拦截");
        String authorization = request.getHeader("Authorization");
        if(authorization==null){
            throw new RuntimeException("权限不足"+ StausEnum.NO_HANDLER);
        }
        if(!authorization.startsWith("Bearer")){
            throw new RuntimeException("权限不足"+StausEnum.HANDLER_EXCEPTION);
        }
        String token=authorization.substring(6);
        Claims claims = JwtUtil.parseJWT(token);
        if(claims==null||"".equals(claims)){
            throw new RuntimeException("权限不足"+StausEnum.PERMISSIONS_EXCEPTION);
        }
        return true;
    }

}

 

拦截器配置类

package com.example.bootandshiro.config;

import com.example.bootandshiro.filter.MyExceptionHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

@Configuration
public class Interceptor extends WebMvcConfigurationSupport {
    @Autowired
    private MyExceptionHandler myExceptionHandler;
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myExceptionHandler)
                .addPathPatterns("/**")
                .excludePathPatterns("/login");
    }
}

 

在主程序中注入key值和jwt的有效时间

public static void main(String[] args) {
        JwtUtil.setKey("java");
        JwtUtil.setTtl(60000);
        SpringApplication.run(BootandshiroApplication.class, args);
    }

用postman测试工具测试程序

首先登录拿到token码然后用token码，然后将token放入请求头去请求其他的被拦截到的控制器

 

登录

然后copy中间的token码根据设定好的带上请求头去请求

实际开发中前端将token码注入cookie,每次请求将token带入请求头

注：未测试

当我们在页面用ajax请求时可以用jquery提供的的方法

代码中的StausEnum.NO_HANDLER

package com.example.bootandshiro.ienum;

public enum StausEnum {
    OK(20000,"成功"),
    NO_HANDLER(10000,"无请求头"),
    HANDLER_EXCEPTION(10001,"请求头错误"),
    PERMISSIONS_EXCEPTION(10003,"无权限");

    private StausEnum(Integer code,String messge){
        this.Code=code;
        this.messge=messge;
    }
    private Integer Code;
    private String messge;

    public Integer getCode() {
        return Code;
    }

    public void setCode(Integer code) {
        Code = code;
    }

    public String getMessge() {
        return messge;
    }

    public void setMessge(String messge) {
        this.messge = messge;
    }
}

总结

优点

• 因为json的通用性，所以JWT是可以进行跨语言支持的，像JAVA,JavaScript,NodeJS,PHP等很多语言都可以使用。
• 因为有了payload部分，所以JWT可以在自身存储一些其他业务逻辑所必要的非敏感信息。
• 便于传输，jwt的构成非常简单，字节占用很小，所以它是非常便于传输的。
• 它不需要在服务端保存会话信息, 所以它易于应用的扩展

安全相关

• 不应该在jwt的payload部分存放敏感信息，因为该部分是客户端可解密的部分。
• 保护好secret私钥，该私钥非常重要。
• 如果可以，请使用https协议

参考文章

https://www.cnblogs.com/jwt-java/p/10837353.html

https://blog.csdn.net/hejie1997/article/details/90081352

https://www.cnblogs.com/wangshouchang/p/9551748.html

http://www.ibloger.net/article/3075.html

jjwt-gitHub：https://github.com/jwtk/jjwt

https://blog.csdn.net/u012240455/article/details/79019825

https://blog.csdn.net/u012017645/article/details/53585872

http://itindex.net/detail/58305-jwt-json-web

http://itindex.net/detail/58305-jwt-json-web

http://itindex.net/detail/58629-json-web-token

https://www.jianshu.com/p/d215e70dc1f9