import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Test
@SuppressWarnings("unused")
public void newReactiveRedisOperationsSessionRepository() {
	LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory();
	RedisSerializationContext<String, Object> serializationContext = RedisSerializationContext
			.<String, Object>newSerializationContext(
					new JdkSerializationRedisSerializer())
			.build();

	// tag::new-reactiveredisoperationssessionrepository[]
	// ... create and configure connectionFactory and serializationContext ...

	ReactiveRedisTemplate<String, Object> redisTemplate = new ReactiveRedisTemplate<>(
			connectionFactory, serializationContext);

	ReactiveSessionRepository<? extends Session> repository =
			new ReactiveRedisOperationsSessionRepository(redisTemplate);
	// end::new-reactiveredisoperationssessionrepository[]
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Override
protected RedisConnectionFactory createConnectionClient(String hostName, int port) {
    RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
    configuration.setHostName(hostName);
    configuration.setPort(port);
    if (JEDIS_AVAILABLE) {
        return new JedisConnectionFactory(configuration);
    } else if (LETTUCE_AVAILABLE) {
        return new LettuceConnectionFactory(configuration);
    } else {
        throw new IllegalArgumentException("No Jedis or lettuce client on classpath. " +
                "Please add one of the implementation to your classpath");
    }
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
private String toString(RedisConnectionFactory redisConnectionFactory) {
    if (redisConnectionFactory == null) {
        return "<none>";
    } else {
        if (redisConnectionFactory instanceof JedisConnectionFactory) {
            JedisConnectionFactory jcf = (JedisConnectionFactory) redisConnectionFactory;
            return jcf.getHostName().toString() + ":" + jcf.getPort();
        } else if (redisConnectionFactory instanceof LettuceConnectionFactory) {
            LettuceConnectionFactory lcf = (LettuceConnectionFactory) redisConnectionFactory;
            return lcf.getHostName().toString() + ":" + lcf.getPort();
        }
        return "<unknown> " + redisConnectionFactory.getClass();
    }
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Bean
public LettuceConnectionFactory connectionFactory() {
    String redisHost = System.getenv().getOrDefault("REDIS_HOST_ENV", "192.168.99.100");
    String redisPort = System.getenv().getOrDefault("REDIS_PORT_ENV", "6379");
    System.out.println("Redis @ "+ redisHost + ":" + redisPort);
    return new LettuceConnectionFactory(redisHost, Integer.valueOf(redisPort));        
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Profile(GitHubClaProfiles.CLOUDFOUNDRY)
@Bean
public RedisConnectionFactory cloudRedisConnectionFactory() {
	CloudFactory cloudFactory = new CloudFactory();
	Cloud cloud = cloudFactory.getCloud();
	RedisConnectionFactory connectionFactory = cloud.getSingletonServiceConnector(RedisConnectionFactory.class, null);

	if(connectionFactory instanceof LettuceConnectionFactory){
		((LettuceConnectionFactory) connectionFactory).setShutdownTimeout(0);
	}

	return connectionFactory;
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(RedisConnectionFactory.class)
public RedisConnectionFactory redisConnectionFactory(RedisProperties redisProperties) {

	LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory();
	connectionFactory.setPort(redisProperties.getPort());
	connectionFactory.setHostName(redisProperties.getHost());
	connectionFactory.setPassword(redisProperties.getPassword());
	connectionFactory.setShutdownTimeout(0);

	return connectionFactory;
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Bean
public LettuceConnectionFactory redisConnectionFactory() {
	RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration(
			redisContainer.getContainerIpAddress(),
			redisContainer.getFirstMappedPort());
	return new LettuceConnectionFactory(configuration);
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Override
public LettuceConnectionFactory configure(LettuceConnectionFactory connectionFactory, RedisConnectionFactoryConfig config) {
	if (config != null) {
		configureConnection(connectionFactory, config);
	}
	return connectionFactory;
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Bean
public LettuceConnectionFactory redisConnectionFactory() {
    return new LettuceConnectionFactory();
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Bean
public LettuceConnectionFactory connectionFactory() {
    return new LettuceConnectionFactory();
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Bean
public RedisConnectionFactory redisConnectionFactory() {
	return new LettuceConnectionFactory();
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Bean
public LettuceConnectionFactory connectionFactory() {
	return new LettuceConnectionFactory();
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Bean
@Primary
public LettuceConnectionFactory redisConnectionFactory() {
	return new LettuceConnectionFactory(redisContainer().getContainerIpAddress(),
			redisContainer().getFirstMappedPort());
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Bean
public LettuceConnectionFactory connectionFactory() {
	return new LettuceConnectionFactory(); // <2>
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
@Bean
public LettuceConnectionFactory redisConnectionFactory() {
	return new LettuceConnectionFactory(redisContainer.getContainerIpAddress(),
			redisContainer.getFirstMappedPort());
}
 

import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; //导入依赖的package包/类
private void configureConnection(LettuceConnectionFactory connectionFactory, RedisConnectionFactoryConfig config) {
	if (config.getConnectionProperties() != null) {
		mapServiceConnectionConfigurer.configure(connectionFactory, config.getConnectionProperties());
	}
}