io.lettuce.core.resource.ClientResources Java Examples

@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
		throws BeansException {
	if (bean instanceof ClientResources) {
		ClientResources cr = (ClientResources) bean;
		if (!cr.tracing().isEnabled()) {
			if (log.isDebugEnabled()) {
				log.debug(
						"Lettuce ClientResources bean is auto-configured to enable tracing.");
			}
			BraveTracing lettuceTracing = BraveTracing.builder().tracing(tracing())
					.excludeCommandArgsFromSpanTags()
					.serviceName(traceRedisProperties.getRemoteServiceName()).build();
			return cr.mutate().tracing(lettuceTracing).build();
		}
		if (log.isDebugEnabled()) {
			log.debug(
					"Lettuce ClientResources bean is skipped for auto-configuration because tracing was already enabled.");
		}
	}
	return bean;
}
 

@Bean
public LettucePoolingClientConfiguration lettucePoolConfig( ClientOptions _co, ClientResources _cr ){
    GenericObjectPoolConfig gopc = new GenericObjectPoolConfig();

    gopc.setMaxIdle( CommonConfig.getInteger( "spring.redis.pool.max-idle", DEFAULT_MAX_IDLE ) );
    gopc.setMinIdle( CommonConfig.getInteger( "spring.redis.pool.min-idle", DEFAULT_MIN_IDLE ) );
    gopc.setMaxTotal( CommonConfig.getInteger( "spring.redis.pool.max-active", DEFAULT_MAX_TOTAL ) );
    gopc.setMaxWaitMillis( CommonConfig.getLong( "spring.redis.pool.max-wait", DEFAULT_MAX_WAIT_MILLIS ) );
    gopc.setEvictorShutdownTimeoutMillis( CommonConfig.getLong( "spring.redis.pool.timeout",
                                                                DEFAULT_EVICTOR_SHUTDOWN_TIMEOUT_MILLIS ) );

    return LettucePoolingClientConfiguration.builder()
            .poolConfig( gopc )
            .clientOptions( _co )
            .clientResources( _cr )
            .build();
}
 

@Bean
@ConditionalOnMissingBean(value = RequestRateLimiterFactory.class)
public RedisRateLimiterFactory redisRateLimiterFactory(ClientResources redisClientResources, RedisProperties redisProperties) {
    RedisURI.Builder builder = RedisURI.builder()
            .withHost(redisProperties.getHost())
            .withPort(redisProperties.getPort());
    if (!StringUtils.isEmpty(redisProperties.getPassword())) {
        builder = builder.withPassword(redisProperties.getPassword());
    }
    if (null != redisProperties.getTimeout()) {
        builder = builder.withTimeout(redisProperties.getTimeout());
    }
    builder = builder.withDatabase(redisProperties.getDatabase())
            .withSsl(redisProperties.isSsl());
    RedisURI redisUri = builder.build();
    return new RedisRateLimiterFactory(RedisClient.create(redisClientResources, redisUri));
}
 

private LettuceClientConfiguration getLettuceClientConfiguration(ClientResources clientResources,
                                                                 Pool pool) {
    LettuceClientConfigurationBuilder builder = createBuilder(pool);
    applyProperties(builder);
    if (StringUtils.hasText(this.properties.getUrl())) {
        customizeConfigurationFromUrl(builder);
    }
    builder.clientResources(clientResources);
    return builder.build();
}
 

public RedisPipeline(ClientResources resources, RedisURI redisURI, String key, long pipelineDelay) {

        super(pipelineDelay);
        if (null != resources) {
            this.redisClient = RedisClient.create(resources, redisURI);
        } else {
            this.redisClient = RedisClient.create(redisURI);
        }
        this.key = key;
    }
 

private LettuceConnectionFactory getLettuceConnectionFactory(GenericApplicationContext context) {
    final LettuceConnectionConfiguration configuration = new LettuceConnectionConfiguration(redisProperties, context.getBeanProvider(RedisSentinelConfiguration.class), context.getBeanProvider(RedisClusterConfiguration.class));
    final ClientResources clientResources = DefaultClientResources.create();
    try {
        return configuration.redisConnectionFactory(context.getBeanProvider(LettuceClientConfigurationBuilderCustomizer.class), clientResources);
    } catch (UnknownHostException e) {
        throw new IllegalStateException(e);
    }
}
 

public LettuceConnectionFactory createFactory(ClientResources clientResources) {
    LettuceClientConfiguration clientConfig = getLettuceClientConfiguration(clientResources,
        this.properties.getLettuce().getPool());
    LettuceConnectionFactory factory = createLettuceConnectionFactory(clientConfig);
    factory.afterPropertiesSet();
    return factory;
}
 

public RedisQueue(String host, ClientResources resources) {
    this(host,6379,resources);
}
 

public RedisQueue(String host, int port, ClientResources resources) {
    this(resources != null? RedisClient.create(resources, RedisURI.create(host, port)) : RedisClient.create(RedisURI.create(host, port)));
}
 

public RedisPriorityQueue(String host, ClientResources resources) {
    super(host, resources);
}
 

public RedisPriorityQueue(String host, int port,ClientResources resources) {
    super(host, port,resources);
}
 

@Override
public LettuceConnectionFactory redisConnectionFactory(ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers,
                                                       ClientResources clientResources) throws UnknownHostException {
    return super.redisConnectionFactory(builderCustomizers, clientResources);
}
 

@Override
public ClientResources getResources() {
  return connection.getResources();
}
 

@Override
public ClientResources getResources() {
  return connection.getResources();
}
 

@Override
public ClientResources getResources() {
  return connection.getResources();
}
 

@Override
public ClientResources getResources() {
  return connection.getResources();
}
 

@Bean( destroyMethod = "shutdown" )
public ClientResources clientResources(){
    return DefaultClientResources.create();
}
 

public RedisPipeline(ClientResources resources, RedisURI redisURI, String key) {

        this(resources,redisURI,key,0);
    }