org.springframework.data.redis.RedisConnectionFailureException Java Examples

@Before("checkRepeat()")
public void before(JoinPoint joinPoint) throws Exception {
    BaseRequest request = getBaseRequest(joinPoint);
    if(request != null){
        final String reqNo = request.getReqNo();
        if(StringUtil.isEmpty(reqNo)){
            throw new SBCException(StatusEnum.REPEAT_REQUEST);
        }else{
            try {
                String tempReqNo = redisTemplate.opsForValue().get(prefixReq +reqNo);
                logger.debug("tempReqNo=" + tempReqNo);

                if((StringUtil.isEmpty(tempReqNo))){
                    redisTemplate.opsForValue().set(prefixReq + reqNo, reqNo, day, TimeUnit.DAYS);
                }else{
                    throw new SBCException("请求号重复,"+ prefixReq +"=" + reqNo);
                }

            } catch (RedisConnectionFailureException e){
                logger.error("redis操作异常",e);
                throw new SBCException("need redisService") ;
            }
        }
    }

}
 

@Override
public DataAccessException convert(Exception source) {
    if (source instanceof RedisConnectionException) {
        return new RedisConnectionFailureException(source.getMessage(), source);
    }
    if (source instanceof RedisRedirectException) {
        RedisRedirectException ex = (RedisRedirectException) source;
        return new ClusterRedirectException(ex.getSlot(), ex.getUrl().getHost(), ex.getUrl().getPort(), source);
    }

    if (source instanceof RedisException) {
        return new InvalidDataAccessApiUsageException(source.getMessage(), source);
    }
    
    if (source instanceof DataAccessException) {
        return (DataAccessException) source;
    }
    
    if (source instanceof RedisTimeoutException) {
        return new QueryTimeoutException(source.getMessage(), source);
    }

    return null;
}
 

@Override
public DataAccessException convert(Exception source) {
    if (source instanceof RedisConnectionException) {
        return new RedisConnectionFailureException(source.getMessage(), source);
    }

    if (source instanceof RedisException) {
        return new InvalidDataAccessApiUsageException(source.getMessage(), source);
    }
    
    if (source instanceof DataAccessException) {
        return (DataAccessException) source;
    }
    
    if (source instanceof RedisTimeoutException) {
        return new QueryTimeoutException(source.getMessage(), source);
    }

    return null;
}
 

@Override
public DataAccessException convert(Exception source) {
    if (source instanceof RedisConnectionException) {
        return new RedisConnectionFailureException(source.getMessage(), source);
    }
    if (source instanceof RedisRedirectException) {
        RedisRedirectException ex = (RedisRedirectException) source;
        return new ClusterRedirectException(ex.getSlot(), ex.getUrl().getHost(), ex.getUrl().getPort(), source);
    }

    if (source instanceof RedisException) {
        return new InvalidDataAccessApiUsageException(source.getMessage(), source);
    }
    
    if (source instanceof DataAccessException) {
        return (DataAccessException) source;
    }
    
    if (source instanceof RedisTimeoutException) {
        return new QueryTimeoutException(source.getMessage(), source);
    }

    return null;
}
 

@Override
public DataAccessException convert(Exception source) {
    if (source instanceof RedisConnectionException) {
        return new RedisConnectionFailureException(source.getMessage(), source);
    }
    if (source instanceof RedisRedirectException) {
        RedisRedirectException ex = (RedisRedirectException) source;
        return new ClusterRedirectException(ex.getSlot(), ex.getUrl().getHost(), ex.getUrl().getPort(), source);
    }

    if (source instanceof RedisException) {
        return new InvalidDataAccessApiUsageException(source.getMessage(), source);
    }
    
    if (source instanceof DataAccessException) {
        return (DataAccessException) source;
    }
    
    if (source instanceof RedisTimeoutException) {
        return new QueryTimeoutException(source.getMessage(), source);
    }

    return null;
}
 

