java redis 推送,使用Spring Data Redis实现基于发布/订阅的消息队列 | zifangsky的个人博客...

package cn.zifangsky.config;

import cn.zifangsky.model.Receiver;

import com.fasterxml.jackson.annotation.JsonAutoDetect;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.connection.RedisClusterConfiguration;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.listener.PatternTopic;

import org.springframework.data.redis.listener.RedisMessageListenerContainer;

import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;

import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

import redis.clients.jedis.JedisCluster;

import redis.clients.jedis.JedisPoolConfig;

import java.util.Arrays;

/**

* Redis相关配置

*

* @author zifangsky

* @date 2018/7/30

* @since 1.0.0

*/

@Configuration

@ConditionalOnClass({JedisCluster.class})

public class RedisConfig {

@Value("${spring.redis.timeout}")

private String timeOut;

@Value("${spring.redis.cluster.nodes}")

private String nodes;

@Value("${spring.redis.cluster.max-redirects}")

private int maxRedirects;

@Value("${spring.redis.jedis.pool.max-active}")

private int maxActive;

@Value("${spring.redis.jedis.pool.max-wait}")

private int maxWait;

@Value("${spring.redis.jedis.pool.max-idle}")

private int maxIdle;

@Value("${spring.redis.jedis.pool.min-idle}")

private int minIdle;

@Bean

public JedisPoolConfig jedisPoolConfig(){

JedisPoolConfig config = new JedisPoolConfig();

config.setMaxTotal(maxActive);

config.setMaxIdle(maxIdle);

config.setMinIdle(minIdle);

config.setMaxWaitMillis(maxWait);

return config;

}

@Bean

public RedisClusterConfiguration redisClusterConfiguration(){

RedisClusterConfiguration configuration = new RedisClusterConfiguration(Arrays.asList(nodes));

configuration.setMaxRedirects(maxRedirects);

return configuration;

}

/**

* JedisConnectionFactory

*/

@Bean

public JedisConnectionFactory jedisConnectionFactory(RedisClusterConfiguration configuration,JedisPoolConfig jedisPoolConfig){

return new JedisConnectionFactory(configuration,jedisPoolConfig);

}

/**

* 使用Jackson序列化对象

* @author zifangsky

* @date 2018/7/30 16:16

* @since 1.0.0

* @return org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer

*/

@Bean

public Jackson2JsonRedisSerializer jackson2JsonRedisSerializer(){

Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

ObjectMapper objectMapper = new ObjectMapper();

objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

serializer.setObjectMapper(objectMapper);

return serializer;

}

/**

* RedisTemplate

*/

@Bean

public RedisTemplate redisTemplate(JedisConnectionFactory factory, Jackson2JsonRedisSerializer jackson2JsonRedisSerializer){

RedisTemplate redisTemplate = new RedisTemplate<>();

redisTemplate.setConnectionFactory(factory);

//字符串方式序列化KEY

StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

redisTemplate.setKeySerializer(stringRedisSerializer);

redisTemplate.setHashKeySerializer(stringRedisSerializer);

//JSON方式序列化VALUE

redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);

redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

redisTemplate.afterPropertiesSet();

return redisTemplate;

}

/**

* Redis message receiver

*/

@Bean

public Receiver redisMessageReceiver(){

return new Receiver();

}

/**

* 消息监听器

*/

@Bean

MessageListenerAdapter messageListenerAdapter(Receiver receiver, Jackson2JsonRedisSerializer jackson2JsonRedisSerializer){

//消息接收者以及对应的默认处理方法

MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver, "receiveMessage");

//消息的反序列化方式

messageListenerAdapter.setSerializer(jackson2JsonRedisSerializer);

return messageListenerAdapter;

}

/**

* message listener container

*/

@Bean

RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory

, MessageListenerAdapter messageListenerAdapter){

RedisMessageListenerContainer container = new RedisMessageListenerContainer();

container.setConnectionFactory(connectionFactory);

//添加消息监听器

container.addMessageListener(messageListenerAdapter, new PatternTopic("topic-test"));

return container;

}

}