org.springframework.data.redis.connection.RedisConnectionFactory

Here are the examples of the java api org.springframework.data.redis.connection.RedisConnectionFactory taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

678 Examples 7

19 Source : RedisSubListenerConfig.java
with GNU General Public License v2.0
from ZoeShaw101

// 使用默认的工厂初始化redis操作模板
@Bean
StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
    return new StringRedisTemplate(connectionFactory);
}

19 Source : DistributedLockFactory.java
with MIT License
from zidoshare

public void setRedisConnectionFactory(RedisConnectionFactory redisConnectionFactory) {
    this.redisConnectionFactory = redisConnectionFactory;
}

19 Source : RedisConfig.java
with GNU General Public License v3.0
from zhshuixian

@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory factory) {
    return RedisCacheManager.builder(factory).cacheDefaults(cacheConfiguration()).transactionAware().build();
}

19 Source : RedisConfig.java
with Apache License 2.0
from zhoutaoo

@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
    // 对象的序列化
    RedisSerializationContext.SerializationPair valueSerializationPair = RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer());
    // 全局redis缓存过期时间
    RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofDays(1)).serializeValuesWith(valueSerializationPair);
    return new RedisCacheManager(RedisCacheWriter.nonLockingRedisCacheWriter(factory), redisCacheConfiguration);
}

19 Source : RedisWebSocketConfig.java
with Apache License 2.0
from zhaowb82

@Bean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
    return new StringRedisTemplate(redisConnectionFactory);
}

19 Source : Redis2Config.java
with Apache License 2.0
from zhaowb82

/**
 * Redis的模板 作为发布者
 * @param connectionFactory
 * @return
 */
@Bean
public StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
    return new StringRedisTemplate(connectionFactory);
}

19 Source : ApiRedisConfig.java
with Apache License 2.0
from zhaowb82

@Bean(name = "apiRedisTemplate")
public RedisTemplate<String, Object> redisTemplate(@Qualifier("apiConnFactory") RedisConnectionFactory apiConnFactory) {
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(apiConnFactory);
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setValueSerializer(new StringRedisSerializer());
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashValueSerializer(new StringRedisSerializer());
    return redisTemplate;
}

19 Source : SpringCacheConfig.java
with Apache License 2.0
from zhaoguhong

@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    RedisCacheManagerBuilder builder = RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(determineConfiguration());
    List<String> cacheNames = this.cacheProperties.getCacheNames();
    if (!cacheNames.isEmpty()) {
        builder.initialCacheNames(new LinkedHashSet<>(cacheNames));
    }
    return builder.build();
}

19 Source : DistributedLock.java
with Apache License 2.0
from zhaoguhong

public boolean unlock(String key) {
    byte[][] keysAndArgs = new byte[2][];
    keysAndArgs[0] = key.getBytes(Charset.forName("UTF-8"));
    keysAndArgs[1] = localLockValue.get().getBytes(Charset.forName("UTF-8"));
    RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
    RedisConnection conn = factory.getConnection();
    try {
        Long result = conn.scriptingCommands().eval(RELEASE_LOCK_SCRIPT.getBytes(Charset.forName("UTF-8")), ReturnType.INTEGER, 1, keysAndArgs);
        if (result != null && result > 0) {
            localLockValue.remove();
            return true;
        }
    } finally {
        RedisConnectionUtils.releaseConnection(conn, factory);
    }
    return false;
}

19 Source : DistributedLock.java
with Apache License 2.0
from zhaoguhong

/**
 * 尝试获取锁
 */
public boolean tryLock(String key) {
    String lockValue = UUID.randomUUID().toString();
    RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
    RedisConnection conn = factory.getConnection();
    try {
        // key不存在则set,并设置超时时间
        Boolean result = conn.set(key.getBytes(Charset.forName("UTF-8")), lockValue.getBytes(Charset.forName("UTF-8")), Expiration.from(60, TimeUnit.SECONDS), RedisStringCommands.SetOption.SET_IF_ABSENT);
        if (result != null && result) {
            localLockValue.set(lockValue);
            return true;
        }
    } finally {
        // 释放连接
        RedisConnectionUtils.releaseConnection(conn, factory);
    }
    return false;
}

19 Source : RedisConfig.java
with MIT License
from zhangyd-c

