org.springframework.session.SessionRepository Java Examples

@Test
public void sessionRepositoryExists() {

	assertThat(this.applicationContext.containsBean("sessionRepository")).isTrue();

	SessionRepository<?> sessionRepository =
		this.applicationContext.getBean("sessionRepository", SessionRepository.class);

	assertThat(sessionRepository).isInstanceOf(GemFireOperationsSessionRepository.class);

	GemfireOperations gemfireOperations =
		((GemFireOperationsSessionRepository) sessionRepository).getSessionsTemplate();

	Region<?, ?> sessionRegion =
		this.applicationContext.getBean(GemFireHttpSessionConfiguration.DEFAULT_SESSION_REGION_NAME, Region.class);

	GemfireTemplate sessionRegionTemplate =
		this.applicationContext.getBean("sessionRegionTemplate", GemfireTemplate.class);

	assertThat(gemfireOperations).isInstanceOf(GemfireAccessor.class);
	assertThat(gemfireOperations).isSameAs(sessionRegionTemplate);
	assertThat(((GemfireAccessor) gemfireOperations).getRegion()).isEqualTo(sessionRegion);
}
 

@Test
public void gemfireSessionRegionAndSessionRepositoryAreNotPresent() {

	assertThat(this.applicationContext.containsBean("gemfireCache")).isTrue();
	assertThat(this.applicationContext.containsBean("sessionRepository")).isTrue();
	assertThat(this.applicationContext.containsBean(GemFireHttpSessionConfiguration.DEFAULT_SESSION_REGION_NAME))
		.isFalse();

	GemFireCache gemfireCache = this.applicationContext.getBean(GemFireCache.class);

	assertThat(gemfireCache).isNotNull();
	assertThat(gemfireCache.rootRegions()).isEmpty();

	SessionRepository<?> sessionRepository = this.applicationContext.getBean(SessionRepository.class);

	assertThat(sessionRepository).isNotNull();
	assertThat(sessionRepository).isNotInstanceOf(GemFireOperationsSessionRepository.class);
	assertThat(sessionRepository.getClass().getName().toLowerCase()).doesNotContain("redis");
}
 

@Test(expected = NoSuchBeanDefinitionException.class)
public void gemfireSessionRegionAndSessionRepositoryAreNotPresent() {

	String sessionsRegionName = GemFireHttpSessionConfiguration.DEFAULT_SESSION_REGION_NAME;

	assertThat(this.applicationContext.containsBean("gemfireCache")).isTrue();
	assertThat(this.applicationContext.containsBean("sessionRepository")).isFalse();
	assertThat(this.applicationContext.containsBean(sessionsRegionName)).isFalse();
	assertThat(this.applicationContext.getBeansOfType(SessionRepository.class)).isEmpty();

	GemFireCache gemfireCache = this.applicationContext.getBean(GemFireCache.class);

	assertThat(gemfireCache).isNotNull();
	assertThat(gemfireCache.rootRegions()).isEmpty();

	this.applicationContext.getBean(SessionRepository.class);
}
 

@Test // gh-1229
void doFilterAdapterGetRequestedSessionIdForInvalidSession() throws Exception {
	SessionRepository<MapSession> sessionRepository = new MapSessionRepository(new HashMap<>());

	this.filter = new SessionRepositoryFilter<>(sessionRepository);
	this.filter.setHttpSessionIdResolver(this.strategy);
	final String expectedId = "HttpSessionIdResolver-requested-id1";
	final String otherId = "HttpSessionIdResolver-requested-id2";

	given(this.strategy.resolveSessionIds(any(HttpServletRequest.class)))
			.willReturn(Arrays.asList(expectedId, otherId));

	doFilter(new DoInFilter() {
		@Override
		public void doFilter(HttpServletRequest wrappedRequest, HttpServletResponse wrappedResponse) {
			assertThat(wrappedRequest.getRequestedSessionId()).isEqualTo(expectedId);
			assertThat(wrappedRequest.isRequestedSessionIdValid()).isFalse();
		}
	});
}
 

@Test
void doFilterAdapterGetRequestedSessionId() throws Exception {
	SessionRepository<MapSession> sessionRepository = spy(new MapSessionRepository(new ConcurrentHashMap<>()));

	this.filter = new SessionRepositoryFilter<>(sessionRepository);
	this.filter.setHttpSessionIdResolver(this.strategy);
	final String expectedId = "HttpSessionIdResolver-requested-id";

	given(this.strategy.resolveSessionIds(any(HttpServletRequest.class)))
			.willReturn(Collections.singletonList(expectedId));
	given(sessionRepository.findById(anyString())).willReturn(new MapSession(expectedId));

	doFilter(new DoInFilter() {
		@Override
		public void doFilter(HttpServletRequest wrappedRequest, HttpServletResponse wrappedResponse) {
			String actualId = wrappedRequest.getRequestedSessionId();
			assertThat(actualId).isEqualTo(expectedId);
		}
	});
}
 

