springboot集成shiro前后端分离使用redis做缓存

最新推荐文章于 2024-08-09 07:08:44 发布
最新推荐文章于 2024-08-09 07:08:44 发布
阅读量1w 收藏 48
点赞数 8
分类专栏： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40102894/article/details/100160811
版权

最近在整理之前做过的项目时，对于后台管理项目用户权限这一块一直没有很详细的去总结过，用户权限管理一直是后台管理项目的核心，这里讲解的shiro，做了前后端分离处理。

项目环境
springboot 2.1.7
durid 1.1.10
mysql 5.7
shiro 1.4.0
shiro-redis：3.1.0

文章目录

一 shiro介绍

1 基础介绍

Apache Shiro是Java的一个安全框架。目前，使用Apache Shiro的人越来越多，因为它相当简单，对比Spring Security，可能没有Spring
Security做的功能强大，但是在实际工作时可能并不需要那么复杂的东西，所以使用小而简单的Shiro就足够了。对于它俩到底哪个好，这个不必纠结，能更简单的解决项目问题就好了。

2 基本功能点

在这里插入图片描述
Authentication：身份认证/登录，验证用户是不是拥有相应的身份；

Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；

Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的；

Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；

Web Support：Web支持，可以非常容易的集成到Web环境；

Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；

Concurrency：shiro支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；

Testing：提供测试支持；

Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；

Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。

3 基本流程图

在这里插入图片描述

Subject：主体，代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，如网络爬虫，机器人等；即一个抽象概念；所有Subject都绑定到SecurityManager，与Subject的所有交互都会委托给SecurityManager；可以把Subject认为是一个门面；SecurityManager才是实际的执行者；

SecurityManager：安全管理器；即所有与安全有关的操作都会与SecurityManager交互；且它管理着所有Subject；可以看出它是Shiro的核心，它负责与后边介绍的其他组件进行交互，如果学习过SpringMVC，你可以把它看成DispatcherServlet前端控制器；

Realm：域，Shiro从从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。

    流程如下：
    
    步骤一：Shiro把用户的数据封装成标识token，token一般封装着用户名，密码等信息。

    步骤二：使用Subject门面获取到封装着用户的数据的标识token

    步骤三：Subject把标识token交给SecurityManager，在SecurityManager安全中心中，SecurityManager把标识token委托给认证器Authenticator进行身份验证。认证器的作用一般是用来指定如何验证，它规定本次认证用到哪些Realm。

    步骤四：认证器Authenticator将传入的标识token，与数据源Realm对比，验证token是否合法。

二 常用的权限管理表关系

5张表，也就是现在流行的权限设计模型RBAC
分别是：用户表 ，角色表，菜单（权限）表 , 用户和角色关联表，角色和菜单关联表

在这里插入图片描述
建表语句在项目中

三 案例介绍

1 案例地址

案例地址

2 搭建案例

pom

    <!--  shiro核心包      -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>${shiro-spring.version}</version>
        </dependency>

        <!--大神的开源插件-->
        <dependency>
            <groupId>org.crazycake</groupId>
            <artifactId>shiro-redis</artifactId>
            <version>${shiro-redis.version}</version>
        </dependency>

ShiroConfig

package com.qiuwei.shiro.config;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.session.mgt.SessionManager;
import org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.time.Duration;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @Author: qiuwei@19pay.com.cn
 * @Version 1.0.0
 */
@Configuration
@Slf4j
@Data
@ConfigurationProperties(
        prefix = "spring.redis"
)
public class ShiroConfig {

    private String host = "localhost";
    private int port = 6379;
    private Duration timeout;

