shiro与springboot整合

shiro主要有三大功能模块

1. Subject：主体，一般指用户。
2. SecurityManager：安全管理器，管理所有Subject，可以配合内部安全组件。(类似于SpringMVC中的DispatcherServlet)
3. Realms：用于进行权限信息的验证，一般需要自己实现。

具体功能

1. Authentication：身份认证/登录(账号密码验证)。
2. Authorization：授权，即角色或者权限验证。
3. Session Manager：会话管理，用户登录后的session相关管理。
4. Cryptography：加密，密码加密等。
5. Web Support：Web支持，集成Web环境。
6. Caching：缓存，用户信息、角色、权限等缓存到如redis等缓存中。
7. Concurrency：多线程并发验证，在一个线程中开启另一个线程，可以把权限自动传播过去。
8. Testing：测试支持；
9. Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问。
10. Remember Me：记住我，登录后，下次再来的话不用登录了。

整合shiro

创建数据库表如下

pom

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.hu</groupId>
    <artifactId>spring-boot-shiro</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>jar</packaging>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-web</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.13</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.48</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

控制器

@Controller
@RequestMapping("/user")
public class UsersController {

    @Autowired
    private UserService userService;

    @RequestMapping("login")
    public ModelAndView login(User user, ServletRequest request) {
        ModelAndView view = new ModelAndView();
        //得到 Subject，并且通过用户名/密码创建 身份验证 Token（即用户身份/凭证）
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken(user.getUsername(), user.getPassword());
        if (!subject.isAuthenticated()) {
            subject.login(token);
        }
        //获取上一次请求路径
        SavedRequest savedRequest = WebUtils.getSavedRequest(request);
        String url = "";
        if (savedRequest != null) {
            url = savedRequest.getRequestUrl();
        } else {
            url = "list";
        }
        view.setViewName("redirect:" + url);
        return view;
    }

    @RequestMapping("list")
    public ModelAndView list() {
        ModelAndView view = new ModelAndView();
        view.addObject("users", this.userService.getUsers());
        view.setViewName("/page/list.html");
        return view;
    }

    @RequestMapping("register")
    public ModelAndView register(User user) throws Exception{
        ModelAndView view = new ModelAndView();
        if (!StringUtils.isEmpty(user.getUsername()) && !StringUtils.isEmpty(user.getPassword())) {
            userService.createUser(user);
        }
        view.setViewName("redirect:/login.html");
        return view;
    }

    @RequestMapping("logout")
    @ResponseBody
    public String logout(User user) {
        Subject subject = SecurityUtils.getSubject();

        /*Session session = subject.getSession(false);
        if(session!=null){
            session.removeAttribute(WebUtils.SAVED_REQUEST_KEY);
        }*/
        subject.logout();

        return "已注销";
    }

    // 权限控制
    @RequiresPermissions("sys:user:add")
    @RequestMapping("add")
    public ModelAndView add(User user) throws Exception{
        ModelAndView view = new ModelAndView();
        if (!StringUtils.isEmpty(user.getUsername()) && !StringUtils.isEmpty(user.getPassword())) {
            userService.createUser(user);
            view.setViewName("redirect:list");
        } else {
            view.addObject("action","add");
            view.setViewName("/page/add.html");
        }
        return view;
    }

    //代表用户角色为admin才可以访问 相当于 subject.checkRole("admin")
    @RequiresRoles("admin")
    @RequestMapping("/update")
    public ModelAndView update(User user) {
        ModelAndView view = new ModelAndView();
        if (!StringUtils.isEmpty(user.getUsername()) && !StringUtils.isEmpty(user.getPassword())) {
            userService.changePassword(user.getUsername(), user.getPassword());
            view.setViewName("redirect:list");
        } else {
            view.addObject("action","update");
            view.addObject("user", this.userService.getUser(user.getId()));
            view.setViewName("/page/add.html");
        }
        return view;
    }

    //代表用户有新增的权限才可以访问
    // 相当于 subject.checkPermitted("system:user:delete")
    @RequiresPermissions("sys:user:delete")
    @RequestMapping("delete")
    public ModelAndView delete(User user) throws Exception {
        if (user.getId() != null) {
            this.userService.deleteUser(user.getId());
        }
        ModelAndView view = new ModelAndView();
        view.setViewName("redirect:list");
        return view;
    }
}

业务类

package com.hu.service.impl;

