pom引入包
<!-- redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.9.0</version>
</dependency>
配置数据源
redis:
database: 21
database2: 22
host: 111.113.6.6
port: 6379
password: 1111111
timeout: 3000 #连接超时
lettuce:
pool:
max-wait: 30000 #连接池最大阻塞等待时间(使用负值表示没有限制)
max-active: 100 #连接池最大连接数(使用负值表示没有限制)
max-idle: 20 #连接池中的最大空闲连接
min-idle: 0 #连接池中的最小空闲连接
配置文件
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
/**
* redis配置类
* @Author: www
*/
@Configuration
public class RedisConfig{
@Value("${spring.redis.database}")
private int database;
@Value("${spring.redis.database2}")
private int database2;
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.password}")
private String password;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.timeout}")
private long timeout;
@Value("${spring.redis.lettuce.pool.max-idle}")
private int maxIdle;
@Value("${spring.redis.lettuce.pool.min-idle}")
private int minIdle;
@Value("${spring.redis.lettuce.pool.max-active}")
private int maxActive;
@Value("${spring.redis.lettuce.pool.max-wait}")
private long maxWait;
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
public GenericObjectPoolConfig getGenericObjectPoolConfig(){
GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
genericObjectPoolConfig.setMaxIdle(maxIdle);
genericObjectPoolConfig.setMinIdle(minIdle);
genericObjectPoolConfig.setMaxTotal(maxActive);
genericObjectPoolConfig.setMaxWaitMillis(maxWait);
genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis(1000);
return genericObjectPoolConfig;
}
//------------------------数据库1
public RedisStandaloneConfiguration productEvn(){
RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
redisStandaloneConfiguration.setDatabase(database);
redisStandaloneConfiguration.setHostName(host);
redisStandaloneConfiguration.setPort(port);
redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
return redisStandaloneConfiguration;
}
//------------------------数据库2
public RedisStandaloneConfiguration previewEvn(){
RedisStandaloneConfiguration redisStandaloneConfiguration2 = new RedisStandaloneConfiguration();
redisStandaloneConfiguration2.setDatabase(database2);
redisStandaloneConfiguration2.setHostName(host);
redisStandaloneConfiguration2.setPort(port);
redisStandaloneConfiguration2.setPassword(RedisPassword.of(password));
return redisStandaloneConfiguration2;
}
public LettuceConnectionFactory createFactory(RedisStandaloneConfiguration redisStandaloneConfiguration) {
LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
.commandTimeout(Duration.ofMillis(timeout))
.poolConfig(getGenericObjectPoolConfig())
.build();
LettuceConnectionFactory factory = new LettuceConnectionFactory(redisStandaloneConfiguration, clientConfig);
factory.afterPropertiesSet();
return factory;
}
public RedisTemplate<String, Object> createRedisTemplate(RedisConnectionFactory redisConnectionFactory){
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
//使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
jackson2JsonRedisSerializer.setObjectMapper(mapper);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash的value序列化方式采用jackson
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
@Bean("redisTemplateProduct")
public RedisTemplate<String, Object> redisTemplateProduct() {
return createRedisTemplate(createFactory(productEvn()));
}
@Bean("redisTemplatePreview")
public RedisTemplate<String, Object> redisTemplatePreview() {
return createRedisTemplate(createFactory(previewEvn()));
}
}
应该时引入tempale
@Component
public class RedisConstant {
@Autowired
@Qualifier("redisTemplateProduct")
private RedisTemplate redisTemplateProduct;
@Autowired
@Qualifier("redisTemplatePreview")
private RedisTemplate redisTemplatePreview;
// 删除key[库1]
public BaseRes delete(String key){
Boolean flag = redisTemplateProduct.delete(key);
if(flag == true){
return success();
}else {
return error("500","redis key值"+key +"删除失败");
}
}
// 删除key[库2]
public BaseRes deleteReview(String key){
Boolean flag = redisTemplatePreview.delete(key);
if(flag == true){
return success();
}else {
return error("500","redis key值"+key +"删除失败");
}
}
}