    /**
     * Filter工厂，设置对应的过滤条件和跳转条件
     *
     * @return ShiroFilterFactoryBean
     */
    @Bean
    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {

        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        // 过滤器链定义映射
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();

        /*
         * anon:所有url都都可以匿名访问，authc:所有url都必须认证通过才可以访问;
         * 过滤链定义，从上向下顺序执行，authc 应放在 anon 下面
         * */
        filterChainDefinitionMap.put("/login", "anon");
        // 配置不会被拦截的链接 顺序判断，如果前端模板采用了thymeleaf，这里不能直接使用 ("/static/**", "anon")来配置匿名访问，必须配置到每个静态目录
//        filterChainDefinitionMap.put("/css/**", "anon");
//        filterChainDefinitionMap.put("/fonts/**", "anon");
//        filterChainDefinitionMap.put("/img/**", "anon");
//        filterChainDefinitionMap.put("/js/**", "anon");
//        filterChainDefinitionMap.put("/html/**", "anon");
        // 所有url都必须认证通过才可以访问
        filterChainDefinitionMap.put("/**", "authc");

        // 配置退出 过滤器,其中的具体的退出代码Shiro已经替我们实现了, 位置放在 anon、authc下面
        filterChainDefinitionMap.put("/logout", "logout");

        // 如果不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面
        // 配器shirot认登录累面地址，前后端分离中登录累面跳转应由前端路由控制，后台仅返回json数据, 对应LoginController中unauth请求
        shiroFilterFactoryBean.setLoginUrl("/un_auth");

        // 登录成功后要跳转的链接, 此项目是前后端分离，故此行注释掉，登录成功之后返回用户基本信息及token给前端
        // shiroFilterFactoryBean.setSuccessUrl("/index");

        // 未授权界面, 对应LoginController中 unauthorized 请求
        shiroFilterFactoryBean.setUnauthorizedUrl("/unauthorized");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }


    /**
     * RedisSessionDAO shiro sessionDao层的实现 通过redis, 使用的是shiro-redis开源插件
     *
     * @return RedisSessionDAO
     */
    @Bean
    public RedisSessionDAO redisSessionDAO() {
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setRedisManager(redisManager());
        redisSessionDAO.setSessionIdGenerator(sessionIdGenerator());
        redisSessionDAO.setExpire(1800);
        return redisSessionDAO;
    }

    /**
     * Session ID 生成器
     *
     * @return JavaUuidSessionIdGenerator
     */
    @Bean
    public JavaUuidSessionIdGenerator sessionIdGenerator() {
        return new JavaUuidSessionIdGenerator();
    }

    /**
     * 自定义sessionManager
     *
     * @return SessionManager
     */
    @Bean
    public SessionManager sessionManager() {
        MySessionManager mySessionManager = new MySessionManager();
        mySessionManager.setSessionDAO(redisSessionDAO());
        return mySessionManager;
    }

    /**
     * 配置shiro redisManager, 使用的是shiro-redis开源插件
     *
     * @return RedisManager
     */
    private RedisManager redisManager() {
        RedisManager redisManager = new RedisManager();
        redisManager.setHost(host);
        redisManager.setPort(port);
        redisManager.setTimeout((int) timeout.toMillis());
        return redisManager;
    }

    /**
     * cacheManager 缓存 redis实现, 使用的是shiro-redis开源插件
     *
     * @return RedisCacheManager
     */
    @Bean
    public RedisCacheManager cacheManager() {
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        // 必须要设置主键名称，shiro-redis 插件用过这个缓存用户信息
        redisCacheManager.setPrincipalIdFieldName("userId");
        return redisCacheManager;
    }


    /**
     *  权限管理，配置主要是Realm的管理认证
     *
     * @return SecurityManager
     */
    @Bean
    public SecurityManager securityManager(ShiroRealm shiroRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(shiroRealm);
        // 自定义session管理 使用redis
        securityManager.setSessionManager(sessionManager());
        // 自定义缓存实现 使用redis
        securityManager.setCacheManager(cacheManager());
        return securityManager;
    }


    /*
     * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
     * 配置以下两个bean(DefaultAdvisorAutoProxyCreator(可选)和AuthorizationAttributeSourceAdvisor)即可实现此功能
     */
    @Bean
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

    @Bean
    public SimpleCookie cookie() {
        // cookie的name,对应的默认是 JSESSIONID
        SimpleCookie cookie = new SimpleCookie("SHARE_JSESSIONID");
        cookie.setHttpOnly(true);
        //  path为 / 用于多个系统共享 JSESSIONID
        cookie.setPath("/");
        return cookie;
    }

    /* 此项目使用 shiro 场景为前后端分离项目，这里先注释掉，统一异常处理已在 GlobalExceptionHand.java 中实现 */

}

ShiroRealm

package com.qiuwei.shiro.config;

import com.qiuwei.shiro.entity.Menu;
import com.qiuwei.shiro.entity.Role;
import com.qiuwei.shiro.entity.User;
import com.qiuwei.shiro.mapper.MenuMapper;
import com.qiuwei.shiro.mapper.RoleMapper;
import com.qiuwei.shiro.mapper.UserMapper;
import com.qiuwei.shiro.util.ShiroUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authc.credential.CredentialsMatcher;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
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.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Objects;

