Spring Shiro基础组件 SessionDao

已于 2022-02-07 22:37:05 修改
阅读量565 收藏
点赞数
分类专栏： Spring Shiro 文章标签： spring shiro
于 2022-02-03 23:00:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xing_hung/article/details/122753850
版权

相关阅读

简介

数据访问对象设计模式规范，用于启用对企业信息系统的Session访问，提供CRUD方法；
提供getActiveSessions()方法，支持处理孤立Session，由ValidatingSessionManager调用；

核心方法

/**
 * 保存
 * 返回值和Session.getId()一致
 */
Serializable create(Session session);

/**
 * 获取
 */
Session readSession(Serializable sessionId) throws UnknownSessionException;

/**
 * 更新
 */
void update(Session session) throws UnknownSessionException;

/**
 * 删除
 */
void delete(Session session);

/**
 * 获取活跃的Session
 */
Collection<Session> getActiveSessions();

实现子类

public interface SessionDAO
    public abstract class AbstractSessionDAO implements SessionDAO
        public abstract class CachingSessionDAO extends AbstractSessionDAO implements CacheManagerAware
            public class EnterpriseCacheSessionDAO extends CachingSessionDAO
        public class MemorySessionDAO extends AbstractSessionDAO

AbstractSessionDAO

简介

SessionDao接口的抽象实现，支持对创建/获取Session的校验，支持可插拔的Session ID生成策略；

核心方法

// Session ID生成器
private SessionIdGenerator sessionIdGenerator;

/**
 * 构造方法
 */
public AbstractSessionDAO() {
    // 默认Session ID生成器为JavaUuidSessionIdGenerator
    this.sessionIdGenerator = new JavaUuidSessionIdGenerator();
}

/**
 * 生成Session ID
 * 由子类的doCreate()方法调用
 * 若子类实现基于EIS数据存储则不需要调用本方法
 */
protected Serializable generateSessionId(Session session) {
    if (this.sessionIdGenerator == null) {
        String msg = "sessionIdGenerator attribute has not been configured.";
        throw new IllegalStateException(msg);
    }
    return this.sessionIdGenerator.generateId(session);
}

/**
 * 保存
 * 算法模板
 */
public Serializable create(Session session) {
    Serializable sessionId = doCreate(session);
    // 校验Session ID
    verifySessionId(sessionId);
    return sessionId;
}

/**
 * 校验Session ID
 */
private void verifySessionId(Serializable sessionId) {
    if (sessionId == null) {
        String msg = "sessionId returned from doCreate implementation is null.  Please verify the implementation.";
        throw new IllegalStateException(msg);
    }
}

/**
 * 绑定Session ID到指定的Session
 * 由子类调用，若子类不关心Session的具体实现
 */
protected void assignSessionId(Session session, Serializable sessionId) {
    ((SimpleSession) session).setId(sessionId);
}

/**
 * 保存
 * 算法细节，由子类实现
 */
protected abstract Serializable doCreate(Session session);

/**
 * 获取
 * 算法模板
 */
public Session readSession(Serializable sessionId) throws UnknownSessionException {
    Session s = doReadSession(sessionId);
    if (s == null) {
        throw new UnknownSessionException("There is no session with id [" + sessionId + "]");
    }
    return s;
}

/**
 * 获取
 * 算法细节，由子类实现
 */
protected abstract Session doReadSession(Serializable sessionId);

CachingSessionDAO

简介

在组件和底层的EIS数据存储之间提供透明的缓存层；

核心方法

// 默认缓存名称
public static final String ACTIVE_SESSION_CACHE_NAME = "shiro-activeSessionCache";
// 缓存管理器
private CacheManager cacheManager;
// 缓存活跃Session
private Cache<Serializable, Session> activeSessions;
// 缓存名称
private String activeSessionsCacheName = ACTIVE_SESSION_CACHE_NAME;

/**
 * 获取活跃Session缓存
 */
private Cache<Serializable, Session> getActiveSessionsCacheLazy() {
    if (this.activeSessions == null) {
        this.activeSessions = createActiveSessionsCache();
    }
    return activeSessions;
}

/**
 * 创建活跃Session缓存
 */
