Shiro + Redis + Jwt

最新推荐文章于 2024-05-27 13:56:04 发布
最新推荐文章于 2024-05-27 13:56:04 发布
阅读量415 收藏
点赞数
分类专栏： # SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yang_Cpp/article/details/115133009
版权

image-20210323172957339

0. 导入依赖

 <dependency>
     <groupId>org.crazycake</groupId>
     <artifactId>shiro-redis-spring-boot-starter</artifactId>
     <version>3.3.1</version>
 </dependency>

配置yml

jwt:
  secret: xxxxxx
  expiration: 86400000
  tokenHeader: Authorization

shiro-redis:
  redis-manager:
    host: xxxxxx
    database: xxxxxxxxxx

1. ShiroConfig

  • 配置安全管理器
  • 配置Session管理器
  • 配置缓存
  • 配置过滤路径
package com.yang.server.config.shiro;

import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.mgt.SessionStorageEvaluator;
import org.apache.shiro.mgt.SubjectDAO;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.spring.web.config.DefaultShiroFilterChainDefinition;
import org.apache.shiro.spring.web.config.ShiroFilterChainDefinition;
import org.apache.shiro.web.filter.authc.AnonymousFilter;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.mgt.DefaultWebSessionStorageEvaluator;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisSessionDAO;
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;

@Configuration
public class ShiroConfig {


    /**
     * shiro过滤器配置
     *
     * @param defaultWebSecurityManager
     * @param shiroFilterChainDefinition
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager,
                                                         ShiroFilterChainDefinition shiroFilterChainDefinition,
                                                         JwtFilter jwtFilter) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        // 设置过滤器
        Map<String, Filter> filter = new HashMap<>();
        filter.put("jwt", jwtFilter);
        shiroFilterFactoryBean.setFilters(filter);
        // 设置过滤路径
        shiroFilterFactoryBean.setFilterChainDefinitionMap(shiroFilterChainDefinition.getFilterChainMap());
        return shiroFilterFactoryBean;
    }

    /**
     * 过滤路径配置
     *
     * @return
     */
    @Bean
    public ShiroFilterChainDefinition shiroFilterChainDefinition() {
        DefaultShiroFilterChainDefinition defaultShiroFilterChainDefinition = new DefaultShiroFilterChainDefinition();
        LinkedHashMap<String, String> filterMap = new LinkedHashMap<>();
        filterMap.put("/doc.html", "anon");
        filterMap.put("/admin", "jwt");
        filterMap.put("/login/info", "jwt");
        defaultShiroFilterChainDefinition.addPathDefinitions(filterMap);
        return defaultShiroFilterChainDefinition;
    }

    /**
     * 安全管理器
     *
     * @return
     */
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(AccountRealm accountRealm,
                                                               RedisCacheManager redisCacheManager,
                                                               DefaultWebSessionManager defaultWebSessionManager) {
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        // 设置realm
        defaultWebSecurityManager.setRealm(accountRealm);
        // 设置redis缓存
        defaultWebSecurityManager.setCacheManager(redisCacheManager);
        // 设置session管理器
        // 关闭session
        DefaultWebSessionStorageEvaluator defaultWebSessionStorageEvaluator = new DefaultWebSessionStorageEvaluator();
        defaultWebSessionStorageEvaluator.setSessionStorageEnabled(false);
        DefaultSubjectDAO defaultSubjectDAO = new DefaultSubjectDAO();
        defaultSubjectDAO.setSessionStorageEvaluator(defaultWebSessionStorageEvaluator);
        defaultWebSecurityManager.setSubjectDAO(defaultSubjectDAO);

//        defaultWebSecurityManager.setSessionManager(defaultWebSessionManager);
        return defaultWebSecurityManager;
    }

    /**
     * redsi session管理
     *
     * @param redisSessionDAO
     * @return
     */
    @Bean
    public DefaultWebSessionManager defaultWebSessionManager(RedisSessionDAO redisSessionDAO) {
        DefaultWebSessionManager defaultWebSessionManager = new DefaultWebSessionManager();
        // 设置redis session管理
        defaultWebSessionManager.setSessionDAO(redisSessionDAO);
        return defaultWebSessionManager;
    }

