SpringBoot整合Shiro(三)

public interface RoleService {

    Set<Role> findRolesByUserId(Integer uid);

    void delPermission(int roleId, int permissionId);

    void addPermission(int i, int i1);
}

@Service
public class RoleServiceImpl implements RoleService {

    @Autowired
    private RoleMapper roleMapper;

    @Override
    public Set<Role> findRolesByUserId(Integer uid) {
        return roleMapper.findRolesByUserId(uid);
    }

    @Override
    public void delPermission(int roleId, int permissionId) {
        roleMapper.delPermission(roleId,permissionId);
    }

    @Override
    public void addPermission(int roleId, int permissionId) {
        roleMapper.addPermission(roleId,permissionId);
    }
}

@Mapper
public interface RoleMapper {
    Set<Role> findRolesByUserId(@Param("uid") Integer uid);

    void delPermission(@Param("roleId") Integer roleId, @Param("permissionId") Integer permissionId);

    void addPermission(@Param("roleId") Integer roleId, @Param("permissionId") Integer permissionId);
}

/**
  * shiro缓存管理器;
  * 需要添加到securityManager中
  *
  * @return
  */
@Bean
public EhCacheManager ehCacheManager() {
    EhCacheManager cacheManager = new EhCacheManager();
    cacheManager.setCacheManagerConfigFile("classpath:config/ehcache-shiro.xml");
    return cacheManager;
}

/**
  * 让某个实例的某个方法的返回值注入为Bean的实例
  * Spring静态注入
  *
  * @return
  */
@Bean
public MethodInvokingFactoryBean getMethodInvokingFactoryBean() {
    MethodInvokingFactoryBean factoryBean = new MethodInvokingFactoryBean();
    factoryBean.setStaticMethod("org.apache.shiro.SecurityUtils.setSecurityManager");
    factoryBean.setArguments(new Object[]{securityManager()});
    return factoryBean;
}

/**
  * 配置核心安全事务管理器
  *
  * @return
  */
@Bean(name = "securityManager")
public SecurityManager securityManager() {
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    //设置自定义realm.
    securityManager.setRealm(shiroRealm());
    //配置记住我 
    securityManager.setRememberMeManager(rememberMeManager());

    //配置 ehcache缓存管理器 
    securityManager.setCacheManager(ehCacheManager());

    //配置自定义session管理，使用redis 
    //securityManager.setSessionManager(sessionManager());

    return securityManager;
}

/**
  * 身份认证realm; (这个需要自己写，账号密码校验；权限等)
  *
  * @return
  */
@Bean
public ShiroRealm shiroRealm() {
    ShiroRealm shiroRealm = new ShiroRealm();
    shiroRealm.setCachingEnabled(true);
    //启用身份验证缓存，即缓存AuthenticationInfo信息，默认false
    shiroRealm.setAuthenticationCachingEnabled(true);
    //缓存AuthenticationInfo信息的缓存名称 在ehcache-shiro.xml中有对应缓存的配置
    shiroRealm.setAuthenticationCacheName("authenticationCache");
    //启用授权缓存，即缓存AuthorizationInfo信息，默认false
    shiroRealm.setAuthorizationCachingEnabled(true);
    //缓存AuthorizationInfo信息的缓存名称  在ehcache-shiro.xml中有对应缓存的配置
    shiroRealm.setAuthorizationCacheName("authorizationCache");

    return shiroRealm;
}

public class ShiroRealm extends AuthorizingRealm {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RoleMapper roleMapper;

    @Autowired
    private PermissionMapper permissionMapper;

    ...
        
    /**
     * 重写方法,清除当前用户的的 授权缓存
     * @param principals
     */
    @Override
    public void clearCachedAuthorizationInfo(PrincipalCollection principals) {
        super.clearCachedAuthorizationInfo(principals);
    }

    /**
     * 重写方法，清除当前用户的 认证缓存
     * @param principals
     */
    @Override
    public void clearCachedAuthenticationInfo(PrincipalCollection principals) {
        super.clearCachedAuthenticationInfo(principals);
    }

    @Override
    public void clearCache(PrincipalCollection principals) {
        super.clearCache(principals);
    }