@Test
@SuppressWarnings("unused")
void newJdbcIndexedSessionRepository() {
	// tag::new-jdbcindexedsessionrepository[]
	JdbcTemplate jdbcTemplate = new JdbcTemplate();

	// ... configure jdbcTemplate ...

	TransactionTemplate transactionTemplate = new TransactionTemplate();

	// ... configure transactionTemplate ...

	SessionRepository<? extends Session> repository = new JdbcIndexedSessionRepository(jdbcTemplate,
			transactionTemplate);
	// end::new-jdbcindexedsessionrepository[]
}
 

/**
 * Creates a new instance
 *
 * @param sessionRepository the <code>SessionRepository</code> to use. Cannot be null.
 */
public SessionRepositoryFilter(SessionRepository<S> sessionRepository) {
	if(sessionRepository == null) {
		throw new IllegalArgumentException("sessionRepository cannot be null");
	}
	this.sessionRepository = sessionRepository;
}
 

@Test
void defaultConfiguration() {
	registerAndRefresh(DefaultConfiguration.class);

	assertThat(this.context.getBean(SessionEventHttpSessionListenerAdapter.class)).isNotNull();
	assertThat(this.context.getBean(SessionRepositoryFilter.class)).isNotNull();
	assertThat(this.context.getBean(SessionRepository.class)).isNotNull();
}
 

@Test
void doFilterLazySessionCreation() throws Exception {
	SessionRepository<MapSession> sessionRepository = spy(new MapSessionRepository(new ConcurrentHashMap<>()));

	this.filter = new SessionRepositoryFilter<>(sessionRepository);

	doFilter(new DoInFilter() {
		@Override
		public void doFilter(HttpServletRequest wrappedRequest, HttpServletResponse wrappedResponse) {
		}
	});

	verifyZeroInteractions(sessionRepository);
}
 

@Bean
public <S extends Session> SessionRepositoryFilter<? extends Session> springSessionRepositoryFilter(
		SessionRepository<S> sessionRepository) {
	SessionRepositoryFilter<S> sessionRepositoryFilter = new SessionRepositoryFilter<>(sessionRepository);
	sessionRepositoryFilter.setHttpSessionIdResolver(this.httpSessionIdResolver);
	return sessionRepositoryFilter;
}
 

SpringSessionBackedSessionInformation(S session, SessionRepository<S> sessionRepository) {
	super(resolvePrincipal(session), session.getId(), Date.from(session.getLastAccessedTime()));
	this.sessionRepository = sessionRepository;
	Boolean expired = session.getAttribute(EXPIRED_ATTR);
	if (Boolean.TRUE.equals(expired)) {
		super.expireNow();
	}
}
 

/**
 * Creates a new instance.
 * @param sessionRepository the <code>SessionRepository</code> to use. Cannot be null.
 */
public SessionRepositoryFilter(SessionRepository<S> sessionRepository) {
	if (sessionRepository == null) {
		throw new IllegalArgumentException("sessionRepository cannot be null");
	}
	this.sessionRepository = sessionRepository;
}
 

/**
 * Creates a new instance.
 * @param sessionRepository the {@link SessionRepository} to use. Cannot be null.
 */
public SessionRepositoryMessageInterceptor(SessionRepository<S> sessionRepository) {
	Assert.notNull(sessionRepository, "sessionRepository cannot be null");
	this.sessionRepository = sessionRepository;
	this.matchingMessageTypes = EnumSet.of(SimpMessageType.CONNECT, SimpMessageType.MESSAGE,
			SimpMessageType.SUBSCRIBE, SimpMessageType.UNSUBSCRIBE);
}
 

@Test
@SuppressWarnings("unused")
void mapRepository() {
	// tag::new-mapsessionrepository[]
	SessionRepository<? extends Session> repository = new MapSessionRepository(new ConcurrentHashMap<>());
	// end::new-mapsessionrepository[]
}
 

@Test
@SuppressWarnings("unused")
void newRedisIndexedSessionRepository() {
	// tag::new-redisindexedsessionrepository[]
	RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();

	// ... configure redisTemplate ...

	SessionRepository<? extends Session> repository = new RedisIndexedSessionRepository(redisTemplate);
	// end::new-redisindexedsessionrepository[]
}
 

public SpringSessionBackedSessionInformation(ExpiringSession session, SessionRepository<? extends ExpiringSession> sessionRepository) {
    super(resolvePrincipal(session), session.getId(), new Date(session.getLastAccessedTime()));
    this.sessionRepository = sessionRepository;
    if (session.isExpired()) {
        super.expireNow();
    }
}
 

@Test
public void noSessionRepositoryBeanIsPresent() {

	assertThat(this.applicationContext).isNotNull();
	assertThat(this.applicationContext.containsBean("sessionRepository")).isFalse();
	assertThat(this.applicationContext.getBeansOfType(SessionRepository.class)).isEmpty();
}
 

@Bean
SessionRepository<?> sessionRepository() {
	return mock(SessionRepository.class);
}
 

@Bean
SessionRepository sessionRepository() {
	return mock(SessionRepository.class);
}
 

@Bean
public SessionRepository<ExpiringSession> sessionRepository() {
	return new MapSessionRepository();
}