SpringBoot集成Shiro权限管理框架

欢乐少年1904

已于 2022-10-11 19:07:01 修改

阅读量499

点赞数 1

于 2022-10-11 19:06:04 首次发布

本文链接：https://blog.csdn.net/liuerpeng1904/article/details/127269544

版权

Shiro用户权限管理设计

Shiro 简介与功能 (Shiro能干什么)

Apache Shiro 是 Java 的一个安全（权限）框架;
Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE 环境，也可以用在 JavaEE 环境;
Shiro 可以完成：认证、授权、加密、会话管理、Web 集成、缓存等
Authentication：身份认证/登录，验证用户是不是拥有相应的身份；
Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通 JavaSE 环境，也可以是 Web 环境的;

Shiro主要有三大功能模块:

Subiect : 主题 , 一般指用户
SecurityManager：安全管理器，管理所有Subject，可以配合内部安全组件。(类似于SpringMVC中的DispatcherServlet)
Realms：用于进行权限信息的验证，一般需要自己实现。

细分功能:

Authentication：身份认证/登录(账号密码验证)。
Authorization：授权，即角色或者权限验证。
Session Manager：会话管理，用户登录后的session相关管理。
Cryptography：加密，密码加密等。
Web Support：Web支持，集成Web环境。
Caching：缓存，用户信息、角色、权限等缓存到如redis等缓存中。
Concurrency：多线程并发验证，在一个线程中开启另一个线程，可以把权限自动传播过去。
Testing：测试支持；
Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问。
Remember Me：记住我，登录后，下次再来的话不用登录了。

Spring Boot 集成 Shiro 教程

1. pom.xml文件引入相关依赖

     <!-- shiro -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.6.0</version>
        </dependency>

2. 创建对应的实体类 , 用户类,角色类和权限类

用户类

package com.example.springtest.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.List;

/**
 * 用户表,包含用户的基本信息
 */
@Data
@AllArgsConstructor
public class User {

    // 用户的id
    private Long id;

    // 用户的名字
    private String name;

    // 用户的密码
    private String password;

    /**
     * 用户对应的角色集合(角色对应了权限)
     */
    private List<Role> roles;
}

角色类

package com.example.springtest.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.List;

/**
 * 角色表,用户与角色挂钩,角色与权限挂钩
 */
@Data
@AllArgsConstructor
public class Role {

    // 角色的id
    private Long id;

    // 角色的名字
    private String roleName;

    /**
     * 角色对应权限集合
     */
    private List<Permissions> permissions;
}

权限类

package com.example.springtest.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * 权限对应的实体类,权限与角色挂钩
 */
@Data
@AllArgsConstructor
public class Permissions {

    // 权限的id
    private Long id;
    // 权限的名字
    private String permissionsName;
}

三个实体类之间的关系如下

用户类 : 用户用户用户类包含了用户的基本信息以及包含了用户所属的所有的角色 , 我们来用一个列表进行封装
{.is-info}

角色类 : 角色类与用户类进行挂钩,表示中用户代表这个角色 , 角色又与权限进行绑定(每一个角色的权限我们用一个列表进行封装),那么角色的用处就是建立了用户与权限之间的桥梁,建立二者之间的关系 (用户与权限相关联)
{.is-info}

权限类 : 代表了权限 , 权限与角色进行挂钩 , 权限属于角色 , 角色又属于用户 , 所以也可以这样说权限间接性属于用户,那么用户再访问后端接口时 , 就会获取到当前登录的用户的权限与接口的权限作对比,没有这个用户没有权限访问这个接口 , 那么接口将防返回没有权限
{.is-info}

3. 创建工具类,来模拟操作数据库

package com.example.springtest.pojo;

import lombok.Data;

import java.util.ArrayList;
import java.util.List;

/**
 * @author lep
 * @date 2022-06-22 11:45
 */
@Data
public class MySqlTool {

    // 所有的用户 (以及用户的角色,和角色的权限) : 模拟数据库
    public static List<User> users = new ArrayList<>();