/**
 * @Author: qiuwei@19pay.com.cn
 * @Version 1.0.0
 */
@Slf4j
@Component
public class ShiroRealm extends AuthorizingRealm {

    private UserMapper userMapper;

    private RoleMapper roleMapper;

    private MenuMapper menuMapper;

    @Autowired
    @SuppressWarnings("all")
    public ShiroRealm(UserMapper userMapper, RoleMapper roleMapper, MenuMapper menuMapper) {
        this.userMapper = userMapper;
        this.roleMapper = roleMapper;
        this.menuMapper = menuMapper;
    }

    /**
     * 授权
     *
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {

        log.info("开始执行授权操作.......");

        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();

        /**
         * 查询用户角色
         * 如果身份认证的时候没有传入User对象，这里只能取到userName
         * 也就是SimpleAuthenticationInfo构造的时候第一个参数传递需要User对象
         */
        User user = (User) principalCollection.getPrimaryPrincipal();

        if (user == null) {
            log.error("用户不存在");
            throw new UnknownAccountException("用户不存在");
        }

        //TODO 是否为超级管理员   是  全部菜单权限


        /**
         * 查询用户角色
         */

        List<Role> roles = this.roleMapper.listRoleByUserId(user.getUserId());

        if(CollectionUtils.isNotEmpty(roles)){
            for (Role role : roles) {
                authorizationInfo.addRole(role.getRoleName());
                // 根据角色查询权限
                List<Menu> menus = this.menuMapper.listMenuByRoleId(role.getRoleId());
                for (Menu m : menus) {
                    authorizationInfo.addStringPermission(m.getPerms());
                }
            }
        }

        return authorizationInfo;
    }


    /**
     * 认证
     *
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {

        log.info("开始进行身份认证......");

        //获取用户的输入的账号.
        String username = (String) authenticationToken.getPrincipal();

        //通过username从数据库中查找 User对象.
        //实际项目中，这里可以根据实际情况做缓存，如果不做，Shiro自己也是有时间间隔机制，2分钟内不会重复执行该方法
        User user = userMapper.findByUsername(username);
        if (Objects.isNull(user)) {
            return null;
        }

        return new SimpleAuthenticationInfo(
                // 这里传入的是user对象，比对的是用户名，直接传入用户名也没错，但是在授权部分就需要自己重新从数据库里取权限
                user,
                // 密码
                user.getPassword(),
                // salt = username + salt
                ByteSource.Util.bytes(user.getSalt()),
                // realm name
                getName()
        );
    }


    /**
     * 将自己的验证方式加入容器
     *
     * 凭证匹配器（由于我们的密码校验交给Shiro的SimpleAuthenticationInfo进行处理了）
     *
     * @param credentialsMatcher
     */
    @Override
    public void setCredentialsMatcher(CredentialsMatcher credentialsMatcher) {
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();

        /**
         * 散列算法:这里可以使用MD5算法 也可以使用SHA-256
         */
        hashedCredentialsMatcher.setHashAlgorithmName(ShiroUtils.hashAlgorithmName);
        /**
         * 散列的次数，比如散列2次，相当于 md5(md5(""));
         */
        hashedCredentialsMatcher.setHashIterations(ShiroUtils.hashIterations);
       super.setCredentialsMatcher(hashedCredentialsMatcher);
    }

}

ShiroUtils

package com.qiuwei.shiro.util;

import com.qiuwei.shiro.entity.User;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.crypto.hash.SimpleHash;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;

/**
 * Shiro工具类
 */
public class ShiroUtils {
    /**  加密算法 */
    public final static String hashAlgorithmName = "SHA-256";
    /**  循环次数 */
    public final static int hashIterations = 16;

    public static String sha256(String password, String salt) {
        return new SimpleHash(hashAlgorithmName, password, salt, hashIterations).toString();
    }

    // 获取一个测试账号 admin
    public static void main(String[] args) {
        // 3743a4c09a17e6f2829febd09ca54e627810001cf255ddcae9dabd288a949c4a
        System.out.println(sha256("admin","123")) ;
    }

    /**
     * 获取会话
     */
    public static Session getSession() {
        return SecurityUtils.getSubject().getSession();
    }
    
    /**
     * Subject：主体，代表了当前“用户”
     */
    public static Subject getSubject() {
        return SecurityUtils.getSubject();
    }

    public static User getUserEntity() {
        return (User)SecurityUtils.getSubject().getPrincipal();
    }