    /**
     * 定制realm注入
     *
     * @return
     */
    @Bean
    public AccountRealm getRealm() {
        AccountRealm accountRealm = new AccountRealm();
        // 开启验证缓存
        accountRealm.setAuthenticationCachingEnabled(true);
        // 开启授权缓存
        accountRealm.setAuthorizationCachingEnabled(true);
        return accountRealm;
    }
}

2. JwtFilter

自定义过滤器，重写过滤规则

package com.yang.server.config.shiro;

import com.alibaba.fastjson.JSON;
import com.google.common.base.Strings;
import com.yang.server.common.lang.Result;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authc.AuthenticatingFilter;
import org.apache.shiro.web.util.WebUtils;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMethod;

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

@Component
public class JwtFilter extends AuthenticatingFilter {

    /**
     * 从请求中获取token
     * @param servletRequest
     * @param servletResponse
     * @return
     * @throws Exception
     */
    @Override
    protected AuthenticationToken createToken(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
        return getToken(servletRequest, servletResponse);
    }


    /**
     * 请求首先进入preHandle中，我们进行跨域请求授权
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = WebUtils.toHttp(request);
        HttpServletResponse httpServletResponse = WebUtils.toHttp(response);
        httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("origin"));
        httpServletResponse.setHeader("Access-control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));

        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name()))
        {
            httpServletResponse.setStatus(org.springframework.http.HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }

    /**
     * 访问被允许，请求过来后首先走这里，若是通过，直接放行，否则走onAccessDenied；
     * 此处一般放行特殊请求，一般进行跨域option请求处理
     * @param request
     * @param response
     * @param mappedValue
     * @return
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        return super.isAccessAllowed(request, response, mappedValue);
    }

    /**
     * isAccessAllowed未通过走这里，这里一般需要进行验证，走realm进行验证
     * @param servletRequest
     * @param servletResponse
     * @return
     * @throws Exception
     */
    @Override
    protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
        return executeLogin(servletRequest, servletResponse);
    }


    /**
     * 登录成功后处理
     * @param token
     * @param subject
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @Override
    protected boolean onLoginSuccess(AuthenticationToken token, Subject subject, ServletRequest request, ServletResponse response) throws Exception {
        return super.onLoginSuccess(token, subject, request, response);
    }

    /**
     * 登录失败后处理
     * @param token
     * @param e
     * @param request
     * @param response
     * @return
     */
    @Override
    protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e, ServletRequest request, ServletResponse response) {
        // 捕获登录过程中的异常
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        Throwable throwable = e.getCause() == null ? e : e.getCause();
        Result result = Result.error(throwable.getLocalizedMessage());
        String s = JSON.toJSONString(result);
        try {
            httpServletResponse.setContentType("application/json;charset=utf-8");
            PrintWriter writer = httpServletResponse.getWriter();
            writer.print(s);

        } catch (IOException ioException) {
            ioException.printStackTrace();
        }
        return false;
    }

    /**
     * 工具方法，获取请求头中的token
     * @param servletRequest
     * @param servletResponse
     * @return
     */
    protected JwtToken getToken(ServletRequest servletRequest, ServletResponse servletResponse){
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        String token = request.getHeader("Authorization");
        if (Strings.isNullOrEmpty(token)){
            return new JwtToken("");
        }
        return new JwtToken(token);
    }
}

3. 自定义Token

自定义AuthenticationToken，用于Realm验证

package com.yang.server.config.shiro;

import org.apache.shiro.authc.AuthenticationToken;

public class JwtToken implements AuthenticationToken {

    private String token;

    public JwtToken(String token) {
        this.token = token;
    }

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

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

4. JwtUtil

  • 生成token
  • 验证token是否过期
  • 刷新token
package com.yang.server.config.shiro;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.apache.shiro.authc.AuthenticationToken;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

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

@Component
public class JwtTokenUtil {
    private final String CLAIM_KEY_USERNAME = "sub";
    private final String CLAIM_KEY_CREATED = "created";
    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.expiration}")
    private Long expiration;

