正文
spring-boot+mybatisPlus+shiro的集成demo 我用了5天
小程序：扫一扫查出行【扫一扫了解最新限行尾号】
复制小程序
spring-boot + mybatis-plus + shiro 的集成demo我用了五天
关于shiro框架，我还是从飞机哪里听来的，就连小贱都知道，可我母鸡啊。简单百度了下，结论很好上手，比spring的security要简单许多...于是我就是开始了我的shiro学习之路 。正巧这几天在研究spring-boot集成mybatis-plus 于是乎我就把shiro也揉了进去，但是效果并不像我预期想象的那样。
以下是我这几天血泪换来的成果-->
基本概念
shiro ：隶属Apache 简单易用的java安全框架 三大件 ：Subject, SecurityManager 和 Realm
Subject:即当前操作用户
SecurityManager:安全管理器
Realm:用户数据的概念，域
过程：
1）建表 数据库一般至少有五张表
1-user：用户账号密码
2-role：角色ID，一个账户可以有很多角色
3-permission权限ID，一个角色可以有很多权限
4-user_role关系对照表：记录每个userID有的角色
5-role_permission关系对照表，记录每个role有的permission
-- 用户表
DROP TABLE IF EXISTS `user_info`;
CREATE TABLE `user_info` (
`uid` int(11) NOT NULL,
`name` varchar(255) DEFAULT NULL,
`pass_word` varchar(255) DEFAULT NULL COMMENT '密码',
`salt` varchar(255) DEFAULT NULL COMMENT '加密',
`state` tinyint(4) NOT NULL COMMENT '状态',
`username` varchar(255) DEFAULT NULL COMMENT '用户名',
`email` varchar(64) DEFAULT NULL COMMENT '邮箱',
`crtime` datetime DEFAULT NULL COMMENT '创建时间',
PRIMARY KEY (`uid`),
UNIQUE KEY(`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8; -- 角色表
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`available` bit(1) DEFAULT NULL,
`description` varchar(255) DEFAULT NULL,
`role` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8; -- 用户角色表
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role` (
`uid` int(11) NOT NULL,
`role_id` int(11) NOT NULL,
PRIMARY KEY(`uid`,`role_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8; -- 权限表
DROP TABLE IF EXISTS `sys_permission`;
CREATE TABLE `sys_permission` (
`id` int(11) NOT NULL COMMENT 'PMK',
`available` bit(1) DEFAULT NULL COMMENT '是否激活',
`name` varchar(255) DEFAULT NULL,
`parent_id` bigint(20) DEFAULT NULL,
`parent_ids` varchar(255) DEFAULT NULL,
`permission` varchar(255) DEFAULT NULL COMMENT '权限',
`resource_type` enum('menu','button') DEFAULT NULL,
`url` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8; -- 角色权限表
DROP TABLE IF EXISTS `sys_role_permission`;
CREATE TABLE `sys_role_permission` (
`permission_id` int(11) NOT NULL,
`role_id` int(11) NOT NULL,
PRIMARY KEY(`role_id`,`permission_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
2）项目搭建
spring-boot mybatis-plus shiro
1.pom.xml 贴出部分
<!-- mybits-plus -starter-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatisplus-spring-boot-starter</artifactId>
<version>1.0.5</version>
</dependency>
<!-- MP 核心库 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus</artifactId>
<version>2.1.8</version>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.2</version>
</dependency>
<!-- 模板引擎 代码生成 -->
<dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity</artifactId>
<version>1.7</version>
</dependency>
<!-- mybits-plus -end-->
<!--shiro 登录认证-->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.4.0</version>
</dependency>
<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>5.1.35</scope>
</dependency>
<!--druid 数据库连接池监控-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.0</version>
</dependency>
<!--jasypt 数据库加解密-->
<dependency>
<groupId>com.github.ulisesbocchio</groupId>
<artifactId>jasypt-spring-boot-starter</artifactId>
<version>1.8</version>
</dependency>
2.先集成mybatis-plus 利用自动生成方法生成 新建5张表的POJO 和 Mapper Service文件
3.编写ShiroConfig配置类
package com.zxt.ms.configs; import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.mgt.SecurityManager;
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.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver; import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties; /**
* @ClassName ShiroConfig
* @Description ms 梦想家
* @Author Zhai XiaoTao https://www.cnblogs.com/zhaiyt
* @Date 2019/1/26 17:27
* @Version 1.0
*/
@Slf4j
@Configuration
public class ShiroConfig { @Bean(name = "lifecycleBeanPostProcessor")
public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
return new LifecycleBeanPostProcessor();
} /**
* shiro自带过滤器,无需再另外设置filter
*
* @param securityManager
* @return
*/
@Bean
public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) { log.info("ShiroConfig.shirFilter() start ..."); ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
//设置安全管理器
shiroFilterFactoryBean.setSecurityManager(securityManager);
//配置过滤器
Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>(); //没登录的页面
shiroFilterFactoryBean.setLoginUrl("/notLogin");
// 设置无权限时跳转的 url;
shiroFilterFactoryBean.setUnauthorizedUrl("/notRole"); /*
* shiro 内置枚举
* anon 表示可以匿名使用
* authc 表示需要认证(登录)才能使用，没有参数
*/
//静态资源允许访问
filterChainDefinitionMap.put("/css/**", "anon");
filterChainDefinitionMap.put("/images/**", "anon");
filterChainDefinitionMap.put("/js/**", "anon");
filterChainDefinitionMap.put("/layer/**", "anon"); //游客，开发权限
filterChainDefinitionMap.put("/guest/**", "anon");
//用户，需要角色权限 “user”
filterChainDefinitionMap.put("/user/**", "roles[user]");
//管理员，需要角色权限 “admin”
filterChainDefinitionMap.put("/admin/**", "roles[admin]");
//开放登陆接口
filterChainDefinitionMap.put("/login", "anon");
filterChainDefinitionMap.put("/loginUser", "anon");
//其余接口一律拦截
//主要这行代码必须放在所有权限设置的最后，不然会导致所有 url 都被拦截
filterChainDefinitionMap.put("/**", "authc"); //过滤器注入工厂类
shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap); log.info("ShiroConfig.shirFilter() end ...");
return shiroFilterFactoryBean;
} /**
* @return org.apache.shiro.mgt.SecurityManager
* @Description <安全管理器Bean>
* @Author Zhaiyt
* @Date 14:35 2019/1/28
* @Param
**/
@Bean
public SecurityManager securityManager() {
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
//注入realm
securityManager.setRealm(myShiroRealm());
return securityManager;
} /**
* @return com.zxt.ms.configs.ShiroRealm
* @Description <域 的概念 Shiro 从从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，
* 那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；
* 可以把Realm看成DataSource ， 即安全数据源>
* @Author Zhaiyt
* @Date 14:38 2019/1/28
* @Param
**/
@Bean
public ShiroRealm myShiroRealm() {
ShiroRealm myShiroRealm = new ShiroRealm();
myShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
return myShiroRealm;
} /**
* @return org.springframework.web.servlet.handler.SimpleMappingExceptionResolver
* @Description <异常处理>
* @Author Zhaiyt
* @Date 15:20 2019/1/28
* @Param
**/
@Bean(name = "simpleMappingExceptionResolver")
public SimpleMappingExceptionResolver createSimpleMappingExceptionResolver() {
SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
Properties mappings = new Properties();
mappings.setProperty("DatabaseException", "databaseError");//数据库异常处理
mappings.setProperty("UnauthorizedException", "403");
exceptionResolver.setExceptionMappings(mappings); // None by default
exceptionResolver.setDefaultErrorView("error"); // No default
exceptionResolver.setExceptionAttribute("ex"); // Default is "exception"
return exceptionResolver;
} /**
* 因为我们的密码是加过密的，所以，如果要Shiro验证用户身份的话，需要告诉它我们用的是md5加密的，并且是加密了两次。
* @Description <加密>
* @Author Zhaiyt
* @Date 16:18 2019/1/29
* @Param
* @return org.apache.shiro.authc.credential.HashedCredentialsMatcher
**/
@Bean
public HashedCredentialsMatcher hashedCredentialsMatcher() {
HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
hashedCredentialsMatcher.setHashAlgorithmName("md5");//散列算法:这里使用MD5算法;
hashedCredentialsMatcher.setHashIterations(2);//散列的次数，比如散列两次，相当于 md5(md5(""));
return hashedCredentialsMatcher;
} /**
* @Description <因为只有开启了AOP才执行doGetAuthorizationInfo()，也就权限拦截>
* @Author Zhaiyt
* @Date 16:18 2019/1/29
* @Param
* @return org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor
**/
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager){
AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
return authorizationAttributeSourceAdvisor;
}
}
shiro配置类编写主要需要注意以下几点：
1.Shiro 过滤器
2.SecurityManager 安全管理器
3.加密方式
4.域需要注入到SecurityManager中
4.自定义ShiroRealm编写：
package com.zxt.ms.configs; import com.zxt.ms.entity.UserInfo;
import com.zxt.ms.service.IUserInfoService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
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.crypto.hash.SimpleHash;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component; import java.util.Set; /**
* @ClassName ShiroRealm
* @Description ms 梦想家
* @Author Zhai XiaoTao https://www.cnblogs.com/zhaiyt
* @Date 2019/1/26 16:54
* @Version 1.0
*/
@Slf4j
@Component
public class ShiroRealm extends AuthorizingRealm { @Autowired
private IUserInfoService userInfoServiceImpl; /**
* @Description <权限验证>
* @Author Zhaiyt
* @Date 14:57 2019/1/28
* @Param
* @return org.apache.shiro.authz.AuthorizationInfo
**/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) { //因为非正常退出，即没有显式调用 SecurityUtils.getSubject().logout()
if (!SecurityUtils.getSubject().isAuthenticated()) {
log.info("非正常退出，清除缓存");
doClearCache(principalCollection);
SecurityUtils.getSubject().logout();
return null;
} UserInfo userInfo = (UserInfo)principalCollection.getPrimaryPrincipal();
String username = userInfo.getUsername();
//用户存在 授权
if(StringUtils.isNotBlank(username)){
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
Set<String> roles=userInfoServiceImpl.findRoleByUser(userInfo.getUsername());
Set<String> permissions=userInfoServiceImpl.findPermissionByUser(userInfo.getUsername());
authorizationInfo.setRoles(roles);
authorizationInfo.setStringPermissions(permissions);
return authorizationInfo;
}
return null;
} /**
* @Description <身份验证>
* @Author Zhaiyt
* @Date 14:58 2019/1/28
* @Param
* @return org.apache.shiro.authc.AuthenticationInfo
**/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
log.info("shiroRealm.doGetAuthenticationInfo() start ...");
//获取用户的输入的账号.
String username = (String)authenticationToken.getPrincipal(); //实际项目中，这里可以根据实际情况做缓存，如果不做，Shiro自己也是有时间间隔机制，2分钟内不会重复执行该方法
if(StringUtils.isNotBlank(username)){ UserInfo userInfo = userInfoServiceImpl.findByUsername(username); if(userInfo == null){
log.error("用户不存在");
throw new UnknownAccountException("用户名或密码错误！");
} SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
userInfo, //用户名
userInfo.getPassword(), //密码
ByteSource.Util.bytes(userInfo.getCredentialsSalt()),//salt=username+salt
getName() //realm name
);
return authenticationInfo;
}
throw new UnknownAccountException("用户名或密码错误！");
}
@Bean
public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator(){
DefaultAdvisorAutoProxyCreator creator = new DefaultAdvisorAutoProxyCreator();
creator.setProxyTargetClass(true);
return creator;
} /**
* 清除权限缓存
* 使用方法：在需要清除用户权限的地方注入 ShiroRealm,
* 然后调用其clearCache方法。
*/
public void clearCache() {
PrincipalCollection principals = SecurityUtils.getSubject().getPrincipals();
super.clearCache(principals);
} public static void main(String[] args) {
String hashAlgorithmName = "MD5";
String credentials = "123456";
int hashIterations = 2;
ByteSource credentialsSalt = ByteSource.Util.bytes("zhaizhai");
Object obj = new SimpleHash(hashAlgorithmName, credentials, credentialsSalt, hashIterations);
System.out.println(obj);
}
}
ShiroRealm 需要集成 AuthorizingRealm 这个里面要实现两个方法，一个认证 doGetAuthenticationInfo，一个授权 doGetAuthorizationInfo
5.测试controller编写
package com.zxt.ms.controller; import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.MapUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map; /**
* @ClassName TestController
* @Description ms 梦想家
* @Author Zhai XiaoTao https://www.cnblogs.com/zhaiyt
* @Date 2019/1/28 16:16
* @Version 1.0
*/
@Slf4j
@Controller
public class HomeController { @RequiresPermissions(value = "admin")
@RequestMapping(value = "/index")
public String test(){
return "index";
} @GetMapping(value = "/login")
public String login(){
return "login";
} @RequestMapping("/loginUser")
@ResponseBody
public Map<String,Object> login(HttpServletRequest request, HttpServletResponse response) throws Exception{
log.info("HomeController.login()");
String username = request.getParameter("username");
String password = request.getParameter("password");
String rememberMe = request.getParameter("rememberMe");
Map<String,Object> map = new HashMap<>();
String ret="";
Subject currentUser = SecurityUtils.getSubject();
if (!currentUser.isAuthenticated()) {
UsernamePasswordToken token = new UsernamePasswordToken(username,
password);
token.setRememberMe(rememberMe=="true");
map.put("code","FAILD");
try {
currentUser.login(token);
map.put("code","SUCCESS");
map.put("msg","登陆成功");
} catch (UnknownAccountException ex) {
map.put("msg","账号错误");
log.error(MapUtils.getString(map,"msg"));
} catch (IncorrectCredentialsException ex) {
map.put("msg","密码错误");
log.error(MapUtils.getString(map,"msg"));
} catch (LockedAccountException ex) {
map.put("msg","账号已被锁定，请与管理员联系");
log.error(MapUtils.getString(map,"msg"));
} catch (AuthenticationException ex) {
map.put("msg","您没有授权");
log.error(MapUtils.getString(map,"msg"));
}
}
return map;
}
}
代码基本上就上面那些，但是我深知，仅仅只有上面那些东西根本就跑不起来，我不知道我为什么要写这样的东西，可能某个小哥在看我写的博客时候也会骂我吧，写的什么鬼鸡仔。。。 我是没有办法把所有东西都整到这来，没有任何意义，有些坑必须自己去踩，只有踩过了，也许才会记得更清楚。
下面我要说坑了：
1.编写shiroFilter的时候我没有将静态数据过滤，导致页面展示格式错乱
2.登陆使用的是ajax，而shiro当做是表单的提交，所以一开始的 login controller 写的是有问题，导致一直报 302
3.认证无法通过，在shiro配置类中我指定了加密方式，为MD5 2次离散 ，在Realm中我指定了需要加 salt 的加密方式，因此密码的加密方式为 MD5 + salt 我使用main 跑出来加密后的数据，添加至数据库，可是一直无法认证成功，后发现在SecurityManager注入的ShiroRealm实体没有set加密方法...
4.认证成功后无法回调授权方法，原因，需要权限校验的方法上添加 @RequiresPermissions(value = "admin") OK