    /**
     * 自定义方法：清除所有 授权缓存
     */
    public void clearAllCachedAuthorizationInfo() {
        getAuthorizationCache().clear();
    }

    /**
     * 自定义方法：清除所有 认证缓存
     */
    public void clearAllCachedAuthenticationInfo() {
        getAuthenticationCache().clear();
    }

    /**
     * 自定义方法：清除所有的  认证缓存  和 授权缓存
     */
    public void clearAllCache() {
        clearAllCachedAuthenticationInfo();
        clearAllCachedAuthorizationInfo();
    }
}

@RestController
@RequestMapping("userInfo")
public class UserController {

    @Autowired
    private UserService userService;

    @Autowired
    private RoleService roleService;

    .....

    /**
     * 给admin用户添加 userInfo:del 权限
     * @param model
     * @return
     */
    @RequestMapping(value = "/addPermission",method = RequestMethod.GET)
    @ResponseBody
    public String addPermission(Model model) {

        //在sys_role_permission 表中  将 删除的权限 关联到admin用户所在的角色
        roleService.addPermission(1,3);

        //添加成功之后 清除缓存
        DefaultWebSecurityManager securityManager = (DefaultWebSecurityManager)SecurityUtils.getSecurityManager();
        ShiroRealm shiroRealm = (ShiroRealm) securityManager.getRealms().iterator().next();
        //清除权限 相关的缓存
        shiroRealm.clearAllCache();
        return "给admin用户添加 userInfo:del 权限成功";

    }

    /**
     * 删除admin用户 userInfo:del 权限
     * @param model
     * @return
     */
    @RequestMapping(value = "/delPermission",method = RequestMethod.GET)
    @ResponseBody
    public String delPermission(Model model) {

        //在sys_role_permission 表中  将 删除的权限 关联到admin用户所在的角色
        roleService.delPermission(1,3);
        //添加成功之后 清除缓存
        DefaultWebSecurityManager securityManager = (DefaultWebSecurityManager) SecurityUtils.getSecurityManager();
        ShiroRealm shiroRealm = (ShiroRealm) securityManager.getRealms().iterator().next();
        //清除权限 相关的缓存
        shiroRealm.clearAllCache();
        return "删除admin用户userInfo:del 权限成功";
    }

}

Subject subject = SecurityUtils.getSubject();
Session session = subject.getSession();

public class ShiroSessionListener implements SessionListener {

    /**
     * 统计在线人数
     * juc包下线程安全自增
     */
    private final AtomicInteger sessionCount = new AtomicInteger(0);

    /**
     * 会话创建时触发
     *
     * @param session
     */
    @Override
    public void onStart(Session session) {
        //会话创建，在线人数加一
        sessionCount.incrementAndGet();
    }

    /**
     * 退出会话时触发
     *
     * @param session
     */
    @Override
    public void onStop(Session session) {
        //会话退出,在线人数减一
        sessionCount.decrementAndGet();
    }

    /**
     * 会话过期时触发
     *
     * @param session
     */
    @Override
    public void onExpiration(Session session) {
        //会话过期,在线人数减一
        sessionCount.decrementAndGet();
    }

    /**
     * 获取在线人数使用
     *
     * @return
     */
    public AtomicInteger getSessionCount() {
        return sessionCount;
    }
}

/**
  * 配置session监听
  *
  * @return
  */
@Bean("sessionListener")
public ShiroSessionListener sessionListener() {
    ShiroSessionListener sessionListener = new ShiroSessionListener();
    return sessionListener;
}

/**
  * 配置会话ID生成器
  *
  * @return
  */
@Bean
public SessionIdGenerator sessionIdGenerator() {
    return new JavaUuidSessionIdGenerator();
}

/**
  * SessionDAO的作用是为Session提供CRUD并进行持久化的一个shiro组件
  * MemorySessionDAO 直接在内存中进行会话维护
  * EnterpriseCacheSessionDAO  提供了缓存功能的会话维护，默认情况下使用MapCache实现，内部使用ConcurrentHashMap保存缓存的会话。
  *
  * @return
  */