protected Cache<Serializable, Session> createActiveSessionsCache() {
    Cache<Serializable, Session> cache = null;
    CacheManager mgr = getCacheManager();
    if (mgr != null) {
        String name = getActiveSessionsCacheName();
        cache = mgr.getCache(name);
    }
    return cache;
}

/**
 * 保存
 */
public Serializable create(Session session) {
    Serializable sessionId = super.create(session);
    // 缓存Session
    cache(session, sessionId);
    return sessionId;
}

/**
 * 获取缓存的Session
 */
protected Session getCachedSession(Serializable sessionId) {
    Session cached = null;
    if (sessionId != null) {
        Cache<Serializable, Session> cache = getActiveSessionsCacheLazy();
        if (cache != null) {
            cached = getCachedSession(sessionId, cache);
        }
    }
    return cached;
}

/**
 * 从指定缓存中获取Session
 */
protected Session getCachedSession(Serializable sessionId, Cache<Serializable, Session> cache) {
    return cache.get(sessionId);
}

/**
 * 缓存Session
 */
protected void cache(Session session, Serializable sessionId) {
    if (session == null || sessionId == null) {
        return;
    }
    Cache<Serializable, Session> cache = getActiveSessionsCacheLazy();
    if (cache == null) {
        return;
    }
    cache(session, sessionId, cache);
}

/**
 * 向指定缓存中放入Session
 */
protected void cache(Session session, Serializable sessionId, Cache<Serializable, Session> cache) {
    cache.put(sessionId, session);
}

/**
 * 获取
 */
public Session readSession(Serializable sessionId) throws UnknownSessionException {
    // 先从缓存中获取
    Session s = getCachedSession(sessionId);
    if (s == null) {
        // 缓存中不存在则从底层数据存储中获取
        s = super.readSession(sessionId);
    }
    return s;
}

/**
 * 更新
 * 算法模板
 */
public void update(Session session) throws UnknownSessionException {
    doUpdate(session);
    if (session instanceof ValidatingSession) {
        // 校验Session有效性
        if (((ValidatingSession) session).isValid()) {
            // 更新缓存
            cache(session, session.getId());
        } else {
            // Session失效，清除缓存
            uncache(session);
        }
    } else {
        // 更新缓存
        cache(session, session.getId());
    }
}

/**
 * 更新
 * 算法细节，由子类实现
 */
protected abstract void doUpdate(Session session);

/**
 * 删除
 * 算法模板
 */
public void delete(Session session) {
    // 清除缓存
    uncache(session);
    // 删除
    doDelete(session);
}

/**
 * 删除
 * 算法细节，由子类实现
 */
protected abstract void doDelete(Session session);

/**
 * 清除缓存
 */
protected void uncache(Session session) {
    if (session == null) {
        return;
    }
    Serializable id = session.getId();
    if (id == null) {
        return;
    }
    Cache<Serializable, Session> cache = getActiveSessionsCacheLazy();
    if (cache != null) {
        cache.remove(id);
    }
}

/**
 * 获取活跃的Session
 */
public Collection<Session> getActiveSessions() {
    Cache<Serializable, Session> cache = getActiveSessionsCacheLazy();
    if (cache != null) {
        return cache.values();
    } else {
        return Collections.emptySet();
    }
}

EnterpriseCacheSessionDAO

简介

基于内存映射的CacheManager，本质上无逻辑处理，依赖父类缓存实现；

核心方法

/**
 * 构造方法
 */
public EnterpriseCacheSessionDAO() {
    // 设置基于内存映射的CacheManager
    setCacheManager(new AbstractCacheManager() {
        @Override
        protected Cache<Serializable, Session> createCache(String name) throws CacheException {
            return new MapCache<Serializable, Session>(name, new ConcurrentHashMap<Serializable, Session>());
        }
    });
}

/**
 * 保存
 */
protected Serializable doCreate(Session session) {
    Serializable sessionId = generateSessionId(session);
    assignSessionId(session, sessionId);
    return sessionId;
}

/**
 * 获取
 * 不做处理，依赖父类缓存实现
 */
protected Session doReadSession(Serializable sessionId) {
    return null; //should never execute because this implementation relies on parent class to access cache, which
    //is where all sessions reside - it is the cache implementation that determines if the
    //cache is memory only or disk-persistent, etc.
}

/**
 * 更新
 * 不做处理，依赖父类缓存实现
 */
