shiro学习四：使用springboot整合shiro，正常的企业级后端开发shiro认证鉴权流程。使用redis做token的过滤。md5做密码的加密。

最新推荐文章于 2023-04-13 12:17:43 发布
最新推荐文章于 2023-04-13 12:17:43 发布
阅读量439 收藏 1
点赞数
分类专栏： shiro 文章标签： 过滤器 shiro java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40036754/article/details/111638183
版权

文章目录

前言

一、逻辑

1. 登录逻辑

shiro 做安全权限控制。那么shiro的过滤器和数据源的处理主要是针对token的认证和授权。
而用户的密码验证则还是在service层中进行处理。

  1. 首先将用户登录的接口 /user/login 在shiro过滤器中放开，不在拦截，设置为 anon
  2. 发送post请求携带用户名和密码，进行登录。走这个请求时，在上一步已经被设置了白名单。走控制器，业务层service，在这里进行判断，用户名密码判断无误后，设置token和id，然后返回到前端。
  3. 总结一下：用户的密码登录和shiro是无关的，正常的判断即可。注意的是需要返回的数据，这里仅有id和token。token也是UUID生成的，并存在redis中。
  4. 访问其他接口时，拿着token放在请求头中，然后发请求，没有被shiro设置在白名单里的请求会被shiro拦截，拦截流程如下：
    ShiroAccessControlFilter类：isAccessAllowed()：onAccessDenied(),用到了ShiroUsernamePasswordToken类
    ->ShiroRealm类:doGetAuthenticationInfo方法
    ->ShiroHashedCredentialsMatcher类：doCredentialsMatch（）
  5. 根据博客三，这里重写的doCredentialsMatch()方法就是 shiro的过滤器的最后一步，也是至关重要的一步。
    6. 接下来就可以去控制的接口了，如果遇到@RequiresPermissions() 注解，再去ShiroRealm类中doGetAuthorizationInfo（）授权方法去授予权限即可，再去接口即可。

2. 项目目录结构

在这里插入图片描述

3. 开发逻辑

a. redis 开发工具类

redis的配置类和工具类，我就不再贴出，本博客主要写shiro的代码，代码可去GitHub上拉取下来观看

  1. config包下的RedisConfig配置类
  2. serializer包下的MyStringRedisSerializer序列化类
  3. utils包下的RedisUtil类

代码不再贴了，都在GitHub上

b. 密码加密工具类

  1. utils 包下的 PasswordUtils 工具类。
  2. PasswordEncoder密码编码类。

代码不再贴了，都在GitHub上

c. swagger配置

  1. config包下的 SwaggerConfig配置类
  2. 配置类上的启动注解 @EnableSwagger2

代码不再贴了，都在GitHub上

d. shiro开发 流程

  1. 先开发 ShiroConfig，设置自定义过滤器 ShiroAccessControlFilter，并设置过滤器的白名单
    对登录的请求设置为 anon。
  2. 开发 ShiroAccessControlFilter拦截器，这里是对 token 的简单过滤验证，并进行主体提交，提交到自定义数据域 realm。
    开发拦截器中，还要开发ShiroUsernamePasswordToken，自己实现shiro认证机制，就要重写类 UsernamePasswordToken
  3. 开发自定义realm：ShiroRealm类。数据域部分，进行授权和认证。
    认证：对token进行过滤，用户名密码登录部分还是在业务层处理
    授权：从数据库中获取，设计到表 role、permission、user_role、role_permission 四个表
  4. 开发 token 的最后过滤处理 ShiroHashedCredentialsMatcher，继承 HashedCredentialsMatcher类实现方法doCredentialsMatch()

以上四步其实就是 shiro 开发的全部，基本上都是配置式的代码。

二、shiro代码开发

1. shiroConfig.java

package com.feng.config;

import com.feng.shiro.ShiroAccessControlFilter;
import com.feng.shiro.ShiroHashedCredentialsMatcher;
import com.feng.shiro.ShiroRealm;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

@Configuration
public class ShiroConfig {

