shiro+jwt实现无状态鉴权

最新推荐文章于 2023-08-20 20:56:12 发布
最新推荐文章于 2023-08-20 20:56:12 发布
阅读量525 收藏 5
点赞数
分类专栏： 学习笔记
原文链接：https://www.jianshu.com/p/9b6eb3308294
版权

Shiro+JWT实现无状态鉴权

转载自简书 coderymy 大神的文章

原文地址 https://www.jianshu.com/p/9b6eb3308294

声明：本文纯粹萌新转载来学习，以免丢失链接，并记录自己在此基础上的一些修改，请支持原作者！

技术选型：

原有的鉴权是通过单一Shiro+redis，保存用户的SessionId来完成的，单机环境提供服务完全没有问题。由于萌新手贱搭建服务集群，突然就遇到了一个问题：

用户操作被莫名的中断并拒绝，弹回登录界面。

在大致了解了SessionId的生成原理后，了解了负载均衡到不同的服务器时，直接导致sessionId发生变化，可能由于当初老大在设计鉴权的时候没有时间写，遂只用了单机版，只用shiro做了个sessionID的校验。

后萌新面向百度了解了JWT的使用原理，可以通过JWT令牌的形式，让客户能够不借助sessionId进行授权访问，每次向服务器提供令牌，如果校验通过，即可正常访问。

因此我重构了之前的代码，使用Shiro+JWT令牌的形式，做新的鉴权模块。

由于已经有前辈给出了详尽的解决方案，这里不再赘述。以下为在前辈的代码基础上做的一些小修改，不定时根据业务需要更新：

1. SpringBoot+Shiro+Jwt

  1. 由于需要对shiro的SecurityManager进行设置，所以不能使用shiro-spring-boot-starter进行与springboot的整合，只能使用spring-shiro

此外，如果需要整合nacos还需要引入相关的依赖。

<!-- 自动依赖导入 shiro-core 和 shiro-web -->
 	<dependency>
         <groupId>org.apache.shiro</groupId>
         <artifactId>shiro-spring</artifactId>
         <version>1.4.1</version>
     </dependency>
     <dependency>
         <groupId>io.jsonwebtoken</groupId>
         <artifactId>jjwt</artifactId>
         <version>0.9.1</version>
     </dependency>
     <dependency>
         <groupId>com.auth0</groupId>
         <artifactId>java-jwt</artifactId>
         <version>3.11.0</version>
     </dependency>
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
         <version>1.18.12</version>
     </dependency>

  1. 由于需要实现无状态的web，所以使用不到Shiro的Session功能，严谨点就是将其关闭

    public class JwtDefaultSubjectFactory extends DefaultWebSubjectFactory {

    @Override
    public Subject createSubject(SubjectContext context) {
        // 不创建 session
        context.setSessionCreationEnabled(false);
        return super.createSubject(context);
    }
}

    这样如果调用getSession()方法会抛出异常

1.1 流程

  1. 用户请求，不携带token，就在JwtFilter处抛出异常/返回没有登录，让它去登陆
  2. 用户请求，携带token，就到JwtFilter中获取jwt，封装成JwtToken对象。然后使用JwtRealm进行认证
  3. 在JwtRealm中进行认证判断这个token是否有效，也就是
执行流程：1. 客户端发起请求，shiro的过滤器生效，判断是否是login或logout的请求<br/>    如果是就直接执行请求<br/>    如果不是就进入JwtFilter2. JwtFilter执行流程    1. 获取header是否有"Authorization"的键，有就获取，没有就抛出异常    2. 将获取的jwt字符串封装在创建的JwtToken中，使用subject执行login()方法进行校验。这个方法会调用创建的JwtRealm    3. 执行JwtRealm中的认证方法，使用`jwtUtil.isVerify(jwt)`判断是否登录过    4. 返回true就使基础执行下去

1.2 快速开始

0. JwtDeafultSubjectFactory

package cn.coderymy.shiro;

import org.apache.shiro.subject.Subject;
import org.apache.shiro.subject.SubjectContext;
import org.apache.shiro.web.mgt.DefaultWebSubjectFactory;

public class JwtDefaultSubjectFactory extends DefaultWebSubjectFactory {

