import org.springframework.session.data.redis.RedisOperationsSessionRepository; //导入依赖的package包/类
@Test
public void qualifiedConnectionFactoryRedisConfig() {
	registerAndRefresh(RedisConfig.class,
			QualifiedConnectionFactoryRedisConfig.class);

	RedisOperationsSessionRepository repository = this.context
			.getBean(RedisOperationsSessionRepository.class);
	RedisConnectionFactory redisConnectionFactory = this.context
			.getBean("qualifiedRedisConnectionFactory", RedisConnectionFactory.class);
	assertThat(repository).isNotNull();
	assertThat(redisConnectionFactory).isNotNull();
	RedisOperations redisOperations = (RedisOperations) ReflectionTestUtils
			.getField(repository, "sessionRedisOperations");
	assertThat(redisOperations).isNotNull();
	assertThat(ReflectionTestUtils.getField(redisOperations, "connectionFactory"))
			.isEqualTo(redisConnectionFactory);
}
 

import org.springframework.session.data.redis.RedisOperationsSessionRepository; //导入依赖的package包/类
@Test
public void primaryConnectionFactoryRedisConfig() {
	registerAndRefresh(RedisConfig.class, PrimaryConnectionFactoryRedisConfig.class);

	RedisOperationsSessionRepository repository = this.context
			.getBean(RedisOperationsSessionRepository.class);
	RedisConnectionFactory redisConnectionFactory = this.context
			.getBean("primaryRedisConnectionFactory", RedisConnectionFactory.class);
	assertThat(repository).isNotNull();
	assertThat(redisConnectionFactory).isNotNull();
	RedisOperations redisOperations = (RedisOperations) ReflectionTestUtils
			.getField(repository, "sessionRedisOperations");
	assertThat(redisOperations).isNotNull();
	assertThat(ReflectionTestUtils.getField(redisOperations, "connectionFactory"))
			.isEqualTo(redisConnectionFactory);
}
 

import org.springframework.session.data.redis.RedisOperationsSessionRepository; //导入依赖的package包/类
@Test
public void qualifiedAndPrimaryConnectionFactoryRedisConfig() {
	registerAndRefresh(RedisConfig.class,
			QualifiedAndPrimaryConnectionFactoryRedisConfig.class);

	RedisOperationsSessionRepository repository = this.context
			.getBean(RedisOperationsSessionRepository.class);
	RedisConnectionFactory redisConnectionFactory = this.context
			.getBean("qualifiedRedisConnectionFactory", RedisConnectionFactory.class);
	assertThat(repository).isNotNull();
	assertThat(redisConnectionFactory).isNotNull();
	RedisOperations redisOperations = (RedisOperations) ReflectionTestUtils
			.getField(repository, "sessionRedisOperations");
	assertThat(redisOperations).isNotNull();
	assertThat(ReflectionTestUtils.getField(redisOperations, "connectionFactory"))
			.isEqualTo(redisConnectionFactory);
}
 

import org.springframework.session.data.redis.RedisOperationsSessionRepository; //导入依赖的package包/类
@Test
public void namedConnectionFactoryRedisConfig() {
	registerAndRefresh(RedisConfig.class, NamedConnectionFactoryRedisConfig.class);

	RedisOperationsSessionRepository repository = this.context
			.getBean(RedisOperationsSessionRepository.class);
	RedisConnectionFactory redisConnectionFactory = this.context
			.getBean("redisConnectionFactory", RedisConnectionFactory.class);
	assertThat(repository).isNotNull();
	assertThat(redisConnectionFactory).isNotNull();
	RedisOperations redisOperations = (RedisOperations) ReflectionTestUtils
			.getField(repository, "sessionRedisOperations");
	assertThat(redisOperations).isNotNull();
	assertThat(ReflectionTestUtils.getField(redisOperations, "connectionFactory"))
			.isEqualTo(redisConnectionFactory);
}
 

import org.springframework.session.data.redis.RedisOperationsSessionRepository; //导入依赖的package包/类
@Test
public void testSessionTimeout() {
    RedisOperationsSessionRepository innerRepository = (RedisOperationsSessionRepository)ReflectionTestUtils
            .getField(sessionRepository, "repository");
    Integer sessionTimeout = (Integer) ReflectionTestUtils.getField(innerRepository, "defaultMaxInactiveInterval");
    Assert.isTrue(Integer.valueOf(12345).equals(sessionTimeout));
}
 

import org.springframework.session.data.redis.RedisOperationsSessionRepository; //导入依赖的package包/类
private void validateSpringSessionUsesRedis() {
	RedisOperationsSessionRepository repository = validateSessionRepository(
			RedisOperationsSessionRepository.class);
	assertThat(repository.getSessionCreatedChannelPrefix())
			.isEqualTo("spring:session:event:created:");
	assertThat(new DirectFieldAccessor(repository).getPropertyValue("redisFlushMode"))
			.isEqualTo(RedisFlushMode.ON_SAVE);
}
 

import org.springframework.session.data.redis.RedisOperationsSessionRepository; //导入依赖的package包/类
@Test
public void redisSessionStoreWithCustomizations() {
	load(Collections.<Class<?>>singletonList(RedisAutoConfiguration.class),
			"spring.session.store-type=redis", "spring.session.redis.namespace=foo",
			"spring.session.redis.flush-mode=immediate");
	RedisOperationsSessionRepository repository = validateSessionRepository(
			RedisOperationsSessionRepository.class);
	assertThat(repository.getSessionCreatedChannelPrefix())
			.isEqualTo("spring:session:foo:event:created:");
	assertThat(new DirectFieldAccessor(repository).getPropertyValue("redisFlushMode"))
			.isEqualTo(RedisFlushMode.IMMEDIATE);
}
 

import org.springframework.session.data.redis.RedisOperationsSessionRepository; //导入依赖的package包/类
@Test
@SuppressWarnings("unused")
public void newRedisOperationsSessionRepository() {
	// tag::new-redisoperationssessionrepository[]
	RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();

	// ... configure redisTemplate ...

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