import com.hu.dao.PermissionDao;
import com.hu.dao.UserDao;
import com.hu.dao.UserRoleDao;
import com.hu.entity.User;
import com.hu.entity.UserRole;
import com.hu.service.UserService;
import com.hu.util.PasswordHelper;
import com.hu.util.Util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;
    @Autowired
    private UserRoleDao userRoleDao;
    @Autowired
    private PermissionDao permissionDao;

    @Override
    @Transactional
    public User createUser(User user) throws Exception {
        if (this.userDao.findUserByUsername(user.getUsername()) != null) {
            throw new Exception("用户名已存在");
        }
        user.setUserId(Util.getUUID());
        PasswordHelper.encryptPassword(user);
        user.setStatus(0);
        return userDao.save(user);
    }

    @Override
    public int deleteUser(Integer id) throws Exception {
        return this.userDao.deleteUser(id);
    }

    @Override
    public User getUser(Integer id) {
        return this.userDao.getOne(id);
    }

    @Override
    public int changePassword(String userId, String newPassword) {
        User user = this.userDao.findUserByUsername(userId);
        user.setPassword(newPassword);
        PasswordHelper.encryptPassword(user);
        return userDao.save(user) == null ? -1 : 1;
    }

    @Override
    public void addUserRoles(String userId, String... roleIds) {
        List<UserRole> roles = new ArrayList<>();
        for (String roleId : roleIds) {
            roles.add(new UserRole(userId, roleId));
        }
        this.userRoleDao.saveAll(roles);
    }

    @Override
    public void delUserRoles(String userId, String... roleIds) {
        for (String roleId : roleIds) {
            this.userRoleDao.delRole(userId, roleId);
        }
    }

    @Override
    public List<User> getUsers() {
        return this.userDao.findAll();
    }

    @Override
    public User findByUsername(String username) {
        return this.userDao.findUserByUsername(username);
    }

    @Override
    public Set<String> findRoles(String username) {
        return this.userDao.findRoles(username);
    }

    @Override
    public Set<String> findPermissions(String username) {
        return this.userDao.findPermissions(username);
    }
}

主html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org" lang="zh-CN" >
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>用户信息</title>
    <link href="../css/bootstrap.min.css" rel="stylesheet">
    <script src="../js/jquery-2.1.0.min.js"></script>
    <script src="../js/bootstrap.min.js"></script>
    <style type="text/css">
        td, th {
            text-align: center;
        }
    </style>
</head>
<body>
<div class="container">
    <h3 style="text-align: center">用户列表</h3>
    <table border="1" class="table table-bordered table-hover">
        <tr>
            <td colspan="2" align="center"><a class="btn btn-primary" href="add.html" th:href="@{/user/add}">添加用户</a></td>
            <td colspan="2" align="center"><a class="btn btn-primary" href="logout.html" th:href="@{/user/logout}">退出</a></td>
        </tr>
        <tr class="success">
            <th>ID</th>
            <th>用户名</th>
            <th>操作</th>
        </tr>
        <tr th:each="user:${users}">
            <td th:text="${user.userId}"></td>
            <td th:text="${user.username}"></td>
            <td><a class="btn btn-default btn-sm" href="update.html" th:href="@{/user/update(id=${user.id})}">修改</a>&nbsp;
                <a class="btn btn-default btn-sm" href="delete.html" th:href="@{/user/delete(id=${user.id})}">删除</a></td>
        </tr>
    </table>
</div>
</body>
</html>

密码规则

public class PasswordHelper {
    private static RandomNumberGenerator randomNumberGenerator = new SecureRandomNumberGenerator();
    //这些要与Realm中一致
    private static String algorithmName = "md5";
    private final static int hashIterations = 1;

    static public  void encryptPassword(User user) {
        //加盐
        user.setSalt(randomNumberGenerator.nextBytes().toHex());
        String newPassword = new SimpleHash(algorithmName, user.getPassword(), ByteSource.Util.bytes(user.getSalt()),hashIterations).toHex();
        user.setPassword(newPassword);
    }
}

Realm

@Component
public class UserRealm extends AuthorizingRealm implements Serializable {

    @Autowired
    private UserService userService;

    /**
     * 授权
     * @param principals
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        String username = (String) principals.getPrimaryPrincipal();
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        return authorizationInfo;
    }

    /**
     * 认证
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(
            AuthenticationToken token) throws AuthenticationException {
        String username = (String) token.getPrincipal();
        User user = userService.findByUsername(username);
        if(user == null){
            throw new UnknownAccountException(); //没找到账号
        }

        if(user.getStatus()==1){
            throw new LockedAccountException(); //账号被锁定
        }

        SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
                user.getUsername(),
                user.getPassword(),
                ByteSource.Util.bytes(user.getSalt()),
                getName());
        return authenticationInfo;
    }


}

ShiroConfig

@Configuration
public class ShiroConfig {

    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        //如果没有登录，返回的json
        /*shiroFilterFactoryBean.getFilters().put("authc", new UserFilter() {
            @Override
            protected void redirectToLogin(ServletRequest request, ServletResponse response) throws IOException {
                HttpServletResponse resp = (HttpServletResponse) response;
                HttpResponseUtils.renderJson(resp, com.hu.util.R.UNLOGIN());
            }
        });*/