    @Override
    public Subject createSubject(SubjectContext context) {
        // 不创建 session
        context.setSessionCreationEnabled(false);
        return super.createSubject(context);
    }
}

1. 创建JwtUtil

这个一般是固定的写法，其中写了大量注释

package cn.coderymy.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.apache.commons.codec.binary.Base64;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
/*
* 总的来说，工具类中有三个方法
* 获取JwtToken，获取JwtToken中封装的信息，判断JwtToken是否存在
* 1. encode()，参数是=签发人，存在时间，一些其他的信息=。返回值是JwtToken对应的字符串
* 2. decode()，参数是=JwtToken=。返回值是荷载部分的键值对
* 3. isVerify()，参数是=JwtToken=。返回值是这个JwtToken是否存在
* */
public class JwtUtil {
    //创建默认的秘钥和算法，供无参的构造方法使用
    private static final String defaultbase64EncodedSecretKey = "badbabe";
    private static final SignatureAlgorithm defaultsignatureAlgorithm = SignatureAlgorithm.HS256;

    public JwtUtil() {
        this(defaultbase64EncodedSecretKey, defaultsignatureAlgorithm);
    }

    private final String base64EncodedSecretKey;
    private final SignatureAlgorithm signatureAlgorithm;

    public JwtUtil(String secretKey, SignatureAlgorithm signatureAlgorithm) {
        this.base64EncodedSecretKey = Base64.encodeBase64String(secretKey.getBytes());
        this.signatureAlgorithm = signatureAlgorithm;
    }

    /*
     *这里就是产生jwt字符串的地方
     * jwt字符串包括三个部分
     *  1. header
     *      -当前字符串的类型，一般都是“JWT”
     *      -哪种算法加密，“HS256”或者其他的加密算法
     *      所以一般都是固定的，没有什么变化
     *  2. payload
     *      一般有四个最常见的标准字段（下面有）
     *      iat：签发时间，也就是这个jwt什么时候生成的
     *      jti：JWT的唯一标识
     *      iss：签发人，一般都是username或者userId
     *      exp：过期时间
     *
     * */
    public String encode(String iss, long ttlMillis, Map<String, Object> claims) {
        //iss签发人，ttlMillis生存时间，claims是指还想要在jwt中存储的一些非隐私信息
        if (claims == null) {
            claims = new HashMap<>();
        }
        long nowMillis = System.currentTimeMillis();

        JwtBuilder builder = Jwts.builder()
                .setClaims(claims)
                .setId(UUID.randomUUID().toString())//2. 这个是JWT的唯一标识，一般设置成唯一的，这个方法可以生成唯一标识
                .setIssuedAt(new Date(nowMillis))//1. 这个地方就是以毫秒为单位，换算当前系统时间生成的iat
                .setSubject(iss)//3. 签发人，也就是JWT是给谁的（逻辑上一般都是username或者userId）
                .signWith(signatureAlgorithm, base64EncodedSecretKey);//这个地方是生成jwt使用的算法和秘钥
        if (ttlMillis >= 0) {
            long expMillis = nowMillis + ttlMillis;
            Date exp = new Date(expMillis);//4. 过期时间，这个也是使用毫秒生成的，使用当前时间+前面传入的持续时间生成
            builder.setExpiration(exp);
        }
        return builder.compact();
    }

    //相当于encode的方向，传入jwtToken生成对应的username和password等字段。Claim就是一个map
    //也就是拿到荷载部分所有的键值对
    public Claims decode(String jwtToken) {

        // 得到 DefaultJwtParser
        return Jwts.parser()
                // 设置签名的秘钥
                .setSigningKey(base64EncodedSecretKey)
                // 设置需要解析的 jwt
                .parseClaimsJws(jwtToken)
                .getBody();
    }

    //判断jwtToken是否合法
    public boolean isVerify(String jwtToken) {
        //这个是官方的校验规则，这里只写了一个”校验算法“，可以自己加
        Algorithm algorithm = null;
        switch (signatureAlgorithm) {
            case HS256:
                algorithm = Algorithm.HMAC256(Base64.decodeBase64(base64EncodedSecretKey));
                break;
            default:
                throw new RuntimeException("不支持该算法");
        }
        JWTVerifier verifier = JWT.require(algorithm).build();
        verifier.verify(jwtToken);  // 校验不通过会抛出异常
        //判断合法的标准：1. 头部和荷载部分没有篡改过。2. 没有过期
        return true;
    }