    /**
     * token 的过滤
     * 自定义token 校验
     * 学习说明：其实 下面的 ShiroHashedCredentialsMatcher（自定义的） 也继承了 HashedCredentialsMatcher。
     * 需要在 CustomRealm bean 中进行设置
     * @return
     */
    @Bean(name = "shiroHashedCredentialsMatcher")
    public ShiroHashedCredentialsMatcher shiroHashedCredentialsMatcher() {
        return new ShiroHashedCredentialsMatcher();
    }

    /**
     * 登录的 认证域
     *
     * @param hashedCredentialsMatcher
     * @return
     */
    @Bean(name = "shiroRealm")
    public ShiroRealm getShiroRealm(@Qualifier("shiroHashedCredentialsMatcher") HashedCredentialsMatcher hashedCredentialsMatcher) {
        ShiroRealm shiroRealm = new ShiroRealm();
        // 自定义 处理 token 过滤
        shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher);
        return shiroRealm;
    }


    /**
     * shiro 的安全管理器
     *
     * @param shiroRealm
     * @return
     */
    @Bean(name = "securityManager")
    public SecurityManager securityManager(@Qualifier("shiroRealm") ShiroRealm shiroRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(shiroRealm);
        return securityManager;
    }
    /**
     * shiro 的过滤器
     * 需要了解 shiro 的权限关键字含义：
     *  anon，表示不拦截的路径
     *  authc,表示拦截的路径
     *
     *  匹配时，首先匹配 anon 的，然后最后匹配 authc
     *
     * @param securityManager
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(@Qualifier("securityManager") SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        /*
         * 自定义过滤器
         * */
        //自定义拦截器限制并发人数,参考博客：
        LinkedHashMap<String, Filter> filtersMap = new LinkedHashMap<>();
        //用来校验token
        filtersMap.put("token", new ShiroAccessControlFilter());
        shiroFilterFactoryBean.setFilters(filtersMap);
        /*
         * 以下为权限控制
         * */
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        // 配置不会被拦截的链接 顺序判断
        filterChainDefinitionMap.put("/user/login", "anon");
//        filterChainDefinitionMap.put("/user/test", "anon");

        // 拦截所有
        filterChainDefinitionMap.put("/**", "token,authc");

        // 没有登录的用户请求需要登录的页面时自动跳转到登录页面。 配置 shiro 默认登录界面地址，
        shiroFilterFactoryBean.setLoginUrl("/api/user/login");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }

    /**
     * 下面两个配置类 AuthorizationAttributeSourceAdvisor 和 DefaultAdvisorAutoProxyCreator，开启 shiro aop 注解 支持.
     * 使用代理方式;所以需要开启代码支持;
     * <p>
     * 如果不加 使用 @RequirePermissions 无效
     *
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

    @Bean
    @ConditionalOnMissingBean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }
}

2. ShiroAccessControlFilter

package com.feng.shiro;

import com.alibaba.fastjson.JSON;
import com.feng.constant.Constant;
import com.feng.exception.BusinessException;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authc.*;
import org.apache.shiro.web.filter.AccessControlFilter;
import org.springframework.util.StringUtils;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName: CustomAccessControlerFilter
 * @Description： 自定义的 token 过滤器。
 * @createTime:
 * @Author: 冯凡利
 * @UpdateUser: 冯凡利
 * @Version: 0.0.1
 */

/**
 * 这里的异常，全局异常无法处理，比较高级没有到达 方法，所以需要自己处理  try-catch
 */