    //    静态初始化块 , 初始化数据
    static {
//        添加两个用户 张三和李四
//          1.1 创建四个权限
        Permissions permissions1 = new Permissions(1L, "delete"); //删除
        Permissions permissions2 = new Permissions(2L, "add");    //添加
        Permissions permissions3 = new Permissions(3L, "select"); //查询
        Permissions permissions4 = new Permissions(4L, "update"); //修改

//          1.2 创建一个角色(role1:拥有查询权限)
        List<Permissions> permissions_1 = new ArrayList<>();
        permissions_1.add(permissions3);
        permissions_1.add(permissions4);
        Role role1 = new Role(1L, "role1", permissions_1); //查询和修改
//          1.3 创建一个角色(role2 : 拥有添加和查询的权限)
        List<Permissions> permissions_2 = new ArrayList<>();
        permissions_2.add(permissions2);
        permissions_2.add(permissions3);
        Role role2 = new Role(2L, "role2", permissions_2); //查询和添加
//        2.1 创建一个张三 , 分配角色1(role1)
        List<Role> roles1 = new ArrayList<>();
        roles1.add(role1);
        User user1 = new User(1L, "张三", "88888888", roles1);
//        2.2 创建一个李四 , 分配角色2(role2)
        List<Role> roles2 = new ArrayList<>();
        roles2.add(role2);
        User user2 = new User(1L, "李四", "77777777", roles2);
        users.add(user1);
        users.add(user2);
    }

    /**
     * 获取一个指定的用户
     *
     * @param name 用户的名字
     * @return 返回用户的信息(模拟查询数据库)
     */
    public static User getUser(String name) {

        for (User user : users) {
            if (user.getName().equals(name)) {
                return user;
            }
        }
        return null;
    }

}

4. 自定义Realm用于查询用户的角色权限并把角色权限保存到权限管理器 (重要)

package com.example.springtest.config;

import com.example.springtest.pojo.MySqlTool;
import com.example.springtest.pojo.Permissions;
import com.example.springtest.pojo.Role;
import com.example.springtest.pojo.User;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
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.springframework.util.StringUtils;

/**
 * 自定义Realm用于查询用户的角色和权限信息并保存到权限管理器：
 */
public class CustomRealm extends AuthorizingRealm {


    /**
     * @MethodName doGetAuthorizationInfo
     * @Description 权限配置类
     * @Param [principalCollection]
     * @Return AuthorizationInfo
     * @Author WangShiLin
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //获取登录用户名
        String name = (String) principalCollection.getPrimaryPrincipal();
        //查询用户名称
        User user = MySqlTool.getUser(name);
        //添加角色和权限
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
//        循环用户的角色,来添加角色
        for (Role role : user.getRoles()) {
            //添加角色
            simpleAuthorizationInfo.addRole(role.getRoleName());
            //循环每一个角色的权限来添加权限
            for (Permissions permissions : role.getPermissions()) {
                simpleAuthorizationInfo.addStringPermission(permissions.getPermissionsName());
            }
        }
        return simpleAuthorizationInfo;
    }

    /**
     * @MethodName doGetAuthenticationInfo
     * @Description 认证配置类
     * @Param [authenticationToken]
     * @Return AuthenticationInfo
     * @Author WangShiLin
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        if (StringUtils.isEmpty(authenticationToken.getPrincipal())) {
            return null;
        }
//        获取用户信息
        String name = authenticationToken.getPrincipal().toString();
//        获取到用户信息
        User user = MySqlTool.getUser(name);
        if (user == null) {
            //这里返回后会报出对应异常
            return null;
        } else {
            //这里验证authenticationToken和simpleAuthenticationInfo的信息
            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(name, user.getPassword().toString(), getName());
            return simpleAuthenticationInfo;
        }
    }
}

5. 把自定义的Realm和权限管理器(SecurityManager)注入到Spring容器中 (重要)

package com.example.springtest.config;

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.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

/**
 * ShiroConfig.java，把CustomRealm和SecurityManager等注入到spring容器中：
 */
@Configuration
public class ShiroConfig {

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

    //将自己的验证方式加入容器
    @Bean
    public CustomRealm myShiroRealm() {
        CustomRealm customRealm = new CustomRealm();
        return customRealm;
    }

    //权限管理，配置主要是Realm的管理认证
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(myShiroRealm());
        return securityManager;
    }