protected void doUpdate(Session session) {
    //does nothing - parent class persists to cache.
}

/**
 * 删除
 * 不做处理，依赖父类缓存实现
 */
protected void doDelete(Session session) {
    //does nothing - parent class removes from cache.
}

MemorySessionDAO

简介

基于内存的SessionDao接口的简单实现，Session存储在内存的ConcurrentMap中；

核心方法

// Session集合
private ConcurrentMap<Serializable, Session> sessions;

/**
 * 保存
 * 算法细节
 */
protected Serializable doCreate(Session session) {
    // 生成Session ID
    Serializable sessionId = generateSessionId(session);
    // 绑定Session ID
    assignSessionId(session, sessionId);
    // 存储Session
    storeSession(sessionId, session);
    return sessionId;
}

/**
 * 存储
 */
protected Session storeSession(Serializable id, Session session) {
    if (id == null) {
        throw new NullPointerException("id argument cannot be null.");
    }
    return sessions.putIfAbsent(id, session);
}

/**
 * 获取
 * 算法细节
 */
protected Session doReadSession(Serializable sessionId) {
    return sessions.get(sessionId);
}

/**
 * 更新
 */
public void update(Session session) throws UnknownSessionException {
    storeSession(session.getId(), session);
}

/**
 * 删除
 */
public void delete(Session session) {
    if (session == null) {
        throw new NullPointerException("session argument cannot be null.");
    }
    Serializable id = session.getId();
    if (id != null) {
        sessions.remove(id);
    }
}

/**
 * 获取活跃的Session
 */