@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
    return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(factory)).cacheDefaults(RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofDays(30))).transactionAware().build();
}

19 Source : ValidateCodeBeanAutoConfiguration.java
with MIT License
from ZeroOrInfinity

@Bean
@ConditionalOnMissingBean(type = "top.dcenter.ums.security.core.auth.validate.codes.sms.SmsValidateCodeProcessor")
public SmsValidateCodeProcessor smsValidateCodeProcessor(@NonNull ValidateCodeGeneratorHolder validateCodeGeneratorHolder, @NonNull ValidateCodeProperties validateCodeProperties, @Nullable @Autowired(required = false) RedisConnectionFactory redisConnectionFactory) {
    return new SmsValidateCodeProcessor(validateCodeGeneratorHolder, validateCodeProperties.getValidateCodeCacheType(), redisConnectionFactory);
}

19 Source : ValidateCodeBeanAutoConfiguration.java
with MIT License
from ZeroOrInfinity

@Bean
@ConditionalOnMissingBean(type = "top.dcenter.ums.security.core.auth.validate.codes.slider.SliderCoderProcessor")
public SliderCoderProcessor sliderCoderProcessor(@NonNull ValidateCodeGeneratorHolder validateCodeGeneratorHolder, @NonNull ValidateCodeProperties validateCodeProperties, @Nullable @Autowired(required = false) RedisConnectionFactory redisConnectionFactory) {
    return new SliderCoderProcessor(validateCodeGeneratorHolder, validateCodeProperties, redisConnectionFactory);
}

19 Source : RedisConfig.java
with MIT License
from Zealon159

/**
 * 缓存管理器
 */
@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    // 初始化一个RedisCacheWriter
    RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
    // 设置CacheManager的值序列化方式为json序列化
    RedisSerializer<Object> jsonSerializer = new GenericJackson2JsonRedisSerializer();
    RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair.fromSerializer(jsonSerializer);
    RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);
    // 设置默认超过期时间是30秒
    defaultCacheConfig = defaultCacheConfig.entryTtl(Duration.ofSeconds(300));
    // 初始化RedisCacheManager
    return new RedisCacheManager(redisCacheWriter, defaultCacheConfig);
}

19 Source : RedisConfig.java
with MIT License
from Zealon159

@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate<String, Object> redis = new RedisTemplate<>();
    redis.setConnectionFactory(redisConnectionFactory);
    this.setSerializer(redis);
    return redis;
}

19 Source : RedisConfig.java
with MIT License
from Zealon159

@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    return new RedisCacheManager(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory), // 默认策略,未配置的 key 会使用这个
    this.getRedisCacheConfigurationWithTtl(30), // 指定 key 策略
    this.getRedisCacheConfigurationMap());
}

19 Source : RedisConfig.java
with MIT License
from Zealon159

@Bean
StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
    return new StringRedisTemplate(connectionFactory);
}

19 Source : RedisConfig.java
with Apache License 2.0
from yzx-66

// 配置CacheManager
@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    return new RedisCacheManager(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory), // TODO 180
    // 默认策略,未配置的 key 会使用这个
    this.getRedisCacheConfigurationWithTtl(1), // 指定 key 策略
    this.getRedisCacheConfigurationMap());
}

19 Source : RedisCacheConfig.java
with GNU General Public License v3.0
from ywhs

@Autowired
public void setRedisConnectionFactory(RedisConnectionFactory redisConnectionFactory) {
    this.redisConnectionFactory = redisConnectionFactory;
}

19 Source : RedisHealthIndicatorTests.java
with Apache License 2.0
from yuanmabiji

private RedisHealthIndicator createHealthIndicator(RedisConnection redisConnection) {
    RedisConnectionFactory redisConnectionFactory = mock(RedisConnectionFactory.clreplaced);
    given(redisConnectionFactory.getConnection()).willReturn(redisConnection);
    return new RedisHealthIndicator(redisConnectionFactory);
}

19 Source : RedisHealthIndicator.java
with Apache License 2.0
from yuanmabiji

/**
 * Simple implementation of a {@link HealthIndicator} returning status information for
 * Redis data stores.
 *
 * @author Christian Dupuis
 * @author Richard Santana
 * @since 2.0.0
 */
