Spring boot 利用Redis实现队列消息监听简单示例

我的应用场景：当某个业务系统接收到MQ消息需要按照顺序进行执行时，且收到的消息间隔时间过短时，可以把需要执行的消息放到队列里面进行逐个消费，因为对消息执行的代码加锁是不行的，因为消息间隔时间小，容易出错，只能对消息再进行一层封装，然后执行.,这种情况只适用于消息不是必须实时消费。

1.Redis配置

主要配置序列化和反序列化使用的方式.

package com.example.demo.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * 集成Redis
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<String, String>();

        redisTemplate.setConnectionFactory(factory);
        redisTemplate.afterPropertiesSet();
        setSerializer(redisTemplate);
        return redisTemplate;
    }

    private void setSerializer(RedisTemplate<String, String> template) {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
    }
}

2.按照存储Redis数据
这里面的value实际就是得到的消费消息.

@SpringBootTest
@RunWith(SpringRunner.class)
class DemoApplicationTests {
	private static final String key = "test007";

	@Autowired
	private RedisTemplate redisTemplate;

	@Test
	void contextLoads() {
		System.out.println(redisTemplate == null);
		redisTemplate.opsForList().leftPush(key , 12345);
		redisTemplate.opsForList().leftPush(key , 125678);
		Long size = redisTemplate.opsForList().size(key);
		System.out.println(size);

/*		Object object = redisTemplate.opsForList().rightPop(key);
		Object pop = redisTemplate.opsForList().rightPop(key);
		System.out.println(object);
		System.out.println(pop);
		Long temp = redisTemplate.opsForList().size(key);
		System.out.println(temp);*/

	}

}

监听器进行监听消费
定时器执行间隔，可以依照不同业务场景进行配置,用key的size进行判断redis是否存储了消费消息。因为是单线程，所以不会存在线程安全问题.
定时器执行需要在启动类加上@EnableScheduling注解.

@Component
@Slf4j
public class MyTask001 {
	
	//这里需要把key提取成常量， 因为存取需要同一个key
    private static final String key = "test007";
	
	//标识符，判断redis里面是否有消息.
    private static  Long keyNum = 0L;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 定时执行队列信息消费
     */
    @Scheduled(cron = "55 * * * * ?")
    public void testTask(){
        try {
            keyNum = redisTemplate.opsForList().size(key);
            while(keyNum > 0){
                Object object = redisTemplate.opsForList().rightPop(key);
                //执行的业务代码,单线程，因此不必对业务代码进行加锁.且是顺序执行.
                System.out.println(object);
                //再次获取标识符
                keyNum = redisTemplate.opsForList().size(key);
            }
        } catch (Exception e) {
            log.info("定时器异常信息,{}",e);
        }
    }

}

附录: