Add SimpleRedisOperationsSessionRepository

Author: vpavic

spring-session-data-redis/src/main/java/org/springframework/session/data/redis/SimpleRedisOperationsSessionRepository.java

@@ -0,0 +1,270 @@
+/*
+ * Copyright 2014-2019 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *      https://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.springframework.session.data.redis;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import org.springframework.core.NestedExceptionUtils;
+import org.springframework.dao.NonTransientDataAccessException;
+import org.springframework.data.redis.core.BoundHashOperations;
+import org.springframework.data.redis.core.RedisOperations;
+import org.springframework.session.MapSession;
+import org.springframework.session.Session;
+import org.springframework.session.SessionRepository;
+import org.springframework.util.Assert;
+
+/**
+ * TODO.
+ *
+ * @author Vedran Pavic
+ * @since 2.2.0
+ */
+public class SimpleRedisOperationsSessionRepository implements
+		SessionRepository<SimpleRedisOperationsSessionRepository.RedisSession> {
+
+	private static final String DEFAULT_KEY_NAMESPACE = "spring:session:";
+
+	private final RedisOperations<String, Object> sessionRedisOperations;
+
+	private Duration defaultMaxInactiveInterval = Duration
+			.ofSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
+
+	private String keyNamespace = DEFAULT_KEY_NAMESPACE;
+
+	private RedisFlushMode flushMode = RedisFlushMode.ON_SAVE;
+
+	public SimpleRedisOperationsSessionRepository(
+			RedisOperations<String, Object> sessionRedisOperations) {
+		Assert.notNull(sessionRedisOperations, "sessionRedisOperations mut not be null");
+		this.sessionRedisOperations = sessionRedisOperations;
+	}
+
+	public void setDefaultMaxInactiveInterval(Duration defaultMaxInactiveInterval) {
+		Assert.notNull(defaultMaxInactiveInterval,
+				"defaultMaxInactiveInterval must not be null");
+		this.defaultMaxInactiveInterval = defaultMaxInactiveInterval;
+	}
+
+	public void setKeyNamespace(String keyNamespace) {
+		Assert.hasText(keyNamespace, "keyNamespace must not be empty");
+		this.keyNamespace = keyNamespace;
+	}
+
+	public void setFlushMode(RedisFlushMode flushMode) {
+		Assert.notNull(flushMode, "flushMode must not be null");
+		this.flushMode = flushMode;
+	}
+
+	@Override
+	public RedisSession createSession() {
+		RedisSession session = new RedisSession();
+		session.setMaxInactiveInterval(this.defaultMaxInactiveInterval);
+		session.flushIfRequired();
+		return session;
+	}
+
+	@Override
+	public void save(RedisSession session) {
+		session.save();
+	}
+
+	@Override
+	public RedisSession findById(String sessionId) {
+		Map<String, Object> entries = getSessionBoundHashOperations(sessionId).entries();
+		if (entries == null || entries.isEmpty()) {
+			return null;
+		}
+		MapSession session = new RedisSessionMapper(sessionId).apply(entries);
+		if (session.isExpired()) {
+			deleteById(sessionId);
+			return null;
+		}
+		return new RedisSession(session);
+	}
+
+	@Override
+	public void deleteById(String sessionId) {
+		this.sessionRedisOperations.delete(sessionId);
+	}
+
+	/**
+	 * Returns the {@link RedisOperations} used for sessions.
+	 * @return the {@link RedisOperations} used for sessions
+	 */
+	public RedisOperations<String, Object> getSessionRedisOperations() {
+		return this.sessionRedisOperations;
+	}
+
+	private BoundHashOperations<String, String, Object> getSessionBoundHashOperations(
+			String sessionId) {
+		String key = getSessionKey(sessionId);
+		return this.sessionRedisOperations.boundHashOps(key);
+	}
+
+	private String getSessionKey(String sessionId) {
+		return this.keyNamespace + sessionId;
+	}
+
+	/**
+	 * TODO.
+	 */
+	final class RedisSession implements Session {
+
+		private final MapSession cached;
+
+		private Map<String, Object> delta = new HashMap<>();
+
+		private boolean isNew;
+
+		private String originalSessionId;
+
+		RedisSession() {
+			this(new MapSession());
+			this.delta.put(RedisSessionMapper.CREATION_TIME_KEY,
+					getCreationTime().toEpochMilli());
+			this.delta.put(RedisSessionMapper.MAX_INACTIVE_INTERVAL_KEY,
+					(int) getMaxInactiveInterval().getSeconds());
+			this.delta.put(RedisSessionMapper.LAST_ACCESSED_TIME_KEY,
+					getLastAccessedTime().toEpochMilli());
+			this.isNew = true;
+		}
+
+		RedisSession(MapSession cached) {
+			this.cached = cached;
+			this.originalSessionId = cached.getId();
+		}
+
+		@Override
+		public String getId() {
+			return this.cached.getId();
+		}
+
+		@Override
+		public String changeSessionId() {
+			return this.cached.changeSessionId();
+		}
+
+		@Override
+		public <T> T getAttribute(String attributeName) {
+			return this.cached.getAttribute(attributeName);
+		}
+
+		@Override
+		public Set<String> getAttributeNames() {
+			return this.cached.getAttributeNames();
+		}
+
+		@Override
+		public void setAttribute(String attributeName, Object attributeValue) {
+			this.cached.setAttribute(attributeName, attributeValue);
+			putAttribute(attributeName, attributeValue);
+		}
+
+		@Override
+		public void removeAttribute(String attributeName) {
+			this.cached.removeAttribute(attributeName);
+			putAttribute(attributeName, null);
+		}
+
+		@Override
+		public Instant getCreationTime() {
+			return this.cached.getCreationTime();
+		}
+
+		@Override
+		public void setLastAccessedTime(Instant lastAccessedTime) {
+			this.cached.setLastAccessedTime(lastAccessedTime);
+			putAttribute(RedisSessionMapper.LAST_ACCESSED_TIME_KEY,
+					getLastAccessedTime().toEpochMilli());
+		}
+
+		@Override
+		public Instant getLastAccessedTime() {
+			return this.cached.getLastAccessedTime();
+		}
+
+		@Override
+		public void setMaxInactiveInterval(Duration interval) {
+			this.cached.setMaxInactiveInterval(interval);
+			putAttribute(RedisSessionMapper.MAX_INACTIVE_INTERVAL_KEY,
+					(int) getMaxInactiveInterval().getSeconds());
+		}
+
+		@Override
+		public Duration getMaxInactiveInterval() {
+			return this.cached.getMaxInactiveInterval();
+		}
+
+		@Override
+		public boolean isExpired() {
+			return this.cached.isExpired();
+		}
+
+		private void flushIfRequired() {
+			if (SimpleRedisOperationsSessionRepository.this.flushMode == RedisFlushMode.IMMEDIATE) {
+				save();
+			}
+		}
+
+		private void save() {
+			saveChangeSessionId();
+			saveDelta();
+			if (this.isNew) {
+				this.isNew = false;
+			}
+		}
+
+		private void saveChangeSessionId() {
+			String sessionId = getId();
+			if (!sessionId.equals(this.originalSessionId)) {
+				if (!this.isNew) {
+					String originalSessionIdKey = getSessionKey(this.originalSessionId);
+					String sessionIdKey = getSessionKey(sessionId);
+					try {
+						SimpleRedisOperationsSessionRepository.this.sessionRedisOperations
+								.rename(originalSessionIdKey, sessionIdKey);
+					}
+					catch (NonTransientDataAccessException ex) {
+						if (!"ERR no such key".equals(NestedExceptionUtils
+								.getMostSpecificCause(ex).getMessage())) {
+							throw ex;
+						}
+					}
+				}
+				this.originalSessionId = sessionId;
+			}
+		}
+
+		private void saveDelta() {
+			if (!this.delta.isEmpty()) {
+				getSessionBoundHashOperations(getId()).putAll(this.delta);
+				this.delta.clear();
+			}
+		}
+
+		private void putAttribute(String name, Object value) {
+			this.delta.put(RedisSessionMapper.ATTRIBUTE_PREFIX + name, value);
+			flushIfRequired();
+		}
+
+	}
+
+}