    /**
     * 根据用户信息生成token字符串
     * @param username
     * @return
     */
    public String generateToken(String username){
        HashMap<String, Object> claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME, username);
        claims.put(CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }

    /**
     * 根绝负载生成token
     * @param claims
     * @return
     */
    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationTime())
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
    }

    /**
     * 生成过期时间
     * @return
     */
    private Date generateExpirationTime() {
        return new Date(System.currentTimeMillis() + expiration);
    }

    /**
     * 从token中获取用户名
     * @param token
     * @return
     */
    public String getUserNameFromToken(String token){
        String username;
        try{
            Claims claims = getClaimsFromToken(token);
            username = claims.getSubject();
        } catch (Exception e){
            e.printStackTrace();
            return null;
        }
        return username;
    }

    /**
     * 从token中获取荷载
     * @param token
     * @return
     */
    public Claims getClaimsFromToken(String token) {
        return Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
    }


    /**
     * 判断token是否过期
     * @param token
     * @return
     */
    public boolean isTokenExpired(String token) {
        Date expiredDate = getExpirationDateFromToken(token);
        return expiredDate.before(new Date());
    }

    /**
     * 获取token过期时间
     * @param token
     * @return
     */
    private Date getExpirationDateFromToken(String token) {
        Claims claims = getClaimsFromToken(token);
        return claims.getExpiration();
    }

    /**
     * 判断token是否可以刷新
     * @param token
     * @return
     */
    public boolean canRefresh(String token){
        return isTokenExpired(token);
    }

    public String refresh(String token){
        Claims claims = getClaimsFromToken(token);
        claims.put(CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }

}

5. 自定义Realm

进行验证和授权操作

package com.yang.server.config.shiro;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.yang.server.mapper.AdminMapper;
import com.yang.server.pojo.Admin;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.UnauthenticatedException;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;

public class AccountRealm extends AuthorizingRealm {

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Autowired
    private AdminMapper adminMapper;

