版本
- SpringBoot:2.2.5.RELEASE
- Jdk:1.8
- Maven:3.5.2
- Idea:2019.3
依赖
pom.xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>
配置
RedisConfigProperties.java
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* @author liujiazhong
* @date 2020/4/9 9:41
*/
@Data
@ConfigurationProperties("gardenia.redis")
public class RedisConfigProperties {
private String host;
private Integer port;
private String password;
private Integer database;
private Integer maxTotal;
private Integer maxIdle;
private Integer timeBetweenEvictionRunsMillis;
private Integer minEvictableIdleTimeMillis;
private Boolean testOnBorrow;
private Integer maxWaitMillis;
private Integer socketTimeout;
}
RedisConfig.java
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
/**
* @author liujiazhong
* @date 2020/4/9 10:06
*/
@Configuration
@EnableConfigurationProperties(RedisConfigProperties.class)
public class RedisConfig {
private final RedisConfigProperties properties;
public RedisConfig(RedisConfigProperties properties) {
this.properties = properties;
}
@Bean
public JedisConnectionFactory jedisConnectionFactory() {
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(properties.getMaxTotal());
poolConfig.setMaxIdle(properties.getMaxIdle());
poolConfig.setMaxWaitMillis(properties.getMaxWaitMillis());
poolConfig.setTimeBetweenEvictionRunsMillis(properties.getTimeBetweenEvictionRunsMillis());
poolConfig.setTestOnBorrow(properties.getTestOnBorrow());
poolConfig.setMinEvictableIdleTimeMillis(properties.getMinEvictableIdleTimeMillis());
RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration();
redisConfig.setHostName(properties.getHost());
redisConfig.setPort(properties.getPort());
redisConfig.setPassword(properties.getPassword());
redisConfig.setDatabase(properties.getDatabase());
JedisClientConfiguration clientConfig = JedisClientConfiguration.builder()
.usePooling()
.poolConfig(poolConfig)
.and().build();
return new JedisConnectionFactory(redisConfig, clientConfig);
}
@Bean
public RedisTemplate<String, Object> redisTemplate() {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(jedisConnectionFactory());
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
application.yml
gardenia:
redis:
host: 127.0.0.1
port: 6379
database: 0
password:
maxTotal: 120
maxIdle: 10
maxWaitMillis: 500
socketTimeout: 5000
timeBetweenEvictionRunsMillis: 30000
minEvictableIdleTimeMillis: 30000
testOnBorrow: true
食用
RedisCache.java
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* spring redis 工具类
*
* @author liujiazhong
* @date 2020/3/31 9:32
*/
@Component
public class RedisCache {
private final RedisTemplate<String, Object> redisTemplate;
public RedisCache(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}
public void setCacheObject(String key, Object value) {
ValueOperations<String, Object> operation = redisTemplate.opsForValue();
operation.set(key, value);
}
public void setCacheObject(String key, Object value, Integer timeout, TimeUnit timeUnit) {
ValueOperations<String, Object> operation = redisTemplate.opsForValue();
operation.set(key, value, timeout, timeUnit);
}
public Object getCacheObject(String key) {
ValueOperations<String, Object> operation = redisTemplate.opsForValue();
return operation.get(key);
}
public void deleteObject(String key) {
redisTemplate.delete(key);
}
public void deleteObject(Collection<String> collection) {
redisTemplate.delete(collection);
}
public <T> void setCacheList(String key, List<T> dataList) {
ListOperations<String, Object> listOperation = redisTemplate.opsForList();
if (CollectionUtils.isNotEmpty(dataList)) {
for (T t : dataList) {
listOperation.leftPush(key, t);
}
}
}
public List<Object> getCacheList(String key) {
ListOperations<String, Object> listOperation = redisTemplate.opsForList();
return listOperation.range(key, 0, -1);
}
public void setCacheSet(String key, Set<Object> dataSet) {
BoundSetOperations<String, Object> setOperation = redisTemplate.boundSetOps(key);
for (Object t : dataSet) {
setOperation.add(t);
}
}
public Set<Object> getCacheSet(String key) {
BoundSetOperations<String, Object> operation = redisTemplate.boundSetOps(key);
return operation.members();
}
public void setCacheMap(String key, Map<String, Object> dataMap) {
HashOperations<String, String, Object> hashOperations = redisTemplate.opsForHash();
if (MapUtils.isNotEmpty(dataMap)) {
dataMap.forEach((k, v) -> hashOperations.put(key, k, v));
}
}
public Map<String, Object> getCacheMap(String key) {
HashOperations<String, String, Object> hashOperations = redisTemplate.opsForHash();
return hashOperations.entries(key);
}
public Collection<String> keys(String pattern) {
return redisTemplate.keys(pattern);
}
public Long increment(String key, Long delta) {
ValueOperations<String, Object> operation = redisTemplate.opsForValue();
return operation.increment(key, delta);
}
}
总结
整合Spring Data Redis
链接
Spring Data Redis:https://spring.io/projects/spring-data-redis#overview
Redis:https://redis.io/