@Bean
public SessionDAO sessionDAO() {
    EnterpriseCacheSessionDAO enterpriseCacheSessionDAO = new EnterpriseCacheSessionDAO();
    //使用ehCacheManager
    enterpriseCacheSessionDAO.setCacheManager(ehCacheManager());
    //设置session缓存的名字 默认为 shiro-activeSessionCache
    enterpriseCacheSessionDAO.setActiveSessionsCacheName("shiro-activeSessionCache");
    //sessionId生成器
    enterpriseCacheSessionDAO.setSessionIdGenerator(sessionIdGenerator());
    return enterpriseCacheSessionDAO;
}

/**
  * 配置保存sessionId的cookie
  * 注意：这里的cookie 不是上面的记住我 cookie 记住我需要一个cookie session管理 也需要自己的cookie
  *
  * @return
  */
@Bean("sessionIdCookie")
public SimpleCookie sessionIdCookie() {
    //这个参数是cookie的名称
    SimpleCookie simpleCookie = new SimpleCookie("session_id");
    //setcookie的httponly属性如果设为true的话，会增加对xss防护的安全系数。它有以下特点：

    //setcookie()的第七个参数
    //设为true后，只能通过http访问，javascript无法访问
    //防止xss读取cookie
    simpleCookie.setHttpOnly(true);
    simpleCookie.setPath("/");
    //maxAge=-1表示浏览器关闭时失效此Cookie
    simpleCookie.setMaxAge(-1);
    return simpleCookie;
}

/**
  * 配置会话管理器，设定会话超时及保存
  * @return
  */
@Bean("sessionManager")
public SessionManager sessionManager() {

    DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
    Collection<SessionListener> listeners = new ArrayList<SessionListener>();
    //配置监听
    listeners.add(sessionListener());
    sessionManager.setSessionListeners(listeners);
    sessionManager.setSessionIdCookie(sessionIdCookie());
    sessionManager.setSessionDAO(sessionDAO());
    sessionManager.setCacheManager(ehCacheManager());

    //全局会话超时时间（单位毫秒），默认30分钟  暂时设置为10秒钟 用来测试
    sessionManager.setGlobalSessionTimeout(1800000);
    //是否开启删除无效的session对象  默认为true
    sessionManager.setDeleteInvalidSessions(true);
    //是否开启定时调度器进行检测过期session 默认为true
    sessionManager.setSessionValidationSchedulerEnabled(true);
    //设置session失效的扫描时间, 清理用户直接关闭浏览器造成的孤立会话 默认为 1个小时
    //设置该属性 就不需要设置 ExecutorServiceSessionValidationScheduler 底层也是默认自动调用ExecutorServiceSessionValidationScheduler
    //暂时设置为 5秒 用来测试
    sessionManager.setSessionValidationInterval(3600000);

    //取消url 后面的 JSESSIONID
    sessionManager.setSessionIdUrlRewritingEnabled(false);

    return sessionManager;
}

org.apache.shiro.crypto.CryptoException: Unable to execute 'doFinal' with cipher instance [javax.crypto.Cipher@461df537].

//全局会话超时时间（单位毫秒），默认30分钟  暂时设置为10秒钟 用来测试
sessionManager.setGlobalSessionTimeout(1800000);
//是否开启删除无效的session对象  默认为true
sessionManager.setDeleteInvalidSessions(true);
//是否开启定时调度器进行检测过期session 默认为true
sessionManager.setSessionValidationSchedulerEnabled(true);
//设置session失效的扫描时间, 清理用户直接关闭浏览器造成的孤立会话 默认为 1个小时
//设置该属性 就不需要设置 ExecutorServiceSessionValidationScheduler 底层也是默认自动调用ExecutorServiceSessionValidationScheduler
//暂时设置为 5秒 用来测试
sessionManager.setSessionValidationInterval(3600000);

//取消url 后面的 JSESSIONID
sessionManager.setSessionIdUrlRewritingEnabled(false);

/**
  * 配置核心安全事务管理器
  *
  * @return
  */
@Bean(name = "securityManager")
public SecurityManager securityManager() {
   ...
       
    //配置自定义session管理
    securityManager.setSessionManager(sessionManager());

    return securityManager;
}