Spring Boot Shiro

Shiro 核心 API

Subject：用户主体（每次请求都会创建Subject）。

    principal：代表身份。可以是用户名、邮件、手机号码等等，用来标识一个登录主体的身份。

    credential：代表凭证。常见的有密码，数字证书等。

SecurityManager：安全管理器（关联 Realm），用于安全校验。

Realm：Shiro 连接数据的桥梁。


Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储。

Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率。

CacheManager：缓存控制器，来管理如用户、角色、权限等缓存的控制器。

SessionManager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中。

SessionDAO：会话储存。

Shiro 认证与授权

身份认证：

    Step1：应用程序代码调用 Subject.login(token) 方法后，传入代表最终用户身份的 AuthenticationToken 实例 Token。

    Step2：将 Subject 实例委托给应用程序的 SecurityManager（Shiro 的安全管理）并开始实际的认证工作。

    Step3、4、5：SecurityManager 根据具体的 Realm 进行安全认证。

权限认证（涉及到三张表：用户表、角色表和权限表）：

    权限（Permission）：即操作资源的权利（添加、修改、删除、查看操作的权利）。
    
    角色（Role）：指的是用户担任的角色，一个角色可以有多个权限。
    
    用户（User）：在 Shiro 中，代表访问系统的用户，即上面提到的 Subject 认证主体。


请求步骤：

    浏览器发出第一次请求的时候，去redis里找不到对应的session，会进入到登录页。
    
    当在登录页输入完正确的账号密码后，才能登录成功。

    根据登录成功后的session生成sessionId，并传到前端浏览器中，浏览器以cookie存储，同时将session存储到redis中。
    
    每次浏览器访问后台，都会刷新session的过期时间expireTime。
    
    当浏览器再次请求时，将当前浏览器中的所有的cookie设置到request headers请求头中。
    根据传入的sessionId串到共享的redis存储中匹配。
    如果匹配不到，则会跳转到登录页，如果匹配成功，则会访问通过。

Spring Boot Shiro 依赖

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
</dependency>

自定义 Realm

自定义 Realm 需要继承 AuthorizingRealm 类，该类封装了很多方法，且继承自 Realm 类。

重写以下两个方法：
    doGetAuthenticationInfo() 方法：用来验证当前登录的用户，获取认证信息。
    doGetAuthorizationInfo() 方法：为当前登录成功的用户授予权限和分配角色。

public class CustomRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;

    /**
     * 登录成功的用户授予权限和分配角色
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        //获取用户名
        String account = (String) principals.getPrimaryPrincipal();

        //从数据库查询用户角色信息
        User user = userService.getUserByAccount(account);

        //设置角色
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        Set<String> roles = new HashSet();
        if (user.getAdmin()) {
            roles.add(Base.ROLE_ADMIN);
        }
        authorizationInfo.setRoles(roles);

        return authorizationInfo;
    }

    /**
     * 执行认证逻辑
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //获取用户名
        String account = (String) token.getPrincipal();

        //从数据库查询该用户
        User user = userService.getUserByAccount(account);

        if (null == user) {
            throw new UnknownAccountException();    //没找到该帐号
        }
        if (UserStatus.blocked.equals(user.getStatus())) {
            throw new LockedAccountException(); //帐号锁定
        }

        //传入用户名和密码进行身份认证，并返回认证信息
        return new SimpleAuthenticationInfo(
                user.getAccount(),
                user.getPassword(),
                ByteSource.Util.bytes(user.getSalt()),  //盐（密码加盐加密处理）
                getName()
        );
    }
}

自定义 SessionDAO

Cachemanager缓存里可以包含权限认证的缓存、用户及权限信息的缓存等，也可以做Session缓存。

SessionDAO是做Session持久化的，可以使用Redis来存储。

默认 SessionDAO：MemorySessionDAO：

    将Session保存在内存中，存储结构是ConcurrentHashMap。

    public class MemorySessionDAO extends AbstractSessionDAO {

        private ConcurrentMap<Serializable, Session> sessions = new ConcurrentHashMap();

        protected Serializable doCreate(Session session) {
            Serializable sessionId = this.generateSessionId(session);
            this.assignSessionId(session, sessionId);
            this.storeSession(sessionId, session);
            return sessionId;
        }
    }


/**
 * 将Session保存到Redis
 */
public class CustomSessionDAO extends CachingSessionDAO {

    @Autowired
    private RedisTemplate redisTemplate;

    //默认缓存过期时间：30分钟
    public final static long DEFAULT_EXPIRE = 60 * 30;

    @Override
    protected Serializable doCreate(Session session) {
        //创造SessionId
        Serializable sessionId = generateSessionId(session);
        //注册SessionId
        assignSessionId(session, sessionId);
        //缓存Session
        redisTemplate.opsForValue().set(sessionId.toString(), session, DEFAULT_EXPIRE, TimeUnit.SECONDS);
        return sessionId;
    }