    public static Long getUserId() {
        return getUserEntity().getUserId();
    }

    public static void setSessionAttribute(Object key, Object value) {
        getSession().setAttribute(key, value);
    }

    public static Object getSessionAttribute(Object key) {
        return getSession().getAttribute(key);
    }

    public static boolean isLogin() {
        return SecurityUtils.getSubject().getPrincipal() != null;
    }

    public static void logout() {
        SecurityUtils.getSubject().logout();
    }
}

MySessionManager

package com.qiuwei.shiro.config;

import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.apache.shiro.web.util.WebUtils;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.Serializable;

/**
 *
 * @Author: qiuwei@19pay.com.cn
 * @Version 1.0.0
 *
 * 自定义session管理
 * <br/>
 * 传统结构项目中，shiro从cookie中读取sessionId以此来维持会话，在前后端分离的项目中（也可在移动APP项目使用），
 * 我们选择在ajax的请求头中传递sessionId，因此需要重写shiro获取sessionId的方式。
 * 自定义MySessionManager类继承DefaultWebSessionManager类，重写getSessionId方法
 */

public class MySessionManager extends DefaultWebSessionManager {

    private static final String AUTHORIZATION = "Authorization";

    private static final String REFERENCED_SESSION_ID_SOURCE = "Stateless request";

    @Override
    protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
        String id = WebUtils.toHttp(request).getHeader(AUTHORIZATION);
        //如果请求头中有 Authorization 则其值为sessionId
        if (!StringUtils.isEmpty(id)) {
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, REFERENCED_SESSION_ID_SOURCE);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
            return id;
        } else {
            //否则按默认规则从cookie取sessionId
            return super.getSessionId(request, response);
        }
    }
}

3 前后端分离需要注意的点

  1. 传统结构项目中，shiro从cookie中读取sessionId以此来维持会话，在前后端分离的项目中（也可在移动APP项目使用），我们选择在ajax的请求头中传递sessionId，因此需要重写shiro获取sessionId的方式。自定义MySessionManager类继承DefaultWebSessionManager类，重写getSessionId方法
  2. 登入失败，登入地址，前后端分离，不应该直接跳转页面，而是返回响应结果

4 测试

UserController

package com.qiuwei.shiro.controller;

import com.qiuwei.shiro.util.Response;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @Author: qiuwei@19pay.com.cn
 * @Version 1.0.0
 */
@RestController
@Slf4j
@RequestMapping("user")
public class UserController {


    @Autowired
    private Response response;


    @GetMapping("list")
    @RequiresPermissions("user:list")
    public Response listUser() {
        return response.success("用户列表");
    }


    @GetMapping("{userId}")
    @RequiresPermissions("user:detail")
    public Response detailUser(@PathVariable("userId") Long userId) {
        return response.success("用户详情");
    }


    @PostMapping("add")
    @RequiresRoles("admin")
    @RequiresPermissions("user:add")
    public Response addUser() {
        return response.success("添加用户成功");
    }

    @DeleteMapping("del")
    @RequiresRoles("role")
    public Response delUser() {
        return response.success("删除用户");
    }
}

LoginController

package com.qiuwei.shiro.controller;

import com.qiuwei.shiro.entity.User;
import com.qiuwei.shiro.service.UserService;
import com.qiuwei.shiro.util.CacheUser;
import com.qiuwei.shiro.util.Response;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author: qiuwei@19pay.com.cn
 * @Version 1.0.0
 */
@Slf4j
@RestController
public class LoginController {


    private Response response;

    private UserService userService;

    @Autowired
    @SuppressWarnings("all")
    public LoginController(Response response, UserService userService) {
        this.response = response;
        this.userService = userService;
    }

    /**
     * description: 登录
     *
     * @return 登录结果
     */
    @PostMapping("/login")
    public Response login(User user) {
        log.warn("进入登录.....");

        String username = user.getUsername();
        String password = user.getPassword();

        if (StringUtils.isBlank(username)) {
            return response.failure("用户名为空！");
        }

        if (StringUtils.isBlank(password)) {
            return response.failure("密码为空！");
        }

        CacheUser loginUser = userService.login(username, password);
        // 登录成功返回用户信息
        return response.success("登录成功！", loginUser);
    }

    /**
     * description: 登出
     */
    @RequestMapping("/logout")
    public Response logOut() {
        userService.logout();
        return response.success("登出成功！");
    }

