第九篇：SpringBoot整合Shiro+Jwt

最新推荐文章于 2024-11-01 00:03:14 发布
最新推荐文章于 2024-11-01 00:03:14 发布
阅读量482 收藏 4
点赞数
分类专栏： SpringBoot 文章标签： shiro jwt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_Qiang17/article/details/104803992
版权

Shiro安全认证框架

Shiro 概述

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架，使用shiro就可以非常快速的完成认证、授权等功能的开发，降低系统成本。

Shiro 认证流程

在这里插入图片描述
具体流程分析如下:

  1. 首先调用Subject.login(token)进行登录，其会自动委托给Security Manager，调用之前必须通过SecurityUtils. setSecurityManager()设置；
  2. SecurityManager负责真正的身份验证逻辑；它会委托给Authenticator进行身份验证；
  3. Authenticator才是真正的身份验证者，Shiro API中核心的身份认证入口点，此处可以自定义插入自己的实现；
  4. Authenticator可能会委托给相应的AuthenticationStrategy进行多Realm身份验证，默认ModularRealmAuthenticator会调用AuthenticationStrategy进行多Realm身份验证；
  5. Authenticator会把相应的token传入Realm，从Realm获取身份验证信息，如果没有返回/抛出异常表示身份验证失败了。此处可以配置多个Realm，将按照相应的顺序及策略进行访问。
Jwt

  1. 什么是JWT
    JWT(Json Web Token)，是一种工具，格式为XXXX.XXXX.XXXX的字符串，JWT以一种安全的方式在用户和服务器之间传递存放在JWT中的不敏感信息。

  2. 为什么要用JWT
    设想这样一个场景，在我们登录一个网站之后，再把网页或者浏览器关闭，下一次打开网页的时候可能显示的还是登录的状态，不需要再次进行登录操作，通过JWT就可以实现这样一个用户认证的功能。当然使用Session可以实现这个功能，但是使用Session的同时也会增加服务器的存储压力，而JWT是将存储的压力分布到各个客户端机器上，从而减轻服务器的压力。

  3. JWT长什么样子？
    JWT由3个子字符串组成，分别为Header，Payload以及Signature，结合JWT的格式即：Header.Payload.Signature。（Claim是描述Json的信息的一个Json，将Claim转码之后生成Payload）。

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1ODY1MTA3MTIsInVzZXJuYW1lIjoiZGV2aW4ifQ.9MHYCpJCfKBbaDcJV4NUneL8OM9BdNaNrLgGW3Nznxc
Shiro + Jwt 应用实践
  1. pom.xml 添加 Shiro 和 Jwt 依赖
		<!-- 整合shiro -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
        </dependency>
        
        <!-- jwt依赖 -->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.2.0</version>
        </dependency>
  1. 编写 JwtUtil 工具类
@Component
public class JwtUtil {


    /**
     * 失效时间
     */
    private static final long EXPIRE_TIME = 5 * 60 * 1000;

    /**
     * 生成token 5分钟后过期
     * @author 药岩
     * @date 2020/2/10
     * @param  * @param username
     * @return java.lang.String
     */
    public static String sign(String username, String secret){
        Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
        try {
            Algorithm algorithm = Algorithm.HMAC256(secret);
            return JWT.create()
                    //payload 载荷
                    .withClaim("username", username)
                    //设置过期时间
                    .withExpiresAt(date)
                    //创建一个新的JWT，并使用给定的算法进行标记
                    .sign(algorithm);
        } catch (UnsupportedEncodingException e) {
            return null;
        }

    }

    /**
     * 校验token是否正确
     * @author 药岩
     * @date 2020/2/10
     * @param  * @param token
     * @param userName 
     * @return boolean
     */
    public static boolean validateToken(String token, String userName, String secret){
        try {
            Algorithm algorithm = Algorithm.HMAC256(secret);
            //在token中附带了username信息
            JWTVerifier verifier = JWT.require(algorithm)
                    .withClaim("username", userName)
                    .build();
            //验证token
            verifier.verify(token);
            return true;
        } catch (Exception e) {
            return false;
        }

    }

    /**
     * 获取token中的信息无需secretKey也能获取
     * @author 药岩
     * @date 2020/2/10
     * @param  * @param token 
     * @return java.lang.String
     */
    public static String getUserName(String token){
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("username").asString();
        } catch (JWTDecodeException e) {
            return null;
        }
    }
}
  1. 编写 JwtToken 实现 AuthenticationToken 接口
