/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.shiro.session.mgt.eis;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.cache.CacheManagerAware;
import org.apache.shiro.session.Session;
import org.apache.shiro.session.UnknownSessionException;
import org.apache.shiro.session.mgt.ValidatingSession;
import java.io.Serializable;
import java.util.Collection;
import java.util.Collections;
/**
* An CachingSessionDAO is a SessionDAO that provides a transparent caching layer between the components that
* use it and the underlying EIS (Enterprise Information System) session backing store (for example, filesystem,
* database, enterprise grid/cloud, etc).
* <p/>
* This implementation caches all active sessions in a configured
* {@link #getActiveSessionsCache() activeSessionsCache}. This property is {@code null} by default and if one is
* not explicitly set, a {@link #setCacheManager cacheManager} is expected to be configured which will in turn be used
* to acquire the {@code Cache} instance to use for the {@code activeSessionsCache}.
* <p/>
* All {@code SessionDAO} methods are implemented by this class to employ
* caching behavior and delegates the actual EIS operations to respective do* methods to be implemented by
* subclasses (doCreate, doRead, etc).
*
* @author Les Hazlewood
* @since 0.2
*/
public abstract class CachingSessionDAO extends AbstractSessionDAO implements CacheManagerAware {
/**
* The default active sessions cache name, equal to {@code shiro-activeSessionCache}.
*/
public static final String ACTIVE_SESSION_CACHE_NAME = "shiro-activeSessionCache";
/**
* The CacheManager to use to acquire the Session cache.
*/
private CacheManager cacheManager;
/**
* The Cache instance responsible for caching Sessions.
*/
private Cache<Serializable, Session> activeSessions;
/**
* The name of the session cache, defaults to {@link #ACTIVE_SESSION_CACHE_NAME}.
*/
private String activeSessionsCacheName = ACTIVE_SESSION_CACHE_NAME;
/**
* Default no-arg constructor.
*/
public CachingSessionDAO() {
}
/**
* Sets the cacheManager to use for acquiring the {@link #getActiveSessionsCache() activeSessionsCache} if
* one is not configured.
*
* @param cacheManager the manager to use for constructing the session cache.
*/
public void setCacheManager(CacheManager cacheManager) {
this.cacheManager = cacheManager;
}
/**
* Returns the CacheManager to use for acquiring the {@link #getActiveSessionsCache() activeSessionsCache} if
* one is not configured. That is, the {@code CacheManager} will only be used if the
* {@link #getActiveSessionsCache() activeSessionsCache} property is {@code null}.
*
* @return the CacheManager used by the implementation that creates the activeSessions Cache.
*/
public CacheManager getCacheManager() {
return cacheManager;
}
/**
* Returns the name of the actives sessions cache to be returned by the {@code CacheManager}. Unless
* overridden by {@link #setActiveSessionsCacheName(String)}, defaults to {@link #ACTIVE_SESSION_CACHE_NAME}.
*
* @return the name of the active sessions cache.
*/
public String getActiveSessionsCacheName() {
return activeSessionsCacheName;
}
/**
* Sets the name of the active sessions cache to be returned by the {@code CacheManager}. Defaults to
* {@link #ACTIVE_SESSION_CACHE_NAME}.
*
* @param activeSessionsCacheName the name of the active sessions cache to be returned by the {@code CacheManager}.
*/
public void setActiveSessionsCacheName(String activeSessionsCacheName) {
this.activeSessionsCacheName = activeSessionsCacheName;
}
/**
* Returns the cache instance to use for storing active sessions. If one is not available (it is {@code null}),
* it will be {@link CacheManager#getCache(String) acquired} from the {@link #setCacheManager configured}
* {@code CacheManager} using the {@link #getActiveSessionsCacheName() activeSessionsCacheName}.
*
* @return the cache instance to use for storing active sessions or {@code null} if the {@code Cache} instance
* should be retrieved from the
*/
public Cache<Serializable, Session> getActiveSessionsCache() {
return this.activeSessions;
}
/**
* Sets the cache instance to use for storing active sessions. If one is not set (it remains {@code null}),
* it will be {@link CacheManager#getCache(String) acquired} from the {@link #setCacheManager configured}
* {@code CacheManager} using the {@link #getActiveSessionsCacheName() activeSessionsCacheName}.
*
* @param cache the cache instance to use for storing active sessions or {@code null} if the cache is to be
* acquired from the {@link #setCacheManager configured} {@code CacheManager}.
*/
public void setActiveSessionsCache(Cache<Serializable, Session> cache) {
this.activeSessions = cache;
}
/**
* Returns the active sessions cache, but if that cache instance is null, first lazily creates the cache instance
* via the {@link #createActiveSessionsCache()} method and then returns the instance.
* <p/>
* Note that this method will only return a non-null value code if the {@code CacheManager} has been set. If
* not set, there will be no cache.
*
* @return the active sessions cache instance.
*/
private Cache<Serializable, Session> getActiveSessionsCacheLazy() {
if (this.activeSessions == null) {
this.activeSessions = createActiveSessionsCache();
}
return activeSessions;
}
/**
* Creates a cache instance used to store active sessions. Creation is done by first
* {@link #getCacheManager() acquiring} the {@code CacheManager}. If the cache manager is not null, the
* cache returned is that resulting from the following call:
* <pre> String name = {@link #getActiveSessionsCacheName() getActiveSessionsCacheName()};
* cacheManager.getCache(name);</pre>
*
* @return a cache instance used to store active sessions, or {@code null} if the {@code CacheManager} has
* not been set.
*/
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;
}
/**
* Calls {@code super.create(session)}, then caches the session keyed by the returned {@code sessionId}, and then
* returns this {@code sessionId}.
*
* @param session Session object to create in the EIS and then cache.
*/
public Serializable create(Session session) {
Serializable sessionId = super.create(session);
cache(session, sessionId);
return sessionId;
}
/**
* Returns the cached session with the corresponding {@code sessionId} or {@code null} if there is
* no session cached under that id (or if there is no Cache).
*
* @param sessionId the id of the cached session to acquire.
* @return the cached session with the corresponding {@code sessionId}, or {@code null} if the session
* does not exist or is not cached.
*/
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;
}
/**
* Returns the Session with the specified id from the specified cache. This method simply calls
* {@code cache.get(sessionId)} and can be overridden by subclasses for custom acquisition behavior.
*
* @param sessionId the id of the session to acquire.
* @param cache the cache to acquire the session from
* @return the cached session, or {@code null} if the session wasn't in the cache.
*/
protected Session getCachedSession(Serializable sessionId, Cache<Serializable, Session> cache) {
return cache.get(sessionId);
}
/**
* Caches the specified session under the cache entry key of {@code sessionId}.
*
* @param session the session to cache
* @param sessionId the session id, to be used as the cache entry key.
* @since 1.0
*/
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);
}
/**
* Caches the specified session in the given cache under the key of {@code sessionId}. This implementation
* simply calls {@code cache.put(sessionId,session)} and can be overridden for custom behavior.
*
* @param session the session to cache
* @param sessionId the id of the session, expected to be the cache key.
* @param cache the cache to store the session
*/
protected void cache(Session session, Serializable sessionId, Cache<Serializable, Session> cache) {
cache.put(sessionId, session);
}
/**
* Attempts to acquire the Session from the cache first using the session ID as the cache key. If no session
* is found, {@code super.readSession(sessionId)} is called to perform the actual retrieval.
*
* @param sessionId the id of the session to retrieve from the EIS.
* @return the session identified by {@code sessionId} in the EIS.
* @throws UnknownSessionException if the id specified does not correspond to any session in the cache or EIS.
*/
public Session readSession(Serializable sessionId) throws UnknownSessionException {
Session s = getCachedSession(sessionId);
if (s == null) {
s = super.readSession(sessionId);
}
return s;
}
/**
* Updates the state of the given session to the EIS by first delegating to
* {@link #doUpdate(org.apache.shiro.session.Session)}. If the session is a {@link ValidatingSession}, it will
* be added to the cache only if it is {@link ValidatingSession#isValid()} and if invalid, will be removed from the
* cache. If it is not a {@code ValidatingSession} instance, it will be added to the cache in any event.
*
* @param session the session object to update in the EIS.
* @throws UnknownSessionException if no existing EIS session record exists with the
* identifier of {@link Session#getId() session.getId()}
*/
public void update(Session session) throws UnknownSessionException {
doUpdate(session);
if (session instanceof ValidatingSession) {
if (((ValidatingSession) session).isValid()) {
cache(session, session.getId());
} else {
uncache(session);
}
} else {
cache(session, session.getId());
}
}
/**
* Subclass implementation hook to actually persist the {@code Session}'s state to the underlying EIS.
*
* @param session the session object whose state will be propagated to the EIS.
*/
protected abstract void doUpdate(Session session);
/**
* Removes the specified session from any cache and then permanently deletes the session from the EIS by
* delegating to {@link #doDelete}.
*
* @param session the session to remove from caches and permanently delete from the EIS.
*/
public void delete(Session session) {
uncache(session);
doDelete(session);
}
/**
* Subclass implementation hook to permanently delete the given Session from the underlying EIS.
*
* @param session the session instance to permanently delete from the EIS.
*/
protected abstract void doDelete(Session session);
/**
* Removes the specified Session from the cache.
*
* @param session the session to remove from the cache.
*/
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);
}
}
/**
* Returns all active sessions in the system.
* <p/>
* <p>This implementation merely returns the sessions found in the activeSessions cache. Subclass implementations
* may wish to override this method to retrieve them in a different way, perhaps by an RDBMS query or by other
* means.
*
* @return the sessions found in the activeSessions cache.
*/
public Collection<Session> getActiveSessions() {
Cache<Serializable, Session> cache = getActiveSessionsCacheLazy();
if (cache != null) {
return cache.values();
} else {
return Collections.emptySet();
}
}
}