@Override
public DataAccessException convert(Exception source) {
    if (source instanceof RedisConnectionException) {
        return new RedisConnectionFailureException(source.getMessage(), source);
    }
    if (source instanceof RedisRedirectException) {
        RedisRedirectException ex = (RedisRedirectException) source;
        return new ClusterRedirectException(ex.getSlot(), ex.getUrl().getHost(), ex.getUrl().getPort(), source);
    }

    if (source instanceof RedisException) {
        return new InvalidDataAccessApiUsageException(source.getMessage(), source);
    }
    
    if (source instanceof DataAccessException) {
        return (DataAccessException) source;
    }
    
    if (source instanceof RedisTimeoutException) {
        return new QueryTimeoutException(source.getMessage(), source);
    }

    return null;
}
 

@Override
public DataAccessException convert(Exception source) {
    if (source instanceof RedisConnectionException) {
        return new RedisConnectionFailureException(source.getMessage(), source);
    }
    if (source instanceof RedisRedirectException) {
        RedisRedirectException ex = (RedisRedirectException) source;
        return new ClusterRedirectException(ex.getSlot(), ex.getUrl().getHost(), ex.getUrl().getPort(), source);
    }

    if (source instanceof RedisException) {
        return new InvalidDataAccessApiUsageException(source.getMessage(), source);
    }
    
    if (source instanceof DataAccessException) {
        return (DataAccessException) source;
    }
    
    if (source instanceof RedisTimeoutException) {
        return new QueryTimeoutException(source.getMessage(), source);
    }

    return null;
}
 

private Runnable loop() {
    return () -> {
        while (true) {
            AtomicInteger count = new AtomicInteger(0);
            topicMap.forEach((k, v) -> {
                try {
                    String message = mqUtil.getRedisTemplate().opsForList().rightPop(k);
                    if (message == null) {
                        count.getAndIncrement();
                    } else {
                        pushTask(v, message, k);
                    }
                } catch (RedisConnectionFailureException connException) {
                    log.error("redis无法连接,10s后重试", connException);
                    sleep(10);
                } catch (Exception e) {
                    log.error("redis消息队列异常", e);
                }
            });
            if (count.get() == topicMap.keySet().size()) {
                //当所有的队列都为空时休眠1s
                sleep(1);
            }
        }
    };
}
 

@Override
public DataAccessException convert(Exception source) {
    if (source instanceof RedisConnectionException) {
        return new RedisConnectionFailureException(source.getMessage(), source);
    }
    if (source instanceof RedisRedirectException) {
        RedisRedirectException ex = (RedisRedirectException) source;
        return new ClusterRedirectException(ex.getSlot(), ex.getUrl().getHost(), ex.getUrl().getPort(), source);
    }

    if (source instanceof RedisException) {
        return new InvalidDataAccessApiUsageException(source.getMessage(), source);
    }
    
    if (source instanceof DataAccessException) {
        return (DataAccessException) source;
    }
    
    if (source instanceof RedisTimeoutException) {
        return new QueryTimeoutException(source.getMessage(), source);
    }

    return null;
}
 

@Bean
public RetryOperations retryOperations() {
	RetryTemplate retryTemplate = new RetryTemplate();
	retryTemplate.setRetryPolicy(new SimpleRetryPolicy(3,
			Collections.<Class<? extends Throwable>, Boolean>singletonMap(RedisConnectionFailureException.class, true)));
	ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
	backOffPolicy.setInitialInterval(1000L);
	backOffPolicy.setMaxInterval(1000L);
	backOffPolicy.setMultiplier(2);
	retryTemplate.setBackOffPolicy(backOffPolicy);
	return retryTemplate;
}
 

@Override
public <T> T fetch(Function<Commands, T> block) {
    try {
        return redisTemplate.execute(new SessionCallback<T>() {
            @Override
            @SuppressWarnings("unchecked")
            public <K, V> T execute(RedisOperations<K, V> operations) throws DataAccessException {
                RedisConnectionCommands commands = new RedisConnectionCommands((RedisOperations<String, String>) operations);
                return block.apply(commands);
            }
        });
    } catch (RedisConnectionFailureException e) {
        throw new RedisConnectException(e);
    }
}
 

