Redis轻量级的消息队列

redis轻量级的消息队列

• redis有两种模式：
  • 生产者消费者模式
  • 发布者与订阅者模式

我们先看看redis的官方文档介绍

Redis列表

为了解释List数据类型，最好从一点理论开始，因为术语List经常被信息技术人员以不正当的方式使用。例如，“Python Lists”不是名称所暗示的（Linked Lists），而是Arrays（实际上相同的数据类型在Ruby中称为Array）。

从非常一般的观点来看，List只是一系列有序元素：10,20,1,2,3是一个列表。但是使用Array实现的List的属性与使用Linked List实现的List的属性非常不同 。

Redis列表通过链接列表实现。这意味着即使列表中有数百万个元素，也会在常量时间内在列表的头部或尾部添加新元素。使用LPUSH命令将新元素添加到具有十个元素的列表的头部的速度与将具有1000万个元素的元素添加到列表头部的速度相同。

有什么缺点？在使用Array（常量时间索引访问）实现的列表中，通过索引访问元素非常快，而在链接列表实现的列表中则不是那么快（其中操作需要与所访问元素的索引成比例的工作量）。

Redis列表使用链接列表实现，因为对于数据库系统，能够以非常快的方式将元素添加到很长的列表中是至关重要的。正如您稍后将看到的那样，Redis Lists可以在恒定时间内保持恒定长度。

当快速访问大量元素集合的中间位置很重要时，可以使用不同的数据结构，称为排序集。排序集将在本教程后面介绍。

我们就是利用List这种数据类型他的特性进行应用的，他就是类似于java的链表。

• redis服务端的操作

所述LPUSH命令将一个新元素到一个列表，在左侧（在头部），而RPUSH命令将一个新元素到一个列表，在右侧（在尾部）。最后， LRANGE命令从列表中提取元素范围：

> rpush mylist A
(integer) 1
> rpush mylist B
(integer) 2
> lpush mylist first
(integer) 3
> lrange mylist 0 -1
1) "first"
2) "A"
3) "B"


Redis列表中定义的一个重要操作是弹出元素的能力。弹出元素是从列表中检索元素并同时从列表中删除元素的操作。您可以从左侧和右侧弹出元素，类似于如何在列表的两侧推送元素：


> rpush mylist a b c
(integer) 3
> rpop mylist
"c"
> rpop mylist
"b"
> rpop mylist
"a"

java示例-生产消费模式

• 生产者

package com.example.demo.RedisTest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * @Author: zengwei
 * @Date: 2019/7/25 14:58
 * @Version 1.0
 */
@Component
public class Producer {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private ListOperations<String,String> listRedis;

    @PostConstruct
    private void init(){
        listRedis = stringRedisTemplate.opsForList();
    }

    public void publishMessage(String message){
        listRedis.leftPush("message",message);
    }
}

• 消费者

package com.example.demo.RedisTest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * @Author: zengwei
 * @Date: 2019/7/25 15:01
 * @Version 1.0
 */
@Component
public class Consumer {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private ListOperations<String,String> listRedis;

    @PostConstruct
    public void init(){
        listRedis = stringRedisTemplate.opsForList();
    }

    public void receive(){
        while (true){
            String message = listRedis.rightPop("message");
            if (message == null || message.isEmpty()){
                System.out.println("消息队列为空");
                break;
            }
            System.out.println("message:    " + message);
        }
    }
}

• 测试

package com.example.demo.controller;

import com.example.demo.RedisTest2.SendService;
import com.example.demo.RedisTest.Consumer;
import com.example.demo.RedisTest.Producer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author: zengwei
 * @Date: 2019/7/25 15:09
 * @Version 1.0
 */
@Controller
@RequestMapping(value = "/redis")
public class RedisController {
    @Autowired
    private Producer producer;
    @Autowired
    private Consumer consumer;
    @Autowired
    private SendService sendService;
    
    @RequestMapping(value = "/send/{message}")
    public void Producer(@PathVariable("message") String message){
        //生产消息
        producer.publishMessage(message);
    }

    @RequestMapping(value = "/receive")
    public void Consumer(){
        //消费消息
        consumer.receive();
    }
}

• 用poseman请求接口添加消息就好了
  
• 我们去redis看看数据
  
• 我们去消费消息
  
• 控制台信息
  

java示例-发布订阅模式

• 消息订阅者

package com.example.demo.RedisTest2;

import org.springframework.stereotype.Component;

/**
 *  消息订阅者
 * @Author: zengwei
 * @Date: 2019/7/25 16:41
 * @Version 1.0
 */
@Component
public class Receiver {

    public void receive(String message){
        System.out.println("Receive:    " + message);
    }
}

• 消息发布者

package com.example.demo.RedisTest2;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

/**
 *  消息发布者
 * @Author: zengwei
 * @Date: 2019/7/25 16:39
 * @Version 1.0
 */
@Component
public class SendService {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public void sendMessage(String message){
        stringRedisTemplate.convertAndSend("myChannel",message);
    }
}

package com.example.demo.RedisTest2;

import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;

/**
 *  订阅配置
 * @Author: zengwei
 * @Date: 2019/7/25 16:43
 * @Version 1.0
 */
@Configuration
@AutoConfigureAfter({Receiver.class})
public class SubscriberConfig {

    /**
     * 注入消息监听适配器
     * @param receiver
     * @return
     */
    @Bean
    public MessageListenerAdapter getMessageListenerAdapter(Receiver receiver){
        //设置消息接收者和接收者的方法
        return new MessageListenerAdapter(receiver,"receive");
    }

    /**
     * 注入消息监听容器
     * @param redisConnectionFactory
     * @param messageListenerAdapter
     * @return
     */
    @Bean
    public RedisMessageListenerContainer getRedisMessageListenerContainer(RedisConnectionFactory redisConnectionFactory,
                                                                          MessageListenerAdapter messageListenerAdapter){
        RedisMessageListenerContainer redisMessageListenerContainer = new RedisMessageListenerContainer();
        redisMessageListenerContainer.setConnectionFactory(redisConnectionFactory);
        redisMessageListenerContainer.addMessageListener(messageListenerAdapter,new PatternTopic("myChannel"));
        return redisMessageListenerContainer;
    }
}

• 测试

package com.example.demo.controller;

import com.example.demo.RedisTest2.SendService;
import com.example.demo.RedisTest.Consumer;
import com.example.demo.RedisTest.Producer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;

/**
 * @Author: zengwei
 * @Date: 2019/7/25 15:09
 * @Version 1.0
 */
@Controller
@RequestMapping(value = "/redis")
public class RedisController {
    @Autowired
    private Producer producer;
    @Autowired
    private Consumer consumer;
    @Autowired
    private SendService sendService;

    @RequestMapping(value = "/send/{message}")
    @ResponseBody
    public Object Producer(@PathVariable("message") String message){
        //生产消息
        producer.publishMessage(message);
        return "添加消息成功！";
    }

    @RequestMapping(value = "/receive")
    @ResponseBody
    public Object Consumer(){
        //消费消息
        consumer.receive();
        return "消费消息成功！";
    }

    @RequestMapping(value = "/send2/{message}")
    public void sendMessage(@PathVariable("message") String message){
        //发送消息
        sendService.sendMessage(message);
    }

}

• posman测试
  
• 控制台打印