概念
Apache Shiro 是java的一个安全框架，Shiro可以非常容易的开发出足够好的应用，其不仅可以用在javaSE环境，也可以用在javaEE环境。Shiro可以帮助我们完成：认证，授权，加密，会话，管理，与Web集合，缓存等。
Java领域中spring security也是一个开源的权限管理框架，但是spring security依赖spring运行，而shiro就相对独立，最主要是因为shiro使用简单，灵活，所以现在越来越多的用户选择shiro。
基本功能
Authentication
身份认证/登录，验证用户是不是拥有相应的身份Authorization
授权，即权限验证，验证某个已认证的用户是否拥有某个权限，判断用户是否能做事情，常见的如：验证某个用是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限Session Manager
会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中，会话可以是普通javaSE环境的，也可以是如Web环境的。
Cryptography
加密，保护数据的安全性，如密码加密储存到数据库，而不是明文存储。- Web Support:Web 支持，可以非常容易的集成到web环境。
- Caching:缓存，比如用户登录后，其用户信息，用户的角色/权限不必每次去查，这样可以提高效率。
- Concurrency:shiro支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去。
- Testing:提供测试支持。
- Run As:允许一个用户假装为另一个用户的身份进行访问。
- Remember Me:记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。
- Shiro:不会去维护用户，维护权限，这些需要我们自己去设计/提供然后通过相应的接口注入给Shiro即可。
架构
subject
Subject即主体，外部应用与subject进行交互，subject记录了当前操作用户，将用户的概念理解为当前操作的主体，可能是一个通过浏览器请求的用户，也可能是一个运行的程序。 Subject在shiro中是一个接口，接口中定义了很多认证授相关的方法，外部程序通过subject进行认证授，而subject是通过SecurityManager安全管理器进行认证授权SecurityManager
SecurityManager即安全管理器，对全部的subject进行安全管理，它是shiro的核心，负责对所有的subject进行安全管理。
通过SecurityManager可以完成subject的认证、授权等，实质上SecurityManager是通过Authenticator进行认证，
通过Authorizer进行授权，通过SessionManager进行会话管理等。
SecurityManager是一个接口，继承了Authenticator, Authorizer, SessionManager这三个接口。Authenticator
Authenticator即认证器，对用户身份进行认证，Authenticator是一个接口，shiro提供ModularRealmAuthenticator实现类，
通过ModularRealmAuthenticator基本上可以满足大多数需求，也可以自定义认证器。Authorizer
Authorizer即授权器，用户通过认证器认证通过，在访问功能时需要通过授权器判断用户是否有此功能的操作权限。realm
Realm即领域，相当于datasource数据源，securityManager进行安全认证需要通过Realm获取用户权限数据，比如：如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息。
注意：不要把realm理解成只是从数据源取数据，在realm中还有认证授权校验的相关的代码sessionManager
sessionManager即会话管理，shiro框架定义了一套会话管理，它不依赖web容器的session，所以shiro可以使用在非web应用上，也可以将分布式应用的会话集中在一点管理，此特性可使它实现单点登录。SessionDAO
SessionDAO即会话dao，是对session会话操作的一套接口，比如要将session存储到数据库，可以通过jdbc将会话存储到数据库。CacheManager
CacheManager即缓存管理，将用户权限数据存储在缓存，这样可以提高性能。Cryptography
Cryptography即密码管理，shiro提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能。默认过滤器
shiro.ini
shiro.ini配置文件共有[main]，[users]，[roles]，[urls]共4部分组成
1. [main] 用于定义全局变量
2. [users] 用于定义用户名及密码
3. [roles] 用于定义角色
4. [urls] 用于定义访问url及拦截验证方式[main]
#提供了对根对象 securityManager 及其依赖的配置
securityManager=org.apache.shiro.mgt.DefaultSecurityManager
jdbcRealm = xxxxx
securityManager.realms=$jdbcRealm[users]
#提供了对用户/密码及其角色的配置，用户名=密码，角色 1，角色 2 username=password,role1,role2
#定义用户信息
[users]
#用户名=密码
admin=123456
test=123[roles]
#提供了角色及权限之间关系的配置，角色=权限 1，权限 2 role1=permission1,permission2
[roles]
role1=admin:query,admin:add,admin:update,admin:delete,admin:export
role2=user:query,user:add
role3=test:query,test:export[urls]
#用于 web，提供了对 web url 拦截相关的配置，url=拦截器[参数]，拦截器
Realm域
Realm：域，Shiro 从 Realm 获取安全数据（如用户、角色、权限），就是说 SecurityManager要验证用户身份，那么它需要从 Realm 获取相应的用户进行比较以确定用户身份是否合法；也需要从 Realm 得到用户相应的角色/权限进行验证用户是否能进行操作；可以把 Realm 看成 DataSource ，即安全数据源。如我们之前的ini配置方式 将使用org.apache.shiro.realm.text.IniRealm。
Shiro默认使用自带的IniRealm，IniRealm从ini配置文件中读取用户的信息，大部分情况下需要从系统的数据库中读取用户信息，
**所以需要自定义realm**jar包
<!-- shiro核心依赖 -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.4.2</version>
</dependency>Realm
package com.bdqn.shiro;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.jdbc.JdbcRealm;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;
public class JDBCRealmTest {
public static void main(String[] args) {
//1.读取配置文件，初始化工厂对象
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
//2.获取SecurityManager实例
SecurityManager manager = factory.getInstance();
//3.将SecurityManager绑定到工具类
SecurityUtils.setSecurityManager(manager);
//4.通过SecurityUtils得到当前登录的用户
Subject currentUser = SecurityUtils.getSubject();
//5.窗口登录令牌
UsernamePasswordToken token = new UsernamePasswordToken("test","123");
try {
//6.登录并传入令牌
currentUser.login(token);
System.out.println("身份信息验证成功！");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("身份信息验证失败！");
}
//7.退出
currentUser.logout();
}
}加到项目中的验样子
Spring Boot框架
shiro
mysql
- 配置 application.properties
#加载驱动
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#数据库连接路径
spring.datasource.url=jdbc:mysql://localhost:3306/erp?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
#数据库用户名
spring.datasource.username=root
#数据源类型（阿里巴巴）
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
#thymeleaf
spring.thymeleaf.cache=false
#日期格式
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8
#mybatis-plus
#mybatis-plus.mapper-locations=classpath:mapper/*Mapper.xml,classpath:mapper/*/*Mapper.xml
#日志
logging.level.com.bdqn=debug- ShiroConfiguration 类
package com.bdqn.sys.config;
import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;
import com.bdqn.sys.realm.UserRealm;
import org.apache.shiro.authc.credential.CredentialsMatcher;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
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.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.DelegatingFilterProxy;
import java.util.LinkedHashMap;
import java.util.Map;
@Configuration
public class ShiroConfiguration {
private static final String SHIRO_DIALECT = "shiroDialect";
private static final String SHIRO_FILTER = "shiroFilter";
private String hashAlgorithmName = "md5";// 加密方式
private int hashIterations = 2;// 散列次数
/**
* 声明凭证匹配器
*/
@Bean("credentialsMatcher")
public HashedCredentialsMatcher hashedCredentialsMatcher() {
HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
credentialsMatcher.setHashAlgorithmName(hashAlgorithmName);
credentialsMatcher.setHashIterations(hashIterations);
return credentialsMatcher;
}
/**
* 注入自定义的UserRealm
* @return
*/
@Bean
public UserRealm getUserRealm(CredentialsMatcher credentialsMatcher){
UserRealm userRealm = new UserRealm();
//注入凭证匹配器
userRealm.setCredentialsMatcher(credentialsMatcher);
return userRealm;
}
/**
* 创建DefaultWebSecurityManager对象，关联自定义的UserRealm对象
* @param userRealm
* @return
*/
@Bean
public DefaultWebSecurityManager getDefaultWebSecurityManager(UserRealm userRealm){
//创建DefaultWebSecurityManager对象
DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
//关联自定义realm
defaultWebSecurityManager.setRealm(userRealm);
//返回DefaultWebSecurityManager对象
return defaultWebSecurityManager;
}
/**
* 创建ShiroFilterFactoryBean对象，设置安全管理器
* @param securityManager
* @return
*/
@Bean(SHIRO_FILTER)
public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager securityManager){
//创建ShiroFilterFactoryBean对象
ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
//设置安全管理器
factoryBean.setSecurityManager(securityManager);
//设置过滤器链
Map<String,String> filterChainDefinitionsMap = new LinkedHashMap<String,String>();
//放行路径（匿名访问）
filterChainDefinitionsMap.put("/resources/**","anon");//静态资源
filterChainDefinitionsMap.put("/sys/user/login","anon");//登录请求
filterChainDefinitionsMap.put("/sys/login","anon");//去到登录页面
filterChainDefinitionsMap.put("/","anon");//去到登录页面
filterChainDefinitionsMap.put("/login.html","anon");//去到登录页面
filterChainDefinitionsMap.put("/favicon.ico","anon");//小图标
//退出
filterChainDefinitionsMap.put("/logout","logout");
//拦截请求
filterChainDefinitionsMap.put("/**","authc");
//将过滤器链设置到shiroFilterFactoryBean对象中
factoryBean.setFilterChainDefinitionMap(filterChainDefinitionsMap);
//身份验证失败要去到登录页面
//如果不设置loginUrl,则默认找login.jsp页面
factoryBean.setLoginUrl("/sys/login");
return factoryBean;
}
/**
* 注册shiro的委托过滤器，相当于之前在web.xml里面配置的
*
* @return
*/
@Bean
public FilterRegistrationBean<DelegatingFilterProxy> delegatingFilterProxy() {
FilterRegistrationBean<DelegatingFilterProxy> filterRegistrationBean = new FilterRegistrationBean<DelegatingFilterProxy>();
DelegatingFilterProxy proxy = new DelegatingFilterProxy();
proxy.setTargetFilterLifecycle(true);
proxy.setTargetBeanName(SHIRO_FILTER);
filterRegistrationBean.setFilter(proxy);
return filterRegistrationBean;
}
/* 加入注解的使用，不加入这个注解不生效--开始 */
/**
*
* @param securityManager
* @return
*/
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
return authorizationAttributeSourceAdvisor;
}
@Bean
public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
advisorAutoProxyCreator.setProxyTargetClass(true);
return advisorAutoProxyCreator;
}
/* 加入注解的使用，不加入这个注解不生效--结束 */
/**
* 这里是为了能在html页面引用shiro标签，上面两个函数必须添加，不然会报错
*
* @return
*/
@Bean(name = SHIRO_DIALECT)
public ShiroDialect shiroDialect() {
return new ShiroDialect();
}
}- Realm 类
package com.bdqn.sys.realm;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.bdqn.sys.entity.Permission;
import com.bdqn.sys.entity.User;
import com.bdqn.sys.service.PermissionService;
import com.bdqn.sys.service.RoleService;
import com.bdqn.sys.service.UserService;
import com.bdqn.sys.utils.SystemConstant;
import com.bdqn.sys.vo.LoginUserVo;
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 javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* 自定义Realm
*/
public class UserRealm extends AuthorizingRealm {
@Resource
private UserService userService;
@Resource
private RoleService roleService;
@Resource
private PermissionService permissionService;
/**
* 授权
* @param principalCollection
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
//创建授权对象
SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
//1.获取当前登录主体
LoginUserVo loginUserVo = (LoginUserVo) principalCollection.getPrimaryPrincipal();
//2.获取当前用户拥有的权限列表
Set<String> permissions = loginUserVo.getPermissions();
//3.判断当前登录用户是否是超级管理员
if(loginUserVo.getUser().getType()== SystemConstant.SUPERUSER){
//超级管理员拥有所有操作权限
simpleAuthorizationInfo.addStringPermission("*:*");
}else{//普通用户
//判断权限集合是否有数据
if(permissions!=null && permissions.size()>0){
//非超级管理员需要根据自己拥有的角色进行授权
simpleAuthorizationInfo.addStringPermissions(permissions);
}
}
return simpleAuthorizationInfo;
}
/**
* 身份验证
* @param authenticationToken
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
//获取当前登录主体
String userName = (String) authenticationToken.getPrincipal();
try {
//根据用户名查询用户信息的方法
User user = userService.findUserByName(userName);
//对象不为空
if(user!=null){
//创建当前登录用户对象
//创建登录用户对象，传入用户信息，角色列表，权限列表
LoginUserVo loginUserVo = new LoginUserVo(user,null,null);
/***************************关联权限代码开始***************************************/
//创建条件构造器对象
QueryWrapper<Permission> queryWrapper = new QueryWrapper<Permission>();
queryWrapper.eq("type",SystemConstant.TYPE_PERMISSION);//只查权限不查菜单
//根据当前登录用户ID查询该用户拥有的角色列表
Set<Integer> currentUserRoleIds = userService.findUserRoleByUserId(user.getId());
//创建集合保存每个角色下拥有的权限菜单ID
Set<Integer> pids = new HashSet<Integer>();
//循环遍历当前用户拥有的角色列表
for (Integer roleId : currentUserRoleIds) {
//4.根据角色ID查询每个角色下拥有的权限菜单
Set<Integer> permissionIds = roleService.findRolePermissionByRoleId(roleId);
//5.将查询出来的权限id放到集合中
pids.addAll(permissionIds);
}
//创建集合保存权限
List<Permission> list = new ArrayList<Permission>();
//判断pids集合是否有值
if(pids!=null && pids.size()>0){
queryWrapper.in("id",pids);
//执行查询
list = permissionService.list(queryWrapper);
}
//查询权限编码
Set<String> perCodes = new HashSet<String>();
//循环每一个菜单
for (Permission permission : list) {
perCodes.add(permission.getPercode());
}
//给权限集合赋值
loginUserVo.setPermissions(perCodes);
/***************************关联权限代码结束***************************************/
//创建盐值(以用户名作为盐值)
ByteSource salt = ByteSource.Util.bytes(user.getSalt());
//创建身份验证对象
//参数1：当前登录对象 参数2：密码 参数3：盐值 参数4：域名
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(loginUserVo,user.getLoginpwd(),salt,"");
return info;
}
} catch (Exception e) {
e.printStackTrace();
}
//验证失败
return null;
}
}
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。