        //拦截器.
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        filterChainDefinitionMap.put("/500*", "anon");
        filterChainDefinitionMap.put("/reg.html", "anon");
        filterChainDefinitionMap.put("/user/login*", "anon");
        filterChainDefinitionMap.put("/user/register*", "anon");
        filterChainDefinitionMap.put("/user/**", "authc");
        filterChainDefinitionMap.put("/page/**", "authc");
        filterChainDefinitionMap.put("/**", "authc");
        //不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面
        shiroFilterFactoryBean.setLoginUrl("/login.html");
        //未授权跳转
        shiroFilterFactoryBean.setUnauthorizedUrl("/page/fail.html");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }

    //凭证匹配器 密码校验交给Shiro的SimpleAuthenticationInfo进行处理
    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        hashedCredentialsMatcher.setHashAlgorithmName("md5");//使用MD5算法;
        //hashedCredentialsMatcher.setHashIterations(2);//散列的次数
        return hashedCredentialsMatcher;
    }


    //自定义Realm
    @Bean
    public UserRealm myShiroRealm() {
        UserRealm myShiroRealm = new UserRealm();
        myShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return myShiroRealm;
    }

    //获得SecurityManager 实例
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //指定 securityManager 的 realms 实现，可以设置多个
        //securityManager 会按照 realms 指定的顺序进行身份认证。此处我们使用显示指定顺序的方式指定了 Realm 的顺序，
        // 如果不设置，那么 securityManager 会按照 realm 声明的顺序进行使用（即无需设置 realms 属性，其会自动发现 ）。
        securityManager.setRealm(myShiroRealm());
        return securityManager;
    }

    @Bean
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){
        return new LifecycleBeanPostProcessor();
    }
}

测试，必须要登录才可以使用功能。

权限控制

权限表增加权限，在角色表添加角色，并且选了用户和角色的对应关系。

授权

@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
    String username = (String) principals.getPrimaryPrincipal();
    SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
    //在数据库中查询用户拥有的角色/权限
    authorizationInfo.setRoles(userService.findRoles(username));
    authorizationInfo.setStringPermissions(userService.findPermissions(username));
    return authorizationInfo;
}

在配置类中加入AOP

 // 授权使用注解  需要开启Spring AOP
 // 自动代理所有的advisor
 // DefaultAdvisorAutoProxyCreator创建代理更加通用强大
 // a.指定一个DefaultAdvisorAutoProxyCreator Bean的定义.
 // b.会自动代理Advisor的类
 @Bean
 @DependsOn({"lifecycleBeanPostProcessor"})
 public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator(){
     DefaultAdvisorAutoProxyCreator proxyCreator = new DefaultAdvisorAutoProxyCreator();
     proxyCreator.setProxyTargetClass(true);
     return proxyCreator;
 }

 // 属于StaticMethodMatcherPointcutAdvisor
@Bean
 public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(){
     AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
     advisor.setSecurityManager(securityManager());
     return advisor;
 }

增加处理类：

@Configuration
public class MyException implements HandlerExceptionResolver {

    @Override
    public ModelAndView resolveException(HttpServletRequest request,
                                         HttpServletResponse response, Object handler, Exception ex) {

        ModelAndView modelAndView = new ModelAndView();
        Map<String, Object> attributes = new HashMap<>();
        if (ex instanceof UnauthorizedException) {
            attributes.put("msg", "用户无权限");
        } else if (ex instanceof UnknownAccountException) {
            attributes.put("msg", "用户名密码有误");
        } else if (ex instanceof IncorrectCredentialsException) {
            attributes.put("msg", "用户名密码有误");
        } else if (ex instanceof LockedAccountException) {
            attributes.put("msg", "账号已被锁定");
        } else {
            attributes.put("msg", ex.getMessage());
        }
        modelAndView.addAllObjects(attributes);
        modelAndView.setViewName("/500");
        return modelAndView;
    }
}

在控制器中加入相应的注解，测试、没有权限的不能访问相关功能。

会话管理

会话管理器管理着应用中所有 Subject 的会话的创建、维护、删除、失效、验证等工作。是 Shiro 的核心组件，顶层组件 SecurityManager 直接继承了 SessionManager，且提供了SessionsSecurityManager 实现直接把会话管理委托给相应的 SessionManager，DefaultSecurityManager 及 DefaultWebSecurityManager 默认 SecurityManager 都继承了 SessionsSecurityManager。

Shiro 提供了三个默认实现：

DefaultSessionManager：DefaultSecurityManager 使用的默认实现，用于 JavaSE 环境；
ServletContainerSessionManager：DefaultWebSecurityManager 使用的默认实现，用于 Web 环境，其直接使用 Servlet 容器的会话；
DefaultWebSessionManager：用于 Web 环境的实现，可以替代 ServletContainerSessionManager，自己维护着会话，直接废弃了 Servlet 容器的会话管理。

可以设置会话的全局过期时间（毫秒为单位），默认30分钟：sessionManager. globalSessionTimeout=1800000

会话监听器