    /**
     * 支持jwt token
     *
     * @param token
     * @return
     */
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JwtToken;
    }

    /**
     * 登录认证
     *
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        JwtToken jwtToken = (JwtToken) authenticationToken;
        String token = (String) jwtToken.getPrincipal();
        // 没有token，未登录，防止登录
        if (token.equals("")){
            throw new UnauthenticatedException("未登录");
        }

        // 判断token是否过期
        if (jwtTokenUtil.isTokenExpired(token)) {
            throw new ExpiredCredentialsException("token过期");
        }
        // 未过期，判断是否存在该用户
        String username = jwtTokenUtil.getUserNameFromToken(token);
        System.out.println("AccountRealm===>username:" + username);
        Admin admin = adminMapper.selectOne(new QueryWrapper<Admin>().eq("username", username));
        // 用户不存在
        if (admin == null) {
            throw new UnknownAccountException("用户不存在");
        }
        // 用户存在, 判断用户是否锁定
        System.out.println(admin.getEnabled());
        if (!admin.getEnabled()) {
            throw new LockedAccountException("用户被锁定");
        }
        // 用户未被锁定，放行
        return new SimpleAuthenticationInfo(jwtToken.getPrincipal(), jwtToken.getCredentials(), getName());
    }

    /**
     * 授权
     *
     * @param principals
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }
}
透晓西桥
关注
专栏目录
SpringBoot集成Shiro、Jwt和Redis
10-24
SpringBoot集成Shiro、Jwt和Redis，使用MyBatisPlus框架实现后台数据库操作。
shiro整合jwt+redis
零度的博客
09-17 2970
前两篇文章我们整合了shiro+jwt无状态权限验证，这样只把tocken存储在前端，后端只验证Tocken是否合法。 考虑一个问题就是我们在设置了token过期时间之后会使前端用户退出在APP端的话很不友好，而且也不是很安全。 两种业务模式仅供参考： 1.BS架构时 我需要前端在国半小时自动退出，那么我们可以直接使用tocken过期自动退出。 2.在app端我不想让...
整合shiro+jwt+redis，实现会话共享
weixin_51304175的博客
04-05 2296
第一步：导入shiro-redis的starter包以及jwt的工具包 官方文档：https://github.com/alexxiyang/shiro-redis/blob/master/docs/README.md#spring-boot-starter <dependency> <groupId>org.crazycake</groupId> <artifactId>shiro-redis-spring-boot-starter<.
JWT+shiro+redis整合
yc_Cabbage的博客
08-15 1674
JWT+shiro+redis整合
Shiro+Jwt+Redis
最新发布
qq_43907296的博客
05-27 782
​ 而JWT(全称：Json Web Token)是一种特殊的Token，它采用了JSON格式来对Token进行编码和解码，并携带了更多的信息，例如用户ID、角色、权限等。它包含了三部分：头部（Header）、数据（Payload）和签名（Signature）。其中，头部和数据都是经过Base64编码的JSON字符串，而签名是对头部和数据进行签名后得到的字符串。
基于springboot+shiro+jwt+vue+redis的后台管理系统源码.zip
01-08
1、基于springboot+shiro+jwt+vue+redis的后台管理系统源码.zip 2、该资源包括项目的全部源码，下载可以直接使用！ 3、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料...
基于springboot+mybatis+shiro+redis+vue构建的前后端分离的企业通用办公管理系统，特别适合个人学习
06-16
基于 springboot+mybatis_+shiro + redis+activiti+quarts+quartz+vue 写的一个前后分离办公企业管理系统 ，通用服务端，用于学习。 使用技术 服务端： springboot(2.2.1) + mybatis-push + shiro(1.4.0) + redis +...
boot_shiro_jwt:springboot+shiro+redis+jwt 基于Restful接口用户权限认证
05-14
【标题】"boot_shiro_jwt:springboot+shiro+redis+jwt 基于Restful接口用户权限认证" 涉及的核心技术是将Spring Boot、Apache Shiro、Redis和JSON Web Tokens（JWT）结合，以实现一个现代化的、安全的RESTful API...
SpringBoot+shiro+redis+jwt .zip
01-03
本项目通过`SpringBoot`整合`Shiro`和`Redis`，利用`JWT`来实现用户鉴权，旨在提供一种简洁、高效的解决方案。 首先，`SpringBoot`简化了传统`Spring`项目的配置和依赖管理，通过自动配置特性，开发者可以快速构建...
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统
04-19
报表后端采用技术： SpringBoot整合SSM，spring security 全注解式的权限管理和JWT方式禁用Session,采用redis存储token及权限信息 报表前端采用Bootstrap框架，结合Jquery Ajax，整合前端Layer.js（提供弹窗）+...
SpringBoot+Shiro+JWT+Jedis+MybatisPlus+前后端分离+基于url通用权限管理系统
01-25
前后端分离（这里只展示后台），基于url拦截的通用权限管理系统，采用jwt+redis的机制取代传统session+cookie的认证授权方式，shiro框架，配置Jedis，以redis作缓存
SpringBoot_Shiro_JWT_Redis:SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新
05-14
SpringBoot_Shiro_JWT_Redis SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新 前端代码为一个博客页面，使用了Semantic UI框架结合thymeleaf模板 SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权 [TOC] 一、引言 ​ 在微服务中我们一般采用的是无状态登录，而传统的session方式，在前后端分离的微服务架构下，如继续使用则必将要解决跨域sessionId问题、集群session共享问题等等。这显然是费力不讨好的，而整合shiro，却很不恰巧的与我们的期望有所违背，原因： 　　（1）shiro默认的拦截跳转都是跳转url页面，而前后端分离后，后端并无权干涉页面跳转。 　　（2）shiro默认使用的登录拦截校验机制恰恰就是使用的session。 　　这当然不是我们
Shiro + JWT + SpringBoot + MySQL + Redis(Jedis)实现无状态鉴权机制
10-17
Shiro + JWT + SpringBoot + MySQL + Redis(Jedis)实现无状态鉴权机制(Restful风格API)(改为数据库形式(MySQL)) 博客源码 附件
springboot整和jwt、shiro、redis实现token自动刷新
08-19
springboot整和jwt、shiro、redis实现token自动刷新
ShiroJwt：API SpringBoot + Shiro + Java-Jwt + Redis（Jedis）
02-04
ShiroJwt 前端地址： : 疑问查看 项目相关 JavaDoc： ： 关联文档： : 教程目录： : 可转换数据库形式（MySQL）： : 解决无法直接返回401错误： ://note.dolyw.com/shirojwt/ShiroJwt03-401.html 实现Shiro的Cache（Redis）功能： : 项目介绍 RESTful API Maven集成Mybatis Generator（逆向工程） Shiro + Java-JWT实现无状态鉴权机制（令牌） 密码加密（采用AES-128 + Base6
shiro-redis-jwt整合
qq_41184981的博客
10-31 957
一、整合流程逻辑 二、整合步骤 1. 导入shiro-redis的starter包：还有jwt的工具包，以及为了简化开发，我引入了hutool工具包。 <!--shiro-redis整合--> <dependency> <groupId>org.crazycake</groupId> <artifactId>shiro-redis-spring-boot-starter</artifactId> <ver
前后端分离权限设计方案:shiro+redis+jwt
热门推荐
weixin_43401380的博客
08-30 1万+
1.postman模拟用户发送请求. 登录接口: 访问登录外的其他接口: 请求头中添加cookie信息: 用户发送每次请求都会校验是否存储的用户认证信息,如果没有则会默认请求访问登录接口 源码如下: AccessControlFilter.java有很多子类,具体走哪个过滤器可以从shiro配置中自行配置,这里配置的是 自定义的PersonalUserFilter(主要作用是根据业务逻辑如果无认证信息就直接异常提示),下面就贴一下这个的源码: ...
Shiro+JWT+Redis实现用户校验
m0_60561133的博客
08-29 487
Shiro基础知识 1. shiro基本功能 认证：验证用户登录认证； 授权：即权限验证，对已经登录的用户验证是否有相应的权限； 会话管理：用户在认证成功之后创建会话，当前用户的所有信息都会保存在这个会话中； 密码管理：加密管理，对敏感信息进行加密处理； 2. shiro核心组件 subject：表示当前用户角色及权限信息 Security Manager:安全管理器，实现对内部实例的管理，并通过他来提供安全管理的各种服务 Realm：相当于shiro进行认证和授权的数据源， Authenticator:认
分布式权限 shiro + jwt + redis(第三期)
qq_21561833的博客
10-30 1660
但是自己这个项目最开始使用的shiro，而且权限对应的角色，菜单都已经写好了，所以主体采用的shiro。使用jwt 标识每个用户的身份。使用redis 存储每个用户的权限。JWT由3部分组成：标头(Header)、有效载荷(Payload)和签名(Signature)。在传输的时候，会将JWT的3部分分别进行Base64编码后用.进行连接形成最终传输的字符串。在这个realm里面有认证和授权的逻辑。然后可以从jwt字符串中解析出用户的id。生成token，将用户id和锁拥有的权限存储进入redis。
shiro+jwt+redis
05-19
Shiro是一个强大且易于使用的Java安全框架，可以用于认证、授权、加密、会话管理等安全操作。 JWT（JSON Web Token）是一种用于身份验证的开放标准，可安全地在客户端和服务器之间传输信息。 Redis是一种快速、可扩展的内存数据存储，可用于缓存、会话管理等用途。 结合Shiro、JWT和Redis可以实现以下功能： 1. 用户身份验证：使用JWT生成令牌，对于每个请求，后端可以使用Shiro来验证令牌，并从Redis中获取用户数据。 2. 用户权限控制：使用Shiro的授权功能，可以根据用户的角色和权限来控制用户对资源的访问。 3. 会话管理：使用Redis作为Shiro的会话存储，可以实现分布式环境下的会话管理，并且可以轻松地实现会话的共享和失效。 综上所述，结合Shiro、JWT和Redis可以实现一个强大、安全、可扩展的Web应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值