    @Override
    protected void doUpdate(Session session) {
        if (session instanceof ValidatingSession && !((ValidatingSession) session).isValid()) {
            //会话过期/停止
            return;
        }
        redisTemplate.opsForValue().set(session.getId().toString(), session, DEFAULT_EXPIRE, TimeUnit.SECONDS);
    }

    @Override
    protected void doDelete(Session session) {
        redisTemplate.delete(session.getId().toString());
    }

    @Override
    protected Session doReadSession(Serializable sessionId) {
        return (Session) redisTemplate.opsForValue().get(sessionId.toString());
    }
}

自定义 SessionManager（待完善）

public class CustomSessionManager extends DefaultWebSessionManager {

    public static final String TOKEN = "token";

    /**
     * 调用登陆接口的时候，是没有token的。
     * 登陆成功后，产生了token，我们把它放到request中。
     * 返回结果给客户端的时候，把它从request中取出来，并且传递给客户端。
     * 客户端每次带着这个token过来，就相当于是浏览器的cookie的作用，也就能维护会话了。
     */
    @Override
    public Serializable getSessionId(SessionKey key) {
        Serializable sessionId = key.getSessionId();
        if(sessionId == null && WebUtils.isWeb(key)){
            HttpServletRequest request = WebUtils.getHttpRequest(key);
            HttpServletResponse response = WebUtils.getHttpResponse(key);
            sessionId = this.getSessionId(request,response);
        }
        HttpServletRequest request = WebUtils.getHttpRequest(key);
        request.setAttribute(TOKEN,sessionId.toString());
        return sessionId;
    }

    /**
     * DefaultWebSessionManager默认实现中，是通过Cookie确定SessionId。
     * 重写时，只需要把获取SessionId的方式变更为在request header中获取即可。
     */
    @Override
    protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String id = httpRequest.getHeader(TOKEN);

        if (!StringUtils.isEmpty(id)) {
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, ShiroHttpServletRequest.COOKIE_SESSION_ID_SOURCE);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
            return id;
        }
        return super.getSessionId(request, response);
    }
}

配置类 ShiroConfig

@Configuration
public class ShiroConfig {

    /**
     * 创建 ShiroFilterFactoryBean
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        
        //设置securityManager
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        //LinkedHashMap 是有序的，进行顺序拦截器配置
        Map<String, String> filterMap = new LinkedHashMap();
        filterMap.put("/static/**", "anon");    //无需认证可以访问
        filterMap.put("/login", "anon");
        filterMap.put("/register", "anon");

        //配置退出过滤器，其中具体的退出代码Shiro已经替我们实现了，登出后跳转配置的LoginUrl
        filterMap.put("/logout", "logout");

        filterMap.put("/**/create", "authc");   //必须认证才可以访问
        filterMap.put("/**/update", "authc");
        filterMap.put("/**/delete", "authc");
        filterMap.put("/upload", "authc");

        filterMap.put("/admin", "perms[admin]");    //资源必须得到资源权限才能访问，多个参数写法：perms["admin,user"]
        filterMap.put("/admin", "role[admin]"); //资源必须得到角色权限才能访问

        filterMap.put("/**", "anon");


