一：引入maven依赖
<!-- springboot整合redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<!-- 排除lettuce包，使用jedis代替-->
<exclusions>
<exclusion>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
二：添加redis配置
redis:
host: localhost #哨兵模式下不用配置
port: 6379 # 哨兵模式下不用配置
password: 123456
database: 0
timeout: 1000
jedis:
pool:
#最大连接数
max-active: 1024
#最大阻塞等待时间(负数表示没限制)
max-wait: 20000
#最大空闲
max-idle: 200
#最小空闲
min-idle: 10
sentinel:
master: mymaster
nodes: 192.168.24.127:26379,192.168.24.128:26379,192.168.24.129:26379
三：编写redis配置类（切换注释即可切换单机、哨兵集群模式）
@Configuration
@EnableAutoConfiguration
public class RedisConfig {
private static Logger logger= LoggerFactory.getLogger(RedisConfig.class);
/** 单击版配置 **/
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port}")
private Integer port;
/** 哨兵模式配置 **/
@Value("#{'${spring.redis.sentinel.nodes}'.split(',')}")
private List<String> nodes;
@Value("${spring.redis.sentinel.master}")
private String master;
@Value("${spring.redis.password}")
private String password;
@Bean
@ConfigurationProperties(prefix="spring.redis")
public JedisPoolConfig getRedisConfig(){
JedisPoolConfig config = new JedisPoolConfig();
return config;
}
/**
* *单机版配置
* @param @param jedisPoolConfig
* @return JedisConnectionFactory
*/
@Bean
public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig) {
//不使用过时的JedisConnectionFactory直接配置属性
RedisStandaloneConfiguration redisStandaloneConfiguration=new RedisStandaloneConfiguration();
redisStandaloneConfiguration.setHostName(host);
redisStandaloneConfiguration.setPort(port);
RedisPassword redisPassword=RedisPassword.of(password);
redisStandaloneConfiguration.setPassword(redisPassword);
JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcf =
(JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration.builder();
//修改我们的连接池配置
jpcf.poolConfig(jedisPoolConfig);
//通过构造器来构造jedis客户端配置
JedisClientConfiguration jedisClientConfiguration = jpcf.build();
return new JedisConnectionFactory(redisStandaloneConfiguration,jedisClientConfiguration);
}
/**
* 哨兵模式配置
* @return
*/
/*@Bean
public RedisSentinelConfiguration sentinelConfiguration(){
RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration();
//配置matser的名称
redisSentinelConfiguration.master(master);
redisSentinelConfiguration.setPassword(RedisPassword.of(password));
//配置redis的哨兵sentinel
Set<RedisNode> redisNodeSet = new HashSet<>();
nodes.forEach(x->{
redisNodeSet.add(new RedisNode(x.split(":")[0],Integer.parseInt(x.split(":")[1])));
});
logger.info("redisNodeSet -->"+redisNodeSet);
redisSentinelConfiguration.setSentinels(redisNodeSet);
return redisSentinelConfiguration;
}*/
/**
* 哨兵模式配置
* @return
*/
/*@Bean
public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig, RedisSentinelConfiguration sentinelConfig) {
JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(sentinelConfig,jedisPoolConfig);
return jedisConnectionFactory;
}*/
/**
* 自定义redisTemplate
* @param redisConnectionFactory
* @return
*/
@Bean
public RedisTemplate<String,Object> redisTemplate(JedisConnectionFactory redisConnectionFactory){
RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
//自定义序列化方式
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
redisTemplate.setKeySerializer(jackson2JsonRedisSerializer);
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.setEnableTransactionSupport(true);// 开启事务
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
/**
* 注入封装RedisTemplate
* @return RedisUtil
* @throws
* @Title:redisUtil
*/
@Bean(name = "redisUtil")
public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
RedisUtil redisUtil = new RedisUtil();
redisUtil.setRedisTemplate(redisTemplate);
return redisUtil;
}
}
四：shiro整合redis插件相关配置（切换注释即可切换单机、哨兵集群模式）
/**
* 配置shiro redisManager(单机版)
* 使用的是shiro-redis开源插件
*
* @return
*/
public RedisManager redisManager() {
RedisManager redisManager = new RedisManager();
redisManager.setHost(host);
redisManager.setPort(port);
redisManager.setExpire(1800);
redisManager.setTimeout(timeout);
redisManager.setPassword(password);
logger.info("配置redis连接设置" + host + ":" + port);
return redisManager;
}
/**
* 配置shiro redisSentinelManager(哨兵模式)
* 使用的是shiro-redis开源插件
* @return
*/
/*public RedisSentinelManager redisSentinelManager(){
RedisSentinelManager redisSentinelManager = new RedisSentinelManager();
redisSentinelManager.setMasterName(master);
redisSentinelManager.setHost(redisNodes);
redisSentinelManager.setPassword(password);
return redisSentinelManager;
}*/
/**
* cacheManager 缓存 redis实现
* 使用的是shiro-redis开源插件
*
* @return
*/
@Bean
public RedisCacheManager cacheManager() {
RedisCacheManager redisCacheManager = new RedisCacheManager();
redisCacheManager.setRedisManager(redisManager());
//redisCacheManager.setRedisManager(redisSentinelManager());
return redisCacheManager;
}
/**
* RedisSessionDAO shiro sessionDao层的实现 通过redis
* 使用的是shiro-redis开源插件
*/
@Bean
public RedisSessionDAO redisSessionDAO() {
RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
redisSessionDAO.setRedisManager(redisManager());
//redisSessionDAO.setRedisManager(redisSentinelManager());
return redisSessionDAO;
}
网友评论