会话监听器用于监听会话创建、过期及停止事件：

public class MySessionListener1 implements SessionListener {  
    @Override  
    public void onStart(Session session) {//会话创建时触发  
        System.out.println("会话创建：" + session.getId());  
    }  
    @Override  
    public void onExpiration(Session session) {//会话过期时触发  
        System.out.println("会话过期：" + session.getId());  
    }  
    @Override  
    public void onStop(Session session) {//退出/会话过期时触发  
        System.out.println("会话停止：" + session.getId());  
    }    
}

如果只想监听某一个事件，可以继承SessionListenerAdapter实现：

public class MySessionListener2 extends SessionListenerAdapter {  
    @Override  
    public void onStart(Session session) {  
        System.out.println("会话创建：" + session.getId());  
    }  
}

会话存储 / 持久化

Shiro 提供 SessionDAO 用于会话的 CRUD，即 DAO（Data Access Object）模式实现，如 DefaultSessionManager 在创建完 session 后会调用该方法；如保存到关系数据库/文件系统/NoSQL 数据库；即可以实现会话的持久化；返回会话 ID；主要此处返回的ID.equals(session.getId())；

//如DefaultSessionManager在创建完session后会调用该方法；如保存到关系数据库/文件系统/NoSQL数据库；即可以实现会话的持久化；返回会话ID；主要此处返回的ID.equals(session.getId())；  
Serializable create(Session session);  
//根据会话ID获取会话  
Session readSession(Serializable sessionId) throws UnknownSessionException;  
//更新会话；如更新会话最后访问时间/停止会话/设置超时时间/设置移除属性等会调用  
void update(Session session) throws UnknownSessionException;  
//删除会话；当会话过期/会话停止（如用户退出时）会调用  
void delete(Session session);  
//获取当前所有活跃用户，如果用户量多此方法影响性能  
Collection<Session> getActiveSessions();

AbstractSessionDAO提供了SessionDAO的基础实现，如生成会话ID等；CachingSessionDAO提供了对开发者透明的会话缓存的功能，只需要设置相应的CacheManager即可；MemorySessionDAO直接在内存中进行会话维护；而EnterpriseCacheSessionDAO提供了缓存功能的会话维护，默认情况下使用MapCache实现，内部使用ConcurrentHashMap保存缓存的会话。

Shiro 提供了使用 Ehcache 进行会话存储，Ehcache 可以配合 TerraCotta 实现容器无关的分布式集群。

首先增加依赖：

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-ehcache</artifactId>
    <version>1.2.2</version>
</dependency>

shiro-web.ini 文件：

sessionDAO=org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO
sessionDAO. activeSessionsCacheName=shiro-activeSessionCache
sessionManager.sessionDAO=$sessionDAO
cacheManager = org.apache.shiro.cache.ehcache.EhCacheManager
cacheManager.cacheManagerConfigFile=classpath:ehcache.xml
securityManager.cacheManager = $cacheManager

sessionDAO. activeSessionsCacheName：设置 Session 缓存名字，默认就是 shiro-activeSessionCache；
cacheManager：缓存管理器，用于管理缓存的，此处使用 Ehcache 实现；
cacheManager.cacheManagerConfigFile：设置 ehcache 缓存的配置文件；
securityManager.cacheManager：设置 SecurityManager 的 cacheManager，会自动设置实现了 CacheManagerAware 接口的相应对象，如 SessionDAO 的 cacheManager；

配置 ehcache.xml：

<cache name="shiro-activeSessionCache"
       maxEntriesLocalHeap="10000"
       overflowToDisk="false"
       eternal="false"
       diskPersistent="false"
       timeToLiveSeconds="0"
       timeToIdleSeconds="0"
       statistics="true"/>

Cache 的名字为 shiro-activeSessionCache，即设置的 sessionDAO 的 activeSessionsCacheName 属性值。

另外可以通过如下 ini 配置设置会话 ID 生成器：

sessionIdGenerator=org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator
sessionDAO.sessionIdGenerator=$sessionIdGenerator

用于生成会话 ID，默认就是 JavaUuidSessionIdGenerator，使用 java.util.UUID 生成。

如果需要存储到数据库 自定义实现 SessionDAO，继承 CachingSessionDAO 即可：

public class MySessionDAO extends CachingSessionDAO {
    private JdbcTemplate jdbcTemplate = JdbcTemplateUtils.jdbcTemplate();
     protected Serializable doCreate(Session session) {
        Serializable sessionId = generateSessionId(session);
        assignSessionId(session, sessionId);
        String sql = "insert into sessions(id, session) values(?,?)";
        jdbcTemplate.update(sql, sessionId, SerializableUtils.serialize(session));
        return session.getId();
    }
protected void doUpdate(Session session) {
    if(session instanceof ValidatingSession && !((ValidatingSession)session).isValid()) {
        return; //如果会话过期/停止 没必要再更新了
    }
        String sql = "update sessions set session=? where id=?";
        jdbcTemplate.update(sql, SerializableUtils.serialize(session), session.getId());
    }
    protected void doDelete(Session session) {
        String sql = "delete from sessions where id=?";
        jdbcTemplate.update(sql, session.getId());
    }
    protected Session doReadSession(Serializable sessionId) {
        String sql = "select session from sessions where id=?";
        List<String> sessionStrList = jdbcTemplate.queryForList(sql, String.class, sessionId);
        if(sessionStrList.size() == 0) return null;
        return SerializableUtils.deserialize(sessionStrList.get(0));
    }
}