@Slf4j
public class ShiroAccessControlFilter extends AccessControlFilter {
    /**
     * 是否 允许 访问下一层
     * true： 允许，交下一个Filter 处理
     * false： 交给自己处理，往下执行 onAccessDenied 方法
     * @param servletRequest
     * @param servletResponse
     * @param o
     * @return
     * @throws Exception
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest servletRequest, ServletResponse servletResponse, Object o) throws Exception {
        return false;
    }

    /**
     * 表示访问拒绝时是否自己处理，
     * 如果返回 true 表示自己不处理且 继续拦截器执行，往下执行
     * 返回 false 表示自己已经处理了（比如重定向到另一个界面）处理完毕。
     *
     * @param servletRequest
     * @param servletResponse
     * @return
     * @throws Exception
     */
    @Override
    protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
        HttpServletRequest request= (HttpServletRequest) servletRequest;
        try {
            log.info("接口请求方式{}",request.getMethod());
            log.info("接口请求地址",request.getRequestURI());
            String token=request.getHeader(Constant.TOKEN_SESSION_ID);
            if(StringUtils.isEmpty(token)){
                throw new BusinessException(4010001,"用户凭证已失效请重新登录认证");
            }
            ShiroUsernamePasswordToken customUsernamePasswordToken=new ShiroUsernamePasswordToken(token);
            getSubject(servletRequest,servletResponse).login(customUsernamePasswordToken);
        } catch (BusinessException e) {
            customResponse(e.getMessageCode(),e.getMessage(),servletResponse);
            return false;
        } catch (AuthenticationException e) {
            if(e.getCause() instanceof BusinessException){
                BusinessException businessException= (BusinessException) e.getCause();
                customResponse(businessException.getMessageCode(),businessException.getMessage(),servletResponse);
            }else {
                customResponse(4000001,"用户认证失败",servletResponse);
            }
            return false;
        }catch (Exception e){
            customResponse(5000001,"系统异常",servletResponse);
            return false;
        }
        return true;
    }

    /**
     * 异常处理
     * 因为这里的位置是高于业务层的，所以这里的异常只能通过流的形式输出到前端。
     * @param code
     * @param msg
     * @param response
     */
    private void customResponse(int code, String msg, ServletResponse response) {
        // 自定义异常的类，用户返回给客户端相应的JSON格式的信息
        try {
            Map<String, Object> result = new HashMap<>();
            result.put("code", code);
            result.put("msg", msg);
            response.setContentType("application/json; charset=utf-8");
            response.setCharacterEncoding("UTF-8");
            String userJson = JSON.toJSONString(result);
            // 写入到 流中，返回到客户端
            OutputStream out = response.getOutputStream();
            out.write(userJson.getBytes(StandardCharsets.UTF_8));
            out.flush();
        } catch (IOException e) {
            log.error("eror={}", e.getLocalizedMessage());
        }
    }
}

3. ShiroUsernamePasswordToken

package com.feng.shiro;

import org.apache.shiro.authc.UsernamePasswordToken;

public class ShiroUsernamePasswordToken extends UsernamePasswordToken {

    private String token;

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

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

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

4. ShiroRealm

package com.feng.shiro;

import com.feng.bean.SysUser;
import com.feng.service.PermissionService;
import com.feng.service.RoleService;
import com.feng.service.UserService;
import com.feng.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

@Slf4j
public class ShiroRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;

    @Resource
    private RoleService roleService;

    @Resource
    private PermissionService permissionService;

    @Autowired
    private RedisUtil redisUtil;

