相对于redis的集群配置 这篇文章相对比较死板。用于学习redis集群配置的一个过渡
现在application.yml中配置redis链接属性文件
redis:
host: ${ip} //输入你要填入的IP地址
password: password
port: 6379
timeout: 3000
database: 10 #可不配,因为底层默认值为6379
pool:
max-active: -1 # 连接池最大连接数(使用负值表示没有限制)
max-wait: -1 # 连接池最大阻塞等待时间(使用负值表示没有限制)
max-idle: 8 # 连接池中的最大空闲连接
min-idle: 0 # 连接池中的最小空闲连接
redis2:
host: ${ip1}
password: password1
port: 6379
timeout: 3000
database: 10 #可不配,因为底层默认值为6379
如果
redis2:
host: ${ip1}
password: password1
port: 6379
timeout: 3000
database: 10 #可不配,因为底层默认值为6379
数据源的数据在配置文件中获取不到 可以单独写一个公共配置文件获取多个配置文件数据
例如 filebase.properties 文件
spring.redis2.host: 127.0.0.1
spring.redis2.port: 6379
spring.redis2.password: 131540
spring.redis2.timeout: 3000
spring.redis2.database: 3
实现配置redis工厂链接池
package com.longyao.petrochina.config.redis;
import com.alibaba.druid.util.StringUtils;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.cache.annotation.EnableCaching;
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.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
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.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisPoolConfig;
import java.time.Duration;
/**
* @Author: cq
* @Date: 2020/9/7 17:44
* @Version 1.0
*/
@EnableCaching
@Configuration
public class RedisBatchConfig {
@Value("${spring.redis.pool.max-active}")
private Integer redisPoolMaxActive;
@Value("${spring.redis.pool.max-wait}")
private Integer redisPoolMaxWait;
@Value("${spring.redis.pool.max-idle}")
private Integer redisPoolMaxIdle;
@Value("${spring.redis.pool.min-idle}")
private Integer redisPoolMinIdle;
@Value("${spring.redis2.host}")
private String host;
@Value("${spring.redis2.port}")
private Integer port;
@Value("${spring.redis2.password}")
private String password;
@Value("${spring.redis2.timeout}")
private String timeOut;
@Value("${spring.redis2.database}")
private Integer database;
@Value("${spring.redis.host}")
private String host0;
@Value("${spring.redis.port}")
private Integer port0;
@Value("${spring.redis.password}")
private String password0;
@Value("${spring.redis.timeout}")
private String timeOut0;
@Value("${spring.redis.database}")
private Integer database0;
/*****************************单机版********************************/
// /**
// * 配置redis 工厂
// * @return
// */
// @Bean("batchConnectionFactory")
// public LettuceConnectionFactory batchConnectionFactory() {
// RedisStandaloneConfiguration redisStandaloneConfiguration =
// new RedisStandaloneConfiguration();
// redisStandaloneConfiguration.setHostName(host);
// redisStandaloneConfiguration.setDatabase(database);
// redisStandaloneConfiguration.setPassword(password);
// redisStandaloneConfiguration.setPort(port);
//
// return this.getLettuceConnectionFactory(redisStandaloneConfiguration);
// }
//
// /**
// * 配置redis
// * @param batchConnectionFactory
// * @return
// */
// @Bean("batchRedisTemplate")
// @ConditionalOnBean(name = "batchRedisTemplate")
// public RedisTemplate<String, Object> batchRedisTemplate(@Qualifier("batchConnectionFactory") LettuceConnectionFactory batchConnectionFactory) {
// RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
// redisTemplate.setConnectionFactory(batchConnectionFactory);
// Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
// ObjectMapper om = new ObjectMapper();
// om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
// jackson2JsonRedisSerializer.setObjectMapper(om);
// RedisSerializer<?> stringSerializer = new StringRedisSerializer();
// redisTemplate.setKeySerializer(stringSerializer);
// redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
// redisTemplate.afterPropertiesSet();
// redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
// redisTemplate.setHashKeySerializer(stringSerializer);
//
// return redisTemplate;
// }
//
// /**
// * 公共数据封装
// */
// private LettuceConnectionFactory getLettuceConnectionFactory(RedisStandaloneConfiguration redisStandaloneConfiguration){
// GenericObjectPoolConfig genericObjectPoolConfig =
// new GenericObjectPoolConfig();
// genericObjectPoolConfig.setMaxIdle(redisPoolMaxIdle);
// genericObjectPoolConfig.setMinIdle(redisPoolMinIdle);
// genericObjectPoolConfig.setMaxTotal(redisPoolMaxActive);
// genericObjectPoolConfig.setMaxWaitMillis(redisPoolMaxWait);
// LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder
// builder = LettucePoolingClientConfiguration.builder().
// commandTimeout(Duration.ofMillis(Integer.parseInt(timeOut)));
// builder.poolConfig(genericObjectPoolConfig);
// LettuceClientConfiguration lettuceClientConfiguration = builder.build();
// //根据配置和客户端配置创建连接
// LettuceConnectionFactory lettuceConnectionFactory = new
// LettuceConnectionFactory(redisStandaloneConfiguration,lettuceClientConfiguration);
// lettuceConnectionFactory .afterPropertiesSet();
// return lettuceConnectionFactory;
// }
/*****************************多机版本********************************/
/**
* 配置redis工厂
* @param host
* @param port
* @param password
* @param minIdle
* @param maxIdle
* @param maxTotal
* @param maxWaitMillis
* @param dataBase
* @return
*/
public RedisConnectionFactory connectionFactory(String host, int port, String password, int minIdle,int maxIdle,
int maxTotal, long maxWaitMillis, int dataBase) {
//spring 2.*版本之前
// JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
// jedisConnectionFactory.setHostName(host);
// jedisConnectionFactory.setPort(port);
//
// if (!StringUtils.isEmpty(password)) {
// jedisConnectionFactory.setPassword(password);
// }
//
// if (dataBase != 0) {
// jedisConnectionFactory.setDatabase(dataBase);
// }
//
// jedisConnectionFactory.setPoolConfig(poolConfig(minIdle,maxIdle, maxTotal, maxWaitMillis, false));
// jedisConnectionFactory.afterPropertiesSet();
//spring 2.*版本
RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
redisStandaloneConfiguration.setDatabase(dataBase);
redisStandaloneConfiguration.setHostName(host);
redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
redisStandaloneConfiguration.setPort(port);
JedisClientConfiguration.JedisClientConfigurationBuilder jedisClientConfigurationBuilder = JedisClientConfiguration.builder();
JedisClientConfiguration jedisClientConfiguration = jedisClientConfigurationBuilder
.usePooling().poolConfig(this.poolConfig(minIdle,maxIdle,maxTotal,maxWaitMillis,false)).build();
return new JedisConnectionFactory(redisStandaloneConfiguration,jedisClientConfiguration);
}
//连接池配置
public JedisPoolConfig poolConfig(int minIdle,int maxIdle, int maxTotal, long maxWaitMillis, boolean testOnBorrow) {
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxIdle(maxIdle);
poolConfig.setMinIdle(minIdle);
poolConfig.setMaxTotal(maxTotal);
poolConfig.setMaxWaitMillis(maxWaitMillis);
poolConfig.setTestOnBorrow(testOnBorrow);
poolConfig.setNumTestsPerEvictionRun(10);
return poolConfig;
}
//------------------------------------
@Bean(name = "redisOrderTemplate")
public StringRedisTemplate redisOrderTemplate() {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(
connectionFactory(host, port, password, redisPoolMinIdle,redisPoolMaxIdle, redisPoolMaxActive, redisPoolMaxWait, database));
return template;
}
//------------------------------------
@Bean(name = "redisUserTemplate")
public StringRedisTemplate userUserTemplate() {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(
connectionFactory(host0, port0, password0, redisPoolMinIdle,redisPoolMaxIdle, redisPoolMaxActive, redisPoolMaxWait, database0));
return template;
}
}
//spring 2.*版本和之前版本链接我都写在了上面 两者使用没有多大的区别可能看我的另一篇文章解释
https://blog.csdn.net/cq__cy/article/details/108467914