        //设置默认登录的URL，身份认证失败会访问该URL
        shiroFilterFactoryBean.setLoginUrl("/login");
        //身份认证设置成功之后要跳转的URL
        shiroFilterFactoryBean.setSuccessUrl("/index");
        //设置未授权界面，权限认证失败会访问该URL
        shiroFilterFactoryBean.setUnauthorizedUrl("/unAuthorized");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterMap);
        return shiroFilterFactoryBean;
    }

    /**
     * 配置安全管理器：DefaultWebSecurityManager
     */
    @Bean
    public SecurityManager securityManager(CustomRealm realm, SessionManager sessionManager) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm);
        securityManager.setSessionManager(sessionManager);
        return securityManager;
    }

    /**
     * 创建自定义 Realm
     */
    @Bean
    public CustomRealm customRealm() {
        CustomRealm shiroRealm = new CustomRealm();
        //配置密码加密
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        matcher.setHashAlgorithmName("md5");    //加密方式
        matcher.setHashIterations(2);   //加密次数
        shiroRealm.setCredentialsMatcher(matcher);
        return shiroRealm;
    }

    /**
     * 配置 SessionManager
     */
    @Bean
    public SessionManager sessionManager() {
        CustomSessionManager customSessionManager = new CustomSessionManager();
        //session过期时间：1小时（默认半小时）
        customSessionManager.setGlobalSessionTimeout(60 * 60 * 1000);
        customSessionManager.setSessionDAO(new CustomSessionDAO());
        return customSessionManager;
    }

    /**
     * Spring Boot Shiro 开启注释
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }
}

Session的查询、刷新

SimpleSession几个属性：

    Serializable id：session id；

    Date startTimestamp：session的创建时间；

    Date stopTimestamp：session的失效时间；

    Date lastAccessTime：session的最近一次访问时间，初始值是startTimestamp

    long timeout：session的有效时长，默认30分钟

    boolean expired：session是否到期

    Map<Object, Object> attributes：session的属性容器


查询：Session session = SecurityUtils.getSubject().getSession();   //返回的就是绑定在当前subjuct的session。

刷新：SimpleSession的touch()

    public void touch() {
        this.lastAccessTime = new Date();
    }

    Web应用，每次进入ShiroFilter都会自动调用session.touch()来更新最后访问时间。

    过期时间判断：当前时间-lastAccessTime=是否超过有效时长。

Shiro支持三种方式的授权

1、编程式，通过写if/else授权代码块

    Subject subject = SecurityUtils.getSubject();
    if(subject.hasRole("admin")) {
        // 有权限，执行相关业务
    } else {
        // 无权限，给相关提示
    }

2、注解式，通过在执行的Java方法上放置相应的注解完成

    @RequiresPermissions("admin")
    public List<User> listUser() {
        // 有权限，获取数据  
    }

3、JSP/GSP标签，在JSP/GSP页面通过相应的标签完成

    <shiro:hasRole name="admin">
        <!-- 有权限 -->
    </shiro:hasRole>

Spring Boot 集成 Shiro 和 Ehcache（待完善）

引入配置文件 ehcache.xml：

    application.xml配置文件添加：spring.cache.ehcache.config=classpath:ehcache.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
             updateCheck="false">
        
        <diskStore path="java.io.tmpdir/shiro-cache"/>

        <defaultCache   //默认缓存策略
                eternal="false" //对象是否永久有效，一但设置了，timeout将不起作用
                maxElementsInMemory="1000"  //缓存最大元素数目
                overflowToDisk="false"  //当内存中对象数量达到maxElementsInMemory时，Ehcache将对象写到磁盘中。
                diskPersistent="false"  //是否在磁盘上持久化。指重启JVM后，数据是否有效。默认为false
                timeToIdleSeconds="0"   //设置对象在失效前的允许闲置时间（单位：s）,默认是0（永久有效）。
                timeToLiveSeconds="600" //设置对象在失效前允许存活时间（单位：s）,默认是0（永久有效）。
                //当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存
                //LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）
                memoryStoreEvictionPolicy="LRU" />
     
        <cache
                name="users"    //缓存名称
                eternal="false"
                maxElementsInMemory="500"
                overflowToDisk="false"
                diskPersistent="false"
                timeToIdleSeconds="0"
                timeToLiveSeconds="300"
                memoryStoreEvictionPolicy="LRU" />
    </ehcache>

Controller 与 Service 使用

Controller：

    @PostMapping("/login")
    public Result login(@RequestBody User user) {
        Result r = new Result();
        //获取Subject用户主体
        Subject subject = SecurityUtils.getSubject();
        //封装用户数据
        UsernamePasswordToken token = new UsernamePasswordToken(user.getAccount(), user.getPassword());
        try {
            //执行认证操作（调用UserRealm中的方法认证）
            subject.login(token);
            //认证通过
            User currentUser = userService.getUserByAccount(user.getAccount());
            subject.getSession().setAttribute(Base.CURRENT_USER, currentUser);
            r.setResultCode(ResultCode.SUCCESS);
            r.getData().put("token", subject.getSession().getId());
        } catch (UnknownAccountException e) {
            r.setResultCode(ResultCode.USER_NOT_EXIST); //用户不存在
        } catch (LockedAccountException e) {
            r.setResultCode(ResultCode.USER_ACCOUNT_FORBIDDEN); //账号被锁定
        }catch (IncorrectCredentialsException e) {
            r.setResultCode(ResultCode.USER_LOGIN_PASSWORD_ERROR);   //密码错误
        } catch (AuthenticationException e) {
            r.setResultCode(ResultCode.USER_LOGIN_ERROR);   //认证错误（包含以上错误）
        }
        return r;
    }

    @PostMapping("/register")
    public Result register(@RequestBody User user) {
        Result r = new Result();

        User temp = userService.getUserByAccount(user.getAccount());
        if (null != temp) {
            r.setResultCode(ResultCode.USER_HAS_EXISTED);
            return r;
        }

        userService.saveUser(user);

        r.setResultCode(ResultCode.SUCCESS);
        return r;
    }

Service：

    @Override
    @Transactional
    public void saveUser(User user) {
        //密码加密
        String newPassword = new SimpleHash(
                "md5",user.getPassword(),
                ByteSource.Util.bytes("salt"),2).toHex();

        user.setPassword(newPassword);

        return userRepository.save(user);
    }