@Test
public void shouldEmailEmbeddedRedisConfigurationBeCreated() throws Exception {
    //Arrange
    int port = 6381;
    List<String> settings = ImmutableList.of("appendfilename email_appendonly.aof",
            "save 900 1");

    //Act
    EmailEmbeddedRedisConfiguration emailEmbeddedRedisConfiguration = new EmailEmbeddedRedisConfiguration(port, settings);

    //Assert
    assertions.assertThat(emailEmbeddedRedisConfiguration.emailEmbeddedRedis())
            .isNotNull();
    assertions.assertThat(emailEmbeddedRedisConfiguration.redisConnectionFactory())
            .isNotNull()
            .isInstanceOf(JedisConnectionFactory.class);


    //Act
    TimeUnit.SECONDS.sleep(3);
    emailEmbeddedRedisConfiguration.preDestroy();

    TimeUnit.SECONDS.sleep(1);
    //Assert
    assertions.assertThat(emailEmbeddedRedisConfiguration.emailEmbeddedRedis().isActive()).isFalse();

    exportException.expect(RedisConnectionFailureException.class);
    emailEmbeddedRedisConfiguration.redisConnectionFactory().getConnection();
}
 

@Bean
public RetryOperations retryOperations() {
	RetryTemplate retryTemplate = new RetryTemplate();
	retryTemplate.setRetryPolicy(new SimpleRetryPolicy(3, Collections.<Class<? extends Throwable>, Boolean>singletonMap(RedisConnectionFailureException.class, true)));
	ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
	backOffPolicy.setInitialInterval(1000L);
	backOffPolicy.setMaxInterval(1000L);
	backOffPolicy.setMultiplier(2);
	retryTemplate.setBackOffPolicy(backOffPolicy);
	return retryTemplate;
}
 

protected void startDequeue() {
    String queueName = queue.getQueueName();

    threadingStrategy.start(queueName, new Runnable() {
        public void run() {
            try {
                processNextMessage();
            } catch (RedisConnectionFailureException e) {
                connectionFailureHandler.serverConnectionFailed(e);
            }
        }
    });
}
 

public void serverConnectionFailed(RedisConnectionFailureException e) {
    int count = incrementFailureCounterAndGetCount();

    if (shouldLogError(count)) {
        logger.error("Could not connect to Redis after {} attempts, retrying in {}ms...", connectionFailuresCounter, millisToWaitAfterConnectionFailure,e);
        resetErrorCount();
    } else {
        logger.warn("Error connecting to Redis ({}), retrying in {}ms...", e.getMessage(), millisToWaitAfterConnectionFailure);
    }

    waitAfterConnectionFailure();
}
 

public void registerLastEventTimestamp(Event event) {

	    try {
            // register last timestamp
            final String eventTimestamp = Long.toString(event.getCreationTimestamp().getEpochSecond());
            redisTemplate.boundHashOps(LAST_TS_HASHNAME).put(event.getIncoming().getDeviceGuid(), eventTimestamp);
	    } catch (RedisConnectionFailureException ex) {
	        LOGGER.error("RedisConnectionFailureException: {}", ex.getMessage());
        }

	}
 

@Override
protected boolean needLogStackTrace(Throwable e) {
    if (e instanceof RedisConnectionFailureException) {
        return false;
    }
    return true;
}
 

private void whenConnectionFailureTimes(int count) {
    for (int i = 0; i < count; i++) {
        defaultConnectionFailureHandler.serverConnectionFailed(new RedisConnectionFailureException("error!"));
    }
}
 

/**
 * Called when a connection failure happens. This method is called in the context of each message processing thread.
 * @param e the details on the connection failure
 */
void serverConnectionFailed(RedisConnectionFailureException e);