Extract RedisSessionMapper

Author: vpavic

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2018 the original author or authors.
+ * 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.
@@ -21,7 +21,6 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
-import java.util.function.Function;
 
 import org.reactivestreams.Publisher;
 import reactor.core.publisher.Mono;
@@ -47,29 +46,6 @@ public class ReactiveRedisOperationsSessionRepository implements
 	 */
 	public static final String DEFAULT_NAMESPACE = "spring:session";
 
-	/**
-	 * The key in the Hash representing {@link Session#getCreationTime()}.
-	 */
-	static final String CREATION_TIME_KEY = "creationTime";
-
-	/**
-	 * The key in the Hash representing {@link Session#getLastAccessedTime()}.
-	 */
-	static final String LAST_ACCESSED_TIME_KEY = "lastAccessedTime";
-
-	/**
-	 * The key in the Hash representing {@link Session#getMaxInactiveInterval()} .
-	 */
-	static final String MAX_INACTIVE_INTERVAL_KEY = "maxInactiveInterval";
-
-	/**
-	 * The prefix of the key used for session attributes. The suffix is the name of
-	 * the session attribute. For example, if the session contained an attribute named
-	 * attributeName, then there would be an entry in the hash named
-	 * sessionAttr:attributeName that mapped to its value.
-	 */
-	static final String ATTRIBUTE_PREFIX = "sessionAttr:";
-
 	private final ReactiveRedisOperations<String, Object> sessionRedisOperations;
 
 	/**
@@ -171,7 +147,7 @@ public Mono<RedisSession> findById(String id) {
 		return this.sessionRedisOperations.opsForHash().entries(sessionKey)
 				.collectMap((e) -> e.getKey().toString(), Map.Entry::getValue)
 				.filter((map) -> !map.isEmpty())
-				.map(new SessionMapper(id))
+				.map(new RedisSessionMapper(id))
 				.filter((session) -> !session.isExpired())
 				.map(RedisSession::new)
 				.switchIfEmpty(Mono.defer(() -> deleteById(id).then(Mono.empty())));
@@ -186,7 +162,7 @@ public Mono<Void> deleteById(String id) {
 	}
 
 	private static String getAttributeKey(String attributeName) {
-		return ATTRIBUTE_PREFIX + attributeName;
+		return RedisSessionMapper.ATTRIBUTE_PREFIX + attributeName;
 	}
 
 	private String getSessionKey(String sessionId) {
@@ -215,10 +191,12 @@ final class RedisSession implements Session {
 		 */
 		RedisSession() {
 			this(new MapSession());
-			this.delta.put(CREATION_TIME_KEY, getCreationTime().toEpochMilli());
-			this.delta.put(MAX_INACTIVE_INTERVAL_KEY,
+			this.delta.put(RedisSessionMapper.CREATION_TIME_KEY,
+					getCreationTime().toEpochMilli());
+			this.delta.put(RedisSessionMapper.MAX_INACTIVE_INTERVAL_KEY,
 					(int) getMaxInactiveInterval().getSeconds());
-			this.delta.put(LAST_ACCESSED_TIME_KEY, getLastAccessedTime().toEpochMilli());
+			this.delta.put(RedisSessionMapper.LAST_ACCESSED_TIME_KEY,
+					getLastAccessedTime().toEpochMilli());
 			this.isNew = true;
 			this.flushImmediateIfNecessary();
 		}
@@ -275,7 +253,8 @@ public Instant getCreationTime() {
 		@Override
 		public void setLastAccessedTime(Instant lastAccessedTime) {
 			this.cached.setLastAccessedTime(lastAccessedTime);
-			putAndFlush(LAST_ACCESSED_TIME_KEY, getLastAccessedTime().toEpochMilli());
+			putAndFlush(RedisSessionMapper.LAST_ACCESSED_TIME_KEY,
+					getLastAccessedTime().toEpochMilli());
 		}
 
 		@Override
@@ -286,7 +265,7 @@ public Instant getLastAccessedTime() {
 		@Override
 		public void setMaxInactiveInterval(Duration interval) {
 			this.cached.setMaxInactiveInterval(interval);
-			putAndFlush(MAX_INACTIVE_INTERVAL_KEY,
+			putAndFlush(RedisSessionMapper.MAX_INACTIVE_INTERVAL_KEY,
 					(int) getMaxInactiveInterval().getSeconds());
 		}
 
@@ -358,36 +337,4 @@ private Mono<Void> saveChangeSessionId() {
 
 	}
 
-	private static final class SessionMapper
-			implements Function<Map<String, Object>, MapSession> {
-
-		private final String id;
-
-		private SessionMapper(String id) {
-			this.id = id;
-		}
-
-		@Override
-		public MapSession apply(Map<String, Object> map) {
-			MapSession session = new MapSession(this.id);
-
-			session.setCreationTime(
-					Instant.ofEpochMilli((long) map.get(CREATION_TIME_KEY)));
-			session.setLastAccessedTime(
-					Instant.ofEpochMilli((long) map.get(LAST_ACCESSED_TIME_KEY)));
-			session.setMaxInactiveInterval(
-					Duration.ofSeconds((int) map.get(MAX_INACTIVE_INTERVAL_KEY)));
-
-			map.forEach((name, value) -> {
-				if (name.startsWith(ATTRIBUTE_PREFIX)) {
-					session.setAttribute(name.substring(ATTRIBUTE_PREFIX.length()),
-							value);
-				}
-			});
-
-			return session;
-		}
-
-	}
-
 }

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

@@ -264,33 +264,6 @@ public class RedisOperationsSessionRepository implements
 	 */
 	public static final String DEFAULT_NAMESPACE = "spring:session";
 
-	/**
-	 * The key in the Hash representing
-	 * {@link org.springframework.session.Session#getCreationTime()}.
-	 */
-	static final String CREATION_TIME_ATTR = "creationTime";
-
-	/**
-	 * The key in the Hash representing
-	 * {@link org.springframework.session.Session#getMaxInactiveInterval()}
-	 * .
-	 */
-	static final String MAX_INACTIVE_ATTR = "maxInactiveInterval";
-
-	/**
-	 * The key in the Hash representing
-	 * {@link org.springframework.session.Session#getLastAccessedTime()}.
-	 */
-	static final String LAST_ACCESSED_ATTR = "lastAccessedTime";
-
-	/**
-	 * The prefix of the key used for session attributes. The suffix is the name of
-	 * the session attribute. For example, if the session contained an attribute named
-	 * attributeName, then there would be an entry in the hash named
-	 * sessionAttr:attributeName that mapped to its value.
-	 */
-	static final String SESSION_ATTR_PREFIX = "sessionAttr:";
-
 	private int database = RedisOperationsSessionRepository.DEFAULT_DATABASE;
 
 	/**
@@ -480,17 +453,18 @@ private MapSession loadSession(String id, Map<Object, Object> entries) {
 		MapSession loaded = new MapSession(id);
 		for (Map.Entry<Object, Object> entry : entries.entrySet()) {
 			String key = (String) entry.getKey();
-			if (CREATION_TIME_ATTR.equals(key)) {
+			if (RedisSessionMapper.CREATION_TIME_KEY.equals(key)) {
 				loaded.setCreationTime(Instant.ofEpochMilli((long) entry.getValue()));
 			}
-			else if (MAX_INACTIVE_ATTR.equals(key)) {
+			else if (RedisSessionMapper.MAX_INACTIVE_INTERVAL_KEY.equals(key)) {
 				loaded.setMaxInactiveInterval(Duration.ofSeconds((int) entry.getValue()));
 			}
-			else if (LAST_ACCESSED_ATTR.equals(key)) {
+			else if (RedisSessionMapper.LAST_ACCESSED_TIME_KEY.equals(key)) {
 				loaded.setLastAccessedTime(Instant.ofEpochMilli((long) entry.getValue()));
 			}
-			else if (key.startsWith(SESSION_ATTR_PREFIX)) {
-				loaded.setAttribute(key.substring(SESSION_ATTR_PREFIX.length()),
+			else if (key.startsWith(RedisSessionMapper.ATTRIBUTE_PREFIX)) {
+				loaded.setAttribute(
+						key.substring(RedisSessionMapper.ATTRIBUTE_PREFIX.length()),
 						entry.getValue());
 			}
 		}
@@ -689,7 +663,7 @@ private BoundHashOperations<Object, Object, Object> getSessionBoundHashOperation
 	 * @return the attribute key name
 	 */
 	static String getSessionAttrNameKey(String attributeName) {
-		return SESSION_ATTR_PREFIX + attributeName;
+		return RedisSessionMapper.ATTRIBUTE_PREFIX + attributeName;
 	}
 
 	/**
@@ -719,9 +693,12 @@ final class RedisSession implements Session {
 		RedisSession(Duration maxInactiveInterval) {
 			this(new MapSession());
 			this.cached.setMaxInactiveInterval(maxInactiveInterval);
-			this.delta.put(CREATION_TIME_ATTR, getCreationTime().toEpochMilli());
-			this.delta.put(MAX_INACTIVE_ATTR, (int) getMaxInactiveInterval().getSeconds());
-			this.delta.put(LAST_ACCESSED_ATTR, getLastAccessedTime().toEpochMilli());
+			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;
 		}
 
@@ -745,7 +722,8 @@ public void setNew(boolean isNew) {
 		@Override
 		public void setLastAccessedTime(Instant lastAccessedTime) {
 			this.cached.setLastAccessedTime(lastAccessedTime);
-			this.putAndFlush(LAST_ACCESSED_ATTR, getLastAccessedTime().toEpochMilli());
+			this.putAndFlush(RedisSessionMapper.LAST_ACCESSED_TIME_KEY,
+					getLastAccessedTime().toEpochMilli());
 		}
 
 		@Override
@@ -780,7 +758,8 @@ public Instant getLastAccessedTime() {
 		@Override
 		public void setMaxInactiveInterval(Duration interval) {
 			this.cached.setMaxInactiveInterval(interval);
-			this.putAndFlush(MAX_INACTIVE_ATTR, (int) getMaxInactiveInterval().getSeconds());
+			this.putAndFlush(RedisSessionMapper.MAX_INACTIVE_INTERVAL_KEY,
+					(int) getMaxInactiveInterval().getSeconds());
 		}
 
 		@Override

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

@@ -0,0 +1,97 @@
+/*
+ * 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.Map;
+import java.util.function.Function;
+
+import org.springframework.session.MapSession;
+import org.springframework.session.Session;
+import org.springframework.util.Assert;
+
+/**
+ * A {@link Function} that converts a {@link Map} representing Redis hash to a
+ * {@link MapSession}.
+ *
+ * @author Vedran Pavic
+ * @since 2.2.0
+ */
+final class RedisSessionMapper implements Function<Map<String, Object>, MapSession> {
+
+	/**
+	 * The key in the hash representing {@link Session#getCreationTime()}.
+	 */
+	static final String CREATION_TIME_KEY = "creationTime";
+
+	/**
+	 * The key in the hash representing {@link Session#getLastAccessedTime()}.
+	 */
+	static final String LAST_ACCESSED_TIME_KEY = "lastAccessedTime";
+
+	/**
+	 * The key in the hash representing {@link Session#getMaxInactiveInterval()}.
+	 */
+	static final String MAX_INACTIVE_INTERVAL_KEY = "maxInactiveInterval";
+
+	/**
+	 * The prefix of the key in the hash used for session attributes. For example, if the
+	 * session contained an attribute named {@code attributeName}, then there would be an
+	 * entry in the hash named {@code sessionAttr:attributeName} that mapped to its value.
+	 */
+	static final String ATTRIBUTE_PREFIX = "sessionAttr:";
+
+	private final String sessionId;
+
+	RedisSessionMapper(String sessionId) {
+		Assert.hasText(sessionId, "sessionId must not be empty");
+		this.sessionId = sessionId;
+	}
+
+	@Override
+	public MapSession apply(Map<String, Object> map) {
+		Assert.notEmpty(map, "map must not be empty");
+		MapSession session = new MapSession(this.sessionId);
+		Long creationTime = (Long) map.get(CREATION_TIME_KEY);
+		if (creationTime == null) {
+			handleMissingKey(CREATION_TIME_KEY);
+		}
+		session.setCreationTime(Instant.ofEpochMilli(creationTime));
+		Long lastAccessedTime = (Long) map.get(LAST_ACCESSED_TIME_KEY);
+		if (lastAccessedTime == null) {
+			handleMissingKey(LAST_ACCESSED_TIME_KEY);
+		}
+		session.setLastAccessedTime(Instant.ofEpochMilli(lastAccessedTime));
+		Integer maxInactiveInterval = (Integer) map.get(MAX_INACTIVE_INTERVAL_KEY);
+		if (maxInactiveInterval == null) {
+			handleMissingKey(MAX_INACTIVE_INTERVAL_KEY);
+		}
+		session.setMaxInactiveInterval(Duration.ofSeconds(maxInactiveInterval));
+		map.forEach((name, value) -> {
+			if (name.startsWith(ATTRIBUTE_PREFIX)) {
+				session.setAttribute(name.substring(ATTRIBUTE_PREFIX.length()), value);
+			}
+		});
+		return session;
+	}
+
+	private static void handleMissingKey(String key) {
+		throw new IllegalStateException(key + " key must not be null");
+	}
+
+}