public class JwtToken implements AuthenticationToken {

    private static final long serialVersionUID = 2334863906091691445L;
    /**
     * 秘钥
     */
    private String token;


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


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

    @Override
    public Object getCredentials() {
        return token;
    }
}
  1. 自定义 shiro 的过滤器，不要使用 shiro 默认的过滤器
public class JwtShiroFilter extends BasicHttpAuthenticationFilter {
    private final Logger log = LoggerFactory.getLogger(JwtShiroFilter.class);

    @Autowired
    private RedisUtil redisUtil;

    /**
     * 如果带有 token，则对 token 进行检查，否则直接通过
     * @param request
     * @param response
     * @param mappedValue
     * @return
     * @throws UnauthorizedException
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws UnauthorizedException {
        if (isLoginAttempt(request, response)) {
            try {
                executeLogin(request, response);
                return true;
            } catch (Exception e) {
                //非法请求
                responseError(response, e.getMessage());
            }
        }
        //如果请求头不存在 Token，则可能是执行登陆操作或者是游客状态访问，无需检查 token，直接返回 true
        return true;
    }

    /**
     * 判断用户是否想要登入
     * @author 药岩
     * @date 2020/2/10
     * @param  * @param request
     * @param response 
     * @return boolean
     */
    @Override
    protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
        HttpServletRequest httpServletRequest = (HttpServletRequest)request;
        String authorization = httpServletRequest.getHeader("Authorization");   
        return authorization != null;
    }

    /**
     * 执行登陆操作
     */
    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception{
        HttpServletRequest httpServletRequest = (HttpServletRequest)request;
        String authorization = httpServletRequest.getHeader("Authorization");
        JwtToken token = new JwtToken(authorization);

        // 提交给realm进行登入，如果错误他会抛出异常并被捕获
        getSubject(request, response).login(token);
        // 如果没有抛出异常则代表登入成功，返回true
        return true;

    }


    /**
     * 对跨域提供支持
     */
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) 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"));
        // 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }

    /**
     * 将非法请求跳转到 /401
     */
    private void responseError(ServletResponse response, String message) {
        try {
            HttpServletResponse httpServletResponse = (HttpServletResponse) response;
            //设置编码，否则中文字符在重定向时会变为空字符串
            message = URLEncoder.encode(message, "UTF-8");
            httpServletResponse.sendRedirect("/unauthorized/" + message);
        } catch (IOException e) {
            log.error(e.getMessage());
        }
    }
}
  1. 自定义 JwtShiroRealm 继承 AuthorizingRealm 实现认证与授权
/**
 * 监视授权信息
 * @ClassName ShiroUserRealm
 * @Author 药岩
 * @Date 2020/2/10
 * Version 1.0
 */
public class JwtShiroRealm extends AuthorizingRealm {

    @Autowired
    private AuthorityDao authorityDao;

    @Autowired
    private LoginDao loginDao;

    @Autowired
    private LoginServer loginServer;

    public void setLoginServer(LoginServer loginServer){
        this.loginServer = loginServer;
    }