    /**
     * 设置支持令牌校验
     *
     */
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof ShiroUsernamePasswordToken;
    }

    /**
     * 授权
     * 主要业务：
     * 系统业务出现要验证用户的角色权限的时候，就会调用这个方法
     * 来获取该用户所拥有的角色/权限
     * 这个用户授权的方法我们可以缓存起来不用每次都调用这个方法。
     * 后续的课程我们会结合 redis 实现它
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        log.info("ShiroRealm.doGetAuthorizationInfo()");
        String token= (String) principalCollection.getPrimaryPrincipal();
        String userId= (String) redisUtil.get(token);
        SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();

        //返回该用户的 角色信息 给授权器
        List<String> roleNames = roleService.getRoleNamesByUserId(userId);
        if (null != roleNames && !roleNames.isEmpty()) {
            info.addRoles(roleNames);
        }
        //返回该用户的 权限信息 给授权器
        Set<String> permissionPerms = permissionService.getPermissionPermsByUserId(userId);
        if (permissionPerms != null) {
            info.addStringPermissions(permissionPerms);
        }
        return info;
    }

    /**
     * 认证
     * 主要业务：
     * 当业务代码调用 subject.login(customPasswordToken); 方法后
     * 就会自动调用这个方法 验证用户名/密码
     * 这里我们改造成 验证 token 是否有效 已经自定义了 shiro 验证
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        log.info("ShiroRealm.doGetAuthenticationInfo()");
        ShiroUsernamePasswordToken token = (ShiroUsernamePasswordToken) authenticationToken;
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo((String)token.getPrincipal(), (String)token.getCredentials(), ShiroRealm.class.getName());
        return info;
    }

    private List<String> getRoleByUserId(String userId){
        List<String> roles=new ArrayList<>();
        if(userId.equals("8a938151-53e6-4182-925a-684f3be840e8")){
            roles.add("admin");
        }
        roles.add("test");
        return roles;
    }

    private List<String> getPermissionsByUserId(String userId){
        List<String> permissions=new ArrayList<>();
        if(userId.equals("8a938151-53e6-4182-925a-684f3be840e8")){
            permissions.add("*");
        }
        permissions.add("sys:user:detail");
        permissions.add("sys:user:edit");
        return permissions;
    }
}

5. ShiroHashedCredentialsMatcher

public class ShiroHashedCredentialsMatcher extends HashedCredentialsMatcher {

    @Autowired
    private RedisUtil redisUtil;

    @Override
    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
        ShiroUsernamePasswordToken shiroUsernamePasswordToken= (ShiroUsernamePasswordToken) token;
        String accessToken = (String) shiroUsernamePasswordToken.getPrincipal();
        if(!redisUtil.hasKey(accessToken)){
            throw new BusinessException(4001002,"授权信息信息无效请重新登录");
        }
        return true;
    }
}

三、业务逻辑控制层代码

package com.feng.controller;

import com.feng.bean.SysUser;
import com.feng.service.UserService;
import com.feng.vo.LoginReqVO;
import com.feng.vo.LoginRespVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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


@Slf4j
@RestController
@RequestMapping("/user")
@Api(tags = "用户模块",description = "用户模块相关接口")
public class LoginController {


    @Autowired
    private UserService userService;


    @GetMapping("/page")
    public String index() {
        return "login";
    }


    /**
     * 前端用表单发请求如果使用 form-data、x-www-form-urlencoded 获取 ，则不可用 @RequestBody接受（因为他接受的为json）
     * @param loginReqVO
     * @return
     */
    @ApiOperation(value = "用户登录接口")
    @PostMapping(value = "/login")
    @ResponseBody
    public Map<String, Object> loginUser(@RequestBody LoginReqVO loginReqVO) {
        LoginRespVO info = userService.login(loginReqVO);
        Map<String, Object> result = new HashMap<>();
        result.put("code", 0);
        result.put("data", info);
        return result;
    }

    @ApiOperation(value = "获取用户详情接口")
    @GetMapping("/getuser/{id}")
    @RequiresPermissions("sys:user:detail")
    public Map<String, Object> getUserAllInfo(@PathVariable("id") String id){
        Map<String, Object> result = new HashMap<>();
        SysUser detail = userService.detail(id);
        result.put("code", 0);
        result.put("data", detail);
        return result;
    }

    @GetMapping("/test")
    public Map<String, Object> test(){
        Map<String, Object> result = new HashMap<>();
        result.put("code", 0);
        result.put("data", "sucess");
        return result;
    }
}

五、postman测试和debug分析

1. 登录

登录的URL 在 ShiroConfig.shiroFilterFactoryBean() 方法中已经被设置成了白名单，在shiro的各处打了断电，也不会进入。直接进入到控制器层返回用户id和token。

http://localhost:8082/user/login
{
    "username": "feng",
    "password": "666666"
}

在这里插入图片描述

2. 获取用户信息

此URL 已经被设置走自定义的 ShiroAccessControlFilter 过滤器。
所以debug发请求分析如下：

  1. 先进入 ShiroAccessControlFilter.isAccessAllowed() 方法
  2. 进入到源码 AccessControlFilter.onPreHandle() 方法，这个方法会调用上面的方法和下面的方法
  3. 在进入到 ShiroAccessControlFilter.onAccessDenied() 方法，在这里获取token，并简单验证token是否存在，然后进行 shiro的主体登录。（一会儿，还会返回来）
  4. 主体登录后，debug 跳转到 ShiroRealm.doGetAuthenticationInfo() 进行认证。
  5. 然后流转到 自定义的核心验证类和方法： ShiroHashedCredentialsMatcher.doCredentialsMatch() 方法 。
  6. 然后返回到第三步 的 ShiroAccessControlFilter.onAccessDenied() 方法 的最后一行返回值，返回值为 true。
  7. 然后流转到 ShiroRealm.doGetAuthorizationInfo() 进行授权。这里进入到授权方法是因为在控制器方法上有注解：@RequiresPermissions("sys:user:detail")