public clreplaced RedisHealthIndicator extends AbstractHealthIndicator {

    static final String VERSION = "version";

    static final String REDIS_VERSION = "redis_version";

    private final RedisConnectionFactory redisConnectionFactory;

    public RedisHealthIndicator(RedisConnectionFactory connectionFactory) {
        super("Redis health check failed");
        replacedert.notNull(connectionFactory, "ConnectionFactory must not be null");
        this.redisConnectionFactory = connectionFactory;
    }

    @Override
    protected void doHealthCheck(Health.Builder builder) throws Exception {
        RedisConnection connection = RedisConnectionUtils.getConnection(this.redisConnectionFactory);
        try {
            if (connection instanceof RedisClusterConnection) {
                ClusterInfo clusterInfo = ((RedisClusterConnection) connection).clusterGetClusterInfo();
                builder.up().withDetail("cluster_size", clusterInfo.getClusterSize()).withDetail("slots_up", clusterInfo.getSlotsOk()).withDetail("slots_fail", clusterInfo.getSlotsFail());
            } else {
                Properties info = connection.info();
                builder.up().withDetail(VERSION, info.getProperty(REDIS_VERSION));
            }
        } finally {
            RedisConnectionUtils.releaseConnection(connection, this.redisConnectionFactory);
        }
    }
}

19 Source : RedisAutoConfig.java
with Apache License 2.0
from yl-yue

/**
 * <p>支持FastJson进行Redis存储对象序列/反序列化
 * <p>https://github.com/alibaba/fastjson/wiki/%E5%9C%A8-Spring-%E4%B8%AD%E9%9B%86%E6%88%90-Fastjson
 */
@Bean
public RedisTemplate<String, Object> yueRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(redisConnectionFactory);
    // 支持FastJson进行Redis存储对象序列/反序列化
    if (redisProperties.getRedisSerializer() != RedisSerializerEnum.JDK) {
        redisTemplate.setDefaultSerializer(redisProperties.getRedisSerializer().getRedisSerializer());
    }
    StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    redisTemplate.setKeySerializer(stringRedisSerializer);
    redisTemplate.setHashKeySerializer(stringRedisSerializer);
    return redisTemplate;
}

19 Source : RedisConfig.java
with Apache License 2.0
from xuyisu

@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    return RedisCacheManager.create(connectionFactory);
}

19 Source : RedisConfig.java
with Apache License 2.0
from xuwujing

/**
 * 设置数据存入 redis 的序列化方式,并开启事务
 * @param redisTemplate
 * @param factory
 */
private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
    // 如果不配置Serializer,那么存储的时候缺省使用String,如果用User类型存储,那么会提示错误User can't cast to String!
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
    redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    // 开启事务
    redisTemplate.setEnableTransactionSupport(true);
    redisTemplate.setConnectionFactory(factory);
}

19 Source : RedisConfig.java
with Apache License 2.0
from xuwujing

/**
 * 实例化 RedisTemplate 对象
 * @return
 */
@Bean
public RedisTemplate<String, Object> functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
    return redisTemplate;
}

19 Source : RedisConfig.java
with Apache License 2.0
from xuwujing

/**
 * 设置数据存入 redis 的序列化方式,并开启事务
 *
 * @param redisTemplate
 * @param factory
 */
private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
    /*
		 * 设置 序列化器 .
		 * 如果不设置,那么在用实体类(未序列化)进行存储的时候,会提示错误: Failed to serialize object using DefaultSerializer;
		 */
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
    redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    // 开启事务
    // redisTemplate.setEnableTransactionSupport(true);
    // 将连接工厂设置到模板类中
    redisTemplate.setConnectionFactory(factory);
}

19 Source : RedisSubListenerConfig.java
with Mozilla Public License 2.0
from xjc-opensource

@Bean("name=sendRedisTemplate")
StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
    return new StringRedisTemplate(connectionFactory);
}

19 Source : RedisCacheConfig.java
with GNU General Public License v3.0
from xiaomujiayou

@Bean
@ConditionalOnMissingBean
public RedisCacheManager cacheManager1(RedisConnectionFactory connectionFactory) {
    return new RedisCacheManager(RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory), // 默认策略,未配置的 key 会使用这个
    this.getRedisCacheConfigurationWithTtl(24 * 60 * 60), // 指定 key 策略
    this.getRedisCacheConfigurationMap());
}