    /**
     * 判断token是否事我们的这个jwttoekn
     */
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof JwtToken;
    }

    /**
     * 认证
     * @author 药岩
     * @date 2020/2/10
     * @param  * @param authcToken
     * @return org.apache.shiro.authc.AuthenticationInfo
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
      
        //0. token中存储着输入的用户名
        String token = (String) auth.getCredentials();

        //1. token解密获取username
        String userName = JwtUtil.getUserName(token);
        if (userName == null){
            throw new AuthenticationException("token令牌有误");
        }

        //2.根据用户名去数据库查找是否存在该用户
        Users users = loginDao.selectUserData(userName);

        if(users == null){
            throw new AuthenticationException("用户不存在");
        }

        //3.判断token令牌是否有误
        if (!JwtUtil.validateToken(token, userName, users.getPassword())){
            throw new AuthenticationException("token令牌过期失效");
        }

        return new SimpleAuthenticationInfo(token, token, "jwtRealm");
    }


    /**
     * 授权
     * @author 药岩
     * @date 2020/2/10
     * @param  * @param principals 
     * @return org.apache.shiro.authz.AuthorizationInfo
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        //1.获取用户信息
        String userName = JwtUtil.getUserName(principals.toString());

        //2.根据用户名查找该用户
        Users users = loginDao.selectUserData(userName);

        //2.根据用户信息-->角色信息-->获取资源的访问权陿
        List<String> menus = authorityDao.findUserPermissions(users.getId());
        //3.根据用户信息直接获取访问权限
        List<String> userMenu = authorityDao.findUserMenuPermissions(users.getId());
        //查询角色
        List<String> role = authorityDao.findRoleByUserId(users.getId());
        List<String> list = new ArrayList<>();
        if(menus!=null){
            list.addAll(menus);
        }
        if(userMenu!=null){
            list.addAll(userMenu);
        }
        //4.去重权限
        Set<String> set=new HashSet<>(list);
        Set<String> setRole = new HashSet<>(role);
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.setStringPermissions(set);

        info.setRoles(setRole);
        return info;
    }

}
  1. 编写 Shiro 的配置类 ShiroConfig
/**
 * Shiro 的配置类
 * @ClassName ShiroConfig
 * @Author 药岩
 * @Date 2020/2/10
 * Version 1.0
 */

@Configuration
public class ShiroConfig {