doCreate/doUpdate/doDelete/doReadSession 分别代表创建 / 修改 / 删除 / 读取会话；此处通过把会话序列化后存储到数据库实现；接着在 shiro-web.ini 中配置：

sessionDAO=com.github.zhangkaitao.shiro.chapter10.session.dao.MySessionDAO

其他设置和之前一样，因为继承了 CachingSessionDAO；所有在读取时会先查缓存中是否存在，如果找不到才到数据库中查找。

使用Redis作为Session缓存

需要shiro重写SessionDAO，继承AbstractSessionDAO，实现Redis Session的增刪改查操作

@Data
public class ShiroRedisSessionDao extends AbstractSessionDAO {

    private RedisTemplate<Serializable, Object> redisTemplate;

    @Override
    public Serializable create(final Session session) {
        Serializable id = super.create(session);
        redisTemplate.opsForValue().set(Contans.getKeys(id), session, 3600L, TimeUnit.MINUTES);
        return id;
    }

    @Override
    protected Serializable doCreate(Session session) {
        Serializable sessionId = super.generateSessionId(session);
        super.assignSessionId(session, sessionId);
        return sessionId;
    }

    //根据会话ID获取会话
    @Override
    public Session readSession(Serializable sessionId) throws UnknownSessionException {
        Session session = doReadSession(sessionId);
        if (session == null) {
            throw new UnknownSessionException("There is no session with id [" + sessionId + "]");
        }
        return session;
    }

    @Override
    protected Session doReadSession(final Serializable sessionId) {
        Session session = (SimpleSession) this.redisTemplate.opsForValue().get(Contans.getKeys(sessionId));
        if (session == null) {
            throw new UnknownSessionException("There is no session with id [" + sessionId + "]");
        } else {
            return session;
        }
    }

    @Override
    public void update(final Session session) throws UnknownSessionException {
        if (session instanceof SimpleSession) {
            final Serializable id = session.getId();
            redisTemplate.opsForValue().set(Contans.getKeys(id), session, 3600L, TimeUnit.MINUTES);
        }
    }

    @Override
    public void delete(Session session) {
        redisTemplate.delete(CollectionUtils.arrayToList(Contans.getKeys(session.getId())));
    }

    // 获取当前所有活跃用户，如果用户量多此方法影响性能
    @Override
    public Collection<Session> getActiveSessions() {
        return null;
    }
}

配置Redis不做介绍

配置ShiroConfig

    /* @Bean
     public SimpleCookie rememberMeCookie(){
         //这个参数是cookie的名称，对应前端的checkbox的name = rememberMe
         SimpleCookie simpleCookie = new SimpleCookie("rememberMe");
         //setcookie的httponly属性如果设为true的话，会增加对xss防护的安全系数。它有以下特点：
         //setcookie()的第七个参数
         //设为true后，只能通过http访问，javascript无法访问
         //防止xss读取cookie
         simpleCookie.setHttpOnly(true);
         simpleCookie.setPath("/");
         //记住我cookie生效时间30天 ,单位秒;
         simpleCookie.setMaxAge(2592000);
         return simpleCookie;
     }
     //cookie管理对象;记住我功能,rememberMe管理器
     @Bean
     public CookieRememberMeManager rememberMeManager(){
         CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
         cookieRememberMeManager.setCookie(rememberMeCookie());
         //rememberMe cookie加密的密钥 建议每个项目都不一样 默认AES算法 密钥长度(128 256 512 位)
         cookieRememberMeManager.setCipherKey(Base64.decode("4AvVheFLUs0KTA3K23frgdg=="));
         return cookieRememberMeManager;
     }*/
    //自定义Realm
    @Bean
    public UserRealm myShiroRealm() {
        UserRealm myShiroRealm = new UserRealm();
        return myShiroRealm;
    }

    //配置核心安全事务管理器
    @Bean
    public SecurityManager securityManager(SessionDAO sessionDAO) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //指定 securityManager 的 realms 实现，可以设置多个
        //securityManager 会按照 realms 指定的顺序进行身份认证。此处我们使用显示指定顺序的方式指定了 Realm 的顺序，
        // 如果不设置，那么 securityManager 会按照 realm 声明的顺序进行使用（即无需设置 realms 属性，其会自动发现 ）。
        securityManager.setRealm(myShiroRealm());
        //配置自定义session管理，使用redis
        securityManager.setSessionManager(sessionManager(sessionDAO));
        //配置记住我