    public static void main(String[] args) {
        JwtUtil util = new JwtUtil("tom", SignatureAlgorithm.HS256);
        //以tom作为秘钥，以HS256加密
        Map<String, Object> map = new HashMap<>();
        map.put("username", "tom");
        map.put("password", "123456");
        map.put("age", 20);

        String jwtToken = util.encode("tom", 30000, map);

        System.out.println(jwtToken);
        util.decode(jwtToken).entrySet().forEach((entry) -> {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        });
    }
}

2. 创建JwtFilter

也就是在Shiro的拦截器中多加一个，等下需要在配置文件中注册这个过滤器

package cn.coderymy.filter;

import cn.coderymy.shiro.JwtToken;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.web.filter.AccessControlFilter;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/*
 * 自定义一个Filter，用来拦截所有的请求判断是否携带Token
 * isAccessAllowed()判断是否携带了有效的JwtToken
 * onAccessDenied()是没有携带JwtToken的时候进行账号密码登录，登录成功允许访问，登录失败拒绝访问
 * */
@Slf4j
public class JwtFilter extends AccessControlFilter {
    /*
     * 1. 返回true，shiro就直接允许访问url
     * 2. 返回false，shiro才会根据onAccessDenied的方法的返回值决定是否允许访问url
     * */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
        log.warn("isAccessAllowed 方法被调用");
        //这里先让它始终返回false来使用onAccessDenied()方法
        return false;
    }

    /**
     * 返回结果为true表明登录通过
     */
    @Override
    protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
        log.warn("onAccessDenied 方法被调用");
        //这个地方和前端约定，要求前端将jwtToken放在请求的Header部分

        //所以以后发起请求的时候就需要在Header中放一个Authorization，值就是对应的Token
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        String jwt = request.getHeader("Authorization");
        log.info("请求的 Header 中藏有 jwtToken {}", jwt);
        JwtToken jwtToken = new JwtToken(jwt);
        /*
         * 下面就是固定写法
         * */
        try {
            // 委托 realm 进行登录认证
            //所以这个地方最终还是调用JwtRealm进行的认证
            getSubject(servletRequest, servletResponse).login(jwtToken);
            //也就是subject.login(token)
        } catch (Exception e) {
            e.printStackTrace();
            onLoginFail(servletResponse);
            //调用下面的方法向客户端返回错误信息
            return false;
        }

        return true;
        //执行方法中没有抛出异常就表示登录成功
    }

    //登录失败时默认返回 401 状态码
    private void onLoginFail(ServletResponse response) throws IOException {
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        httpResponse.getWriter().write("login error");
    }
}

3. 创建JwtToken

其中封装了需要传递的jwt字符串

package com.wwstation.authorization.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import org.apache.shiro.authc.AuthenticationToken;

@Data
@AllArgsConstructor
public class JwtToken implements AuthenticationToken {

    private String jwt;

    @Override
    public Object getPrincipal() {
        return jwt;
    }

    @Override
    public Object getCredentials() {
        return jwt;
    }
}

4. JwtRealm

创建判断jwt是否有效的认证方式的Realm

package cn.coderymy.realm;

import cn.coderymy.shiro.JwtToken;
import cn.coderymy.util.JwtUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
@Slf4j
public class JwtRealm extends AuthorizingRealm {
    /*
     * 多重写一个support
     * 标识这个Realm是专门用来验证JwtToken
     * 不负责验证其他的token（UsernamePasswordToken）
     * */
    @Override
    public boolean supports(AuthenticationToken token) {
        //这个token就是从过滤器中传入的jwtToken
        return token instanceof JwtToken;
    }

    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }

    //认证
    //这个token就是从过滤器中传入的jwtToken
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        String jwt = (String) token.getPrincipal();
        if (jwt == null) {
            throw new NullPointerException("jwtToken 不允许为空");
        }
        //判断
        JwtUtil jwtUtil = new JwtUtil();
        if (!jwtUtil.isVerify(jwt)) {
            throw new UnknownAccountException();
        }
        //下面是验证这个user是否是真实存在的
        String username = (String) jwtUtil.decode(jwt).get("username");//判断数据库中username是否存在
        log.info("在使用token登录"+username);
        return new SimpleAuthenticationInfo(jwt,jwt,"JwtRealm");
        //这里返回的是类似账号密码的东西，但是jwtToken都是jwt字符串。还需要一个该Realm的类名

    }

}