    /**
     * 未登录，shiro应重定向到登录界面，此处返回未登录状态信息由前端控制跳转页面
     * @return
     */
    @RequestMapping("/un_auth")
    public Response unAuth() {
        return response.failure(HttpStatus.UNAUTHORIZED, "用户未登录！", null);
    }

    /**
     * 未授权，无权限，此处返回未授权状态信息由前端控制跳转页面
     * @return
     */
    @RequestMapping("/unauthorized")
    public Response unauthorized() {
        return response.failure(HttpStatus.FORBIDDEN, "用户无权限！", null);
    }
}

在这里插入图片描述
登入成功后 redis的数据
在这里插入图片描述
权限测试

admin 在配置角色权限的时候

在这里插入图片描述
配置了 1，3，4权限
所以 预期结果是 用户详情，用户添加有权限， 用户列表没有权限 ，删除用户没有权限

用户列表
在这里插入图片描述
用户详情
在这里插入图片描述

添加用户
在这里插入图片描述
删除用户

在这里插入图片描述
退出登入 查询redis中数据是否清楚

在这里插入图片描述
再次查询详情

在这里插入图片描述
到目前为止 都符合预期

参考文档：
跟我学shiro
SpringBoot2.0 整合 Shiro 框架，实现用户权限管理
SpringBoot2.x.x + Shiro + Redis 前后端分离实现