//        securityManager.setRememberMeManager(rememberMeManager());
        //配置redis缓存
//        securityManager.setCacheManager(cacheManager());
        return securityManager;
    }

    /**
     * 解决无权限页面不跳转 shiroFilterFactoryBean.setUnauthorizedUrl("/page/fail.html") 无效
     *
     * shiro的源代码ShiroFilterFactoryBean.Java定义的filter必须满足filter instanceof AuthorizationFilter，
     * 只有perms，roles，ssl，rest，port才是属于AuthorizationFilter，而anon，authcBasic，auchc，user是AuthenticationFilter，
     * 所以unauthorizedUrl设置后页面不跳转 Shiro注解模式下，登录失败与没有权限都是通过抛出异常。
     * 并且默认并没有去处理或者捕获这些异常。在SpringMVC下需要配置捕获相应异常来通知用户信息
     * @return
     */
    @Bean
    public SimpleMappingExceptionResolver simpleMappingExceptionResolver() {
        SimpleMappingExceptionResolver simpleMappingExceptionResolver=new SimpleMappingExceptionResolver();
        Properties properties=new Properties();
        //这里的 /unauthorized 是页面，不是访问的路径
        properties.setProperty("org.apache.shiro.authz.UnauthorizedException","/page/fail.html");
        properties.setProperty("org.apache.shiro.authz.UnauthenticatedException","/page/fail.html");
        simpleMappingExceptionResolver.setExceptionMappings(properties);
        return simpleMappingExceptionResolver;
    }

    @Bean
    public SessionDAO sessionDAO(RedisTemplate redisTemplate) {
        ShiroRedisSessionDao sessionDao = new ShiroRedisSessionDao();
        sessionDao.setRedisTemplate(redisTemplate);
        return sessionDao;
    }
    //配置会话管理器
    //SessionManager是session的真正管理者，负责shiro的session管理；
    @Bean("sessionManager")
    public SessionManager sessionManager(SessionDAO sessionDAO) {
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        sessionManager.setSessionDAO(sessionDAO);
        sessionManager.setSessionIdCookie(simpleCookie());
        List<SessionListener> arrayList = new ArrayList<>();
        arrayList.add(sessionListener());
        sessionManager.setSessionListeners(arrayList);
        return sessionManager;
    }

    @Bean("sessionListener")
    public SessionListener sessionListener() {
        return new ShiroRedisSessionListener();
    }

    //配置保存sessionId的cookie
    //这里的cookie 不是上面的记住我 cookie
    @Bean
    public SimpleCookie simpleCookie() {
        //这个参数是cookie的名称
        SimpleCookie simpleCookie = new SimpleCookie("sid");
        //setcookie的httponly属性如果设为true的话，会增加对xss防护的安全系数。它有以下特点：
        //setcookie()的第七个参数
        //设为true后，只能通过http访问，javascript无法访问
        //防止xss读取cookie
        simpleCookie.setHttpOnly(true);
        simpleCookie.setPath("/");
        //maxAge=-1表示浏览器关闭时失效此Cookie
        simpleCookie.setMaxAge(-1);
        return simpleCookie;
    }

会话验证

定期的检测会话是否过期，Shiro 提供了会话验证调度器 SessionValidationScheduler实现。

可以通过如下 ini 配置开启会话验证：

sessionValidationScheduler=org.apache.shiro.session.mgt.ExecutorServiceSessionValidationScheduler
sessionValidationScheduler.interval = 3600000
sessionValidationScheduler.sessionManager=$sessionManager
sessionManager.globalSessionTimeout=1800000
sessionManager.sessionValidationSchedulerEnabled=true
sessionManager.sessionValidationScheduler=$sessionValidationScheduler

Shiro 也提供了使用 Quartz 会话验证调度器：

sessionValidationScheduler=org.apache.shiro.session.mgt.quartz.QuartzSessionValidationScheduler
sessionValidationScheduler.sessionValidationInterval = 3600000
sessionValidationScheduler.sessionManager=$sessionManager

使用时需要导入 shiro-quartz 依赖：

<dependency>
     <groupId>org.apache.shiro</groupId>
     <artifactId>shiro-quartz</artifactId>
     <version>1.2.2</version>
</dependency>

会话验证调度器实现都是直接调用 AbstractValidatingSessionManager 的 validateSessions 方法进行验证，其直接调用 SessionDAO 的 getActiveSessions 方法获取所有会话进行验证，如果会话比较多，会影响性能；可以考虑如分页获取会话并进行验证，如：

@Override
 public Collection<Session> getActiveSessions() {
     return null;
 }

在此方法中分页获取，如果在会话过期时不想删除过期的会话，可以通过如下 ini 配置进行设置：

sessionManager.deleteInvalidSessions=false