19 Source : RedisCacheConfig.java
with GNU General Public License v3.0
from xiaomujiayou

/**
 * 分布式锁
 * @param redisConnectionFactory
 * @return
 */
@Bean
public RedisLockRegistry redisLockRegistry(RedisConnectionFactory redisConnectionFactory) {
    return new RedisLockRegistry(redisConnectionFactory, "spring-cloud", 120 * 1000);
}

19 Source : RedisCacheConfig.java
with GNU General Public License v3.0
from xiaomujiayou

// @Bean
// public KeyGenerator simpleKeyGenerator() {
// return (o, method, objects) -> {
// StringBuilder stringBuilder = new StringBuilder();
// stringBuilder.append(o.getClreplaced().getSimpleName());
// stringBuilder.append(".");
// stringBuilder.append(method.getName());
// stringBuilder.append("[");
// for (Object obj : objects) {
// stringBuilder.append(obj.toString());
// }
// stringBuilder.append("]");
// 
// return stringBuilder.toString();
// };
// }
@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    return new RedisCacheManager(RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory), // 默认策略,未配置的 key 会使用这个
    this.getRedisCacheConfigurationWithTtl(24 * 60 * 60), // 指定 key 策略
    this.getRedisCacheConfigurationMap());
}

19 Source : RedisCacheConfig.java
with GNU General Public License v3.0
from xiaomujiayou

/**
 * 分布式锁
 * @param redisConnectionFactory
 * @return
 */
@Bean
public RedisLockRegistry redisLockRegistry(RedisConnectionFactory redisConnectionFactory) {
    return new RedisLockRegistry(redisConnectionFactory, "cps-mall", 120 * 1000);
}

19 Source : RedisCacheConfig.java
with Apache License 2.0
from x-ream

@Bean
public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    return new RedisCacheManager(RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory), // 默认策略,未配置的 key 会使用这个
    this.getRedisCacheConfigurationWithTtl(entryTTL), // 指定 key 策略
    this.getRedisCacheConfigurationMap());
}

19 Source : RedisConfig.java
with MIT License
from WeiziPlus

@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(3L)).serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer())).serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer())).disableCachingNullValues();
    return RedisCacheManager.builder(connectionFactory).cacheDefaults(config).transactionAware().build();
}

19 Source : CacheConfig.java
with Apache License 2.0
from wayn111

@Bean
public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    return RedisCacheManager.builder(connectionFactory).cacheDefaults(defaultCacheConfig()).withInitialCacheConfigurations(singletonMap("menuCache", defaultCacheConfig())).withInitialCacheConfigurations(singletonMap("deptCache", defaultCacheConfig())).withInitialCacheConfigurations(singletonMap("permissionCache", defaultCacheConfig())).withInitialCacheConfigurations(singletonMap("dictCache", defaultCacheConfig())).withInitialCacheConfigurations(singletonMap("timerTaskCache", defaultCacheConfig())).withInitialCacheConfigurations(singletonMap("preplacedwordRetryCache", defaultCacheConfig1())).transactionAware().build();
}

19 Source : RedisCacheAutoConfiguration.java
with MIT License
from uhonliu

/**
 * 配置缓存管理器
 *
 * @param redisConnectionFactory
 * @return
 */
@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    // 生成一个默认配置,通过config对象即可对缓存进行自定义配置
    RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
    // 设置缓存的默认过期时间,也是使用Duration设置
    redisCacheConfiguration = redisCacheConfiguration.entryTtl(Duration.ofHours(1));
    return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory)).cacheDefaults(redisCacheConfiguration).build();
}

19 Source : BaseRedisConfig.java
with MIT License
from tongji4m3

@Bean
public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
    RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
    // 设置Redis缓存有效期为1天
    RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer())).entryTtl(Duration.ofDays(1));
    return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
}

19 Source : BaseRedisConfig.java
with MIT License
from tongji4m3

@Bean
public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
    RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
    /**
     * 设置Redis缓存有效期为1天
     */
    RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer())).entryTtl(Duration.ofDays(1));
    return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
}

19 Source : RedisConfig.java
with MIT License
from swwheihei