5. ShiroConfig

配置一些信息

  1. 因为不适用Session，所以为了防止会调用getSession()方法而产生错误，所以默认调用自定义的Subject方法
  2. 一些修改，关闭SHiroDao等
  3. 注册JwtFilter
package cn.coderymy.config;

import cn.coderymy.filter.JwtFilter;
import cn.coderymy.realm.JwtRealm;
import cn.coderymy.shiro.JwtDefaultSubjectFactory;
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.mgt.SubjectFactory;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.filter.authc.AnonymousFilter;
import org.apache.shiro.web.filter.authc.LogoutFilter;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.servlet.Filter;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

//springBoot整合jwt实现认证有三个不一样的地方，对应下面abc
@Configuration
public class ShiroConfig {
    /*
     * a. 告诉shiro不要使用默认的DefaultSubject创建对象，因为不能创建Session
     * */
    @Bean
    public SubjectFactory subjectFactory() {
        return new JwtDefaultSubjectFactory();
    }

    @Bean
    public Realm realm() {
        return new JwtRealm();
    }

    @Bean
    public DefaultWebSecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm());
        /*
         * b
         * */
        // 关闭 ShiroDAO 功能
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        // 不需要将 Shiro Session 中的东西存到任何地方（包括 Http Session 中）
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        securityManager.setSubjectDAO(subjectDAO);
        //禁止Subject的getSession方法
        securityManager.setSubjectFactory(subjectFactory());
        return securityManager;
    }

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean() {
        ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
        shiroFilter.setSecurityManager(securityManager());
        shiroFilter.setLoginUrl("/unauthenticated");
        shiroFilter.setUnauthorizedUrl("/unauthorized");
        /*
         * c. 添加jwt过滤器，并在下面注册
         * 也就是将jwtFilter注册到shiro的Filter中
         * 指定除了login和logout之外的请求都先经过jwtFilter
         * */
        Map<String, Filter> filterMap = new HashMap<>();
        //这个地方其实另外两个filter可以不设置，默认就是
        filterMap.put("anon", new AnonymousFilter());
        filterMap.put("jwt", new JwtFilter());
        filterMap.put("logout", new LogoutFilter());
        shiroFilter.setFilters(filterMap);

        // 拦截器
        Map<String, String> filterRuleMap = new LinkedHashMap<>();
        filterRuleMap.put("/login", "anon");
        filterRuleMap.put("/logout", "logout");
        filterRuleMap.put("/**", "jwt");
        shiroFilter.setFilterChainDefinitionMap(filterRuleMap);

        return shiroFilter;
    }
}

6. 测试

package cn.coderymy.controller;

import cn.coderymy.util.JwtUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.HashMap;
import java.util.Map;
@Slf4j
@Controller
public class LoginController {

    @RequestMapping("/login")
    public ResponseEntity<Map<String, String>> login(String username, String password) {
        log.info("username:{},password:{}",username,password);
        Map<String, String> map = new HashMap<>();
        if (!"tom".equals(username) || !"123".equals(password)) {
            map.put("msg", "用户名密码错误");
            return ResponseEntity.ok(map);
        }
        JwtUtil jwtUtil = new JwtUtil();
        Map<String, Object> chaim = new HashMap<>();
        chaim.put("username", username);
        String jwtToken = jwtUtil.encode(username, 5 * 60 * 1000, chaim);
        map.put("msg", "登录成功");
        map.put("token", jwtToken);
        return ResponseEntity.ok(map);
    }
    @RequestMapping("/testdemo")
    public ResponseEntity<String> testdemo() {
        return ResponseEntity.ok("我爱蛋炒饭");
    }

}

1.3 授权方面的信息

在JwtRealm中的授权部分，可以使用JwtUtil.decode(jwt).get("username")获取到username，使用username去数据库中查找到对应的权限，然后将权限赋值给这个用户就可以实现权限的认证了