默认是开启的，在会话过期后会调用 SessionDAO 的 delete 方法删除会话：如会话时持久化存储的，可以调用此方法进行删除。

如果是在获取会话时验证了会话已过期，将抛出 InvalidSessionException。

sessionFactory

sessionFactory 是创建会话的工厂，根据相应的 Subject 上下文信息来创建会话；默认提供了 SimpleSessionFactory 用来创建 SimpleSession 会话。

首先自定义一个 Session：

public class OnlineSession extends SimpleSession {
    public static enum OnlineStatus {
        on_line("在线"), hidden("隐身"), force_logout("强制退出");
        private final String info;
        private OnlineStatus(String info) {
            this.info = info;
        }
        public String getInfo() {
            return info;
        }
    }
    private String userAgent; //用户浏览器类型
    private OnlineStatus status = OnlineStatus.on_line; //在线状态
    private String systemHost; //用户登录时系统IP
    //省略其他
}

OnlineSession 用于保存当前登录用户的在线状态，支持如离线等状态的控制。

接着自定义 SessionFactory：

public class OnlineSessionFactory implements SessionFactory {
    @Override
    public Session createSession(SessionContext initData) {
        OnlineSession session = new OnlineSession();
        if (initData != null && initData instanceof WebSessionContext) {
            WebSessionContext sessionContext = (WebSessionContext) initData;
            HttpServletRequest request = (HttpServletRequest) sessionContext.getServletRequest();
            if (request != null) {
                session.setHost(IpUtils.getIpAddr(request));
                session.setUserAgent(request.getHeader("User-Agent"));
                session.setSystemHost(request.getLocalAddr() + ":" + request.getLocalPort());
            }
        }
        return session;
    }
}

根据会话上下文创建相应的 OnlineSession。

最后在 shiro-web.ini 配置文件中配置：

sessionFactory=org.apache.shiro.session.mgt.OnlineSessionFactory
sessionManager.sessionFactory=$sessionFactory

缓存

Shiro 提供了类似于 Spring 的 Cache 抽象，即 Shiro 本身不实现 Cache，但是对 Cache 进行了又抽象，方便更换不同的底层 Cache 实现。Shiro提供的缓存抽象API接口正是：org.apache.shiro.cache.CacheManager。

Shiro支持在2个地方定义缓存管理器，既可以在SecurityManager中定义，也可以在Realm中定义，任选其一即可。

通常我们都会自定义Realm实现，例如将权限数据存放在数据库中，那么在Realm实现中定义缓存管理器再合适不过了。

Shiro设计成既可以在Realm，也可以在SecurityManager中设置缓存管理器，分别在Realm和SecurityManager定义的缓存管理器，他们的区别和联系，请看源码：
下面，我们追踪一下org.apache.shiro.mgt.RealmSecurityManage的源码实现：

protected void applyCacheManagerToRealms() {
    CacheManager cacheManager = getCacheManager();
    Collection<Realm> realms = getRealms();
    if (cacheManager != null && realms != null && !realms.isEmpty()) {
        for (Realm realm : realms) {
            if (realm instanceof CacheManagerAware) {
                ((CacheManagerAware) realm).setCacheManager(cacheManager);
            }
        }
    }
}

真正使用CacheManager的组件是Realm。

缓存方案

基于Redis的集中式缓存方案

本地缓存的实现有几种方式：（1）直接存放到JVM堆内存（2）使用NIO存放在堆外内存，自定义实现或者借助于第三方缓存组件。
不论是采用集中式缓存还是使用本地缓存，shiro的权限数据本身都是直接存放在本地的，不同的是缓存标志的存放位置。采用本地缓存方案是，我们将缓存标志也存放在本地，这样就避免了查询缓存标志的网络请求，能更进一步提升缓存效率

缓存更新

shiro框架的服务端进行了多实例部署，首先需要对session进行同步，因为shiro的认证信息是存放在session中的；其次，当前端操作在某个实例上修改了权限时，需要通知后端服务的多个实例重新获取最新的权限数据。

zookeeper最核心的功能就是统一配置，同时还可以用来实现服务注册与发现，在这里使用的zookeeper特性是：watcher机制。当某个节点的状态发生改变时，监控该节点状态的组件将会收到通知。

缓存实现

把权限信息存到redis

Cache

@Data
public class ShiroRedisCache<K, V> implements Cache<K, V> {
    private RedisTemplate<K, V> redisTemplate;
    private K keyPrefix;
    private RedisSerializer<Object> keySerializer=new JdkSerializationRedisSerializer();
    private RedisSerializer<Object> valueSerializer=new JdkSerializationRedisSerializer();

    public ShiroRedisCache(K keyPrefix, RedisTemplate<K, V> redisTemplate) {
        this.keyPrefix = keyPrefix;
        this.redisTemplate = redisTemplate;
    }

    @Override
    public void clear() throws CacheException {

    }