public Collection<Session> getActiveSessions() {
    Collection<Session> values = sessions.values();
    if (CollectionUtils.isEmpty(values)) {
        return Collections.emptySet();
    } else {
        return Collections.unmodifiableCollection(values);
    }
}
我家有猫已长成
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
EnterpriseCacheSessionDAO类
iteye_10899的博客
11-10 5366
EnterpriseCacheSessionDAO类主要定义了，它继承了CachingSessionDAO抽象类，现对其解析如下： 1.CachingSessionDAO抽象类 可以参考CachingSessionDAO抽象类，主要定义了在缓存中保存session，更新session，删除session，读取session，获取所有的session集合等操作。 2.EnterpriseC...
Spring_shiro介绍
weixin_67695384的博客
06-23 3623
shiro是apache的一个开源框架，是一个权限管理的框架，实现 用户认证、用户授权。spring中有spring security (原名Acegi)，是一个权限框架，它和spring依赖过于紧密，没有shiro使用简单。 shiro不依赖于spring，shiro不仅可以实现 web应用的权限管理，还可以实现c/s系统，分布式系统权限管理，shiro属于轻量框架，越来越多企业项目开始使用shiro。应用场景：shiro 解决应用安全的四要素：Shiro的体系结构具有3个主要概念：Subject(主题)
Shiro 中的 SessionDAO
易梦南蝶的博客
06-13 3677
SessionDAO是用于session持久化的，SessionManager只是负责session的管理，持久化的工作是由SessionDAO完成的。 SessionDAO的继承结构 SessionDAO 接口 SessionDAO接口是Shiro中所有SessionDAO的顶级接口，给出了从持久层（一般而言是关系型数据库）操作session的标准。方法如下： Serializabl...
Shiro自定义SessionDao,将session持久化到数据库
qpalzmwodyz的博客
05-06 821
Shiro自定义SessionDao,将session持久化到数据库1.对应数据库实体类这边用了mybatis-plus以及lombok框架2.造一个工具类来序列号session对象,因为session是一个接口对象,序列化成json比较麻烦3.自定义SessionDao 已经打了注释,基本可以看明白,Service层需要自己写,在此就不赘述了4.将自定义的sessionDao配置到shiro中,shiroConfig类中创建对象,并设置到sessionManager中,不要忘了把sessionmanage
【Shiro权限管理】20.Session持久化(SessionDAO)
程序猿之洞
01-02 1万+
注：该系列所有测试均在之前创建的Shiro3的Web工程的基础上。 上一篇说到了Shiro是如何控制Session会话的，而对于分布式系统，一般都牵扯到Session共享问题， 而想实现Session共享，就要实现Session的持久化操作，即是将内存中的Session持久化至缓存数据库。 本篇就讲解一下使用Shiro实现Session会话的持久化操作，即SessionDAO的相关知识。
Shiro的SessionDao
Hern（宋兆恒）
09-06 1238
SessionDao 对于分布式系统，一般都牵扯到Session共享问题，而想实现Session共享，就要实现Session的持久化操作，即是将内存中的Session持久化至缓存数据库。 SessionDAO是Shiro提供的一个数据交互层的interface接口，其作用是可以将Session写入到数据库中，然后可以对Session进行增删改查操作。 其中SessionDao是最...
详解spring与shiro集成
08-29
<bean id="sessionDAO" class="org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO"> ... <bean id="sessionValidationScheduler" class="org.apache.shiro.session.mgt.quartz....
spring整合shiro
08-25
- **Session管理**：Shiro 可以接管 Spring 的 Session 管理，提供跨域 session 支持，通过 GlobalSessionManager 和 SessionDAO 实现。 4. **源码分析**： - **Controller**：处理用户登录请求，通常包含 login...
spring-boot-shiro-demo
04-22
Shiro的核心组件包括Subject、SecurityManager、Realm等，它们负责处理用户的登录、权限验证以及会话管理。 **2. 动态权限加载更新** 动态权限加载更新是现代应用中常见的需求，它允许我们在运行时根据用户角色和...
spring boot 集成 shiro
05-03
Realm 是 Shiro 认证和授权的核心组件，用于连接应用数据源并处理用户身份验证和权限检查。你需要自定义 Realm 类，继承 `AuthorizingRealm` 并实现其中的 `doGetAuthenticationInfo` 和 `doGetAuthorizationInfo` ...
Shiro笔记四(会话管理)：SessionDao
Welcome
08-21 1万+
四、会话管理 23. Shiro_会话管理   API与HttpSession的API也特别像         在Handler层建议使用原生的HttpSession， 那ShiroSession有什么用呢？ 注意我们在传统的Web应用里面在Sevice里面是没法访问HttpSession的，也不建议这样做，在Handler层的API我们在Service层应该是不...
13. Shiro_SessionDao
qq_36468169的博客
10-30 190
SessionDao：可以把Session存到数据库中，对session进行增删改查操作。 详解：在开发中推荐一般 继承 EnterpreiseCacheSessionDAO就可以了。 再把会话管理器注入进安全管理器当中： <!--securityManage--> <!-- 安全管理器 --> <bean id="secur...
shiro的会话存储/持久化SessionDAO
热门推荐
zsg88的专栏
06-28 1万+
Shiro提供SessionDAO用于会话的CRUD，即DAO（Data Access Object）模式实现：
自定义shiro中RedisSessionDAO的keyPrefix
qq_46416934的博客
04-12 352
shiro中原始的RedisSessionDAO如下，keyPrefix为shiro_redis_session:，某些情况下需要自定义这个值 // // Source code recreated from a .class file by IntelliJ IDEA // (powered by Fernflower decompiler) // package org.crazycake.shiro; import java.io.Serializable; import java.util.Co
spring - shiro - session交给redis托管
ws6afa88的博客
10-15 676
shiro自己也有session，但是我希望将这个session交给redis托管，因为如果系统采用分布式，登录信息只保存在一个节点是肯定不行的。仔细弄了几天，遇到几个坑，查了很多资料，终于走通了。现在做个笔记。有关shiro的认证与校验见https://blog.csdn.net/ws6afa88/article/details/109061610 0. ShiroDemo目录结构 1. 主要依赖 <!--整合shiro--> <dependency> <gro
shiro的SessionDao（十二）
逝者如风
01-17 5113
SessionDao •        AbstractSessionDAO 提供了SessionDAO 的基础实现， 如生成会话ID等 •        CachingSessionDAO 提供了对开发者透明的会话缓存的功能，需要设置相应的 CacheManager •        MemorySessionDAO 直接在内存中进行会话维护 •    EnterpriseCacheSe
Session和DAO 用户登陆
treeshy的博客
03-12 697
用户在html下输入用户名和密码，然后点击登陆，跳转到另外一个界面。 login.html Insert title here Username: Password: MyLogin.java package test.demo1; import java.io.IOException; import javax.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值