    /**
     * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
     * 配置以下两个bean(DefaultAdvisorAutoProxyCreator和AuthorizationAttributeSourceAdvisor)即可实现此功能
     * @author 药岩
     * @date 2020/2/10
     * @param  * @param
     * @return org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator
     */
    @Bean
    @ConditionalOnMissingBean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator autoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        autoProxyCreator.setProxyTargetClass(true);
        return autoProxyCreator;
    }


    /**
     * 开启aop注解支持
     * @author 药岩
     * @date 2020/2/10
     * @param  * @param securityManager
     * @return org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

    /**
     * 自定义shiro
     * @author 药岩
     * @date 2020/2/10
     * @param  * @param
     * @return com.app.common.ShiroUserRealm
     */
    @Bean("jwtRealm")
    public JwtShiroRealm shiroUserRealm(){
        JwtShiroRealm userRealm = new JwtShiroRealm();
        return userRealm;
    }

    /**
     * 注入SecurityManager
     * 配置shiro安全管理器,是shiro框架的核心安全管理器
     * @author 药岩
     * @date 2020/2/10
     * @param  * @param
     * @return org.apache.shiro.mgt.SecurityManager
     */
    @Bean
    public SecurityManager securityManager(){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        defaultWebSecurityManager.setRealm(shiroUserRealm());

        //关闭shiro自带的session
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        defaultWebSecurityManager.setSubjectDAO(subjectDAO);
        return defaultWebSecurityManager;
    }

    /**
     * shiroFilter 的工厂配置
     * @author 药岩
     * @date 2020/2/10
     * @param  * @param securityManager
     * @return org.apache.shiro.spring.web.ShiroFilterFactoryBean
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

        //添加自定义shiro的拦截器
        Map<String, Filter> jwtFilter = new HashMap<>();
        jwtFilter.put("jwt", new JwtShiroFilter());
        shiroFilterFactoryBean.setFilters(jwtFilter);

        //必须设置 securityManager
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        //设置无权限时跳转的URL
        shiroFilterFactoryBean.setUnauthorizedUrl("/unauthorized/无权限");

        //自定义URL
        Map<String, String> map = new HashMap<>();
        map.put("/user/doLogin", "anon");
        map.put("/user/logout", "logout");
        map.put("/swagger-ui.html", "anon");
        map.put("/swagger-resources/**", "anon");
        map.put("/unauthorized/**", "anon");
        map.put("/**", "jwt");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;

    }

}
  1. 添加全局异常处理类
/**
 * 全局异常处理
 * @ClassName GlobalExceptionHandler
 * @Author 药岩
 * @Date 2020/4/10
 * Version 1.0
 */

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {

    /**
     * 处理shiro抛出的异常
     * @author 药岩
     * @date 2020/2/10
     * @param  * @param e
     * @return com.app.common.CommonResult
     */

    @ExceptionHandler(ShiroException.class)
    public CommonResult handleShiroException(Exception e){
        log.error("shiro error[{}]", e.getMessage());
        return CommonResult.failed(401, "您没有权限访问", new int[]{});
    }

    @ExceptionHandler(Exception.class)
    public CommonResult handleException(HttpServletRequest request, Throwable e){
        log.error("系统访问异常error[{}]", e.getMessage());
        return CommonResult.failed(getStatus(request).value(), "访问出错，无法访问：" + e.getMessage(), new int[]{});
    }

    public HttpStatus getStatus(HttpServletRequest request){
        Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
        if (statusCode == null){
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
        return HttpStatus.valueOf(statusCode);
    }


}
  1. controller 层用户登入认证
/**
 * 用户登入验证
 * @ClassName LoginController
 * @Author 药岩
 * @Date 2020/2/10
 * Version 1.0
 */

@RestController
@RequestMapping(value = "/user")
@Api(tags = "LoginController", description = "用户登入验证")
@Slf4j
public class LoginController {

    @Autowired
    private LoginServer loginServer;

    @Autowired
    private RedisUtil redisUtil;

    /**
     * 用于用户登入验证
     * @param
     * @param
     * @return
     */
    @PostMapping(value = "/doLogin")
    public CommonResult login(@RequestBody Users usersLogin,
                              @RequestParam(required=true,value="checked",defaultValue="") String checked,  HttpServletResponse response, HttpServletRequest request) throws UnauthorizedException {
		//通过用户名
        Users users = loginServer.selectUserData(usersLogin.getLoginName());
        if (users == null){
            return CommonResult.failed("用户不存在", new Object[]{});
        }
        usersLogin.setPassword(DigestUtils.md5DigestAsHex(usersLogin.getPassword().getBytes()));
        if (users.getPassword().equals(usersLogin.getPassword())){
            String token = JwtUtil.sign(usersLogin.getLoginName(), usersLogin.getPassword());          
            response.setHeader("Authorization", token);
            log.info("用户[{}]登入成功，生成token[{}]", users.getLoginName(), token);
            return CommonResult.success(token, "登入成功");
        }else {
            return CommonResult.failed("用户名密码错误", new Object[]{});
        }

    }

    /**
     * 登出操作
     */
    @RequestMapping("logout")
    public CommonResult logout(HttpServletRequest request){
        SecurityUtils.getSubject().logout();
        redisUtil.del(request.getHeader("Authorization"));
        return CommonResult.success(new Object[]{}, "登出成功");
    }
}
  1. Postman 测试
    用户登入
    在这里插入图片描述
    携带 token 访问接口资源
    在这里插入图片描述
Springboot整合Shiro+JWT
weixin_43424751的博客
04-18 579
在前后端分离的项目中我们通常会采用jwttoken的方式来作为跨域身份验证解决方案。 引入依赖 <dependency> <groupId>org.crazycake</groupId> <artifactId>shiro-redis-spring-boot-starter</artifactId> <version>3.2.1</version> </dependency> <!
Springboot+Shiro+Jwt实现权限控制
2301_76607156的博客
04-24 1919
因为需要实现一个设备管理系统的权限管理模块，在查阅很多博客以及其他网上资料之后，发现重复、无用的博客很多，因此写一篇文章来记录，以便后面复习。书写顺序。
Spring boot整合shiro+jwt实现前后端分离
08-25
主要为大家详细介绍了Spring boot整合shiro+jwt实现前后端分离，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
springboot集成shiro+jwt详解+完整实例
Timmer的博客
05-26 8397
目录 简介 目的 需要的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集成Shiro+Jwt+Redis
最新发布
weixin_40017062的博客
11-01 641
SpringBoot集成Shiro+Jwt+Redis实现登录认证、权限控制
springboot的模块化开发，集成shiro+jwt实现restful接口的token认证
05-14
最近在搞springboot的模块化开发，集成了shiro+jwt实现restful接口的token认证。 需新增测试表： CREATE TABLE `t_user` ( `user_id` int(11) unsigned zerofill NOT NULL AUTO_INCREMENT, `user_name` varchar(32) DEFAULT '', PRIMARY KEY (`user_id`) )ENGINE=InnoDB DEFAULT CHARSET=utf8 ; CREATE TABLE `auth_user` ( `userId` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '管理员id', `username` varchar(64) NOT NULL DEFAULT '' COMMENT '用户名', `password` varchar(64) NOT NULL DEFAULT '' COMMENT '密码', `salt` varchar(16) DEFAULT NULL COMMENT '扰码', PRIMARY KEY (`userId`) ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COMMENT='管理员表'; -- ---------------------------- -- Records of auth_user -- ---------------------------- INSERT INTO `auth_user` VALUES ('1', 'admin', '958d51602bbfbd18b2a084ba848a827c29952bfef170c936419b0922994c0589', '123456'); INSERT INTO `auth_user` VALUES ('2', 'test', '958d51602bbfbd18b2a084ba848a827c29952bfef170c936419b0922994c0589', '123456');
SpringBoot整合Shiro+Jwt
Amber_Flying的博客
08-28 1873
springboot整合shiro+jwt 学习博客链接:https://blog.csdn.net/wws_p/article/details/107126321(万分感谢) 一、搭建数据库环境 CREATE DATABASE `shiro`; USE `shiro`; DROP TABLE IF EXISTS `role_per`; CREATE TABLE `role_per` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '表主键
基于springboot+shiro+jwt+vue+redis的后台管理系统.zip
08-31
标题 "基于springboot+shiro+jwt+vue+redis的后台管理系统" 描述了一款采用现代技术栈构建的高效、安全且可扩展的后端管理平台。在这个系统中，SpringBoot作为核心框架提供了快速开发的能力，Shiro是用于权限管理和...
Springboot+Shiro+Jwt实现简单的权限控制
xxxzzzqqq_的博客
04-26 1602
因为需要实现一个设备管理系统的权限管理模块，在查阅很多博客以及其他网上资料之后，发现重复、无用的博客很多，因此写一篇文章来记录，以便后面复习。书写顺序。
SpingBoot整合Shiro和JWT
weixin_46648650的博客
03-14 5987
SpingBoot整合Shiro和JWT 项目地址：https://github.com/seam95/SpringBoot-Shiro-Jwt.git Shiro学习知识点 Authentication：身份认 证 / 登录，验证用户是不是拥有相应的身份； Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限； Session Management：会话管
springboot结合shiro和jwt
龙泉诗
03-17 376
项目结构 增加全局异常配置 /** * @Description GlobaException 全局的异常配置 * @Author YiLong Wu * @Date 2020-03-11 22:28 * @Version 1.0.0 */ @RestControllerAdvice public class GlobalException { /** * 处理用户...
SpringBoot整合Shiro+JWT
05-15
本Demo案例为SpringBoot整合Shiro + JWT实现用户认证，代码注释全都有以及sql文件都已经打包，下载之后刷新pom依赖即可直接运行。
SpringBoot集成Shiro、Jwt和Redis
10-24
SpringBoot集成Shiro、Jwt和Redis，使用MyBatisPlus框架实现后台数据库操作。
SpringBoot-Shiro-JWT:spring boot 结合shiro和jwt技术的实践
04-29
springBoot-shiro-jwt 一. shiro 整合 springBoot 实现基本的角色权限控制 二. shiro + springBoot 整合 JWT
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。 　　这当然不是我们
【Java专题_01】springboot+Shiro+Jwt整合方案
热门推荐
weixin_40736233的博客
04-02 1万+
【Java专题_01】springboot+Shiro+Jwt整合方案
springboot+shiro+jwt 兼容session和token
qq_30255033的博客
06-13 2118
springboot+shiro+jwt 兼容session和token
SpringBoot+JWT+Shiro
jakelihua
08-20 731
本文讲解，如何用SpringBoot整合JWT与Shiro。对于JWT和Shiro的讲解看这两篇文章，本文只讲解，最后的结合的代码。
前后端分离SpringBoot整合shiro，使用JWT进行验证
CSDN1642816671的博客
08-05 1099
今天的主要任务是将权限和安全管理搭建完成，首先是在pom中引入相关的jar包 然后在指定的位置创建文件 ShiroConfig是指定shiro注入关系的配置类，这里我直接贴出代码 package com.mansh.vschool.config; import com.mansh.vschool.custom.DatabaseRealm; import com.mansh.vsc...
SpringBoot+Shiro+JWT+Vue+Redis后台系统源码下载
资源摘要信息: "基于springboot+shiro+jwt+vue+redis的后台管理系统.zip" 本资源提供了一个后端管理系统，它融合了多种流行的IT技术栈，包括Spring Boot、Shiro、JWT、Vue和Redis。这个系统的开发难度适中，源码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值