SpringBoot 整合 Shiro 实现登录验证即权限下放、关于Permission

Shiro简介

Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。
Shiro三个核心组件：

• Subject：即“当前操作用户”。但是，在Shiro中，Subject这一概念并不仅仅指人，也可以是第三方进程、后台帐户（Daemon Account）或其他类似事物。它仅仅意味着“当前跟软件交互的东西”。Subject代表了当前用户的安全操作，SecurityManager则管理所有用户的安全操作。
• SecurityManager：它是Shiro框架的核心，典型的Facade模式，Shiro通过SecurityManager来管理内部组件实例，并通过它来提供安全管理的各种服务。
• Realm： Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro会从应用配置的Realm中查找用户及其权限信息。从这个意义上讲，Realm实质上是一个安全相关的DAO：它封装了数据源的连接细节，并在需要时将相关数据提供给Shiro。当配置Shiro时，你必须至少指定一个Realm，用于认证和（或）授权。配置多个Realm是可以的，但是至少需要一个。
  Shiro内置了可以连接大量安全数据源（又名目录）的Realm，如LDAP、关系数据库（JDBC）、类似INI的文本配置资源以及属性文件等。如果缺省的Realm不能满足需求，你还可以插入代表自定义数据源的自己的Realm实现（继承 AuthorizingRealm 类）。

Subject来进行认证和授权，而Subject又委托给SecurityManage，再给SecurityManager注入Realm，从而让SecurityManager能得到合法的用户及其权限进行判断。

Shiro 官网地址：http://shiro.apache.org/

Authentication：身份认证/登录，验证用户是不是拥有相应的身份；

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

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

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

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

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

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

Testing：提供测试支持；

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

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

SpringBoot 整合 Shiro

1. 环境搭建

使用SpringBoot、Mybatis、ThymeLeaf搭建一个简易具有跳转功能的Demo

package cn.mitaowulong.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class UserController {

    @RequestMapping({"/","/index"})
    public String index(Model model) {
        model.addAttribute("msg","Hello Shiro");
        return "index";
    }

    @RequestMapping("/toLogin")
    public String toLogin() {
        return "login";
    }

    @RequestMapping("toAdd")
    public String toAdd() {
        return "user/add";
    }

    @RequestMapping("toUpdate")
    public String toUpdate() {
        return "user/update";
    }

    @RequestMapping("/login")
    public String login() {

        return "index"; //登录成功
    }

    @RequestMapping("nonath")
    @ResponseBody
    public String nonath() {
        return "未经授权不得访问此页面";
    }
}

2. 连接测试用数据库并实现查询功能

pojo实体类：

package cn.mitaowulong.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private int id;

    private String name;

    private String pwd;

    private String perms; //用户权限
}

mapper接口：

package cn.mitaowulong.mapper;

import cn.mitaowulong.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

@Repository
@Mapper
public interface UserMapper {

    public User queryUserByName(String name);

}

mapper.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.mitaowulong.mapper.UserMapper">
    <select id="queryUserByName" parameterType="String" resultType="User" >
        select * from mybatis.user where name=#{name}
    </select>
</mapper>

service层接口：

package cn.mitaowulong.service;

import cn.mitaowulong.pojo.User;

public interface UserService {
    public User queryUserByName(String name);
}

service实现类：

package cn.mitaowulong.service;

import cn.mitaowulong.mapper.UserMapper;
import cn.mitaowulong.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    UserMapper userMapper;

    @Override
    public User queryUserByName(String name) {
        return userMapper.queryUserByName(name);
    }
}

3. 编写Shiro配置类

上文已经说过Shiro的三个核心组件是Subject、SecurityManager、Realm对象，他们依次相互依赖，Realm位于最底层，其次是SecurityManager，最终在业务代码中操作Subject对象
首先导入Shiro的Maven依赖

<!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-spring -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.4.1</version>
</dependency>

我们这里自定义Realm类，需继承 AuthorizingRealm 类，重写用于授权的doGetAuthorizationInfo方法和用于认证的doGetAuthenticationInfo方法