    //Filter工厂，设置对应的过滤条件和跳转条件
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        Map<String, String> map = new HashMap<>();
        //登出
        map.put("user/logout", "logout");
        //对所有用户认证
        map.put("/**", "authc");
        //登录
        shiroFilterFactoryBean.setLoginUrl("/user/login");
        //首页
        shiroFilterFactoryBean.setSuccessUrl("user/index");
        //错误页面，认证不通过跳转
        shiroFilterFactoryBean.setUnauthorizedUrl("/error");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        return shiroFilterFactoryBean;
    }


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

5. 创建一个全局异常拦截,用于拦截当用户访问接口没有权限的情况

package com.example.springtest.config;

import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.AuthorizationException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 统一异常捕获
 */
@ControllerAdvice
@Slf4j
public class MyExceptionHandler {

    @ExceptionHandler
    @ResponseBody
    public String ErrorHandler(AuthorizationException e) {
        log.error("没有通过权限验证！", e);
        return "没有通过权限验证！";
    }
}

6. 创建一个controller来测试Shiro权限管理

package com.example.springtest.controller;

import com.example.springtest.pojo.User;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.AuthorizationException;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.apache.shiro.subject.Subject;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * user对应的Controller , 模拟用户的登录,以及获取信息
 */
@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {

    /**
     * 目前的权限是 :
     * 张三  88888888
     * 权限 : 查询(select)和修改(update)
     * <p>
     * 李四 77777777
     * 权限 : 查询(select)和添加(add)
     */


    @GetMapping("/login")
    public String login(User user) {
        if (StringUtils.isEmpty(user.getName()) || StringUtils.isEmpty(user.getPassword())) {
            return "请输入用户名和密码！";
        }
        System.out.println("开始登录 : " + user);
        //用户认证信息 , 把用户添加到认证中
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(
                user.getName(),
                user.getPassword()
        );
        try {
            //进行验证，这里可以捕获异常，然后返回对应信息
            subject.login(usernamePasswordToken);
        } catch (UnknownAccountException e) {
            log.error("用户名不存在！", e);
            return "用户名不存在！";
        } catch (AuthenticationException e) {
            log.error("账号或密码错误！", e);
            return "账号或密码错误！";
        } catch (AuthorizationException e) {
            log.error("没有权限！", e);
            return "没有权限";
        }
        return "登录成功!";
    }

//  根据角色来进行指定权限(那么拥有role1角色的用户可访问此接口)
    @RequiresRoles("role1")
    @GetMapping("/test1")
    public String test1() {
        return "role1!";
    }

    @RequiresRoles("role2")
    @GetMapping("/test2")
    public String test2() {
        return "role2!";
    }

//  根据具体的权限来限制(那么拥有select权限的人可访问此接口)
    @RequiresPermissions("select")
    @GetMapping("/select")
    public String select() {
        return "查询成功!";
    }

    @RequiresPermissions("update")
    @GetMapping("/update")
    public String update() {
        return "修改成功!";
    }

    @RequiresPermissions("delete")
    @GetMapping("/delete")
    public String delete() {
        return "删除成功!";
    }

    @RequiresPermissions("add")
    @GetMapping("/add")
    public String add() {
        return "添加成功!";
    }
}

最后添加一下常用的Shiro的异常

AuthenticationException 认证异常

Shiro在登录认证过程中，认证失败需要抛出的异常。 AuthenticationException包含以下子类：

CredentitalsException 凭证异常
IncorrectCredentialsException 不正确的凭证
ExpiredCredentialsException 凭证过期
AccountException 账号异常

ConcurrentAccessException: 并发访问异常（多个用户同时登录时抛出）

UnknownAccountException: 未知的账号

ExcessiveAttemptsException: 认证次数超过限制

DisabledAccountException: 禁用的账号

LockedAccountException: 账号被锁定

UnsupportedTokenException: 使用了不支持的Token

AuthorizationException: 授权异常

Shiro在登录认证过程中，授权失败需要抛出的异常。 AuthorizationException包含以下子类：

UnauthorizedException:
抛出以指示请求的操作或对请求的资源的访问是不允许的。
UnanthenticatedException:
当尚未完成成功认证时，尝试执行授权操作时引发异常。

欢乐少年1904

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringBoot集成Shiro权限管理框架

*** 自定义Realm用于查询用户的角色和权限信息并保存到权限管理器：/*** @Description 权限配置类//获取登录用户名 String name =(String) principalCollection . getPrimaryPrincipal();//查询用户名称 User user = MySqlTool . getUser(name);
复制链接

扫一扫