奇奇怪怪的键盘侠
关注
专栏目录
Shiro + JWT + SpringBoot + MySQL + Redis(Jedis)实现无状态鉴权机制
10-17
下面我们将详细探讨这些组件在实现无状态鉴权中的作用。 **Apache Shiro** Apache Shiro是一款轻量级的安全框架，它提供身份认证、授权（权限控制）、会话管理和加密等功能。在这个项目中，Shiro主要负责用户的登录...
SpringBoot+Shiro+Jwt实现登录认证——最干的干货
守夜人爱吃兔子的博客
08-04 1556
1. 概述 1.1 SpringBoot 这个就没什么好说的了，能看到这个教程的，估计都是可以说精通了SpringBoot的使用 1.2 Shiro 一个安全框架，但不只是一个安全框架。它能实现多种多样的功能。并不只是局限在web层。在国内的市场份额占比高于SpringSecurity，是使用最多的安全框架 可以实现用户的认证和授权。比SpringSecurity要简单的多。 1.3 Jwt 我的理解就是可以进行客户端与服务端之间验证的一种技术，取代了之前使用Session来验证的不安全性
SpringBoot整合JWT + Shiro
weixin_43920711的博客
10-28 7214
一、什么是Shiro Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。 三个核心组件：Subject, SecurityManager 和 Realms 三大核心组件： Subject：主体 主体，代表了当前的“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是主体，如第三方进程、网络爬虫、机器人等，Subject是一个抽象概念，所有的Subject都绑定到Securi
Shiro工作原理简析（第二章）
Mr_lifengzi的博客
08-18 565
第二章，说说Shiro是怎么去拦截请求的    可能大部分的同学都知道Shiro是基于过滤器Filter来实现对请求的拦截，从而实现权限控制，下来就具体从源码角度来看看Shiro的工作原理。    首先便是要知道Shiro的过滤器都有哪些，如下图： 挑几个的说说： AbstractFilter：Shiro的顶层过滤器，实现了javax.servlet.Filter。所以，有Filter相关知识可...
springboot集成shiro+jwt详解+完整实例
Timmer的博客
05-26 7410
目录 简介 目的 需要的jar 集成过程 1.配置shiro 2.创建自定义Realm 2.1 LoginRealm用于处理用户登录 2.2 JwtRealm用于在登录之后，用户的token是否正确以及给当前用户授权等 2.3OurModularRealmAuthenticator用于匹配的相应的Realm 2.4 DataAutoToken及实现类 2.5JwtFilter处理在shiro配置的自定义的Filter 2.6 controller层登录和其他接口 2.7 se...
SpringBoot+JWT+Shiro
最新发布
jakelihua
08-20 678
本文讲解，如何用SpringBoot整合JWT与Shiro。对于JWT和Shiro的讲解看这两篇文章，本文只讲解，最后的结合的代码。
Shiro + Java-JWT无状态鉴权认证机制
07-30
《Shiro + Java-JWT无状态鉴权认证机制在SpringBoot环境中的应用》 在现代Web应用程序中，安全性和权限管理是至关重要的组成部分。本文将深入探讨如何在SpringBoot项目中结合Apache Shiro和Java JSON Web Tokens ...
SpringBoot+shiro+redis+jwt .zip
01-03
`JWT`的引入是为了实现无状态的身份验证。用户登录成功后，服务器会生成一个包含用户信息的JWT，并返回给客户端。之后，客户端在每次发送请求时，都将这个JWT放在`Authorization`头中。服务器端验证JWT的有效性，...
ShiroJwt：API SpringBoot + Shiro + Java-Jwt + Redis（Jedis）
02-04
ShiroJwt 前端地址： : 疑问查看 项目相关 JavaDoc： ： 关联文档： : 教程目录： : 可转换数据库形式（MySQL）： : ... Shiro + Java-JWT实现无状态鉴权机制（令牌） 密码加密（采用AES-128 + Base6
oauth2-shiro-jwt:两种登录方式
05-14
1.使用JWT生成Token，使用shiro实现鉴权 2.使用oauth2生成token，spring security实现鉴权 使用JWT生成Token，使用shiro实现鉴权 UMS返回参数说明 名称 类型 说明 type int 请求状态(0:失败;1:成功) messageCode int...
【Java专题_01】springboot+Shiro+Jwt整合方案
weixin_40736233的博客
04-02 1万+
【Java专题_01】springboot+Shiro+Jwt整合方案
Springboot+jwt+shiro实现用户权限控制
m0_67390963的博客
04-25 1631
目录 JWT Shiro 实现过程 1.Springboot环境搭建 2.实现JwtToken、JwtUtil、JwtFilter、这三个类 最近在做前后分离项目，前端验证用到了JWT,后端用的shiro做权限验证，基于springboot实现JWT+Shiro鉴权。 JWT JWT 英文名是 Json Web Token ，是一种用于通信双方之间传递安全信息的简洁的、URL安全的表述性声明规范，经常用在跨域身份验证。 JWT 以 JSON 对象的形式安全传递信息。因为存在数字签名，因此所传递的信息是安全
springboot下shiro和jwt的整合使用
weixin_42404323的博客
06-18 2337
首先shiro做安全框架，将JWT整合到shiro的认证和授权中进行使用，最终的目的就是用户在进行登录的时候，验证成功则返回一个token，后面该用户可以通过这个token是访问自己有权限的接口，启动缓存功能，只有第一次认证需要查询DB，后续访问都是访问缓存（分两种，单机版应用使用EhCache，分布式使用redis） 整合思路： 1.构建一个springBoot项目，引入核心依赖并展示核心代码目录 <!--引入ehcache依赖（单机版本缓存用） --> <depen
基于SpringBoot实现Shiro整合JWT
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
02-26 2262
在上一篇文章基于SpringBoot整Shiro完成了对shiro的整合，这一篇文章我们不妨对项目进行进一步优化，完成基于JWT优化安全校验框架的优化。调用登录接口。若登录通过，即可直接使用当前登录角色的权限调用相关接口。但是这种方式也存在着一定的局限性，由于Shiro认证后会将结果缓存在session会话中，对于分布式结构，session不共享的局限性就暴露出来了。所以为了保证一处认证，处处服务器可用，我们需要整合JWT来完善这个现有的认证逻辑。
SpringBoot+Shiro+JWT实现权限管理
热门推荐
qq_42109746的博客
07-24 1万+
1.为什么使用JWT? 1.简洁(Compact):可以通过URL，POST参数或者在HTTP header发送，因为数据量小，传输速度也很快。 2.自包含(Self-contained)：负载中包含了所有用户所需要的信息，避免了多次查询数据库。 3.安全(security): 与简单的JSON相比，XML和XML数字签名会引入复杂的安全漏洞。 2.认证原理 1.用户登陆之后，使用密码...
SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权验证以及token刷新
weixin_51542566的博客
04-13 1562
1. 本身AccessToken的过期时间为5分钟，RefreshToken过期时间为30分钟，当登录后时间过了5分钟之后，当前AccessToken便会过期失效，再次带上AccessToken访问JWT会抛出TokenExpiredException异常说明Token过期，开始判断是否要进行AccessToken刷新，首先redis查询RefreshToken是否存在，以及时间戳和过期AccessToken所携带的时间戳是否一致，如果存在且一致就进行AccessToken刷新。
SpringBoot+Shiro+JWT
weixin_37375983的博客
11-10 1018
SpringBoot+Shiro+JWT
Shiro系列（一）——Shiro + Springboot + JWT 整合
玖涯博客
02-17 1407
写在前面 本文的出现表示不再进行 Spring Security Oauth 实现的研究了，原因是原开源项目已经被废弃了不再更新了，而且 Oauth 实现的内容有些奇怪，新的项目 spring-authorization-server 目前才发布到 0.1.0，默认只提供了基于内存的实现，个人认为还不是很完善，不适合用到项目中。而且 Spring Security 的 Oauth 流程都实现了，要修改还得从新研究 spring-authorization-server 的实现逻辑，然后进行修改定制，太耗费精
Shiro+Spring Boot+jwt
qq_53946134的博客
08-09 2695
Shiro+SpringBoot+jwt集成小的Dome+源代码，源代码在最后提示：以下是本篇文章正文内容，下面案例可供参考。
Spring Boot + Shiro + JWT：前后端分离权限管理实战
Shiro是一个强大的企业级身份和访问管理框架，而JWT则用于安全地在客户端和服务端之间传递信息，特别适用于无状态的API。 首先，确保在项目的pom.xml文件中添加了Shiro和JWT的相关依赖。Shiro的版本是1.4.0，这里...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值