package cn.mitaowulong.config;

import cn.mitaowulong.pojo.User;
import cn.mitaowulong.service.UserService;
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.realm.AuthorizingRealm;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;

public class UserRealm extends AuthorizingRealm {

    @Autowired
    UserService userService;

    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

		//设置所有用户都拥有的权限
        info.addStringPermission("user:browse");

        //拿到当前登录对象
        Subject subject = SecurityUtils.getSubject();
        User currentUser = (User) subject.getPrincipal();

        //设置当前用户权限
        info.addStringPermission(currentUser.getPerms());

        return info;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;

        //连接数据库进行认证
        User user = userService.queryUserByName(token.getUsername());

        if (user == null) {
            return null; //对应UnknownAccountException
        }

        Subject subject = SecurityUtils.getSubject();
        Session session = subject.getSession();
        session.setAttribute("loginUser",user);
        return new SimpleAuthenticationInfo(user,user.getPwd(),"");
    }
}

再配置ShiroConfig类

package cn.mitaowulong.config;

import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;

@Configuration
public class ShiroConfig {

    @Bean
    public UserRealm getUserRealm() {
        UserRealm userRealm = new UserRealm();
        return userRealm;
    }

    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("getUserRealm") UserRealm userRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //关联userRealm
        securityManager.setRealm(userRealm);
        return securityManager;
    }

    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("getDefaultWebSecurityManager") DefaultWebSecurityManager defaultWebSecurityManager) {
        ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
        bean.setSecurityManager(defaultWebSecurityManager);

        //添加Shiro内置过滤器
        /**
         * anno:无需认证就直接登录
         * authc:必须认证了才能访问
         * user:必须有记住我功能才能使用
         * perms:必须拥有某个角色权限才能访问
         * role:
         */

        LinkedHashMap<String, String> filterMap = new LinkedHashMap<>();
        filterMap.put("/toAdd","perms[user:add]");
        filterMap.put("/toUpdate","perms[user:update]");
        filterMap.put("/toBrowse","perms[user:browse]");
        bean.setFilterChainDefinitionMap(filterMap);

        //设置登录的请求
        bean.setLoginUrl("/toLogin");

        //未授权页面
        bean.setUnauthorizedUrl("/noauth");

        return bean;
    }
}

此时login.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</head>
<body>
<h1>登录</h1>

<p th:text="${msg}" style="color: red"></p>
<form th:action="@{/login}">
    <p>用户名 <input type="text" name="username"></p>
    <p>密码 <input type="password" name="password"></p>
    <p><input type="submit" value="提交"></p>
</form>
</body>
</html>

至此，已经能实现权限认证
当然，Shiro也能与Thymeleaf整合
Maven依赖：

<!--shiro-thymeleaf整合-->
<dependency>
   <groupId>com.github.theborakompanioni</groupId>
   <artifactId>thymeleaf-extras-shiro</artifactId>
   <version>2.0.0</version>
</dependency>

命名空间：

xmlns:shiro="http://www.thymeleaf.org/thymeleaf-extras-shiro"

关于Permission

单个权限 query
单个资源多个权限 user:query user:add 多值 user:query,add
单个资源所有权限 user:query,add,update,delete user:
所有资源某个权限 :view
实例级别的权限控制
单个实例的单个权限 printer:query:lp7200 printer:print:epsoncolor
所有实例的单个权限 printer:print:
所有实例的所有权限 printer::
单个实例的所有权限 printer::lp7200
单个实例的多个权限 printer:query,print:lp7200
字符串通配符权限
规则：“资源标识符：操作：对象实例ID” 即对哪个资源的哪个实例可以进行什么操作。其默认支持通配符权限字符串，“:”表示资源/操作/实例的分割；“,”表示操作的分割；“”表示任意资源/操作/实例。

1、单个资源单个权限
currentUser.checkPermissions(“system:user:update”);
用户拥有资源“system:user”的“update”权限。