    @SuppressWarnings("unchecked")
    @Override
    public V get(K k) throws CacheException {
        final byte[] keyByte = getKey(k);
        byte[] result = this.redisTemplate.execute(new RedisCallback<byte[]>() {
            @Override
            public byte[] doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.get(keyByte);
            }
        });
        return (V) this.valueSerializer.deserialize(result);
    }

    public byte[] getKey(K k) {
        if (k instanceof String) {
            return (this.keyPrefix+(String) k).getBytes();
        }
        return this.keySerializer.serialize(k);
    }

    @Override
    public Set<K> keys() {
        final byte[] pattern=(this.keyPrefix+"*").getBytes();
        return this.redisTemplate.execute(new RedisCallback<Set<K>>(){
            @SuppressWarnings("unchecked")
            @Override
            public Set<K> doInRedis(RedisConnection connection) throws DataAccessException {
                Set<byte[]> keys=connection.keys(pattern);
                if(CollectionUtils.isEmpty(keys)){
                    return Collections.emptySet();
                }
                Set<K> newKeys = new HashSet<K>();
                for(byte[] key:keys){
                    newKeys.add((K)key);
                }
                return newKeys;
            }

        });
    }

    @Override
    public V put(K k, final V v) throws CacheException {
        final byte[] key = getKey(k);
        final V perV=get(k);
        final byte[] values = this.valueSerializer.serialize(v);
        return this.redisTemplate.execute(new RedisCallback<V>() {
            @Override
            public V doInRedis(RedisConnection connection) throws DataAccessException {
                connection.set(key, values);
                return perV;
            }
        });
    }

    @Override
    public V remove(K k) throws CacheException {
        final byte[] key = getKey(k);
        final V perV=get(k);
        return this.redisTemplate.execute(new RedisCallback<V>() {
            @Override
            public V doInRedis(RedisConnection connection) throws DataAccessException {
                connection.del(key);
                return perV;
            }
        });
    }

    @Override
    public int size() {
        return this.redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.dbSize();
            }
        }).intValue();
    }

    @Override
    public Collection<V> values() {
        Set<K> keys = keys();
        if (!CollectionUtils.isEmpty(keys)) {
            List<V> values = new ArrayList<V>(keys.size());
            for (K key : keys) {
                V value = get(key);
                if (value != null) {
                    values.add(value);
                }
            }
            return Collections.unmodifiableList(values);
        } else {
            return Collections.emptyList();
        }
    }
    public static void main(String[] args){
        System.out.println("Cd".matches("^[A-Z]+$"));
    }
}

CacheManager

@Data
public class ShiroRedisCacheManager implements CacheManager {

    private final ConcurrentHashMap<String, ShiroRedisCache> caches = new ConcurrentHashMap<String, ShiroRedisCache>();

    private RedisTemplate redisTemplate;

    private String keyPrefix;

    @SuppressWarnings("unchecked")
    @Override
    public <K, V> Cache<K, V> getCache(String name) throws CacheException {
        ShiroRedisCache<K, V> cache = (ShiroRedisCache<K, V>) caches.get(name);
        if (cache == null) {
            cache = new ShiroRedisCache<>(keyPrefix, this.redisTemplate);
            caches.put(name, cache);
        }
        return cache;
    }
}

public class Contans {
    public static String keyPrefix = "shiro-session:";
    public static String keyPrefixCache = "shiro-cache:";
    public static String getKeys(Serializable id) {
        return Contans.keyPrefix + id.toString();
    }
}

修改配置信息，把缓存管理器配置到Shiro中

    //配置核心安全事务管理器
    @Bean
    public SecurityManager securityManager(SessionDAO sessionDAO,CacheManager cacheManager) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //指定 securityManager 的 realms 实现，可以设置多个
        //securityManager 会按照 realms 指定的顺序进行身份认证。此处我们使用显示指定顺序的方式指定了 Realm 的顺序，
        // 如果不设置，那么 securityManager 会按照 realm 声明的顺序进行使用（即无需设置 realms 属性，其会自动发现 ）。
        securityManager.setRealm(myShiroRealm());
        //配置自定义session管理，使用redis
        securityManager.setSessionManager(sessionManager(sessionDAO));
        //配置记住我
//        securityManager.setRememberMeManager(rememberMeManager());
        //配置redis缓存
        securityManager.setCacheManager(cacheManager);
        return securityManager;
    }

    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate){
        ShiroRedisCacheManager shiroRedisCacheManager = new ShiroRedisCacheManager();
        shiroRedisCacheManager.setKeyPrefix(Contans.keyPrefixCache);
        shiroRedisCacheManager.setRedisTemplate(redisTemplate);
        return shiroRedisCacheManager;
    }

之后，访问用到权限的页面，就会在redis中缓存授权信息。

详细，见 https://github.com/huingsn/my-project

单点登录

https://www.w3cschool.cn/shiro/48371if3.html