点击上方蓝色字体，关注我们
这篇文章我们来学习如何使用Spring Boot集成Apache Shiro。安全应该是互联网公司的一道生命线，几乎任何的公司都会涉及到这方面的需求。这篇文章会先介绍一下Apache Shiro，在结合Spring Boot给出使用案例。
对于一个真正为其存在提供良好案例的框架，以及因此您使用它的理由，它应该满足其他替代方案无法满足的需求。为了理解这一点，我们需要了解Shiro的历史以及创建时的替代方案。
在2008年进入Apache软件基金会之前，Shiro已经有5年的历史，之前被称为JSecurity项目，该项目始于2003年初。2003年，Java应用程序开发人员的通用安全替代方案并不多 - Java认证和授权服务，也称为JAAS。JAAS存在许多缺点 - 虽然其身份验证功能在某种程度上是可以容忍的，但授权方面使用起来很麻烦且令人沮丧。此外，JAAS严重依赖于虚拟机级安全性问题，例如，确定是否应允许在JVM中加载类。作为一名应用程序开发人员，我更关心应用程序最终用户可以做什么，而不是我的代码可以在JVM中做什么。
由于我当时正在使用的应用程序，我还需要访问一个干净的，与容器无关的会话机制。当时游戏中唯一的会话选择是HttpSessions，它需要一个Web容器，或EBJ 2.1 Stateful Session Beans，它需要一个EJB容器。我需要一些可以与容器分离的东西，可以在我选择的任何环境中使用。
最后，存在加密问题。有时候我们都需要保证数据安全，但除非你是加密专家，否则Java密码体系结构很难理解。API充满了检查异常，并且使用起来很麻烦。我希望有一个更清洁的开箱即用的解决方案，可以根据需要轻松加密和解密数据。
因此，从2003年初的安全状况来看，您可以很快意识到在单一，有凝聚力的框架中没有任何东西可以满足所有这些要求。正因为如此，JSecurity，以及后来的Apache Shiro诞生了。
Apache Shiro是一个功能强大且易于使用的Java安全框架，可执行身份验证，授权，加密和会话管理，并可用于保护任何应用程序 - 从命令行应用程序，移动应用程序到最大的Web和企业应用程序。
Authentication（认证）, Authorization（授权）, Session Management（会话管理）, Cryptography（加密）被 Shiro 框架的开发团队称之为应用安全的四大基石。
Authentication（认证）：用户身份识别，通常被称为用户“登录”。
Authorization（授权）：访问控制。比如某个用户是否具有某个操作的使用权限。
Session Management（会话管理）：特定于用户的会话管理,甚至在非web 或 EJB 应用程序。
Cryptography（加密）：在对数据源使用加密算法加密的同时，保证易于使用。
user_info 用户表
sys_user_role 用户角色关联表 (一对多的关系，一个角色对应多个用户)
sys_permission 权限表
sys_role_permission 角色权限关联表 （多对多关系）
sys_role 角色表
pom文件
org.springframework.boot
spring-boot-starter-data-jpa
org.springframework.boot
spring-boot-starter-thymeleaf
net.sourceforge.nekohtml
nekohtml
1.9.22
org.springframework.boot
spring-boot-starter-web
org.apache.shiro
shiro-spring
1.4.0
mysql
mysql-connector-java
runtime
配置文件
spring.datasource.url=jdbc:mysql://localhost:3306/test?
serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.properties.hibernate.hbm2ddl.auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql= true
spring.thymeleaf.cache=false
创建用户类
@Entity
public class UserInfo implements Serializable {
@Id
@GeneratedValue
private Integer uid;
@Column(unique =true)
private String username;//帐号
private String name;//名称（昵称或者真实姓名，不同系统不同定义）
private String password; //密码;
private String salt;//加密密码的盐
private byte state;//用户状态,0:创建未认证（比如没有激活，没有输入验证码等等）--等待验证的用户 , 1:正常状态,2：用户被锁定.
@ManyToMany(fetch= FetchType.EAGER)//立即从数据库中进行加载数据;
@JoinTable(name = "SysUserRole", joinColumns = { @JoinColumn(name = "uid") }, inverseJoinColumns ={@JoinColumn(name = "roleId") })
private List roleList;// 一个用户具有多个角色
// 省略setget方法
}
创建角色类
@Entity
public class SysRole {
@Id@GeneratedValue
private Integer id; // 编号
private String role; // 角色标识程序中判断使用,如"admin",这个是唯一的:
private String description; // 角色描述,UI界面显示使用
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 userInfos;// 一个角色对应多个用户
// 省略setget方法
}
权限类
@Entity
public class SysPermission implements Serializable {
@Id@GeneratedValue
private Integer id;//主键.
private String name;//名称.
@Column(columnDefinition="enum('menu','button')")
private String resourceType;//资源类型，[menu|button]
private String url;//资源路径.
private String permission; //权限字符串,menu例子：role:*，button例子：role:create,role:update,role:delete,role:view
private Long parentId; //父编号
private String parentIds; //父编号列表
private Boolean available = Boolean.FALSE;
@ManyToMany
@JoinTable(name="SysRolePermission",joinColumns={@JoinColumn(name="permissionId")},inverseJoinColumns={@JoinColumn(name="roleId")})
private List roles;
//省略setget方法
}
根据以上的代码会自动生成user_info（用户信息表）、sys_role（角色表）、sys_permission（权限表）、sys_user_role（用户角色表）、sys_role_permission（角色权限表）这五张表，为了方便测试我们给这五张表插入一些初始化数据：
INSERT INTO `user_info` (`uid`,`username`,`name`,`password`,`salt`,`state`) VALUES ('1', 'admin', '管理员', '9c77d6384a1d8a1cc581424e6f0e82d8','root30ea1b94d889ccadeb9f89af63317de2', 0);
INSERT INTO `sys_permission` (`id`,`available`,`name`,`parent_id`,`parent_ids`,`permission`,`resource_type`,`url`) VALUES (1,0,'用户管理',0,'0/','userInfo:view','menu','userInfo/userList');
INSERT INTO `sys_permission` (`id`,`available`,`name`,`parent_id`,`parent_ids`,`permission`,`resource_type`,`url`) VALUES (2,0,'用户添加',1,'0/1','userInfo:add','button','userInfo/userAdd');
INSERT INTO `sys_permission` (`id`,`available`,`name`,`parent_id`,`parent_ids`,`permission`,`resource_type`,`url`) VALUES (3,0,'用户删除',1,'0/1','userInfo:del','button','userInfo/userDel');
INSERT INTO `sys_role` (`id`,`available`,`description`,`role`) VALUES (1,0,'管理员','admin');
INSERT INTO `sys_role` (`id`,`available`,`description`,`role`) VALUES (2,0,'VIP会员','vip');
INSERT INTO `sys_role` (`id`,`available`,`description`,`role`) VALUES (3,1,'test','test');
INSERT INTO `sys_role_permission` VALUES ('1', '1');
INSERT INTO `sys_role_permission` (`permission_id`,`role_id`) VALUES (1,1);
INSERT INTO `sys_role_permission` (`permission_id`,`role_id`) VALUES (2,1);
INSERT INTO `sys_role_permission` (`permission_id`,`role_id`) VALUES (3,2);
INSERT INTO `sys_user_role` (`role_id`,`uid`) VALUES (1,1);
Shiro 配置
首先要配置的是ShiroConfig类，Apache Shiro 核心通过 Filter 来实现，就好像SpringMvc 通过DispachServlet 来主控制一样。 既然是使用 Filter 一般也就能猜到，是通过URL规则来进行过滤和权限校验，所以我们需要定义一系列关于URL的规则和访问权限。
ShiroConfig
@Configuration
public class ShiroConfig {
@Bean
public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
System.out.println("ShiroConfiguration.shirFilter()");
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
shiroFilterFactoryBean.setSecurityManager(securityManager);
//拦截器.
Map filterChainDefinitionMap = new LinkedHashMap();
// 配置不会被拦截的链接 顺序判断
filterChainDefinitionMap.put("/static/**", "anon");
//配置退出 过滤器,其中的具体的退出代码Shiro已经替我们实现了
filterChainDefinitionMap.put("/logout", "logout");
//:这是一个坑呢，一不小心代码就不好使了;
//
filterChainDefinitionMap.put("/**", "authc");
// 如果不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面
shiroFilterFactoryBean.setLoginUrl("/login");
// 登录成功后要跳转的链接
shiroFilterFactoryBean.setSuccessUrl("/index");
//未授权界面;
shiroFilterFactoryBean.setUnauthorizedUrl("/403");
shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
return shiroFilterFactoryBean;
}
@Bean
public MyShiroRealm myShiroRealm(){
MyShiroRealm myShiroRealm = new MyShiroRealm();
return myShiroRealm;
}
@Bean
public SecurityManager securityManager(){
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(myShiroRealm());
return securityManager;
}
}
自定义realm
MyShiroRealm继承 AuthorizingRealm,重写doGetAuthorizationInfo授权方法,和doGetAuthenticationInfo认证方法。
public class MyShiroRealm extends AuthorizingRealm {
@Resource
private UserInfoService userInfoService;
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
System.out.println("权限配置-->MyShiroRealm.doGetAuthorizationInfo()");
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
UserInfo userInfo = (UserInfo)principals.getPrimaryPrincipal();
for(SysRole role:userInfo.getRoleList()){
authorizationInfo.addRole(role.getRole());
for(SysPermission p:role.getPermissions()){
authorizationInfo.addStringPermission(p.getPermission());
}
}
return authorizationInfo;
}
/*主要是用来进行身份认证的，也就是说验证用户输入的账号和密码是否正确。*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
throws AuthenticationException {
System.out.println("MyShiroRealm.doGetAuthenticationInfo()");
// 获取用户的输入的账号.
String username = (String)token.getPrincipal();
// 获取用户的输入的密码
System.out.println(token.getCredentials());
//通过username从数据库中查找 User对象，如果找到，没找到.
//实际项目中，这里可以根据实际情况做缓存，如果不做，Shiro自己也是有时间间隔机制，2分钟内不会重复执行该方法
UserInfo userInfo = userInfoService.findByUsername(username);
System.out.println("----->>userInfo="+userInfo);
if(userInfo == null){
return null;
}
// 进行认证，将正确数据给shiro处理
// 密码不用自己比对，AuthenticationInfo认证信息对象，一个接口，new他的实现类对象SimpleAuthenticationInfo
/* 第一个参数随便放，可以放user对象，程序可在任意位置获取 放入的对象
* 第二个参数必须放密码，
* 第三个参数放 当前realm的名字，因为可能有多个realm*/
SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
userInfo, //用户名
userInfo.getPassword(), //密码
ByteSource.Util.bytes(userInfo.getSalt()),
getName() //realm name
);
//清除之前的授权信息
super.clearCachedAuthorizationInfo(authenticationInfo.getPrincipals());
// 存入用户对象
SecurityUtils.getSubject().getSession().setAttribute("login", userInfo);
// 返回给安全管理器，securityManager，由securityManager比对数据库查询出的密码和页面提交的密码
// 如果有问题，向上抛异常，一直抛到控制器
return authenticationInfo;
}
}
AuthenticationToken
上面定义了接口源码，主要是两个接口，一个是获取委托人信息，一个是获取证明，常用的是用户名和密码的组合。
这里AuthenticationToken只提供接口，一般我们的实体类包含了get/set方法，但是这里抽出了get方法，方便用户自己扩展所需要的实现。
public interface AuthenticationToken extends Serializable {
Object getPrincipal();
Object getCredentials();
}
其中扩展接口HostAuthenticationToken提供了获取用户客户host的功能，源代码如下：
public interface HostAuthenticationToken extends AuthenticationToken {
String getHost();
}
RememberMeAuthenticationToken提供了记住用户的标识：
public interface RememberMeAuthenticationToken extends AuthenticationToken {
boolean isRememberMe();
}
登录过程其实只是处理异常的相关信息，具体的登录验证交给shiro来处理。
@Controller
public class HomeController {
@RequestMapping({"/","/index"})
public String index(){
return"/index";
}
@RequestMapping("/login")
public String login(HttpServletRequest request, Map map) throws Exception{
System.out.println("HomeController.login()");
// 登录失败从request中获取shiro处理的异常信息。
// shiroLoginFailure:就是shiro异常类的全类名.
String exception = (String) request.getAttribute("shiroLoginFailure");
System.out.println("exception=" + exception);
String msg = "";
if (exception != null) {
if (UnknownAccountException.class.getName().equals(exception)) {
System.out.println("UnknownAccountException -- > 账号不存在：");
msg = "UnknownAccountException -- > 账号不存在：";
} else if (IncorrectCredentialsException.class.getName().equals(exception)) {
System.out.println("IncorrectCredentialsException -- > 密码不正确：");
msg = "IncorrectCredentialsException -- > 密码不正确：";
} else if ("kaptchaValidateFailed".equals(exception)) {
System.out.println("kaptchaValidateFailed -- > 验证码错误");
msg = "kaptchaValidateFailed -- > 验证码错误";
} else {
msg = "else >> "+exception;
System.out.println("else -- >" + exception);
}
}
map.put("msg", msg);
// 此方法不处理登录成功,由shiro进行处理
return "/login";
}
@RequestMapping("/403")
public String unauthorizedRole(){
System.out.println("------没有权限-------");
return "403";
}
}
其它dao层和service的代码就不贴出来了大家直接看代码。
登录页面
登录成功会跳转 index 页面，如果错误会返回错误信息。
上面这些操作时候触发MyShiroRealm.doGetAuthorizationInfo()这个方法，也就是权限校验的方法。
可以在数据库中修改不同的权限进行测试，demo中有对用户的增删查改，就不展示了，大家可以下载demo运行。
shiro很强大，这仅仅是完成了登录认证和权限管理、用户管理的增删查改。
github地址：
https://github.com/xiaonongOne/springboot-shiro