/**
 * redis消息监听器容器 可以添加多个监听不同话题的redis监听器,只需要把消息监听器和相应的消息订阅处理器绑定,该消息监听器
 * 通过反射技术调用消息订阅处理器的相关方法进行一些业务处理
 *
 * @param connectionFactory
 * @param listenerAdapter
 * @return
 */
@Bean
RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) {
    RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    container.setConnectionFactory(connectionFactory);
    return container;
}

19 Source : RedisCacheConfig.java
with Apache License 2.0
from sunshinelyz

public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory cf) {
    return mRedisTemplate;
}

19 Source : MagicRedisAutoConfiguration.java
with MIT License
from ssssssss-team

/**
 * 注入redis模块
 */
@Bean
public RedisModule redisFunctions(RedisConnectionFactory connectionFactory) {
    return new RedisModule(connectionFactory);
}

19 Source : MultiRedisSprigBaseApplication.java
with Apache License 2.0
from sonus21

@Bean
public RedisMessageListenerContainer container(RedisConnectionFactory redisConnectionFactory) {
    RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    container.setConnectionFactory(redisConnectionFactory);
    return container;
}

19 Source : ApplicationWithCustomConfiguration.java
with Apache License 2.0
from sonus21

@Bean
public RqueueMessageTemplate rqueueMessageTemplate(RedisConnectionFactory redisConnectionFactory) {
    return new RqueueMessageTemplateImpl(redisConnectionFactory);
}

19 Source : RedisScriptFactoryTest.java
with Apache License 2.0
from sonus21

