我在我的应用程序中使用Redis进行缓存。我经常使用缓存来获取数据。我使用的是spring-boot 1.5.9版，spring-data-redis 1.8.9，jedis 2.9.0和commons-pool 1.6。
我无法理解
这是我正在使用的Redis的配置：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import redis.clients.jedis.JedisPoolConfig;
import java.time.Duration;
@Configuration
public class ApplicationConfiguration {
@Value("${spring.redis.host}")
private String REDIS_HOST;
@Value("${spring.redis.port}")
private int REDIS_PORT;
@Value("${spring.redis.database}")
private int REDIS_DATABASE;
@Value("${spring.redis.pool.max-active}")
private int REDIS_POOL_MAX_ACTIVE;
@Value("${spring.redis.pool.max-idle}")
private int REDIS_POOL_MAX_IDLE;
@Value("${spring.redis.pool.min-idle}")
private int REDIS_POOL_MIN_IDLE;
@Value("${spring.redis.pool.max-wait}")
private long REDIS_POOL_TIMEOUT;
@Value("${spring.redis.timeout}")
private int REDIS_TIMEOUT;
@Bean
public JedisConnectionFactory jedisConnectionFactory() {
JedisPoolConfig poolConfig = new JedisPoolConfig();
//Maximum number of active connections that can be allocated from this pool at the same time
poolConfig.setMaxTotal(REDIS_POOL_MAX_ACTIVE);
//Number of connections to Redis that just sit there and do nothing
poolConfig.setMaxIdle(REDIS_POOL_MAX_IDLE);
//Minimum number of idle connections to Redis - these can be seen as always open and ready to serve
poolConfig.setMinIdle(REDIS_POOL_MIN_IDLE);
//The maximum number of milliseconds that the pool will wait (when there are no available connections) for a connection to be returned before throwing an exception
poolConfig.setMaxWaitMillis(REDIS_POOL_TIMEOUT);
//The minimum amount of time an object may sit idle in the pool before it is eligible for eviction by the idle object evictor
poolConfig.setMinEvictableIdleTimeMillis(Duration.ofSeconds(60).toMillis());
//The minimum amount of time a connection may sit idle in the pool before it is eligible for eviction by the idle connection evictor
poolConfig.setSoftMinEvictableIdleTimeMillis(Duration.ofSeconds(10).toMillis());
//Idle connection checking period
poolConfig.setTimeBetweenEvictionRunsMillis(Duration.ofSeconds(5).toMillis());
//Maximum number of connections to test in each idle check
poolConfig.setNumTestsPerEvictionRun(3);
//Tests whether connection is dead when connection retrieval method is called
poolConfig.setTestOnBorrow(true);
//Tests whether connection is dead when returning a connection to the pool
poolConfig.setTestOnReturn(true);
//Tests whether connections are dead during idle periods
poolConfig.setTestWhileIdle(true);
poolConfig.setBlockWhenExhausted(true);
JedisConnectionFactory connectionFactory = new JedisConnectionFactory(poolConfig);
connectionFactory.setUsePool(true);
connectionFactory.setHostName(REDIS_HOST);
connectionFactory.setPort(REDIS_PORT);
connectionFactory.setDatabase(REDIS_DATABASE);
connectionFactory.setTimeout(REDIS_TIMEOUT);
return connectionFactory;
}
@Bean
public LoggingRedisTemplate stringRedisTemplate(@Autowired JedisConnectionFactory jedisConnectionFactory) {
LoggingRedisTemplate stringRedisTemplate = new LoggingRedisTemplate(jedisConnectionFactory);
stringRedisTemplate.setEnableTransactionSupport(true);
return stringRedisTemplate;
}
@Bean
public RedisCacheManager cacheManager(@Autowired StringRedisTemplate stringRedisTemplate) {
RedisCacheManager cacheManager = new RedisCacheManager(stringRedisTemplate);
cacheManager.setUsePrefix(true);
return cacheManager;
}
}
然后我使用服务来访问数据：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.StringRedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.types.RedisClientInfo;
import org.springframework.stereotype.Component;
import java.util.List;
@Component
public class RedisService {
@Autowired
private LoggingRedisTemplate stringRedisTemplate;
public String getStringValue(final String key) {
// return stringRedisTemplate.opsForValue().get(key);
return readValueWithCallBack(key);
}
public void setStringValue(final String key, final String value) {
// stringRedisTemplate.opsForValue().setIfAbsent(key, value);
writeValueWithCallBack(key,value);
}
public void removeStringValue(final String key) {
// stringRedisTemplate.delete(key);
removeValueWithCallback(key);
}
public Long removeValueWithCallback(final String key){
return (Long) stringRedisTemplate.execute( new RedisCallback<Object>() {
@Override
public Object doInRedis(RedisConnection connection) throws DataAccessException {
StringRedisConnection stringRedisConnection = (StringRedisConnection) connection;
stringRedisConnection.multi();
Long deletedKeysCount = stringRedisConnection.del(key);
stringRedisConnection.exec();
stringRedisConnection.close();
return deletedKeysCount;
}
});
}
public String readValueWithCallBack(final String key){
return (String) stringRedisTemplate.execute( new RedisCallback<Object>() {
@Override
public Object doInRedis(RedisConnection connection) throws DataAccessException {
StringRedisConnection stringRedisConnection = (StringRedisConnection) connection;
String value = stringRedisConnection.get(key);
List<RedisClientInfo> redisClientInfos = stringRedisConnection.getClientList();
stringRedisConnection.close();
return value;
}
});
}
public void writeValueWithCallBack(final String key, final String value){
stringRedisTemplate.execute( new RedisCallback<Object>() {
@Override
public Object doInRedis(RedisConnection connection) throws DataAccessException {
StringRedisConnection stringRedisConnection = (StringRedisConnection) connection;
stringRedisConnection.multi();
stringRedisConnection.set(key,value);
stringRedisConnection.exec();
stringRedisConnection.close();
return null;
}
});
}
}
这是我为避免异常而创建的Redis模板，通常在异常后继续下一步：
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Component;
import java.util.List;
/**
*
* An extension of RedisTemplate that logs exceptions instead of letting them propagate.
* If the Redis server is unavailable, cache operations are always a "miss" and data is fetched from the database.
*/
@Component
public class LoggingRedisTemplate extends StringRedisTemplate {
private static final Logger logger = LoggerFactory.getLogger(LoggingRedisTemplate.class);
public LoggingRedisTemplate(RedisConnectionFactory connectionFactory) {
super(connectionFactory);
}
@Override
public <T> T execute(final RedisCallback<T> action, final boolean exposeConnection, final boolean pipeline) {
try {
return super.execute(action, exposeConnection, pipeline);
}
catch(final Throwable t) {
logger.warn("Error executing cache operation: {}", t.getMessage());
return null;
}
}
@Override
public <T> T execute(final RedisScript<T> script, final List<String> keys, final Object... args) {
try {
return super.execute(script, keys, args);
}
catch(final Throwable t) {
logger.warn("Error executing cache operation: {}", t.getMessage());
return null;
}
}
@Override
public <T> T execute(final RedisScript<T> script, final RedisSerializer<?> argsSerializer, final RedisSerializer<T> resultSerializer, final List<String> keys, final Object... args) {
try {
return super.execute(script, argsSerializer, resultSerializer, keys, args);
}
catch(final Throwable t) {
logger.warn("Error executing cache operation: {}", t.getMessage());
return null;
}
}
@Override
public <T> T execute(final SessionCallback<T> session) {
try {
return super.execute(session);
}
catch(final Throwable t) {
logger.warn("Error executing cache operation: {}", t.getMessage());
return null;
}
}
}
我已从此处参考此日志记录模板：https://stackoverflow.com/a/26666102/8499307
我在application.properties
spring.data.redis.repositories.enabled=false
spring.cache.type=redis
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.database=0
spring.redis.pool.max-active=256
spring.redis.pool.max-idle=12
spring.redis.pool.max-wait=100
spring.redis.pool.min-idle=6
spring.redis.timeout=100
我之前使用stringRedisTemplate.opsForValue().get(key)来获取数据，但在很少的帖子中，他们建议使用回调来正确关闭连接，但这也没有用。
如果需要其他任何内容，请评论。
答案 0 :(得分：2)
已解决的问题：）
我仅在RedisService中进行过更改，现在它就像是一种魅力。一旦完成读/写/删除操作，我就做了更改以关闭连接。
您可以签出以下代码：
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.RedisConnectionFailureException;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
@Component
public class RedisService {
@Autowired
private LoggingRedisTemplate stringRedisTemplate;
private static final Logger logger = LoggerFactory.getLogger(RedisService.class);
public String getStringValue(final String key) {
String data = stringRedisTemplate.opsForValue().get(key);
try {
closeConnection(stringRedisTemplate);
}catch (RedisConnectionFailureException e){
closeClients(stringRedisTemplate);
}finally {
closeConnection(stringRedisTemplate);
}
return data;
}
public void setStringValue(final String key, final String value) {
stringRedisTemplate.opsForValue().setIfAbsent(key, value);
try {
closeConnection(stringRedisTemplate);
}catch (RedisConnectionFailureException e){
closeClients(stringRedisTemplate);
}finally {
closeConnection(stringRedisTemplate);
}
}
public void removeStringValue(final String key) {
stringRedisTemplate.delete(key);
try {
closeConnection(stringRedisTemplate);
}catch (RedisConnectionFailureException e){
closeClients(stringRedisTemplate);
}finally {
closeConnection(stringRedisTemplate);
}
}
private void closeConnection(StringRedisTemplate stringRedisTemplate){
try {
JedisConnectionFactory connectionFactory = (JedisConnectionFactory) stringRedisTemplate.getConnectionFactory();
connectionFactory.getConnection().close();
connectionFactory.destroy();
}catch (RedisConnectionFailureException e){
logger.info("Connection closed already");
}
}
private void closeClients(LoggingRedisTemplate stringRedisTemplate){
try {
if(null != stringRedisTemplate.getClientList()){
stringRedisTemplate.getClientList().remove(0);
stringRedisTemplate.getClientList().remove(1);
stringRedisTemplate.getClientList().forEach(redisClientInfo -> {
String address = redisClientInfo.getAddressPort();
if(null != address){
String [] addressList = address.split(":");
stringRedisTemplate.killClient(addressList[0],Integer.parseInt(addressList[1]));
}
});
}
}catch (Exception e){
logger.warn("Unable to close client connections, ", e);
}
}
}
我希望，它也会对其他人有所帮助：）
答案 1 :(得分：0)
在您的配置中，您启用了事务支持，因此它不会关闭连接。
Your current configuration:
@Bean
public LoggingRedisTemplate stringRedisTemplate(@Autowired JedisConnectionFactory jedisConnectionFactory) {
LoggingRedisTemplate stringRedisTemplate = new LoggingRedisTemplate(jedisConnectionFactory);
stringRedisTemplate.setEnableTransactionSupport(true);
return stringRedisTemplate;
}
Configuration you shoud do:
@Bean
public LoggingRedisTemplate stringRedisTemplate(@Autowired JedisConnectionFactory jedisConnectionFactory) {
LoggingRedisTemplate stringRedisTemplate = new LoggingRedisTemplate(jedisConnectionFactory);
**stringRedisTemplate.setEnableTransactionSupport(false);**
return stringRedisTemplate;
}
or
@Bean
public LoggingRedisTemplate stringRedisTemplate(@Autowired JedisConnectionFactory jedisConnectionFactory) {
LoggingRedisTemplate stringRedisTemplate = new LoggingRedisTemplate(jedisConnectionFactory);
return stringRedisTemplate;
}