qq_40102894
关注
专栏目录
springboot-shiro-redis
01-18
springboot-shiro-redis集成了dao层自动生成插件，开发依赖1.8的jdk
SpringBoot_Shiro_JWT_Redis:SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新
05-14
​ 在微服务中我们一般采用的是无状态登录，而传统的session方式，在前后端分离的微服务架构下，如继续使用则必将要解决跨域sessionId问题、集群session共享问题等等。这显然是费力不讨好的，而整合shiro，却很不...
SpringBoot2.x.x + Shiro + Redis 前后端分离实现
热门推荐
小半的博客
07-06 2万+
文章目录Shiro架构图与基本知识源码地址数据库结构使用的主要框架项目结构详细搭建过程使用及测试感谢 Shiro架构图与基本知识 1、Shiro是Apache下的一个开源项目，我们称之为Apache Shiro。它是一个很易用与Java项目的的安全框架，提供了认证、授权、加密、会话管理，与spring Security 一样都是做一个权限的安全框架，但是与Spring Security 相比，在于...
Shiro-Redis 项目使用教程
最新发布
gitblog_00903的博客
08-09 469
Shiro-Redis 项目使用教程 shiro-redisshiro only provide the support of ehcache and concurrentHashMap. Here is an implement of redis cache can be used by shiro. Hope it will help you!项目地址:https://gitcode.com...
Spring Boot+shiro+redis 安全框架权限认证前后端分离【完整版】总结
一只软件小白的博客
03-06 796
一、导入依赖只导入redis以及shiro <!--redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-re...
springboot整合shiro安全框架以及redis，实现将登录者的信息放到redis中。
m0_64693079的博客
05-11 525
springboot整合shiro安全框架以及redis，实现将登录者的信息放到redis中，这样及时部署到多台服务器，也不会出现权限不足的情况。
SpringBoot整合Shiro和Redis
m0_54861649的博客
04-08 472
demo源码 此demo用SpringBoot+Shiro简单实现了登陆、注册、认证、授权的功能，并用redis做分布式缓存提高性能。 1.准备工作 导入pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
后台管理系统，前后端分离，后端SpringBoot+Shiro+MyBatis+Redis，前端Vue+Elemen.zip
02-22
这是一个基于现代技术栈的后台管理系统实现，采用了前后端分离的架构模式。让我们深入探讨这个系统背后的各个技术组件及其重要性。 首先，后端的核心框架是SpringBoot，它是由Pivotal团队开发的Java轻量级框架，...
后台管理系统，前后端分离，后端SpringBoot+Shiro+MyBatis+Redis，前端Vue+ElementUI+Axios.rar
06-18
这是一个基于Java技术栈的后台管理系统，实现了前后端分离的设计模式，旨在提高开发效率和用户体验。系统的核心技术选用了SpringBoot、Shiro、MyBatis以及Redis，前端则采用了Vue.js、ElementUI和Axios库。下面我们...
后台管理系统前后端分离后端SpringBoot+Shiro+MyBatis+Redis前端Vue+ElementUI+Axios
03-09
标题中的“后台管理系统前后端分离后端SpringBoot+Shiro+MyBatis+Redis前端Vue+ElementUI+Axios”揭示了一个现代Web应用的架构，它采用了前后端分离的设计模式，利用一系列流行的开源技术栈来构建。让我们逐一解析...
springboot集成shiro-redis
xy1073028328的博客
12-20 612
springboot集成shiro-redis springboot集成shiro-redis 近期公司项目中需要用到 shrio做登录认证，认证的token用redis存储，在集成过程中出现了一些问题，写这篇博客就是为了以后在调用的时候避坑，也希望可以帮助到其他遇到同样的问题。 项目架构 项目是前后端分离的项目,主要运用到以下的技术： 后端+后台管理： springboot； mybatise...
springboot+shiro+redis整合
03-12
springboot 整合shiro的认证，redis实现session共享案例
springboot整合shiro，redis缓存session
02-09
为实现Web应用的分布式集群部署，要解决登录session的统一。本文利用shiro做权限控制，redis做session存储，结合spring boot快速配置实现session共享。
springboot+redis+shiro单点登录，统一异常处理，统一日志
07-10
springboot+redis+shiro单点登录，统一异常处理，统一日志,缓存
shiro-redisson基于Redis的ShiroCache和Session实现
08-06
shiro-redisson 是一个 Apache Shiro 的扩展组件，提供了基于 redis 实现的缓存和会话，以支持分布式环境下的应用。底层使用了 redisson 作为 redis 客户端。
springboot_shiro_redis整合(一)-shiro-权限控制
gaogzhen的博客
02-23 946
springboot_shiro_redis整合(一)-shiro-权限控制 目录 文章目录一、前言二、shiro整合redis1、分析2、pom.xml 导入依赖2、相关具体类2.1、封装ShiroUtils 工具类2.2、UserRealm 自定义realm2.3、ShiroConfig 配置类2.4、CustomSessionManager 身份标志获取***后记*** ： 内容 一、前言   目前常用的安全框架为spring security、shiro等，关于二者之间的比较，有兴趣的小伙
shiro用redis实现缓存机制
buling_bulink的博客
06-08 508
shiro用redis实现缓存机制 shiro使用redis实现缓存机制，对redisTemplate的key可以设置StringRedisSerializer序列化，value的序列化默认，为JdkSerializationRedisSerializer，不要设置为Jackson2JsonRedisSerializer，会报错，具体什么错忘记了，没有截图，反正也是序列化的问题。如果有个redisTemplate的全局序列化设置value为Jackson2JsonRedisSerializer，可在shir
shiro使用redis实现cache管理
baidu_33969289的博客
01-27 3589
shiro使用redis实现cache Shiro默认整合了EhCache，来实现缓存，如果我们想用redis替换EhCache来实现缓存怎么做了？我们可以从Shiro的源码来找到一些端倪。 参考代码 https://github.com/gemingyi/shiro_demo 先找到shiro realm类的setCacheManager()方法，可以看到传入参数CacheManage...
springboot整合shiro和redis（超详细案例演示）
m0_57232638的博客
07-08 3521
将Spring Boot、Redis和Shiro整合在一起具有多个优势。首先，通过与Spring Boot的集成，可以简化开发过程，利用其自动配置和约定优于配置的原则。其次，Redis作为高性能的缓存和存储系统，可以提供快速的数据访问和响应时间，通过与Spring Boot和Shiro的整合，可以实现更高效的会话管理和身份验证。此外，通过将Shiro的会话存储在Redis中，可以实现分布式会话管理和高可用性，并支持共享会话和无状态应用程序架构。
springboot整合shiro前后端分离
03-16
Spring Boot整合Shiro可以实现前后端分离的安全认证和授权功能。前端通过Ajax请求后端接口，后端接口通过Shiro进行安全认证和授权，返回相应的结果给前端。 具体实现步骤如下： 1. 引入Shiro和Spring Boot相关依赖。 2. 配置Shiro的安全管理器和过滤器链。 3. 实现自定义Realm，用于认证和授权。 4. 实现登录接口，接收前端传来的用户名和密码，通过Shiro进行认证，返回认证结果给前端。 5. 实现权限接口，接收前端传来的请求，通过Shiro进行授权，返回授权结果给前端。 6. 前端通过Ajax请求后端接口，接收后端返回的认证和授权结果，根据结果进行相应的操作。 通过以上步骤，就可以实现Spring Boot整合Shiro的前后端分离安全认证和授权功能。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值