@CoreUnitTest
@BootstrapRedis(systemRedis = false, port = 6301)
clreplaced RedisScriptFactoryTest extends TestBase {

    private final RedisConnectionFactory redisConnectionFactory;

    private final RqueueMessageTemplate rqueueMessageTemplate;

    RedisScriptFactoryTest(RedisConnectionFactory redisConnectionFactory) {
        this.redisConnectionFactory = redisConnectionFactory;
        this.rqueueMessageTemplate = new RqueueMessageTemplateImpl(redisConnectionFactory);
    }

    @Test
    @TestQueue(value = { "testExpiredMessageMoverWithFailureQueue", "__rq::p-queue::testExpiredMessageMoverWithFailureQueue" })
    void expiredMessageMoverWithFailureQueue() {
        String queueName = "testExpiredMessageMoverWithFailureQueue";
        String zsetName = "__rq::p-queue::testExpiredMessageMoverWithFailureQueue";
        RqueueMessage rqueueMessage1 = RqueueMessage.builder().message("Test message 1").build();
        RqueueMessage rqueueMessage2 = RqueueMessage.builder().message("Test message 2").failureCount(1).build();
        RqueueMessage rqueueMessage3 = RqueueMessage.builder().message("Test message 3").failureCount(110).build();
        RqueueMessage rqueueMessage4 = RqueueMessage.builder().message("Test message 4").build();
        rqueueMessageTemplate.addToZset(zsetName, rqueueMessage1, 1000);
        rqueueMessageTemplate.addToZset(zsetName, rqueueMessage2, 1500);
        rqueueMessageTemplate.addToZset(zsetName, rqueueMessage3, 2000);
        rqueueMessageTemplate.addToZset(zsetName, rqueueMessage4, 2500);
        RedisScript<Long> script = RedisScriptFactory.getScript(ScriptType.MOVE_EXPIRED_MESSAGE);
        RqueueRedisTemplate<Long> rqueueRedisTemplate = new RqueueRedisTemplate<>(redisConnectionFactory);
        ScriptExecutor<String> scriptExecutor = new DefaultScriptExecutor<>(rqueueRedisTemplate.getRedisTemplate());
        scriptExecutor.execute(script, Arrays.asList(queueName, zsetName), 2000, 100, 1);
        List<RqueueMessage> messagesFromList = rqueueMessageTemplate.readFromList(queueName, 0, -1);
        List<RqueueMessage> messagesFromZset = rqueueMessageTemplate.readFromZset(zsetName, 0, -1);
        replacedertEquals(3, messagesFromList.size());
        replacedertEquals(1, messagesFromZset.size());
        replacedertEquals(1, messagesFromList.get(0).getFailureCount());
        replacedertEquals(2, messagesFromList.get(1).getFailureCount());
        replacedertEquals(111, messagesFromList.get(2).getFailureCount());
    }

    @Test
    @TestQueue(value = { "testExpiredMessageMover", "__rq::d-queue::testExpiredMessageMover" })
    void expiredMessageMover() {
        String queueName = "testExpiredMessageMover";
        String zsetName = "__rq::d-queue::testExpiredMessageMover";
        RqueueMessage rqueueMessage1 = RqueueMessage.builder().message("Test message 1").build();
        RqueueMessage rqueueMessage2 = RqueueMessage.builder().message("Test message 2").failureCount(1).build();
        RqueueMessage rqueueMessage3 = RqueueMessage.builder().message("Test message 3").failureCount(110).build();
        RqueueMessage rqueueMessage4 = RqueueMessage.builder().message("Test message 4").build();
        rqueueMessageTemplate.addToZset(zsetName, rqueueMessage1, 1000);
        rqueueMessageTemplate.addToZset(zsetName, rqueueMessage2, 1500);
        rqueueMessageTemplate.addToZset(zsetName, rqueueMessage3, 2000);
        rqueueMessageTemplate.addToZset(zsetName, rqueueMessage4, 2500);
        RedisScript<Long> script = RedisScriptFactory.getScript(ScriptType.MOVE_EXPIRED_MESSAGE);
        RqueueRedisTemplate<Long> rqueueRedisTemplate = new RqueueRedisTemplate<>(redisConnectionFactory);
        ScriptExecutor<String> scriptExecutor = new DefaultScriptExecutor<>(rqueueRedisTemplate.getRedisTemplate());
        scriptExecutor.execute(script, Arrays.asList(queueName, zsetName), 2000, 100, 0);
        List<RqueueMessage> messagesFromList = rqueueMessageTemplate.readFromList(queueName, 0, -1);
        List<RqueueMessage> messagesFromZset = rqueueMessageTemplate.readFromZset(zsetName, 0, -1);
        replacedertEquals(3, messagesFromList.size());
        replacedertEquals(1, messagesFromZset.size());
        replacedertEquals(0, messagesFromList.get(0).getFailureCount());
        replacedertEquals(1, messagesFromList.get(1).getFailureCount());
        replacedertEquals(110, messagesFromList.get(2).getFailureCount());
    }

    @Test
    @TestQueue("testDeleteIfSame")
    void deleteIfSame() {
        String key = "testDeleteIfSame";
        RqueueMessage rqueueMessage = RqueueMessage.builder().message("Test message 1").build();
        RqueueMessage rqueueMessage2 = RqueueMessage.builder().message("Test message 2").build();
        RedisScript<Boolean> script = RedisScriptFactory.getScript(ScriptType.DELETE_IF_SAME);
        RqueueRedisTemplate<RqueueMessage> template = new RqueueMessageTemplateImpl(redisConnectionFactory);
        template.set(key, rqueueMessage);
        ScriptExecutor<String> scriptExecutor = new DefaultScriptExecutor<>(template.getRedisTemplate());
        replacedertTrue(template.exist(key));
        // value mismatch
        replacedertFalse(scriptExecutor.execute(script, Collections.singletonList(key), rqueueMessage2));
        replacedertTrue(template.exist(key));
        // actual delete
        replacedertTrue(scriptExecutor.execute(script, Collections.singletonList(key), rqueueMessage));
        replacedertFalse(template.exist(key));
        // key does not exist test
        replacedertTrue(scriptExecutor.execute(script, Collections.singletonList(key), rqueueMessage2));
        replacedertTrue(scriptExecutor.execute(script, Collections.singletonList(key), rqueueMessage));
    }
}

19 Source : RedisUtils.java
with Apache License 2.0
from sonus21

public static <V> RedisTemplate<String, V> getRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
    return redisTemplateProvider.getRedisTemplate(redisConnectionFactory);
}

19 Source : SimpleRqueueListenerContainerFactory.java
with Apache License 2.0
from sonus21

/**
 * Set redis connection factory, that would be used to configured message template and other
 * components
 *
 * @param redisConnectionFactory redis connection factory object
 */
public void setRedisConnectionFactory(RedisConnectionFactory redisConnectionFactory) {
    notNull(redisConnectionFactory, "redisConnectionFactory must not be null");
    this.redisConnectionFactory = redisConnectionFactory;
}

19 Source : RedisConfig.java
with GNU Lesser General Public License v3.0
from somowhere

