Harmonize naming of session repositories

Resolves: #1455

spring-session-hazelcast/src/integration-test/java/org/springframework/session/hazelcast/AbstractHazelcastIndexedSessionRepositoryITests.java

@@ -30,17 +30,17 @@ import org.springframework.security.core.context.SecurityContext;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.session.FindByIndexNameSessionRepository;
 import org.springframework.session.MapSession;
-import org.springframework.session.hazelcast.HazelcastSessionRepository.HazelcastSession;
+import org.springframework.session.hazelcast.HazelcastIndexedSessionRepository.HazelcastSession;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
- * Abstract base class for Hazelcast integration tests.
+ * Base class for {@link HazelcastIndexedSessionRepository} integration tests.
  *
  * @author Tommy Ludwig
  * @author Vedran Pavic
  */
-abstract class AbstractHazelcastRepositoryITests {
+abstract class AbstractHazelcastIndexedSessionRepositoryITests {
 
 	private static final String SPRING_SECURITY_CONTEXT = "SPRING_SECURITY_CONTEXT";
 
@@ -48,7 +48,7 @@ abstract class AbstractHazelcastRepositoryITests {
 	private HazelcastInstance hazelcastInstance;
 
 	@Autowired
-	private HazelcastSessionRepository repository;
+	private HazelcastIndexedSessionRepository repository;
 
 	@Test
 	void createAndDestroySession() {
@@ -56,7 +56,7 @@ abstract class AbstractHazelcastRepositoryITests {
 		String sessionId = sessionToSave.getId();
 
 		IMap<String, MapSession> hazelcastMap = this.hazelcastInstance
-				.getMap(HazelcastSessionRepository.DEFAULT_SESSION_MAP_NAME);
+				.getMap(HazelcastIndexedSessionRepository.DEFAULT_SESSION_MAP_NAME);
 
 		assertThat(hazelcastMap.size()).isEqualTo(0);
 

spring-session-hazelcast/src/integration-test/java/org/springframework/session/hazelcast/ClientServerHazelcastIndexedSessionRepositoryITests.java

@@ -35,17 +35,16 @@ import org.springframework.test.context.junit.jupiter.SpringExtension;
 import org.springframework.test.context.web.WebAppConfiguration;
 
 /**
- * Integration tests that check the underlying data source - in this case Hazelcast
- * Client.
+ * Integration tests for {@link HazelcastIndexedSessionRepository} using client-server
+ * topology.
  *
  * @author Vedran Pavic
  * @author Artem Bilan
- * @since 1.1
  */
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration
 @WebAppConfiguration
-class HazelcastClientRepositoryITests extends AbstractHazelcastRepositoryITests {
+class ClientServerHazelcastIndexedSessionRepositoryITests extends AbstractHazelcastIndexedSessionRepositoryITests {
 
 	private static GenericContainer container = new GenericContainer<>("hazelcast/hazelcast:3.12.2")
 			.withExposedPorts(5701).withEnv("JAVA_OPTS", "-Dhazelcast.config=/opt/hazelcast/config_ext/hazelcast.xml")

spring-session-hazelcast/src/integration-test/java/org/springframework/session/hazelcast/EmbeddedHazelcastIndexedSessionRepositoryITests.java

@@ -27,8 +27,8 @@ import org.springframework.test.context.junit.jupiter.SpringExtension;
 import org.springframework.test.context.web.WebAppConfiguration;
 
 /**
- * Integration tests that check the underlying data source - in this case Hazelcast
- * Server.
+ * Integration tests for {@link HazelcastIndexedSessionRepository} using embedded
+ * topology.
  *
  * @author Tommy Ludwig
  * @author Vedran Pavic
@@ -36,7 +36,7 @@ import org.springframework.test.context.web.WebAppConfiguration;
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration
 @WebAppConfiguration
-class HazelcastServerRepositoryITests extends AbstractHazelcastRepositoryITests {
+class EmbeddedHazelcastIndexedSessionRepositoryITests extends AbstractHazelcastIndexedSessionRepositoryITests {
 
 	@EnableHazelcastHttpSession
 	@Configuration

spring-session-hazelcast/src/integration-test/java/org/springframework/session/hazelcast/HazelcastITestUtils.java

@@ -42,7 +42,7 @@ public final class HazelcastITestUtils {
 	 */
 	public static HazelcastInstance embeddedHazelcastServer(int port) {
 		MapAttributeConfig attributeConfig = new MapAttributeConfig()
-				.setName(HazelcastSessionRepository.PRINCIPAL_NAME_ATTRIBUTE)
+				.setName(HazelcastIndexedSessionRepository.PRINCIPAL_NAME_ATTRIBUTE)
 				.setExtractor(PrincipalNameExtractor.class.getName());
 
 		Config config = new Config();
@@ -53,8 +53,9 @@ public final class HazelcastITestUtils {
 
 		networkConfig.getJoin().getMulticastConfig().setEnabled(false);
 
-		config.getMapConfig(HazelcastSessionRepository.DEFAULT_SESSION_MAP_NAME).addMapAttributeConfig(attributeConfig)
-				.addMapIndexConfig(new MapIndexConfig(HazelcastSessionRepository.PRINCIPAL_NAME_ATTRIBUTE, false));
+		config.getMapConfig(HazelcastIndexedSessionRepository.DEFAULT_SESSION_MAP_NAME)
+				.addMapAttributeConfig(attributeConfig).addMapIndexConfig(
+						new MapIndexConfig(HazelcastIndexedSessionRepository.PRINCIPAL_NAME_ATTRIBUTE, false));
 
 		return Hazelcast.newHazelcastInstance(config);
 	}

spring-session-hazelcast/src/main/java/org/springframework/session/hazelcast/HazelcastIndexedSessionRepository.java

@@ -0,0 +1,469 @@
+/*
+ * 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.hazelcast;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+
+import com.hazelcast.core.EntryEvent;
+import com.hazelcast.core.HazelcastInstance;
+import com.hazelcast.core.IMap;
+import com.hazelcast.map.listener.EntryAddedListener;
+import com.hazelcast.map.listener.EntryEvictedListener;
+import com.hazelcast.map.listener.EntryRemovedListener;
+import com.hazelcast.query.Predicates;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.session.DelegatingIndexResolver;
+import org.springframework.session.FindByIndexNameSessionRepository;
+import org.springframework.session.FlushMode;
+import org.springframework.session.IndexResolver;
+import org.springframework.session.MapSession;
+import org.springframework.session.PrincipalNameIndexResolver;
+import org.springframework.session.SaveMode;
+import org.springframework.session.Session;
+import org.springframework.session.events.AbstractSessionEvent;
+import org.springframework.session.events.SessionCreatedEvent;
+import org.springframework.session.events.SessionDeletedEvent;
+import org.springframework.session.events.SessionExpiredEvent;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+
+/**
+ * A {@link org.springframework.session.SessionRepository} implementation that stores
+ * sessions in Hazelcast's distributed {@link IMap}.
+ *
+ * <p>
+ * An example of how to create a new instance can be seen below:
+ *
+ * <pre class="code">
+ * Config config = new Config();
+ *
+ * // ... configure Hazelcast ...
+ *
+ * HazelcastInstance hazelcastInstance = Hazelcast.newHazelcastInstance(config);
+ *
+ * HazelcastIndexedSessionRepository sessionRepository =
+ *         new HazelcastIndexedSessionRepository(hazelcastInstance);
+ * </pre>
+ *
+ * In order to support finding sessions by principal name using
+ * {@link #findByIndexNameAndIndexValue(String, String)} method, custom configuration of
+ * {@code IMap} supplied to this implementation is required.
+ *
+ * The following snippet demonstrates how to define required configuration using
+ * programmatic Hazelcast Configuration:
+ *
+ * <pre class="code">
+ * MapAttributeConfig attributeConfig = new MapAttributeConfig()
+ *         .setName(HazelcastIndexedSessionRepository.PRINCIPAL_NAME_ATTRIBUTE)
+ *         .setExtractor(PrincipalNameExtractor.class.getName());
+ *
+ * Config config = new Config();
+ *
+ * config.getMapConfig(HazelcastIndexedSessionRepository.DEFAULT_SESSION_MAP_NAME)
+ *         .addMapAttributeConfig(attributeConfig)
+ *         .addMapIndexConfig(new MapIndexConfig(
+ *                 HazelcastIndexedSessionRepository.PRINCIPAL_NAME_ATTRIBUTE, false));
+ *
+ * Hazelcast.newHazelcastInstance(config);
+ * </pre>
+ *
+ * This implementation listens for events on the Hazelcast-backed SessionRepository and
+ * translates those events into the corresponding Spring Session events. Publish the
+ * Spring Session events with the given {@link ApplicationEventPublisher}.
+ *
+ * <ul>
+ * <li>entryAdded - {@link SessionCreatedEvent}</li>
+ * <li>entryEvicted - {@link SessionExpiredEvent}</li>
+ * <li>entryRemoved - {@link SessionDeletedEvent}</li>
+ * </ul>
+ *
+ * @author Vedran Pavic
+ * @author Tommy Ludwig
+ * @author Mark Anderson
+ * @author Aleksandar Stojsavljevic
+ * @since 2.2.0
+ */
+public class HazelcastIndexedSessionRepository
+		implements FindByIndexNameSessionRepository<HazelcastIndexedSessionRepository.HazelcastSession>,
+		EntryAddedListener<String, MapSession>, EntryEvictedListener<String, MapSession>,
+		EntryRemovedListener<String, MapSession> {
+
+	/**
+	 * The default name of map used by Spring Session to store sessions.
+	 */
+	public static final String DEFAULT_SESSION_MAP_NAME = "spring:session:sessions";
+
+	/**
+	 * The principal name custom attribute name.
+	 */
+	public static final String PRINCIPAL_NAME_ATTRIBUTE = "principalName";
+
+	private static final String SPRING_SECURITY_CONTEXT = "SPRING_SECURITY_CONTEXT";
+
+	private static final boolean SUPPORTS_SET_TTL = ClassUtils.hasAtLeastOneMethodWithName(IMap.class, "setTtl");
+
+	private static final Log logger = LogFactory.getLog(HazelcastIndexedSessionRepository.class);
+
+	private final HazelcastInstance hazelcastInstance;
+
+	private final IndexResolver<HazelcastSession> indexResolver;
+
+	private ApplicationEventPublisher eventPublisher = (event) -> {
+	};
+
+	/**
+	 * If non-null, this value is used to override
+	 * {@link MapSession#setMaxInactiveInterval(Duration)}.
+	 */
+	private Integer defaultMaxInactiveInterval;
+
+	private String sessionMapName = DEFAULT_SESSION_MAP_NAME;
+
+	private FlushMode flushMode = FlushMode.ON_SAVE;
+
+	private SaveMode saveMode = SaveMode.ON_SET_ATTRIBUTE;
+
+	private IMap<String, MapSession> sessions;
+
+	private String sessionListenerId;
+
+	/**
+	 * Create a new {@link HazelcastIndexedSessionRepository} instance.
+	 * @param hazelcastInstance the {@link HazelcastInstance} to use for managing sessions
+	 */
+	public HazelcastIndexedSessionRepository(HazelcastInstance hazelcastInstance) {
+		Assert.notNull(hazelcastInstance, "HazelcastInstance must not be null");
+		this.hazelcastInstance = hazelcastInstance;
+		this.indexResolver = new DelegatingIndexResolver<>(new PrincipalNameIndexResolver<>());
+	}
+
+	@PostConstruct
+	public void init() {
+		this.sessions = this.hazelcastInstance.getMap(this.sessionMapName);
+		this.sessionListenerId = this.sessions.addEntryListener(this, true);
+	}
+
+	@PreDestroy
+	public void close() {
+		this.sessions.removeEntryListener(this.sessionListenerId);
+	}
+
+	/**
+	 * Sets the {@link ApplicationEventPublisher} that is used to publish
+	 * {@link AbstractSessionEvent session events}. The default is to not publish session
+	 * events.
+	 * @param applicationEventPublisher the {@link ApplicationEventPublisher} that is used
+	 * to publish session events. Cannot be null.
+	 */
+	public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
+		Assert.notNull(applicationEventPublisher, "ApplicationEventPublisher cannot be null");
+		this.eventPublisher = applicationEventPublisher;
+	}
+
+	/**
+	 * Set the maximum inactive interval in seconds between requests before newly created
+	 * sessions will be invalidated. A negative time indicates that the session will never
+	 * timeout. The default is 1800 (30 minutes).
+	 * @param defaultMaxInactiveInterval the maximum inactive interval in seconds
+	 */
+	public void setDefaultMaxInactiveInterval(Integer defaultMaxInactiveInterval) {
+		this.defaultMaxInactiveInterval = defaultMaxInactiveInterval;
+	}
+
+	/**
+	 * Set the name of map used to store sessions.
+	 * @param sessionMapName the session map name
+	 */
+	public void setSessionMapName(String sessionMapName) {
+		Assert.hasText(sessionMapName, "Map name must not be empty");
+		this.sessionMapName = sessionMapName;
+	}
+
+	/**
+	 * Sets the Hazelcast flush mode. Default flush mode is {@link FlushMode#ON_SAVE}.
+	 * @param flushMode the new Hazelcast flush mode
+	 */
+	public void setFlushMode(FlushMode flushMode) {
+		Assert.notNull(flushMode, "flushMode cannot be null");
+		this.flushMode = flushMode;
+	}
+
+	/**
+	 * Set the save mode.
+	 * @param saveMode the save mode
+	 */
+	public void setSaveMode(SaveMode saveMode) {
+		Assert.notNull(saveMode, "saveMode must not be null");
+		this.saveMode = saveMode;
+	}
+
+	@Override
+	public HazelcastSession createSession() {
+		MapSession cached = new MapSession();
+		if (this.defaultMaxInactiveInterval != null) {
+			cached.setMaxInactiveInterval(Duration.ofSeconds(this.defaultMaxInactiveInterval));
+		}
+		HazelcastSession session = new HazelcastSession(cached, true);
+		session.flushImmediateIfNecessary();
+		return session;
+	}
+
+	@Override
+	public void save(HazelcastSession session) {
+		if (session.isNew) {
+			this.sessions.set(session.getId(), session.getDelegate(), session.getMaxInactiveInterval().getSeconds(),
+					TimeUnit.SECONDS);
+		}
+		else if (session.sessionIdChanged) {
+			this.sessions.delete(session.originalId);
+			session.originalId = session.getId();
+			this.sessions.set(session.getId(), session.getDelegate(), session.getMaxInactiveInterval().getSeconds(),
+					TimeUnit.SECONDS);
+		}
+		else if (session.hasChanges()) {
+			SessionUpdateEntryProcessor entryProcessor = new SessionUpdateEntryProcessor();
+			if (session.lastAccessedTimeChanged) {
+				entryProcessor.setLastAccessedTime(session.getLastAccessedTime());
+			}
+			if (session.maxInactiveIntervalChanged) {
+				if (SUPPORTS_SET_TTL) {
+					updateTtl(session);
+				}
+				entryProcessor.setMaxInactiveInterval(session.getMaxInactiveInterval());
+			}
+			if (!session.delta.isEmpty()) {
+				entryProcessor.setDelta(new HashMap<>(session.delta));
+			}
+			this.sessions.executeOnKey(session.getId(), entryProcessor);
+		}
+		session.clearChangeFlags();
+	}
+
+	private void updateTtl(HazelcastSession session) {
+		this.sessions.setTtl(session.getId(), session.getMaxInactiveInterval().getSeconds(), TimeUnit.SECONDS);
+	}
+
+	@Override
+	public HazelcastSession findById(String id) {
+		MapSession saved = this.sessions.get(id);
+		if (saved == null) {
+			return null;
+		}
+		if (saved.isExpired()) {
+			deleteById(saved.getId());
+			return null;
+		}
+		return new HazelcastSession(saved, false);
+	}
+
+	@Override
+	public void deleteById(String id) {
+		this.sessions.remove(id);
+	}
+
+	@Override
+	public Map<String, HazelcastSession> findByIndexNameAndIndexValue(String indexName, String indexValue) {
+		if (!PRINCIPAL_NAME_INDEX_NAME.equals(indexName)) {
+			return Collections.emptyMap();
+		}
+		Collection<MapSession> sessions = this.sessions.values(Predicates.equal(PRINCIPAL_NAME_ATTRIBUTE, indexValue));
+		Map<String, HazelcastSession> sessionMap = new HashMap<>(sessions.size());
+		for (MapSession session : sessions) {
+			sessionMap.put(session.getId(), new HazelcastSession(session, false));
+		}
+		return sessionMap;
+	}
+
+	@Override
+	public void entryAdded(EntryEvent<String, MapSession> event) {
+		MapSession session = event.getValue();
+		if (session.getId().equals(session.getOriginalId())) {
+			if (logger.isDebugEnabled()) {
+				logger.debug("Session created with id: " + session.getId());
+			}
+			this.eventPublisher.publishEvent(new SessionCreatedEvent(this, session));
+		}
+	}
+
+	@Override
+	public void entryEvicted(EntryEvent<String, MapSession> event) {
+		if (logger.isDebugEnabled()) {
+			logger.debug("Session expired with id: " + event.getOldValue().getId());
+		}
+		this.eventPublisher.publishEvent(new SessionExpiredEvent(this, event.getOldValue()));
+	}
+
+	@Override
+	public void entryRemoved(EntryEvent<String, MapSession> event) {
+		MapSession session = event.getOldValue();
+		if (session != null) {
+			if (logger.isDebugEnabled()) {
+				logger.debug("Session deleted with id: " + session.getId());
+			}
+			this.eventPublisher.publishEvent(new SessionDeletedEvent(this, session));
+		}
+	}
+
+	/**
+	 * A custom implementation of {@link Session} that uses a {@link MapSession} as the
+	 * basis for its mapping. It keeps track if changes have been made since last save.
+	 *
+	 * @author Aleksandar Stojsavljevic
+	 */
+	final class HazelcastSession implements Session {
+
+		private final MapSession delegate;
+
+		private boolean isNew;
+
+		private boolean sessionIdChanged;
+
+		private boolean lastAccessedTimeChanged;
+
+		private boolean maxInactiveIntervalChanged;
+
+		private String originalId;
+
+		private Map<String, Object> delta = new HashMap<>();
+
+		HazelcastSession(MapSession cached, boolean isNew) {
+			this.delegate = cached;
+			this.isNew = isNew;
+			this.originalId = cached.getId();
+			if (this.isNew || (HazelcastIndexedSessionRepository.this.saveMode == SaveMode.ALWAYS)) {
+				getAttributeNames()
+						.forEach((attributeName) -> this.delta.put(attributeName, cached.getAttribute(attributeName)));
+			}
+		}
+
+		@Override
+		public void setLastAccessedTime(Instant lastAccessedTime) {
+			this.delegate.setLastAccessedTime(lastAccessedTime);
+			this.lastAccessedTimeChanged = true;
+			flushImmediateIfNecessary();
+		}
+
+		@Override
+		public boolean isExpired() {
+			return this.delegate.isExpired();
+		}
+
+		@Override
+		public Instant getCreationTime() {
+			return this.delegate.getCreationTime();
+		}
+
+		@Override
+		public String getId() {
+			return this.delegate.getId();
+		}
+
+		@Override
+		public String changeSessionId() {
+			String newSessionId = this.delegate.changeSessionId();
+			this.sessionIdChanged = true;
+			return newSessionId;
+		}
+
+		@Override
+		public Instant getLastAccessedTime() {
+			return this.delegate.getLastAccessedTime();
+		}
+
+		@Override
+		public void setMaxInactiveInterval(Duration interval) {
+			this.delegate.setMaxInactiveInterval(interval);
+			this.maxInactiveIntervalChanged = true;
+			flushImmediateIfNecessary();
+		}
+
+		@Override
+		public Duration getMaxInactiveInterval() {
+			return this.delegate.getMaxInactiveInterval();
+		}
+
+		@Override
+		public <T> T getAttribute(String attributeName) {
+			T attributeValue = this.delegate.getAttribute(attributeName);
+			if (attributeValue != null
+					&& HazelcastIndexedSessionRepository.this.saveMode.equals(SaveMode.ON_GET_ATTRIBUTE)) {
+				this.delta.put(attributeName, attributeValue);
+			}
+			return attributeValue;
+		}
+
+		@Override
+		public Set<String> getAttributeNames() {
+			return this.delegate.getAttributeNames();
+		}
+
+		@Override
+		public void setAttribute(String attributeName, Object attributeValue) {
+			this.delegate.setAttribute(attributeName, attributeValue);
+			this.delta.put(attributeName, attributeValue);
+			if (SPRING_SECURITY_CONTEXT.equals(attributeName)) {
+				Map<String, String> indexes = HazelcastIndexedSessionRepository.this.indexResolver
+						.resolveIndexesFor(this);
+				String principal = (attributeValue != null) ? indexes.get(PRINCIPAL_NAME_INDEX_NAME) : null;
+				this.delegate.setAttribute(PRINCIPAL_NAME_INDEX_NAME, principal);
+			}
+			flushImmediateIfNecessary();
+		}
+
+		@Override
+		public void removeAttribute(String attributeName) {
+			setAttribute(attributeName, null);
+		}
+
+		MapSession getDelegate() {
+			return this.delegate;
+		}
+
+		boolean hasChanges() {
+			return (this.lastAccessedTimeChanged || this.maxInactiveIntervalChanged || !this.delta.isEmpty());
+		}
+
+		void clearChangeFlags() {
+			this.isNew = false;
+			this.lastAccessedTimeChanged = false;
+			this.sessionIdChanged = false;
+			this.maxInactiveIntervalChanged = false;
+			this.delta.clear();
+		}
+
+		private void flushImmediateIfNecessary() {
+			if (HazelcastIndexedSessionRepository.this.flushMode == FlushMode.IMMEDIATE) {
+				HazelcastIndexedSessionRepository.this.save(this);
+			}
+		}
+
+	}
+
+}

spring-session-hazelcast/src/main/java/org/springframework/session/hazelcast/HazelcastSessionRepository.java

@@ -16,190 +16,33 @@
 
 package org.springframework.session.hazelcast;
 
-import java.time.Duration;
-import java.time.Instant;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.TimeUnit;
-
-import javax.annotation.PostConstruct;
-import javax.annotation.PreDestroy;
-
-import com.hazelcast.core.EntryEvent;
 import com.hazelcast.core.HazelcastInstance;
-import com.hazelcast.core.IMap;
-import com.hazelcast.map.listener.EntryAddedListener;
-import com.hazelcast.map.listener.EntryEvictedListener;
-import com.hazelcast.map.listener.EntryRemovedListener;
-import com.hazelcast.query.Predicates;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.session.DelegatingIndexResolver;
-import org.springframework.session.FindByIndexNameSessionRepository;
 import org.springframework.session.FlushMode;
-import org.springframework.session.IndexResolver;
-import org.springframework.session.MapSession;
-import org.springframework.session.PrincipalNameIndexResolver;
-import org.springframework.session.SaveMode;
-import org.springframework.session.Session;
-import org.springframework.session.events.AbstractSessionEvent;
-import org.springframework.session.events.SessionCreatedEvent;
-import org.springframework.session.events.SessionDeletedEvent;
-import org.springframework.session.events.SessionExpiredEvent;
+import org.springframework.session.SessionRepository;
 import org.springframework.util.Assert;
-import org.springframework.util.ClassUtils;
 
 /**
- * A {@link org.springframework.session.SessionRepository} implementation that stores
- * sessions in Hazelcast's distributed {@link IMap}.
- *
- * <p>
- * An example of how to create a new instance can be seen below:
- *
- * <pre class="code">
- * Config config = new Config();
- *
- * // ... configure Hazelcast ...
- *
- * HazelcastInstance hazelcastInstance = Hazelcast.newHazelcastInstance(config);
- *
- * HazelcastSessionRepository sessionRepository =
- *         new HazelcastSessionRepository(hazelcastInstance);
- * </pre>
- *
- * In order to support finding sessions by principal name using
- * {@link #findByIndexNameAndIndexValue(String, String)} method, custom configuration of
- * {@code IMap} supplied to this implementation is required.
- *
- * The following snippet demonstrates how to define required configuration using
- * programmatic Hazelcast Configuration:
- *
- * <pre class="code">
- * MapAttributeConfig attributeConfig = new MapAttributeConfig()
- *         .setName(HazelcastSessionRepository.PRINCIPAL_NAME_ATTRIBUTE)
- *         .setExtractor(PrincipalNameExtractor.class.getName());
- *
- * Config config = new Config();
- *
- * config.getMapConfig(HazelcastSessionRepository.DEFAULT_SESSION_MAP_NAME)
- *         .addMapAttributeConfig(attributeConfig)
- *         .addMapIndexConfig(new MapIndexConfig(
- *                 HazelcastSessionRepository.PRINCIPAL_NAME_ATTRIBUTE, false));
- *
- * Hazelcast.newHazelcastInstance(config);
- * </pre>
- *
- * This implementation listens for events on the Hazelcast-backed SessionRepository and
- * translates those events into the corresponding Spring Session events. Publish the
- * Spring Session events with the given {@link ApplicationEventPublisher}.
- *
- * <ul>
- * <li>entryAdded - {@link SessionCreatedEvent}</li>
- * <li>entryEvicted - {@link SessionExpiredEvent}</li>
- * <li>entryRemoved - {@link SessionDeletedEvent}</li>
- * </ul>
+ * This {@link SessionRepository} implementation is kept in order to support migration to
+ * {@link HazelcastIndexedSessionRepository} in a backwards compatible manner.
  *
  * @author Vedran Pavic
  * @author Tommy Ludwig
  * @author Mark Anderson
  * @author Aleksandar Stojsavljevic
  * @since 1.3.0
+ * @deprecated since 2.2.0 in favor of {@link HazelcastIndexedSessionRepository}
  */
-public class HazelcastSessionRepository
-		implements FindByIndexNameSessionRepository<HazelcastSessionRepository.HazelcastSession>,
-		EntryAddedListener<String, MapSession>, EntryEvictedListener<String, MapSession>,
-		EntryRemovedListener<String, MapSession> {
+@Deprecated
+public class HazelcastSessionRepository extends HazelcastIndexedSessionRepository {
 
 	/**
-	 * The default name of map used by Spring Session to store sessions.
+	 * Create a new {@link HazelcastSessionRepository} instance.
+	 * @param hazelcastInstance the {@link HazelcastInstance} to use for managing sessions
+	 * @see HazelcastIndexedSessionRepository#HazelcastIndexedSessionRepository(HazelcastInstance)
 	 */
-	public static final String DEFAULT_SESSION_MAP_NAME = "spring:session:sessions";
-
-	/**
-	 * The principal name custom attribute name.
-	 */
-	public static final String PRINCIPAL_NAME_ATTRIBUTE = "principalName";
-
-	private static final String SPRING_SECURITY_CONTEXT = "SPRING_SECURITY_CONTEXT";
-
-	private static final boolean SUPPORTS_SET_TTL = ClassUtils.hasAtLeastOneMethodWithName(IMap.class, "setTtl");
-
-	private static final Log logger = LogFactory.getLog(HazelcastSessionRepository.class);
-
-	private final HazelcastInstance hazelcastInstance;
-
-	private final IndexResolver<HazelcastSession> indexResolver;
-
-	private ApplicationEventPublisher eventPublisher = (event) -> {
-	};
-
-	/**
-	 * If non-null, this value is used to override
-	 * {@link MapSession#setMaxInactiveInterval(Duration)}.
-	 */
-	private Integer defaultMaxInactiveInterval;
-
-	private String sessionMapName = DEFAULT_SESSION_MAP_NAME;
-
-	private FlushMode flushMode = FlushMode.ON_SAVE;
-
-	private SaveMode saveMode = SaveMode.ON_SET_ATTRIBUTE;
-
-	private IMap<String, MapSession> sessions;
-
-	private String sessionListenerId;
-
 	public HazelcastSessionRepository(HazelcastInstance hazelcastInstance) {
-		Assert.notNull(hazelcastInstance, "HazelcastInstance must not be null");
-		this.hazelcastInstance = hazelcastInstance;
-		this.indexResolver = new DelegatingIndexResolver<>(new PrincipalNameIndexResolver<>());
-	}
-
-	@PostConstruct
-	public void init() {
-		this.sessions = this.hazelcastInstance.getMap(this.sessionMapName);
-		this.sessionListenerId = this.sessions.addEntryListener(this, true);
-	}
-
-	@PreDestroy
-	public void close() {
-		this.sessions.removeEntryListener(this.sessionListenerId);
-	}
-
-	/**
-	 * Sets the {@link ApplicationEventPublisher} that is used to publish
-	 * {@link AbstractSessionEvent session events}. The default is to not publish session
-	 * events.
-	 * @param applicationEventPublisher the {@link ApplicationEventPublisher} that is used
-	 * to publish session events. Cannot be null.
-	 */
-	public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
-		Assert.notNull(applicationEventPublisher, "ApplicationEventPublisher cannot be null");
-		this.eventPublisher = applicationEventPublisher;
-	}
-
-	/**
-	 * Set the maximum inactive interval in seconds between requests before newly created
-	 * sessions will be invalidated. A negative time indicates that the session will never
-	 * timeout. The default is 1800 (30 minutes).
-	 * @param defaultMaxInactiveInterval the maximum inactive interval in seconds
-	 */
-	public void setDefaultMaxInactiveInterval(Integer defaultMaxInactiveInterval) {
-		this.defaultMaxInactiveInterval = defaultMaxInactiveInterval;
-	}
-
-	/**
-	 * Set the name of map used to store sessions.
-	 * @param sessionMapName the session map name
-	 */
-	public void setSessionMapName(String sessionMapName) {
-		Assert.hasText(sessionMapName, "Map name must not be empty");
-		this.sessionMapName = sessionMapName;
+		super(hazelcastInstance);
 	}
 
 	/**
@@ -214,262 +57,4 @@ public class HazelcastSessionRepository
 		setFlushMode(hazelcastFlushMode.getFlushMode());
 	}
 
-	/**
-	 * Sets the Hazelcast flush mode. Default flush mode is {@link FlushMode#ON_SAVE}.
-	 * @param flushMode the new Hazelcast flush mode
-	 */
-	public void setFlushMode(FlushMode flushMode) {
-		Assert.notNull(flushMode, "flushMode cannot be null");
-		this.flushMode = flushMode;
-	}
-
-	/**
-	 * Set the save mode.
-	 * @param saveMode the save mode
-	 */
-	public void setSaveMode(SaveMode saveMode) {
-		Assert.notNull(saveMode, "saveMode must not be null");
-		this.saveMode = saveMode;
-	}
-
-	@Override
-	public HazelcastSession createSession() {
-		MapSession cached = new MapSession();
-		if (this.defaultMaxInactiveInterval != null) {
-			cached.setMaxInactiveInterval(Duration.ofSeconds(this.defaultMaxInactiveInterval));
-		}
-		HazelcastSession session = new HazelcastSession(cached, true);
-		session.flushImmediateIfNecessary();
-		return session;
-	}
-
-	@Override
-	public void save(HazelcastSession session) {
-		if (session.isNew) {
-			this.sessions.set(session.getId(), session.getDelegate(), session.getMaxInactiveInterval().getSeconds(),
-					TimeUnit.SECONDS);
-		}
-		else if (session.sessionIdChanged) {
-			this.sessions.delete(session.originalId);
-			session.originalId = session.getId();
-			this.sessions.set(session.getId(), session.getDelegate(), session.getMaxInactiveInterval().getSeconds(),
-					TimeUnit.SECONDS);
-		}
-		else if (session.hasChanges()) {
-			SessionUpdateEntryProcessor entryProcessor = new SessionUpdateEntryProcessor();
-			if (session.lastAccessedTimeChanged) {
-				entryProcessor.setLastAccessedTime(session.getLastAccessedTime());
-			}
-			if (session.maxInactiveIntervalChanged) {
-				if (SUPPORTS_SET_TTL) {
-					updateTtl(session);
-				}
-				entryProcessor.setMaxInactiveInterval(session.getMaxInactiveInterval());
-			}
-			if (!session.delta.isEmpty()) {
-				entryProcessor.setDelta(new HashMap<>(session.delta));
-			}
-			this.sessions.executeOnKey(session.getId(), entryProcessor);
-		}
-		session.clearChangeFlags();
-	}
-
-	private void updateTtl(HazelcastSession session) {
-		this.sessions.setTtl(session.getId(), session.getMaxInactiveInterval().getSeconds(), TimeUnit.SECONDS);
-	}
-
-	@Override
-	public HazelcastSession findById(String id) {
-		MapSession saved = this.sessions.get(id);
-		if (saved == null) {
-			return null;
-		}
-		if (saved.isExpired()) {
-			deleteById(saved.getId());
-			return null;
-		}
-		return new HazelcastSession(saved, false);
-	}
-
-	@Override
-	public void deleteById(String id) {
-		this.sessions.remove(id);
-	}
-
-	@Override
-	public Map<String, HazelcastSession> findByIndexNameAndIndexValue(String indexName, String indexValue) {
-		if (!PRINCIPAL_NAME_INDEX_NAME.equals(indexName)) {
-			return Collections.emptyMap();
-		}
-		Collection<MapSession> sessions = this.sessions.values(Predicates.equal(PRINCIPAL_NAME_ATTRIBUTE, indexValue));
-		Map<String, HazelcastSession> sessionMap = new HashMap<>(sessions.size());
-		for (MapSession session : sessions) {
-			sessionMap.put(session.getId(), new HazelcastSession(session, false));
-		}
-		return sessionMap;
-	}
-
-	@Override
-	public void entryAdded(EntryEvent<String, MapSession> event) {
-		MapSession session = event.getValue();
-		if (session.getId().equals(session.getOriginalId())) {
-			if (logger.isDebugEnabled()) {
-				logger.debug("Session created with id: " + session.getId());
-			}
-			this.eventPublisher.publishEvent(new SessionCreatedEvent(this, session));
-		}
-	}
-
-	@Override
-	public void entryEvicted(EntryEvent<String, MapSession> event) {
-		if (logger.isDebugEnabled()) {
-			logger.debug("Session expired with id: " + event.getOldValue().getId());
-		}
-		this.eventPublisher.publishEvent(new SessionExpiredEvent(this, event.getOldValue()));
-	}
-
-	@Override
-	public void entryRemoved(EntryEvent<String, MapSession> event) {
-		MapSession session = event.getOldValue();
-		if (session != null) {
-			if (logger.isDebugEnabled()) {
-				logger.debug("Session deleted with id: " + session.getId());
-			}
-			this.eventPublisher.publishEvent(new SessionDeletedEvent(this, session));
-		}
-	}
-
-	/**
-	 * A custom implementation of {@link Session} that uses a {@link MapSession} as the
-	 * basis for its mapping. It keeps track if changes have been made since last save.
-	 *
-	 * @author Aleksandar Stojsavljevic
-	 */
-	final class HazelcastSession implements Session {
-
-		private final MapSession delegate;
-
-		private boolean isNew;
-
-		private boolean sessionIdChanged;
-
-		private boolean lastAccessedTimeChanged;
-
-		private boolean maxInactiveIntervalChanged;
-
-		private String originalId;
-
-		private Map<String, Object> delta = new HashMap<>();
-
-		HazelcastSession(MapSession cached, boolean isNew) {
-			this.delegate = cached;
-			this.isNew = isNew;
-			this.originalId = cached.getId();
-			if (this.isNew || (HazelcastSessionRepository.this.saveMode == SaveMode.ALWAYS)) {
-				getAttributeNames()
-						.forEach((attributeName) -> this.delta.put(attributeName, cached.getAttribute(attributeName)));
-			}
-		}
-
-		@Override
-		public void setLastAccessedTime(Instant lastAccessedTime) {
-			this.delegate.setLastAccessedTime(lastAccessedTime);
-			this.lastAccessedTimeChanged = true;
-			flushImmediateIfNecessary();
-		}
-
-		@Override
-		public boolean isExpired() {
-			return this.delegate.isExpired();
-		}
-
-		@Override
-		public Instant getCreationTime() {
-			return this.delegate.getCreationTime();
-		}
-
-		@Override
-		public String getId() {
-			return this.delegate.getId();
-		}
-
-		@Override
-		public String changeSessionId() {
-			String newSessionId = this.delegate.changeSessionId();
-			this.sessionIdChanged = true;
-			return newSessionId;
-		}
-
-		@Override
-		public Instant getLastAccessedTime() {
-			return this.delegate.getLastAccessedTime();
-		}
-
-		@Override
-		public void setMaxInactiveInterval(Duration interval) {
-			this.delegate.setMaxInactiveInterval(interval);
-			this.maxInactiveIntervalChanged = true;
-			flushImmediateIfNecessary();
-		}
-
-		@Override
-		public Duration getMaxInactiveInterval() {
-			return this.delegate.getMaxInactiveInterval();
-		}
-
-		@Override
-		public <T> T getAttribute(String attributeName) {
-			T attributeValue = this.delegate.getAttribute(attributeName);
-			if (attributeValue != null && HazelcastSessionRepository.this.saveMode.equals(SaveMode.ON_GET_ATTRIBUTE)) {
-				this.delta.put(attributeName, attributeValue);
-			}
-			return attributeValue;
-		}
-
-		@Override
-		public Set<String> getAttributeNames() {
-			return this.delegate.getAttributeNames();
-		}
-
-		@Override
-		public void setAttribute(String attributeName, Object attributeValue) {
-			this.delegate.setAttribute(attributeName, attributeValue);
-			this.delta.put(attributeName, attributeValue);
-			if (SPRING_SECURITY_CONTEXT.equals(attributeName)) {
-				Map<String, String> indexes = HazelcastSessionRepository.this.indexResolver.resolveIndexesFor(this);
-				String principal = (attributeValue != null) ? indexes.get(PRINCIPAL_NAME_INDEX_NAME) : null;
-				this.delegate.setAttribute(PRINCIPAL_NAME_INDEX_NAME, principal);
-			}
-			flushImmediateIfNecessary();
-		}
-
-		@Override
-		public void removeAttribute(String attributeName) {
-			setAttribute(attributeName, null);
-		}
-
-		MapSession getDelegate() {
-			return this.delegate;
-		}
-
-		boolean hasChanges() {
-			return (this.lastAccessedTimeChanged || this.maxInactiveIntervalChanged || !this.delta.isEmpty());
-		}
-
-		void clearChangeFlags() {
-			this.isNew = false;
-			this.lastAccessedTimeChanged = false;
-			this.sessionIdChanged = false;
-			this.maxInactiveIntervalChanged = false;
-			this.delta.clear();
-		}
-
-		private void flushImmediateIfNecessary() {
-			if (HazelcastSessionRepository.this.flushMode == FlushMode.IMMEDIATE) {
-				HazelcastSessionRepository.this.save(this);
-			}
-		}
-
-	}
-
 }

spring-session-hazelcast/src/main/java/org/springframework/session/hazelcast/SessionUpdateEntryProcessor.java

@@ -25,13 +25,14 @@ import com.hazelcast.map.AbstractEntryProcessor;
 import com.hazelcast.map.EntryProcessor;
 
 import org.springframework.session.MapSession;
+import org.springframework.session.hazelcast.HazelcastIndexedSessionRepository.HazelcastSession;
 
 /**
  * Hazelcast {@link EntryProcessor} responsible for handling updates to session.
  *
  * @author Vedran Pavic
  * @since 1.3.4
- * @see HazelcastSessionRepository#save(HazelcastSessionRepository.HazelcastSession)
+ * @see HazelcastIndexedSessionRepository#save(HazelcastSession)
  */
 public class SessionUpdateEntryProcessor extends AbstractEntryProcessor<String, MapSession> implements Offloadable {
 

spring-session-hazelcast/src/main/java/org/springframework/session/hazelcast/config/annotation/SpringSessionHazelcastInstance.java

@@ -25,11 +25,11 @@ import java.lang.annotation.Target;
 import com.hazelcast.core.HazelcastInstance;
 
 import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.session.hazelcast.HazelcastSessionRepository;
+import org.springframework.session.hazelcast.HazelcastIndexedSessionRepository;
 
 /**
  * Qualifier annotation for a {@link HazelcastInstance} to be injected in
- * {@link HazelcastSessionRepository}.
+ * {@link HazelcastIndexedSessionRepository}.
  *
  * @author Vedran Pavic
  * @since 2.0.0

spring-session-hazelcast/src/main/java/org/springframework/session/hazelcast/config/annotation/web/http/EnableHazelcastHttpSession.java

@@ -33,7 +33,7 @@ import org.springframework.session.Session;
 import org.springframework.session.SessionRepository;
 import org.springframework.session.config.annotation.web.http.EnableSpringHttpSession;
 import org.springframework.session.hazelcast.HazelcastFlushMode;
-import org.springframework.session.hazelcast.HazelcastSessionRepository;
+import org.springframework.session.hazelcast.HazelcastIndexedSessionRepository;
 import org.springframework.session.web.http.SessionRepositoryFilter;
 
 /**
@@ -81,10 +81,11 @@ public @interface EnableHazelcastHttpSession {
 
 	/**
 	 * This is the name of the Map that will be used in Hazelcast to store the session
-	 * data. Default is {@link HazelcastSessionRepository#DEFAULT_SESSION_MAP_NAME}.
+	 * data. Default is
+	 * {@link HazelcastIndexedSessionRepository#DEFAULT_SESSION_MAP_NAME}.
 	 * @return the name of the Map to store the sessions in Hazelcast
 	 */
-	String sessionMapName() default HazelcastSessionRepository.DEFAULT_SESSION_MAP_NAME;
+	String sessionMapName() default HazelcastIndexedSessionRepository.DEFAULT_SESSION_MAP_NAME;
 
 	/**
 	 * Flush mode for the Hazelcast sessions. The default is {@code ON_SAVE} which only

spring-session-hazelcast/src/main/java/org/springframework/session/hazelcast/config/annotation/web/http/HazelcastHttpSessionConfiguration.java

@@ -36,7 +36,7 @@ import org.springframework.session.SaveMode;
 import org.springframework.session.config.SessionRepositoryCustomizer;
 import org.springframework.session.config.annotation.web.http.SpringHttpSessionConfiguration;
 import org.springframework.session.hazelcast.HazelcastFlushMode;
-import org.springframework.session.hazelcast.HazelcastSessionRepository;
+import org.springframework.session.hazelcast.HazelcastIndexedSessionRepository;
 import org.springframework.session.hazelcast.config.annotation.SpringSessionHazelcastInstance;
 import org.springframework.session.web.http.SessionRepositoryFilter;
 import org.springframework.util.StringUtils;
@@ -56,7 +56,7 @@ public class HazelcastHttpSessionConfiguration extends SpringHttpSessionConfigur
 
 	private Integer maxInactiveIntervalInSeconds = MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS;
 
-	private String sessionMapName = HazelcastSessionRepository.DEFAULT_SESSION_MAP_NAME;
+	private String sessionMapName = HazelcastIndexedSessionRepository.DEFAULT_SESSION_MAP_NAME;
 
 	private FlushMode flushMode = FlushMode.ON_SAVE;
 
@@ -66,11 +66,12 @@ public class HazelcastHttpSessionConfiguration extends SpringHttpSessionConfigur
 
 	private ApplicationEventPublisher applicationEventPublisher;
 
-	private List<SessionRepositoryCustomizer<HazelcastSessionRepository>> sessionRepositoryCustomizers;
+	private List<SessionRepositoryCustomizer<HazelcastIndexedSessionRepository>> sessionRepositoryCustomizers;
 
 	@Bean
-	public HazelcastSessionRepository sessionRepository() {
-		HazelcastSessionRepository sessionRepository = new HazelcastSessionRepository(this.hazelcastInstance);
+	public HazelcastIndexedSessionRepository sessionRepository() {
+		HazelcastIndexedSessionRepository sessionRepository = new HazelcastIndexedSessionRepository(
+				this.hazelcastInstance);
 		sessionRepository.setApplicationEventPublisher(this.applicationEventPublisher);
 		if (StringUtils.hasText(this.sessionMapName)) {
 			sessionRepository.setSessionMapName(this.sessionMapName);
@@ -122,7 +123,7 @@ public class HazelcastHttpSessionConfiguration extends SpringHttpSessionConfigur
 
 	@Autowired(required = false)
 	public void setSessionRepositoryCustomizer(
-			ObjectProvider<SessionRepositoryCustomizer<HazelcastSessionRepository>> sessionRepositoryCustomizers) {
+			ObjectProvider<SessionRepositoryCustomizer<HazelcastIndexedSessionRepository>> sessionRepositoryCustomizers) {
 		this.sessionRepositoryCustomizers = sessionRepositoryCustomizers.orderedStream().collect(Collectors.toList());
 	}
 

spring-session-hazelcast/src/test/java/org/springframework/session/hazelcast/HazelcastIndexedSessionRepositoryTests.java

@@ -39,7 +39,7 @@ import org.springframework.session.FindByIndexNameSessionRepository;
 import org.springframework.session.FlushMode;
 import org.springframework.session.MapSession;
 import org.springframework.session.SaveMode;
-import org.springframework.session.hazelcast.HazelcastSessionRepository.HazelcastSession;
+import org.springframework.session.hazelcast.HazelcastIndexedSessionRepository.HazelcastSession;
 import org.springframework.test.util.ReflectionTestUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -57,12 +57,12 @@ import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;
 
 /**
- * Tests for {@link HazelcastSessionRepository}.
+ * Tests for {@link HazelcastIndexedSessionRepository}.
  *
  * @author Vedran Pavic
  * @author Aleksandar Stojsavljevic
  */
-class HazelcastSessionRepositoryTests {
+class HazelcastIndexedSessionRepositoryTests {
 
 	private static final String SPRING_SECURITY_CONTEXT = "SPRING_SECURITY_CONTEXT";
 
@@ -71,18 +71,18 @@ class HazelcastSessionRepositoryTests {
 	@SuppressWarnings("unchecked")
 	private IMap<String, MapSession> sessions = mock(IMap.class);
 
-	private HazelcastSessionRepository repository;
+	private HazelcastIndexedSessionRepository repository;
 
 	@BeforeEach
 	void setUp() {
 		given(this.hazelcastInstance.<String, MapSession>getMap(anyString())).willReturn(this.sessions);
-		this.repository = new HazelcastSessionRepository(this.hazelcastInstance);
+		this.repository = new HazelcastIndexedSessionRepository(this.hazelcastInstance);
 		this.repository.init();
 	}
 
 	@Test
 	void constructorNullHazelcastInstance() {
-		assertThatIllegalArgumentException().isThrownBy(() -> new HazelcastSessionRepository(null))
+		assertThatIllegalArgumentException().isThrownBy(() -> new HazelcastIndexedSessionRepository(null))
 				.withMessage("HazelcastInstance must not be null");
 	}
 

spring-session-hazelcast/src/test/java/org/springframework/session/hazelcast/config/annotation/web/http/HazelcastHttpSessionConfigurationTests.java

@@ -31,7 +31,7 @@ import org.springframework.session.FlushMode;
 import org.springframework.session.SaveMode;
 import org.springframework.session.config.SessionRepositoryCustomizer;
 import org.springframework.session.hazelcast.HazelcastFlushMode;
-import org.springframework.session.hazelcast.HazelcastSessionRepository;
+import org.springframework.session.hazelcast.HazelcastIndexedSessionRepository;
 import org.springframework.session.hazelcast.config.annotation.SpringSessionHazelcastInstance;
 import org.springframework.test.util.ReflectionTestUtils;
 
@@ -47,7 +47,6 @@ import static org.mockito.Mockito.mock;
  * @author Vedran Pavic
  * @author Aleksandar Stojsavljevic
  */
-@SuppressWarnings("deprecation")
 class HazelcastHttpSessionConfigurationTests {
 
 	private static final String MAP_NAME = "spring:test:sessions";
@@ -74,14 +73,14 @@ class HazelcastHttpSessionConfigurationTests {
 	void defaultConfiguration() {
 		registerAndRefresh(DefaultConfiguration.class);
 
-		assertThat(this.context.getBean(HazelcastSessionRepository.class)).isNotNull();
+		assertThat(this.context.getBean(HazelcastIndexedSessionRepository.class)).isNotNull();
 	}
 
 	@Test
 	void customTableName() {
 		registerAndRefresh(CustomSessionMapNameConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository repository = this.context.getBean(HazelcastIndexedSessionRepository.class);
 		HazelcastHttpSessionConfiguration configuration = this.context.getBean(HazelcastHttpSessionConfiguration.class);
 		assertThat(repository).isNotNull();
 		assertThat(ReflectionTestUtils.getField(configuration, "sessionMapName")).isEqualTo(MAP_NAME);
@@ -91,7 +90,7 @@ class HazelcastHttpSessionConfigurationTests {
 	void setCustomSessionMapName() {
 		registerAndRefresh(BaseConfiguration.class, CustomSessionMapNameSetConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository repository = this.context.getBean(HazelcastIndexedSessionRepository.class);
 		HazelcastHttpSessionConfiguration configuration = this.context.getBean(HazelcastHttpSessionConfiguration.class);
 		assertThat(repository).isNotNull();
 		assertThat(ReflectionTestUtils.getField(configuration, "sessionMapName")).isEqualTo(MAP_NAME);
@@ -101,7 +100,7 @@ class HazelcastHttpSessionConfigurationTests {
 	void setCustomMaxInactiveIntervalInSeconds() {
 		registerAndRefresh(BaseConfiguration.class, CustomMaxInactiveIntervalInSecondsSetConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository repository = this.context.getBean(HazelcastIndexedSessionRepository.class);
 		assertThat(repository).isNotNull();
 		assertThat(ReflectionTestUtils.getField(repository, "defaultMaxInactiveInterval"))
 				.isEqualTo(MAX_INACTIVE_INTERVAL_IN_SECONDS);
@@ -111,7 +110,7 @@ class HazelcastHttpSessionConfigurationTests {
 	void customMaxInactiveIntervalInSeconds() {
 		registerAndRefresh(CustomMaxInactiveIntervalInSecondsConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository repository = this.context.getBean(HazelcastIndexedSessionRepository.class);
 		assertThat(repository).isNotNull();
 		assertThat(ReflectionTestUtils.getField(repository, "defaultMaxInactiveInterval"))
 				.isEqualTo(MAX_INACTIVE_INTERVAL_IN_SECONDS);
@@ -121,7 +120,7 @@ class HazelcastHttpSessionConfigurationTests {
 	void customFlushImmediately() {
 		registerAndRefresh(CustomFlushImmediatelyConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository repository = this.context.getBean(HazelcastIndexedSessionRepository.class);
 		assertThat(repository).isNotNull();
 		assertThat(ReflectionTestUtils.getField(repository, "flushMode")).isEqualTo(FlushMode.IMMEDIATE);
 	}
@@ -130,7 +129,7 @@ class HazelcastHttpSessionConfigurationTests {
 	void customFlushImmediatelyLegacy() {
 		registerAndRefresh(CustomFlushImmediatelyLegacyConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository repository = this.context.getBean(HazelcastIndexedSessionRepository.class);
 		assertThat(repository).isNotNull();
 		assertThat(ReflectionTestUtils.getField(repository, "flushMode")).isEqualTo(FlushMode.IMMEDIATE);
 	}
@@ -139,7 +138,7 @@ class HazelcastHttpSessionConfigurationTests {
 	void setCustomFlushImmediately() {
 		registerAndRefresh(BaseConfiguration.class, CustomFlushImmediatelySetConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository repository = this.context.getBean(HazelcastIndexedSessionRepository.class);
 		assertThat(repository).isNotNull();
 		assertThat(ReflectionTestUtils.getField(repository, "flushMode")).isEqualTo(FlushMode.IMMEDIATE);
 	}
@@ -148,7 +147,7 @@ class HazelcastHttpSessionConfigurationTests {
 	void setCustomFlushImmediatelyLegacy() {
 		registerAndRefresh(BaseConfiguration.class, CustomFlushImmediatelySetLegacyConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository repository = this.context.getBean(HazelcastIndexedSessionRepository.class);
 		assertThat(repository).isNotNull();
 		assertThat(ReflectionTestUtils.getField(repository, "flushMode")).isEqualTo(FlushMode.IMMEDIATE);
 	}
@@ -156,22 +155,22 @@ class HazelcastHttpSessionConfigurationTests {
 	@Test
 	void customSaveModeAnnotation() {
 		registerAndRefresh(BaseConfiguration.class, CustomSaveModeExpressionAnnotationConfiguration.class);
-		assertThat(this.context.getBean(HazelcastSessionRepository.class)).hasFieldOrPropertyWithValue("saveMode",
-				SaveMode.ALWAYS);
+		assertThat(this.context.getBean(HazelcastIndexedSessionRepository.class))
+				.hasFieldOrPropertyWithValue("saveMode", SaveMode.ALWAYS);
 	}
 
 	@Test
 	void customSaveModeSetter() {
 		registerAndRefresh(BaseConfiguration.class, CustomSaveModeExpressionSetterConfiguration.class);
-		assertThat(this.context.getBean(HazelcastSessionRepository.class)).hasFieldOrPropertyWithValue("saveMode",
-				SaveMode.ALWAYS);
+		assertThat(this.context.getBean(HazelcastIndexedSessionRepository.class))
+				.hasFieldOrPropertyWithValue("saveMode", SaveMode.ALWAYS);
 	}
 
 	@Test
 	void qualifiedHazelcastInstanceConfiguration() {
 		registerAndRefresh(QualifiedHazelcastInstanceConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository repository = this.context.getBean(HazelcastIndexedSessionRepository.class);
 		HazelcastInstance hazelcastInstance = this.context.getBean("qualifiedHazelcastInstance",
 				HazelcastInstance.class);
 		assertThat(repository).isNotNull();
@@ -184,7 +183,7 @@ class HazelcastHttpSessionConfigurationTests {
 	void primaryHazelcastInstanceConfiguration() {
 		registerAndRefresh(PrimaryHazelcastInstanceConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository repository = this.context.getBean(HazelcastIndexedSessionRepository.class);
 		HazelcastInstance hazelcastInstance = this.context.getBean("primaryHazelcastInstance", HazelcastInstance.class);
 		assertThat(repository).isNotNull();
 		assertThat(hazelcastInstance).isNotNull();
@@ -196,7 +195,7 @@ class HazelcastHttpSessionConfigurationTests {
 	void qualifiedAndPrimaryHazelcastInstanceConfiguration() {
 		registerAndRefresh(QualifiedAndPrimaryHazelcastInstanceConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository repository = this.context.getBean(HazelcastIndexedSessionRepository.class);
 		HazelcastInstance hazelcastInstance = this.context.getBean("qualifiedHazelcastInstance",
 				HazelcastInstance.class);
 		assertThat(repository).isNotNull();
@@ -209,7 +208,7 @@ class HazelcastHttpSessionConfigurationTests {
 	void namedHazelcastInstanceConfiguration() {
 		registerAndRefresh(NamedHazelcastInstanceConfiguration.class);
 
-		HazelcastSessionRepository repository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository repository = this.context.getBean(HazelcastIndexedSessionRepository.class);
 		HazelcastInstance hazelcastInstance = this.context.getBean("hazelcastInstance", HazelcastInstance.class);
 		assertThat(repository).isNotNull();
 		assertThat(hazelcastInstance).isNotNull();
@@ -227,7 +226,8 @@ class HazelcastHttpSessionConfigurationTests {
 	@Test
 	void sessionRepositoryCustomizer() {
 		registerAndRefresh(SessionRepositoryCustomizerConfiguration.class);
-		HazelcastSessionRepository sessionRepository = this.context.getBean(HazelcastSessionRepository.class);
+		HazelcastIndexedSessionRepository sessionRepository = this.context
+				.getBean(HazelcastIndexedSessionRepository.class);
 		assertThat(sessionRepository).hasFieldOrPropertyWithValue("defaultMaxInactiveInterval",
 				MAX_INACTIVE_INTERVAL_IN_SECONDS);
 	}
@@ -303,6 +303,7 @@ class HazelcastHttpSessionConfigurationTests {
 	}
 
 	@Configuration
+	@SuppressWarnings("deprecation")
 	static class CustomFlushImmediatelySetLegacyConfiguration extends HazelcastHttpSessionConfiguration {
 
 		CustomFlushImmediatelySetLegacyConfiguration() {
@@ -333,6 +334,7 @@ class HazelcastHttpSessionConfigurationTests {
 
 	@Configuration
 	@EnableHazelcastHttpSession(hazelcastFlushMode = HazelcastFlushMode.IMMEDIATE)
+	@SuppressWarnings("deprecation")
 	static class CustomFlushImmediatelyLegacyConfiguration extends BaseConfiguration {
 
 	}
@@ -436,13 +438,13 @@ class HazelcastHttpSessionConfigurationTests {
 
 		@Bean
 		@Order(0)
-		public SessionRepositoryCustomizer<HazelcastSessionRepository> sessionRepositoryCustomizerOne() {
+		public SessionRepositoryCustomizer<HazelcastIndexedSessionRepository> sessionRepositoryCustomizerOne() {
 			return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(0);
 		}
 
 		@Bean
 		@Order(1)
-		public SessionRepositoryCustomizer<HazelcastSessionRepository> sessionRepositoryCustomizerTwo() {
+		public SessionRepositoryCustomizer<HazelcastIndexedSessionRepository> sessionRepositoryCustomizerTwo() {
 			return (sessionRepository) -> sessionRepository
 					.setDefaultMaxInactiveInterval(MAX_INACTIVE_INTERVAL_IN_SECONDS);
 		}