http://localhost:8082/user/getuser/8a938151-53e6-4182-925a-684f3be840e8

在这里插入图片描述

六、注意的点

1. 数据库表的设计

用户登录只涉及到 user 表
shiro的权限授权部分涉及到 role、permission、user_role、role_permission 表。

2. shiro的认证授权流程

一定要多分析下shiro的认证流程，代码执行流程的走向。

java冯坚持
关注
专栏目录
Java企业级权限系统,Spring Security,Apache Shiro,Spring MVC,RBAC模型
08-11
Java企业级权限系统，可供学习Spring Security权限框架、 Apache Shiro权限框架、Spring MVC、 RBAC模型、模块开发等等，内有详细视频教程，由于上传大小限制，可联系免费获取！
Springboot下Shiro+Token使用redis做安全认证方案
Youdmeng的博客
07-07 1653
以前项目中权限认证没有使用安全框架，都是在自定义filter中判断是否登录以及用户是否有操作权限的。 最近开了新项目，搭架子时，想到使用安全框架来解决认证问题，spring security太过庞大，我们的项目不大，所以决定采用Shiro 什么是Shiro Apache Shiro 是一个强大灵活的开源安全框架，可以完全处理身份验证、授权、加密和会话管理。 Realm是Shiro的核心组建，也一样是两步走，认证和授权，在Realm中的表现为以下两个方法。 认证：doGetAuthenticationI.
Shiro集成spring企业级开发
oppoppoppo的专栏
02-15 675
1.核心类ShiroFilterFactoryBean 重要引用 ①securityManager（shiro安全管理器） ②filterChainDefinition
springboot集成shiro,使用token登陆,使用redis缓存
热门推荐
myth_g的博客
08-27 1万+
1.准备用户数据,这里我将数据写死存储; public class Constant implements Serializable { public static final String USERNAME = "gaoyang"; public static final String PASSWORD = "123456"; public static final ...
springboot环境下Shiro+Token+Redis安全认证方案
qq_38785977的博客
07-27 9325
认证我们接收filter传过来的token，并认证login操作的token授权获取到登录用户信息，并取得用户的权限存入roles，以便后期对接口进行操作权限验证/***大坑！，必须重写此方法，不然Shiro会报错}/***授权**@returnlog.info("Shiro权限配置");}/***认证**@returnlog.info("Shiror认证");isAccessAllowed（）判断是否可以登录到系统/**...
SpringBoot_Shiro_JWT_Redis:SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新
05-14
SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新 前端代码为一个博客页面，使用了Semantic UI框架结合thymeleaf模板 SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权 [TOC] 一、引言 ​ ...
springboot整和jwt、shiro、redis实现token自动刷新
08-19
下面将详细介绍如何在Spring Boot中整合JWT、Shiro和Redis实现Token自动刷新。 JWT是一种轻量级的身份验证机制，它通过在客户端存储一个包含用户信息的令牌，每次请求时都将这个令牌发送到服务器进行验证。JWT由三...
SpringBoot集成Shiro、Jwt和Redis
10-24
在SpringBoot中结合Shiro使用Jwt，可以在用户登录成功后生成一个Jwt Token，然后将其返回给客户端。客户端每次请求时带上Token，服务器端验证Token的有效性，以此实现无状态的身份认证。 **Redis** 是一个高性能的...
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统.rar
08-12
项目描述 在上家公司自己集成的一套系统，用了两个多月的时间完成的：Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级开发系统 Springboot作为容器，使用mybatis作为持久层框架 使用官方推荐的thymeleaf做为...
ShiroJwt：API SpringBoot + Shiro + Java-Jwt + Redis（Jedis）
02-04
ShiroJwt 前端地址： : ...实现Shiro的Cache（Redis）功能： : 项目介绍 RESTful API Maven集成Mybatis Generator（逆向工程） Shiro + Java-JWT实现无状态鉴权机制（令牌） 密码加密（采用AES-128 + Base6
Spring+SpringMVC+Ehcache+Shiro+BootStrap企业级开发平台
11-05
【B1】Spring+SpringMVC+Ehcache+Shiro+BootStrap企业级开发平台源码下载 内置功能 用户管理 角色管理 菜单管理 字典管理 部门管理 附件管理 参数管理 连接池监视 日志管理 技术选型 1、后端 核心框架：Spring Framework 安全框架：Apache Shiro 视图框架：Spring MVC 服务端验证：Blade Validator 任务调度：Spring Task 持久层框架：beetlsql 模板引擎：beetl 数据库连接池：Alibaba Druid 缓存框架：Ehcache 日志管理：SLF4J、LOGBACKUP 工具类：Apache Commons、FastJson、EASYPOI、BladeToolBox 2、前端 JS框架：jQuery CSS框架：Twitter Bootstrap 客户端验证：JQuery-html5Validate 富文本：KindEcitor 数据表格：jqGrid 树结构控件：jQuery zTree 弹出层：Layer 日期控件： LayDate
springboot+redis+token保持登录
08-03
通过redis 设置session过期时间，实现token 登录机制
springboot+redis+shiro单点登录，统一异常处理，统一日志
07-10
springboot+redis+shiro单点登录，统一异常处理，统一日志,缓存
SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权验证以及token刷新
最新发布
weixin_51542566的博客
04-13 1581
1. 本身AccessToken的过期时间为5分钟，RefreshToken过期时间为30分钟，当登录后时间过了5分钟之后，当前AccessToken便会过期失效，再次带上AccessToken访问JWT会抛出TokenExpiredException异常说明Token过期，开始判断是否要进行AccessToken刷新，首先redis查询RefreshToken是否存在，以及时间戳和过期AccessToken所携带的时间戳是否一致，如果存在且一致就进行AccessToken刷新。
Spring Boot 2.x + shiro 前后端分离实战-自定义 AccessControlFilter token校验 实战篇 （十）
深入Java世界：探索编程之美与技术深度
09-23 613
Spring Boot 2.x + shiro 前后端分离实战-自定义 AccessControlFilter token校验自定义 token 自定义 token public class CustomPasswordToken extends UsernamePasswordToken { private String token; public CustomPasswordToken(String token) { this.token = token; }
SpringBoot+Shiro学习（七）：Filter过滤器管理
agg7911的博客
05-17 614
SpringBoot+Shiro学习（七）：Filter过滤器管理 Hiwayz关注 0.52018.09.06 19:09*字数 1070阅读 5922评论 1喜欢 20 先从我们写的一个自定义Filter来看： public class RoleOrFilter extends AuthorizationFilter { ...
java jwt token reids_SpringBoot整合shiro+jwt+redis - 无状态token登录（二）授权篇
weixin_42266267的博客
02-24 438
更多最新技术文章欢迎大家访问我的个人博客○( ＾皿＾)っ豆腐别馆上文总览篇中，相信大家已经对接下来要做的事情有了总体思路及印象。总言之我们要做的就只有两件事，一是授权，二即是鉴权。让我们先从授权开始，何为授权？在这里简单地来讲就是要颁发token。何时颁发？毫无疑问，无非就是在登录/注册成功之后。至于上文中提到的根据RefreshToken自动刷新AccessToken，我将之归置为token刷新...
springboot下使用shiro自定义filter的个人经验
BHSZZY的博客
12-28 8940
在springboot中使用shiro，由于没有了xml配置文件，因此使用的方法与spring中有些区别。在踩了无数个坑后，在此将springboot下使用shiro的步骤总结如下。由于本人对shiro的了解不是很深入，在实现了工作需求后就没有继续研究了，因此可能存在遗漏的地方或有错误的地方，还请多包涵。   目标： 在springboot中使用shiro 1.实现用户的登录验证 2.对...
Spring-shiro-Boot-5 shiro中过滤器原理与结构
良之才的专栏
03-16 909
在Restful方式登陆的时候，需要自定义一个拦截器。 用来在参数中或者header里加参数login-token作为登陆凭证。 shiro本身提供了足够多的过滤器，日常在使用的过程中可以在这些过滤器的基础上进行改造，自定义出对应的过滤器。 一、shiro提供的过滤器 ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

java冯坚持

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值