Shiro 核心功能案例讲解 基于SpringBoot 有源码
从实战中学习Shiro的用法。本章使用SpringBoot快速搭建项目。整合SiteMesh框架布局页面。整合Shiro框架实现用身份认证，授权，数据加密功能。通过本章内容，你将学会用户权限的分配规则，SpringBoot整合Shiro的配置，Shiro自定义Realm的创建，Shiro标签式授权和注解式授权的使用场景，等实战技能，还在等什么，快来学习吧！
技术：SpringBoot，Shiro，SiteMesh，Spring，SpringDataJpa，SpringMVC，Bootstrap-sb-admin-1.0.4
说明：前端使用的是Bootstrap-sb-admin模版。注意文章贴出的代码可能不完整，请以github上源码为主，谢谢！
源码：https://github.com/ITDragonBlog/daydayup/tree/master/Shiro 喜欢的朋友可以鼓励（star）下。
效果图：
Shiro 功能介绍
四个核心：登录认证，权限验证，会话管理，数据加密。
六个支持：支持WEB开发，支持缓存，支持线程并发验证，支持测试，支持用户切换，支持"记住我"功能。
• Authentication ：身份认证，也可以理解为登录，验证用户身份。
• Authorization ：权限验证，也可以理解为授权，验证用户是否拥有某个权限；即判断用户是否能进行什么操作。
• Session Manager ：会话管理，用户登录后就是一次会话，在退出前，用户的所有信息都在会话中。
• Cryptography ：数据加密，保护数据的安全性，常见的有密码的加盐加密。
• Web Support ：支持Web开发。
• Caching ：缓存，Shiro将用户信息、拥有的角色/权限数据缓存，以提高程序效率。
• Concurrency ：支持多线程应用的并发验证，即在一个线程中开启另一个线程，Shiro能把权限自动传播过去。
• Testing ：提供测试支持。
• Run As ：允许一个用户以另一个用户的身份进行访问；前提是两个用户运行切换身份。
• Remember Me ：记住我，常见的功能，即登录一次后，在指定时间内免登录。
Shiro 功能介绍
Shiro 架构介绍
三个角色：当前用户 Subject，安全管理器 SecurityManager，权限配置域 Realm。
• Subject ：代表当前用户，提供了很多方法，如login和logout。Subject 只是一个门面，与Subject的所有交互都会委托给SecurityManager，SecurityManager才是真正的执行者；
• SecurityManager ：安全管理器；Shiro的核心，它负责与Shiro的其他组件进行交互，即所有与安全有关的操作都会与SecurityManager 交互；且管理着所有的 Subject；
• Realm ：Shiro 从 Realm 获取安全数据（如用户、角色、权限），SecurityManager 要验证用户身份，必需要从 Realm 获取相应的用户信息，判断用户身份是否合法，判断用户角色或权限是否授权。
SpringBoot 整合SiteMesh
SiteMesh 是一个网页布局和修饰的框架，利用它可以将网页的内容和页面结构分离，以达到页面结构共享的目的。
SiteMesh 统一了页面的风格，减少了重复代码，提高了页面的复用率，是一款值得我们去学习的框架（也有很多坑）。当然，今天的主角是Shiro，这里只介绍它的基本用法。
SpringBoot 整合SiteMesh只需二个步骤：
第一步：配置拦截器FIlter，并在web中注册bean。
第二步：创建装饰页面，引入常用的css和js文件，统一系统样式。
配置拦截器FIlter
指定拦截的URL请求路径，指定装饰页面的文件全路径，指定不需要拦截的URL请求路径。这里拦截所有请求到装饰页面，只有登录页面和静态资源不拦截。
import org.sitemesh.builder.SiteMeshFilterBuilder;
import org.sitemesh.config.ConfigurableSiteMeshFilter;
/**
* 配置SiteMesh拦截器FIlter，指定装饰页面和不需要拦截的路径
* @author itdragon
*/
public class WebSiteMeshFilter extends ConfigurableSiteMeshFilter{
@Override
protected void applyCustomConfiguration(SiteMeshFilterBuilder builder) {
builder.addDecoratorPath("/*", "/WEB-INF/layouts/default.jsp") // 配置装饰页面
.addExcludedPath("/static/*") // 静态资源不拦截
.addExcludedPath("/login**"); // 登录页面不拦截
}
}
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* web.xml 配置
* @author itdragon
*/
@Configuration
public class WebConfig {
@Bean // 配置siteMesh3
public FilterRegistrationBean siteMeshFilter(){
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
WebSiteMeshFilter siteMeshFilter = new WebSiteMeshFilter();
filterRegistrationBean.setFilter(siteMeshFilter);
return filterRegistrationBean;
}
}
创建装饰页面
SiteMesh语法
ITDragon系统-<sitemesh:write property='title'/>
roleList; // 一个用户拥有多个角色
private Integer status; // 用户状态，0表示用户已删除
}
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
/**
* 角色表，决定用户可以访问的页面
* @author itdragon
*/
@Table(name="itdragon_sysrole")
@Entity
public class SysRole {
@Id
@GeneratedValue
private Integer id;
private String role; // 角色
private String description; // 角色描述
private Boolean available = Boolean.FALSE; // 默认不可用
//角色 -- 权限关系：多对多关系; 取出这条数据时，把它关联的数据也同时取出放入内存中
@ManyToMany(fetch=FetchType.EAGER)
@JoinTable(name="SysRolePermission",joinColumns={@JoinColumn(name="roleId")},inverseJoinColumns={@JoinColumn(name="permissionId")})
private List permissions;
// 用户 - 角色关系：多对多关系;
@ManyToMany
@JoinTable(name="SysUserRole",joinColumns={@JoinColumn(name="roleId")},inverseJoinColumns={@JoinColumn(name="uid")})
private List users;
}
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
/**
* 权限表，决定用户的具体操作
* @author itdragon
*/
@Table(name = "itdragon_syspermission")
@Entity
public class SysPermission {
@Id
@GeneratedValue
private Integer id;
private String name; // 名称
private String url; // 资源路径
private String permission; // 权限字符串 如：employees:create,employees:update,employees:delete
private Boolean available = Boolean.FALSE; // 默认不可用
@ManyToMany
@JoinTable(name = "SysRolePermission", joinColumns = { @JoinColumn(name = "permissionId") }, inverseJoinColumns = {@JoinColumn(name = "roleId") })
private List roles;
}
创建自定义安全数据源Realm
Shiro 从 Realm 获取安全数据（如用户、角色、权限），SecurityManager 身份认证和权限认证都是从Realm中获取相应的用户信息，然后做比较判断是否有身份登录，是否有权限操作。
Shiro 支持多个Realm。同时也有不同的认证策略：
• FirstSuccessfulStrategy : 只要有一个Realm成功就返回，后面的忽略；
• AtLeastOneSuccessfulStrategy : 只要有一个Realm成功就通过，返回所有认证成功的信息，默认；
• AllSuccessfulStrategy : 必须所有Realm都成功才算通过
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.apache.shiro.util.ByteSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import com.itdragon.pojo.SysPermission;
import com.itdragon.pojo.SysRole;
import com.itdragon.pojo.User;
import com.itdragon.service.UserService;
/**
* 自定义安全数据Realm，重点
* @author itdragon
*/
public class ITDragonShiroRealm extends AuthorizingRealm {
private static final transient Logger log = LoggerFactory.getLogger(ITDragonShiroRealm.class);
@Autowired
private UserService userService;
/**
* 授权
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
log.info("^^^^^^^^^^^^^^^^^^^^ ITDragon 配置当前用户权限");
String username = (String) principals.getPrimaryPrincipal();
User user = userService.findByAccount(username);
if(null == user){
return null;
}
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
for (SysRole role : user.getRoleList()) {
authorizationInfo.addRole(role.getRole()); // 添加角色
for (SysPermission permission : role.getPermissions()) {
authorizationInfo.addStringPermission(permission.getPermission()); // 添加具体权限
}
}
return authorizationInfo;
}
/**
* 身份认证
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
throws AuthenticationException {
log.info("^^^^^^^^^^^^^^^^^^^^ ITDragon 认证用户身份信息");
String username = (String) token.getPrincipal(); // 获取用户登录账号
User userInfo = userService.findByAccount(username); // 通过账号查加密后的密码和盐，这里一般从缓存读取
if(null == userInfo){
return null;
}
// 1). principal: 认证的实体信息. 可以是 username, 也可以是数据表对应的用户的实体类对象.
Object principal = username;
// 2). credentials: 加密后的密码.
Object credentials = userInfo.getPassword();
// 3). realmName: 当前 realm 对象的唯一名字. 调用父类的 getName() 方法
String realmName = getName();
// 4). credentialsSalt: 盐值. 注意类型是ByteSource
ByteSource credentialsSalt = ByteSource.Util.bytes(userInfo.getSalt());
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(principal, credentials, credentialsSalt, realmName);
return info;
}
}
创建Spring整合Shiro配置类
第一步：配置Shiro拦截器，指定URL请求的权限。首先静态资源和登录请求匿名访问，然后是用户登出操作，最后是所有请求都需身份认证。Shiro拦截器优先级是从上到下，切勿将/**=authc，放在前面。
第二步：配置Shiro生命周期处理器，
第三步：配置自定义Realm，负责身份认证和授权。
第四步：配置安全管理器SecurityManager，Shiro的核心。
import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
/**
* Shiro 配置，重点
* @author itdragon
*/
@Configuration
public class ShiroSpringConfig {
private static final transient Logger log = LoggerFactory.getLogger(ShiroSpringConfig.class);
/**
* 配置拦截器
*
* 定义拦截URL权限，优先级从上到下
* 1). anon : 匿名访问，无需登录
* 2). authc : 登录后才能访问
* 3). logout: 登出
* 4). roles : 角色过滤器
*
* URL 匹配风格
* 1). ?：匹配一个字符，如 /admin? 将匹配 /admin1，但不匹配 /admin 或 /admin/；
* 2). *：匹配零个或多个字符串，如 /admin* 将匹配 /admin 或/admin123，但不匹配 /admin/1；
* 2). **：匹配路径中的零个或多个路径，如 /admin/** 将匹配 /admin/a 或 /admin/a/b
*
* 配置身份验证成功，失败的跳转路径
*/
@Bean
public ShiroFilterFactoryBean shirFilter(DefaultWebSecurityManager securityManager) {
log.info("^^^^^^^^^^^^^^^^^^^^ ITDragon 配置Shiro拦截工厂");
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
shiroFilterFactoryBean.setSecurityManager(securityManager);
Map filterChainDefinitionMap = new LinkedHashMap();
filterChainDefinitionMap.put("/static/**", "anon"); // 静态资源匿名访问
filterChainDefinitionMap.put("/employees/login", "anon");// 登录匿名访问
filterChainDefinitionMap.put("/logout", "logout"); // 用户退出，只需配置logout即可实现该功能
filterChainDefinitionMap.put("/**", "authc"); // 其他路径均需要身份
<%@ include file="/WEB-INF/layouts/header.jsp"%>
SpringBoot 整合Shiro
这是本章的核心知识点，SpringBoot 整合Shiro 有三个步骤：
第一步：创建实体类：用户，角色，权限。确定三者关系，以方便Realm的授权工作。
第二步：创建自定义安全数据源Realm：负责用户登录认证，用户操作授权。
第三步：创建Spring整合Shiro配置类：配置拦截规则，生命周期，安全管理器，安全数据源，等。
创建实体类
实体类：User，SysRole，SysPermission。
权限设计思路：
1). 角色表确定系统菜单资源，权限表确定菜单操作资源。
2). 用户主要通过角色来获取权限，且一个用户可以拥有多个角色（不推荐，但必须支持该功能）。
3). 一个角色可以拥有多个权限，同时也可以有用多个用户。
4). 一个权限可以被多个角色使用。
5). 工作都是从易到难，我们可以先从“一个用户拥有一个角色，一个角色拥有多个权限”开始。
有了上面的分析，三个实体类代码如下，省略了get/set方法。
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import javax.persistence.Transient;
/**
* 用户实体类
* @author itdragon
*/
@Table(name="itdragon_user_shiro")
@Entity
public class User {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private Long id; // 自增长主键，默认ID为1的账号为超级管理员
private String account; // 登录的账号
private String userName; // 注册的昵称
@Transient
private String plainPassword; // 登录时的密码，不持久化到数据库
private String password; // 加密后的密码
private String salt; // 用于加密的盐
private String iphone; // 手机号
private String email; // 邮箱
private String platform; // 用户来自的平台
private String createdDate; // 用户注册时间
private String updatedDate; // 用户最后一次登录时间
@ManyToMany(fetch=FetchType.EAGER)
@JoinTable(name = "SysUserRole", joinColumns = { @JoinColumn(name = "uid") }, inverseJoinColumns ={@JoinColumn(name = "roleId") })
private List