2、单个资源多个权限
ini配置文件
role41=system:user:update,system:user:delete
然后通过如下代码判断
subject().checkPermissions(“system:user:update”, “system:user:delete”);
用户拥有资源“system:user”的“update”和“delete”权限。如上可以简写成：

ini配置（表示角色4拥有system:user资源的update和delete权限）
role42=“system:user:update,delete”
接着可以通过如下代码判断
subject().checkPermissions(“system:user:update,delete”);
通过“system:user:update,delete”验证"system:user:update, system:user:delete"是没问题的，但是反过来是规则不成立。

3、单个资源全部权限
ini配置
role51=“system:user:create,update,delete,view”
然后通过如下代码判断
subject().checkPermissions(“system:user:create,delete,update:view”);
用户拥有资源“system:user”的“create”、“update”、“delete”和“view”所有权限。如上可以简写成：

ini配置文件（表示角色5拥有system:user的所有权限）
role52=system:user:
也可以简写为（推荐上边的写法）：
role53=system:user
然后通过如下代码判断
subject().checkPermissions(“system:user:”);
subject().checkPermissions(“system:user”);
通过“system:user:”验证“system:user:create,delete,update:view”可以，但是反过来是不成立的。

4、所有资源全部权限
ini配置
role61=:view
然后通过如下代码判断
subject().checkPermissions(“user:view”);
用户拥有所有资源的“view”所有权限。假设判断的权限是“"system:user:view”，那么需要“role5=::view”这样写才行。

5、实例级别的权限
5.1、单个实例单个权限
ini配置
role71=user:view:1
对资源user的1实例拥有view权限。
然后通过如下代码判断
subject().checkPermissions(“user:view:1”);

5.2、单个实例多个权限
ini配置
role72=“user:update,delete:1”
对资源user的1实例拥有update、delete权限。
然后通过如下代码判断
subject().checkPermissions(“user:delete,update:1”);
subject().checkPermissions(“user:update:1”, “user:delete:1”);

5.3、单个实例所有权限
ini配置
role73=user::1
对资源user的1实例拥有所有权限。
然后通过如下代码判断
subject().checkPermissions(“user:update:1”, “user:delete:1”, “user:view:1”);

5.4、所有实例单个权限
ini配置
role74=user:auth:
对资源user的1实例拥有所有权限。
然后通过如下代码判断
subject().checkPermissions(“user:auth:1”, “user:auth:2”);

5.5、所有实例所有权限
ini配置
role75=user::
对资源user的1实例拥有所有权限。
然后通过如下代码判断
subject().checkPermissions(“user:view:1”, “user:auth:2”);

6、Shiro对权限字符串缺失部分的处理
如“user:view”等价于“user:view:”；而“organization”等价于“organization:”或者“organization::”。可以这么理解，这种方式实现了前缀匹配。
另外如“user:”可以匹配如“user:delete”、“user:delete”可以匹配如“user:delete:1”、“user::1”可以匹配如“user:view:1”、“user”可以匹配“user:view”或“user:view:1”等。即可以匹配所有，不加可以进行前缀匹配；但是如“:view”不能匹配“system:user:view”，需要使用“::view”，即后缀匹配必须指定前缀（多个冒号就需要多个来匹配）。

7、WildcardPermission
如下两种方式是等价的：
subject().checkPermission(“menu:view:1”);
subject().checkPermission(new WildcardPermission(“menu:view:1”));
因此没什么必要的话使用字符串更方便。
8、性能问题
通配符匹配方式比字符串相等匹配来说是更复杂的，因此需要花费更长时间，但是一般系统的权限不会太多，且可以配合缓存来提供其性能，如果这样性能还达不到要求我们可以实现位操作算法实现性能更好的权限匹配。另外实例级别的权限验证如果数据量太大也不建议使用，可能造成查询权限及匹配变慢。可以考虑比如在sql查询时加上权限字符串之类的方式在查询时就完成了权限匹配。