spring boot和shiro的代码实战
首先说明一下，这里不是基础教程，需要有一定的shiro知识，随便百度一下，都能找到很多的博客叫你基础，所以这里我只给出代码。
官方文档：http://shiro.apache.org/spring-boot.html
shiro的使用其实很简单的，配置也不麻烦，所以不要有任何畏惧。
正文开始
项目结构：
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.6.RELEASE</version>
<relativePath /> <!-- lookup parent from repository -->
</parent>
<groupId>com.hongcheng</groupId>
<artifactId>springboot-shiro-teset</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springboot-shiro-teset</name>
<description>springboot的shiro项目demo</description> <properties>
<java.version>1.8</java.version>
</properties> <dependencies> <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency> <dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency> <dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.4.0</version>
</dependency> <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency> <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies> <build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build></project>
启动类：
package com.hongcheng.springboot_shiro_teset;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class SpringbootShiroTesetApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootShiroTesetApplication.class, args);
}
}
3个JavaBean
package com.hongcheng.springboot_shiro_teset.bean;import java.util.Set;import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
/**
* 用户
* */
@Getter
@Setter
@ToString
@AllArgsConstructor
public class User {
private String id;
private String userName;
private String password;
/**
* 用户对应的角色集合
*/
private Set<Role> roles;
}
package com.hongcheng.springboot_shiro_teset.bean;import java.util.Set;import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;/**
* 角色
* */
@Getter
@Setter
@ToString
@AllArgsConstructor
public class Role { private String id;
private String roleName;
/**
* 角色对应权限集合
*/
private Set<Permission> permissions;
}
package com.hongcheng.springboot_shiro_teset.bean;import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
/**
* 权限，shiro的权限，其实也只是一种资源的标识符，你拥有这个权限，就说明你有这个标识符，那你就可以访问这个资源
* */
@Getter
@Setter
@ToString
@AllArgsConstructor
public class Permission {
private String id;
private String permissionName;
}
ShiroConfig
package com.hongcheng.springboot_shiro_teset.config;import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.authc.pam.AtLeastOneSuccessfulStrategy;
import org.apache.shiro.authc.pam.ModularRealmAuthenticator;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;import com.hongcheng.springboot_shiro_teset.dao.MySessionDao;
import com.hongcheng.springboot_shiro_teset.shiro.CustomRealm;
import com.hongcheng.springboot_shiro_teset.shiro.CustomRealm2;@Configuration
public class ShiroConfig { /**
* 启动代理 <br>
* 作用就是让controller中的@RequiresRoles("admin")、@RequiresPermissions("add")这些权限注解生效 <br>
* 如果不用注解权限，这里可以删掉 <br>
* */
@Bean
@ConditionalOnMissingBean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator defaultAAP = new DefaultAdvisorAutoProxyCreator();
defaultAAP.setProxyTargetClass(true);
return defaultAAP;
} /**
* 加入注解的使用，不加入这个注解不生效 <br>
* 作用就是让controller中的@RequiresRoles("admin")、@RequiresPermissions("add")这些权限注解生效 <br>
* 如果不用注解权限，这里可以删掉 <br>
* */
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
return authorizationAttributeSourceAdvisor;
} /**
* 将自己的验证方式加入容器 <br>
* Realm接口是shiro的一个重要接口，主要负责获取认证和授权信息
* */
@Bean
public CustomRealm myShiroRealm() {
CustomRealm customRealm = new CustomRealm();
/** 密码比较器，shiro有定义了不少hash类型的密码比较器，我们也可以自己重写个自定义的密码比较器，只需要
* 继承SimpleCredentialsMatcher这个类，同时重写doCredentialsMatch()这个方法就好了
* shiro会在org.apache.shiro.realm.AuthenticatingRealm.assertCredentialsMatch(AuthenticationToken, AuthenticationInfo)这个方法里面
* 调用这个密码比较器进行密码的比较
* */
// 如果不用自定义密码比较，md5CredentialsMatcher可以删掉
HashedCredentialsMatcher md5CredentialsMatcher = new HashedCredentialsMatcher();
md5CredentialsMatcher.setHashIterations(20);
md5CredentialsMatcher.setHashAlgorithmName(Md5Hash.ALGORITHM_NAME);
customRealm.setCredentialsMatcher(md5CredentialsMatcher);
return customRealm;
} /**
* Realm可以有对多个，shiro可以根据不同的认证策略，搭配多个Realm进行认证 <br>
* 如果不用多realm验证，这里可以删掉 <br>
* */
@Bean
public CustomRealm2 myShiroRealm2() {
CustomRealm2 customRealm = new CustomRealm2();
return customRealm;
} /**
* 权限管理，配置主要是Realm的管理认证 <br>
* SecurityManager是shiro的一个重要接口，负责管理整个shiro的权限控制 <br>
* 所以我们需要给SecurityManager进行个性化配置
* */
@Bean
public SecurityManager securityManager(RedisTemplate<String, Object> redisTemplate) {
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
/***
* 多realm验证
* */
List<Realm> realmList = new LinkedList<Realm>();
realmList.add(myShiroRealm());
realmList.add(myShiroRealm2());
securityManager.setRealms(realmList);
ModularRealmAuthenticator authenticator = new ModularRealmAuthenticator();
/**
* 认证策略不管选择哪种，都会全部执行完，然后判断是否通过认证
* */
authenticator.setAuthenticationStrategy(new AtLeastOneSuccessfulStrategy());
authenticator.setRealms(realmList);
securityManager.setAuthenticator(authenticator);
/**
* session管理
* sessionManager如果不需要自定义，可以忽略，使用默认的
* */
DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
sessionManager.setSessionIdUrlRewritingEnabled(true); // 允许sessionId进行url重写
/**
* shiro的session是会定期进行删除的
* 详情可以看这里：org.apache.shiro.session.mgt.AbstractValidatingSessionManager.enableSessionValidation()
* org.apache.shiro.session.mgt.ExecutorServiceSessionValidationScheduler.enableSessionValidation()
* */
sessionManager.setGlobalSessionTimeout(10000); // session超时时长
sessionManager.setDeleteInvalidSessions(true); // 删除失效session
sessionManager.setSessionValidationSchedulerEnabled(true); // 允许定期删除
sessionManager.setSessionValidationInterval(15000); // session定期删除时间
/**
* session保存进redis里
* sessionDao如果不需要，可以删掉
* */
MySessionDao sessionDao = new MySessionDao(redisTemplate);
sessionDao.setSessionIdGenerator(new JavaUuidSessionIdGenerator()); // sessionId生成器
sessionManager.setSessionDAO(sessionDao); securityManager.setSessionManager(sessionManager); return securityManager;
} /**
* Filter工厂，设置对应的过滤条件和跳转条件。shiro的权限控制，就是通过filter来控制的
详情看org.apache.shiro.web.filter.mgt.DefaultFilterFilter Name Class
anon org.apache.shiro.web.filter.authc.AnonymousFilter
authc org.apache.shiro.web.filter.authc.FormAuthenticationFilter
authcBasic org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter
authcBearer org.apache.shiro.web.filter.authc.BearerHttpAuthenticationFilter
logout org.apache.shiro.web.filter.authc.LogoutFilter
noSessionCreation org.apache.shiro.web.filter.session.NoSessionCreationFilter
perms org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter
port org.apache.shiro.web.filter.authz.PortFilter
rest org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter
roles org.apache.shiro.web.filter.authz.RolesAuthorizationFilter
ssl org.apache.shiro.web.filter.authz.SslFilter
user org.apache.shiro.web.filter.authc.UserFilter
* */
@Bean
public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
/**
* 请求资源的过滤
* 这一块是必须的，不能去掉
* */
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
shiroFilterFactoryBean.setSecurityManager(securityManager);
Map<String, String> map = new HashMap<>();
//登出
map.put("/logout", "logout");
// 对login这个地址匿名访问
map.put("/login*", "anon");
map.put("/error*", "anon");
//对所有用户认证
map.put("/**", "authc");
//登录
shiroFilterFactoryBean.setLoginUrl("/login.html");
//首页
shiroFilterFactoryBean.setSuccessUrl("/index.html");
//错误页面，认证不通过跳转
shiroFilterFactoryBean.setUnauthorizedUrl("/error.html");
shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
return shiroFilterFactoryBean;
}
}
Realm
package com.hongcheng.springboot_shiro_teset.shiro;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.authc.UnknownAccountException;
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.springframework.beans.factory.annotation.Autowired;import com.hongcheng.springboot_shiro_teset.bean.Permission;
import com.hongcheng.springboot_shiro_teset.bean.Role;
import com.hongcheng.springboot_shiro_teset.bean.User;
import com.hongcheng.springboot_shiro_teset.service.LoginService;public class CustomRealm extends AuthorizingRealm { /**
* 这里可以用@Autowired，因为CustomRealm是在ShiroConfig里面通过@Bean交由spring进行管理的
* */
@Autowired
private LoginService loginService; /**
* 授权
* */
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
//获取登录用户名
String name = (String) principals.getPrimaryPrincipal();
//根据用户名去数据库查询用户信息
User user = loginService.getUserByName(name);
//添加角色和权限
SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
for (Role role : user.getRoles()) {
//添加角色
simpleAuthorizationInfo.addRole(role.getRoleName());
//添加权限
for (Permission permission : role.getPermissions()) {
simpleAuthorizationInfo.addStringPermission(permission.getPermissionName());
}
}
return simpleAuthorizationInfo;
} /***
* 认证，这里只是根据前端获取到的账号密码，让你去别的地方，如数据库，查找他的认证信息 <br>
* 密码的对比并不在这里，SimpleCredentialsMatcher的doCredentialsMatch()方法才是密码对比 <br>
* 如果用户不存在、或者用户被锁定，这里就应该抛出响应的错误<br>
* <br>
* <br>
* 如果使用Token令牌，controller处使用了EasyTypeToken这个类，记得自己去解析token，然后获取相应的用户信息
* */
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
//加这一步的目的是在Post请求的时候会先进认证，然后在到请求
if (authenticationToken.getPrincipal() == null) {
return null;
}
//获取用户信息
String name = authenticationToken.getPrincipal().toString();
User user = loginService.getUserByName(name);
if (user == null) {
//这里返回后会报出对应异常
throw new UnknownAccountException("账号不存在");
} else {
//这里验证authenticationToken和simpleAuthenticationInfo的信息
ByteSource salt = ByteSource.Util.bytes(name); // 加密用的盐
/**
* SimpleAuthenticationInfo这玩意就是你自己保存的用户认证信息，doGetAuthenticationInfo方法主要目的就是通过用户名、或者token去获取这个用户认证信息。
* 以便在后面给密码匹配器进行验证。
* 注意两个名词：
* principal：用户的主体、当事人，按官方的文档说法就是用户的唯一标识，不管你是账号，还是userId，还是身份证，只要唯一就行。
* credentials: 凭证，也就是密码，或者密钥，是可以证明用户身份的东西。
* */
SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(name, user.getPassword().toString(), salt, getName());
return simpleAuthenticationInfo;
}
}}
package com.hongcheng.springboot_shiro_teset.shiro;import org.apache.shiro.authc.AccountException;
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;/**
* 这个是用来多多realm验证的
* */
public class CustomRealm2 extends AuthorizingRealm {
/**
* 授权
* */
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
//添加角色和权限
SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
//添加角色
simpleAuthorizationInfo.addRole("admin");
simpleAuthorizationInfo.addStringPermission("add");
return simpleAuthorizationInfo;
} /***
* 认证
* */
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
String username = authenticationToken.getPrincipal().toString();
if(!"123".equals(username)) {
throw new AccountException("账号找不到");
}
char[] password = (char[]) authenticationToken.getCredentials();
SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(username,password,username);
return simpleAuthenticationInfo;
}}
SessionDAO
package com.hongcheng.springboot_shiro_teset.dao;import java.io.Serializable;
import java.util.Collection;
import java.util.List;import org.apache.shiro.session.Session;
import org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO;
import org.springframework.data.redis.core.RedisTemplate;/**
* 对session的一个持久化处理。<br>
* 将默认的ecache缓存换成了redis，可以作为一个分布式session共享实现
* */
public class MySessionDao extends EnterpriseCacheSessionDAO{ private RedisTemplate<String, Object> redisTemplate; /**
* 这里需要通过传值，将redisTemplate传入。 <br>
* 用@autowried注入是会不行的，因为MySessionDao <br>
* 是由我们自己new的，所以spring不会处理他的属性，另外，这里用applicationContent的getBean() <br>
* 也是会出现问题的，MySessionDao是在shiroConfig中的一个bean中创建的，他的创建顺序可能先于 <br>
* applicationContent的注入。
* */
public MySessionDao (RedisTemplate<String, Object> redisTemplate) {
setCacheManager(null);
this.redisTemplate = redisTemplate;
} /**
* 从redis里面取
* */
protected Session doReadSession(Serializable sessionId) {
System.err.println("获取Session" + sessionId);
Object object = redisTemplate.opsForHash().get("shiro-session", sessionId.toString());
return object == null?null:(Session)object;
} /**
* 更新redis
* */
protected void doUpdate(Session session) {
System.err.println("更新Session" + session.getId());
Serializable sessionId = session.getId();
redisTemplate.opsForHash().put("shiro-session", sessionId.toString(),session);
} /**
* 删除redis
* */
protected void doDelete(Session session) {
System.err.println("删除Session" + session.getId());
Serializable sessionId = session.getId();
redisTemplate.opsForHash().delete("shiro-session", sessionId.toString());
} /**
* 获取全部session，判断是否过期，如果过期，删除 <br>
* 默认实现：org.apache.shiro.session.mgt.eis.CachingSessionDAO.getActiveSessions() <br>
* 默认实现是从CacheManager得缓存里面取的，但是我们这里的没有设置CacheManager，所以一直为空 <br>
* 导致redis中已经过期了的session一直没有被清理，所以这里我们要重写
* */
@SuppressWarnings({ "unchecked", "rawtypes" })
public Collection<Session> getActiveSessions() {
List values = redisTemplate.opsForHash().values("shiro-session");
return values;
}}
RedisConfig
package com.hongcheng.springboot_shiro_teset.config;import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;@Configuration
public class RedisConfig {
/**
* redisTemplate 序列化使用的jdkSerializeable, 存储二进制字节码, 所以自定义序列化类
* 如果没有用的redis，那么这个类可以删掉
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
// 设置value的序列化规则和 key的序列化规则
/**
* 如果用GenericJackson2JsonRedisSerializer来序列号shiro的session，会出现反序列化失败的情况
* 可以考虑使用别的方法进行序列化，session应该要进行加密在保存
* 我这里为了方便，直接用jdk的序列化
* */
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(RedisSerializer.java());
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(RedisSerializer.java());
redisTemplate.afterPropertiesSet();
return redisTemplate;
}}
LoginController
package com.hongcheng.springboot_shiro_teset.controller;import javax.servlet.http.HttpSession;import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.AuthorizationException;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import com.hongcheng.springboot_shiro_teset.bean.User;@RestController
public class LoginController { @RequestMapping("/login")
public String login(User user) { //添加用户认证信息
Subject subject = SecurityUtils.getSubject();
/**
* 如果是账号密码类型，可以创建一个UsernamePasswordToken。
* 如果使用Token令牌，可以使用EasyTypeToken这个类，相对于UsernamePasswordToken，只是把密码视为空串，username视为token。
* 如果用EasyTypeToken，记得要自己去解析token，然后获取相应的用户信息
* */
UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(
user.getUserName(),
user.getPassword()
);
try {
//进行验证，这里可以捕获异常，然后返回对应信息
subject.login(usernamePasswordToken);
// 判断有没有角色
subject.checkRole("admin");
// 判断有没有权限
subject.checkPermissions("query", "add");
} catch (AuthenticationException e) {
e.printStackTrace();
return "账号或密码错误！";
} catch (AuthorizationException e) {
e.printStackTrace();
return "没有权限";
}
return "login success";
}
//注解验角色和权限
@RequiresRoles("admin")
@RequiresPermissions("add")
@RequestMapping("/index")
public String index(HttpSession httpsession) {
Session session = SecurityUtils.getSubject().getSession();
System.err.println(session);
System.err.println(httpsession); /***
* shiro的session和request和response，其实就是HttpServletSession、HttpServletRequest、HttpServletResponse的子类
* org.apache.shiro.web.session.mgt.ServletContainerSessionManager.getSession(SessionKey)可以看到这个结论
* */
httpsession.setAttribute("http", "httpsession测试");
Object attribute = session.getAttribute("http");
System.err.println(attribute);
return "index!";
}
}
Service
package com.hongcheng.springboot_shiro_teset.service;import com.hongcheng.springboot_shiro_teset.bean.User;public interface LoginService {
User getUserByName(String getMapByName) ;
}
package com.hongcheng.springboot_shiro_teset.service;import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.crypto.hash.SimpleHash;
import org.springframework.stereotype.Service;import com.hongcheng.springboot_shiro_teset.bean.Permission;
import com.hongcheng.springboot_shiro_teset.bean.Role;
import com.hongcheng.springboot_shiro_teset.bean.User;@Service
public class LoginServiceImpl implements LoginService {
@Override
public User getUserByName(String getMapByName) {
//模拟数据库查询，正常情况此处是从数据库或者缓存查询。
return getMapByName(getMapByName);
} /**
* 模拟数据库查询
* @param userName
* @return
*/
private User getMapByName(String userName){
//共添加两个用户，两个用户都是admin一个角色，
//chc有query和add权限，zhangsan只有一个query权限
Set<Permission> permissionsSet = new HashSet<>();
permissionsSet.add(new Permission("1","query"));
permissionsSet.add(new Permission("2","add")); Set<Role> roleSet = new HashSet<>();
roleSet.add(new Role("1","admin",permissionsSet)); User user = new User("1","chc",encrypt("123456","chc"),roleSet);
Map<String ,User> map = new HashMap<>();
map.put(user.getUserName(), user); Set<Permission> permissionsSet1 = new HashSet<>();
permissionsSet1.add(new Permission("3","query")); Set<Role> roleSet1 = new HashSet<>();
roleSet1.add(new Role("2","user",permissionsSet1)); User user1 = new User("2","zhangsan",encrypt("123456","zhangsan"),roleSet1);
map.put(user1.getUserName(), user1); return map.get(userName);
} /***
* 模拟加密
* */
private String encrypt(String password,String name) {
String algorithmName = Md5Hash.ALGORITHM_NAME; // 加密算法
String credentials = password; // 密码
String salt = name; // 加密盐值
int hashIterations = 20; // 加密次数
SimpleHash simpleHash = new SimpleHash(algorithmName, credentials, salt, hashIterations);
return simpleHash.toString();
}}
application.properties
# REDIS (RedisProperties)
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=10000
login.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<form action="/login">
用户名：<input name = "userName">
<br>
密码：<input name = "password">
<button>提交</button>
</form>
</body>
</html>
index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
成功登陆
<br>
<a href="logout" rel="external nofollow" >退出</a>
</body>
</html>
error.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
错误
<br>
<a href="/login.html" rel="external nofollow" >登陆</a>
</body>
</html>
MyExceptionHandler
package com.hongcheng.springboot_shiro_teset.filter;import org.apache.shiro.authz.AuthorizationException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;import lombok.extern.slf4j.Slf4j;/**
* 对controller的一个切面增强，可以只针对部分controller
* 这个用不用都无所谓
* */
@ControllerAdvice(basePackages = "com.hongcheng.springboot_shiro_teset.controller")
@Slf4j
public class MyExceptionHandler { /**
* 统一异常处理
* */
@ExceptionHandler()
@ResponseBody
public String ErrorHandler(AuthorizationException e) {
log.error("没有通过权限验证！", e);
return "没有通过权限验证！";
}
}
启动访问localhost:8080，就可以自己看了
项目丢上码云了 https://gitee.com/1281003978/springboot_shiro_demo
2020/05/24，今天有空梳理下源码
一、登录校验：
1：前端输入账号密码，然后在我们的controller里面调用subject的login方法执行登录
2：DelegatingSubject.class的login方法（DelegatingSubject是Subject的一个实现类）：
3：紧着会进入DefaultSecurityManager的login方法，也就是我们的安全管理器
4：继续执行父类AuthenticatingSecurityManager的authenticate方法
注意：Authenticator就是一个认证器，专门用来获取认证的，默认是ModularRealmAuthenticator
5：进入AbstractAuthenticator的认证方法，就是我们上一步所提到的认证器
6：这里就是我们ModularRealmAuthenticator的实现方法了，根据你realm的个数，才用不同的方式进行认证
7：根据realm的个数，才用不同的方式进行认证
单个realm的时候很简单，直接用我们设置的realm进行获取认证信息就行
多个realm的时候比较复杂了，他会根据你设置的不同的策略来进行判断
shiro有三种策略：
- AllSuccessfulStrategy：全部realm都能根据传入的token获取到用户信息才算通过
- AtLeastOneSuccessfulStrategy：至少有一个realm获取到用户信息就算通过，这种策略会把你全部的realm都执行一遍，哪怕你第一个realm就能获取到用户信息
- FirstSuccessfulStrategy：只要有一个realm成功获取到用户信息，就不再继续执行其他realm了
8：你是不是以为已经到头了呢？其实还没有。还要再执行一下AuthenticatingRealm这个类的getAuthenticationInfo方法
AuthenticatingRealm这个类就是我们自定义realm需要继承的一个父类
9：这里就是我们的自定义realm拉，不过一定要注意，doGetAuthenticationInfo只是获取认证信息，也就是根据我们传入的账号 / 用户id / token，反正就是一个能让我们识别出来是哪个用户的东西，去获取这个用户的密码（凭证）
他并不是让你去比较密码是否一致
10：让我们重回第8步的方法，那里还有一个很重要的方法：密码对比
11：密码认证，认证不通过就会抛异常，如果是只有一个realm的，异常就直接抛了。不过如果是多realm的，就是在AuthenticationStrategy的实现类里面判断是不是要跑密码认证失败异常
shiro的一些密码匹配器，当然我们也可以自定义
12：继续回到我们最开始的controller，密码认证异常会一路往上抛，直到我们自己controller进行捕获然后返回信息。当然，如果没有异常那就是成功了
二、获取用户权限，也就是授权。一开始登录的时候，输入账号密码登录，这个时候其实只是认证信息而已，这个时候还没有进行获取权限，只有在shiro需要进行权限判断的时候才会去调用我们自己的realm来进行获取用户权限
1：我们直接让判断下这个用户有没有admin角色
2：调用DelegatingSubject的checkRole方法
3：调用AuthorizingSecurityManager的checkRole方法
有一点希望大家记得：我们平时所使用的SecurityManager都是继承了认证和授权功能的
4：调用ModularRealmAuthorizer的checkRole方法，和认证一样，没有权限就抛异常
5：调用ModularRealmAuthorizer的hasRole方法。为了授权，他会跑遍所有的realm
另外还有一点，看上图红框上面那句，如果我们的realm没有实现Authrizer接口，那就不会用我们的realm，所以如果我们要把认证和授权分开的话，就要分别实现。不然就直接继承AuthorizingRealm吧
6：调用AuthorizingRealm的hasRole方法
7：调用AuthorizingRealm的getAuthorizationInfo方法
8：又到了我们自己的realm了
9：又回到我们第6步的方法了，另外roles本身就是一个set集合
不信你看
三、我们不是配置过session过期策略么，那我们来看下shiro是怎么处理的：
在我们一开始获取subject的时候就会判断是不是要生成当时器去验证session，如果有必要，就会创建一个定时任务池去检查session
1：我们访问的时候，会生成一个subject对象
Subject接口里面有个静态内部类Builder
2：DefaultSecurityManager
3：DefaultSecurityManager
4：DefaultSecurityManager
5：DefaultSecurityManager
6：DefaultSecurityManager
7：DefaultSecurityManager
8：DefaultSecurityManager
9：DefaultSecurityManager
10：DefaultSecurityManager
11：ExecutorServiceSessionValidationScheduler
ScheduledExecutorService service 是一个定时的线程池
外部调用ExecutorServiceSessionValidationScheduler的enableSessionValidation方法，让他把自己作为一个任务扔进任务池里，按指定时间重复执行
12：AbstractValidatingSessionManager
13：DefaultSessionManager
如果我们重写了sessionDAO，就必须要重写getActiveSessions方法，不然很多关于session的校验都会出问题
14：AbstractValidatingSessionManager
15：AbstractValidatingSessionManager
16：DefaultSessionManager
17：CachingSessionDAO
18：MySessionDao
四：shiro 的 session、request、response和Tomcat为我们生成的session、request、response 有什么区别？
这里我先说一下结论。shiro有自己的session、request、response实现类，内部包装了Tomcat的session、request、response。
代码下次再补上