@Bean
public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    return RedisCacheManager.create(connectionFactory);
}

19 Source : TracingRedisConnectionFactory.java
with Apache License 2.0
from sofastack

/**
 * OpenTracing instrumentation of a {@link RedisConnectionFactory}.
 * <p>
 * This clreplaced delegates invocations to the given {@link RedisConnectionFactory}, returning
 * OpenTracing wrappers for {@link RedisConnection} and {@link RedisClusterConnection} only.
 *
 * @author Daniel del Castillo
 */
public clreplaced TracingRedisConnectionFactory implements RedisConnectionFactory, ReactiveRedisConnectionFactory {

    private final RedisConnectionFactory delegate;

    private final RedisActionWrapperHelper actionWrapper;

    public TracingRedisConnectionFactory(RedisConnectionFactory delegate, RedisActionWrapperHelper actionWrapper) {
        this.delegate = delegate;
        this.actionWrapper = actionWrapper;
    }

    @Override
    public RedisConnection getConnection() {
        // support cluster connection
        RedisConnection connection = this.delegate.getConnection();
        if (connection instanceof RedisClusterConnection) {
            return new TracingRedisClusterConnection((RedisClusterConnection) connection, actionWrapper);
        }
        return new TracingRedisConnection(connection, actionWrapper);
    }

    @Override
    public RedisClusterConnection getClusterConnection() {
        return new TracingRedisClusterConnection(delegate.getClusterConnection(), actionWrapper);
    }

    @Override
    public boolean getConvertPipelineAndTxResults() {
        return delegate.getConvertPipelineAndTxResults();
    }

    @Override
    public RedisSentinelConnection getSentinelConnection() {
        return new TracingRedisSentinelConnection(delegate.getSentinelConnection(), actionWrapper);
    }

    @Override
    public DataAccessException translateExceptionIfPossible(RuntimeException e) {
        return delegate.translateExceptionIfPossible(e);
    }

    @Override
    public ReactiveRedisConnection getReactiveConnection() {
        if (this.delegate instanceof ReactiveRedisConnectionFactory) {
            ReactiveRedisConnectionFactory connectionFactory = (ReactiveRedisConnectionFactory) this.delegate;
            ReactiveRedisConnection connection = connectionFactory.getReactiveConnection();
            // support cluster connection
            if (connection instanceof ReactiveRedisClusterConnection) {
                return new TracingReactiveRedisClusterConnection((ReactiveRedisClusterConnection) connection, actionWrapper);
            }
            return new TracingReactiveRedisConnection(connectionFactory.getReactiveConnection(), actionWrapper);
        }
        // TODO: shouldn't we throw an exception?
        return null;
    }

    @Override
    public ReactiveRedisClusterConnection getReactiveClusterConnection() {
        if (delegate instanceof ReactiveRedisConnectionFactory) {
            return ((ReactiveRedisConnectionFactory) delegate).getReactiveClusterConnection();
        }
        // TODO: shouldn't we throw an exception?
        return null;
    }
}

19 Source : RedisAutoConfiguration.java
with Apache License 2.0
from smart-cloud

@Bean
public StringRedisTemplate initStringRedisTemplate(final RedisConnectionFactory connectionFactory) {
    StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
    stringRedisTemplate.setConnectionFactory(connectionFactory);
    stringRedisTemplate.setKeySerializer(new StringRedisSerializer());
    stringRedisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    stringRedisTemplate.setHashKeySerializer(new StringRedisSerializer());
    stringRedisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
    return stringRedisTemplate;
}

19 Source : RedisConfig.java
with MIT License
from sika-code

@Primary
@Bean("redisTemplate")
@ConditionalOnProperty(name = "spring.redis.host", matchIfMissing = true)
public RedisTemplate<String, Object> getSingleRedisTemplate(RedisConnectionFactory factory, RedisSerializer redisSerializer) {
    return buildRedisTemplate(factory, redisSerializer);
}

19 Source : RedisConfig.java
with MIT License
from sika-code

@Primary
@Bean("redisTemplate")
@ConditionalOnProperty(name = "spring.redis.cluster.nodes")
public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory factory, RedisSerializer redisSerializer) {
    return buildRedisTemplate(factory, redisSerializer);
}

See More Examples