Redis实现消息队列

最新推荐文章于 2024-08-13 18:22:26 发布
最新推荐文章于 2024-08-13 18:22:26 发布
阅读量276 收藏 4
点赞数
文章标签： 数据库 测试 java
原文链接：https://my.oschina.net/voole/blog/728897
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

基于Redis消息队列-实现短信服务化

1.Redis实现消息队列原理

常用的消息队列有RabbitMQ,ActiveMQ，个人觉得这种消息队列太大太重，本文介绍下基于Redis的轻量级消息队列服务。 
一般来说，消息队列有两种模式，一种是发布者订阅模式，另外一种是生产者和消费者模式。Redis的消息队列，也是基于这2种原理的实现。 
发布者和订阅者模式：发布者发送消息到队列，每个订阅者都能收到一样的消息。 
生产者和消费者模式：生产者将消息放入队列，多个消费者共同监听，谁先抢到资源，谁就从队列中取走消息去处理。注意，每个消息只能最多被一个消费者接收。

2.Redis消息队列使用场景

在我们的项目中，使用消息队列来实现短信的服务化，任何需要发送短信的模块，都可以直接调用短信服务来完成短信的发送。比如用户系统登录注册短信，订单系统的下单成功的短信等。

3.SpringMVC中实现Redis消息队列

因为我们短信只需要发送一次，所以我们使用的是消息队列的生产者和消费者模式。

3.1引入Maven依赖

引入Redis相应的maven依赖，这里需要spring-data-redis和jedis

    //pom.xml
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>1.6.0.RELEASE</version>
    </dependency>

      <!-- jedis -->
      <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
             <version>2.5.1</version>
        </dependency>

3.2配置redis生成者消费者模式

    //applicationContext-redis.xml
    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:redis="http://www.springframework.org/schema/redis"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
                            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-34.0.xsd     
                            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
                            http://www.springframework.org/schema/aop  http://www.springframework.org/schema/aop/spring-aop.xsd
                            http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.0.xsd
                            http://www.springframework.org/schema/redis http://www.springframework.org/schema/redis/spring-redis-1.0.xsd">
    <description>spring-data-redis配置</description>

    <bean id="redisConnectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.host}"></property>
        <property name="port" value="${redis.port}"></property>
        <property name="usePool" value="true"></property>
    </bean>

    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="redisConnectionFactory"></property>
    </bean>

    <bean id="jdkSerializer"
        class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />

    <bean id="smsMessageListener"
        class="org.springframework.data.redis.listener.adapter.MessageListenerAdapter">
        <property name="delegate" ref="smsMessageDelegateListener" />
        <property name="serializer" ref="jdkSerializer" />
    </bean>

    <bean id="sendMessage" class="com.djt.common.cache.redis.queue.SendMessage">
        <property name="redisTemplate" ref="redisTemplate"/>
    </bean>

    <redis:listener-container>
        <redis:listener ref="smsMessageListener" method="handleMessage"
            serializer="jdkSerializer" topic="sms_queue_web_online" />
    </redis:listener-container>

    <!-- jedis -->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="300" /> <!-- 最大能够保持idel状态的对象数  -->
        <property name="maxTotal" value="60000" /> <!-- 最大分配的对象数 -->
        <property name="testOnBorrow" value="true" /> <!-- 当调用borrow Object方法时，是否进行有效性检查 -->
    </bean>

    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
        <constructor-arg index="0" ref="jedisPoolConfig" />
        <constructor-arg index="1" value="${redis.host}" />
        <constructor-arg index="2" value="${redis.port}" type="int" />
    </bean>

</beans>

主要的配置说明： 
1.序列化：一般我们向Redis发送一个消息定义的Java对象，这个对象需要序列化。这里使用JdkSerializationRedisSerializer：

<bean id="jdkSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />

2.发送者：

<bean id="sendMessage" class="com.djt.common.cache.redis.queue.SendMessage">
        <property name="redisTemplate" ref="redisTemplate"/>
    </bean>

3.监听者：

    <bean id="smsMessageListener"
        class="org.springframework.data.redis.listener.adapter.MessageListenerAdapter">
        <property name="delegate" ref="smsMessageDelegateListener" />
        <property name="serializer" ref="jdkSerializer" />
    </bean>
    <redis:listener-container>
        <redis:listener ref="smsMessageListener" method="handleMessage"
            serializer="jdkSerializer" topic="sms_queue_web_online" />
    </redis:listener-container>

smsMessageListener：消息监听器 
redis:listener-container：定义消息监听，method：监听消息执行的方法，serializer：序列化，topic：监听主题（可以理解为队列名称）

3.3代码实现

1.定义短信消息对象SmsMessageVo

public class SmsMessageVo implements Serializable {
    //id
    private Integer smsId;

    //手机号
    private String mobile;

    //类型，1：验证码 2：订单通知
    private Byte type;

    //短信创建时间
    private Date createDate;

    //短信消息处理时间
    private Date processTime;

    //短信状态，1：未发送 2：发送成功 3：发送失败
    private Byte status;

    //短信内容
    private String content;

    //省略setter和getter方法
    ...

2.定义消息队列发送对象SendMessage

//SendMessage.java
public class SendMessage {

    private RedisTemplate<String, Object> redisTemplate;


    public RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }



    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }



    public void sendMessage(String channel, Serializable message) {
        redisTemplate.convertAndSend(channel, message);
    }
}

3.发送消息

    String smsContent = templateToContent(template.getContent(),
                    regMsgCode);
    SmsMessageVo smsMessageVo = new SmsMessageVo();
    smsMessageVo.setMobile(mobile);
    smsMessageVo.setType((byte) SmsType.VERIFICATION.getType());
    smsMessageVo.setChannelId(1);
    smsMessageVo.setContent(smsContent);
    smsMessageVo.setCreateDate(new Date());
    smsMessageVo.setStatus((byte) SmsSendStatus.TO_SEND.getType());
    smsMessageVo.setTemplateId(1);

    //先把待发送的短信存入数据库
    SmsQueue smsQueue = new SmsQueue();
    BeanUtils.copyProperties(smsQueue, smsMessageVo);
    smsQueueService.addSmsQueue(smsQueue);

    //异步发送短信到redis队列
    sendMessage.sendMessage(Constants.REDIS_QUEUE_SMS_WEB, smsMessageVo);
    //Constants.REDIS_QUEUE_SMS_WEB = "sms_queue_web_online",和applicationContext-redis中topic配置一样

4.监听消息

//SmsMessageDelegateListener.java
@Component("smsMessageDelegateListener")
public class SmsMessageDelegateListener {

    @Autowired
    private SmsQueueService smsQueueService;

    //监听Redis消息
    public void handleMessage(Serializable message){
        if(message instanceof SmsMessageVo){
            SmsMessageVo messageVo = (SmsMessageVo) message;

            //发送短信
            SmsSender smsSender = SmsSenderFactory.buildEMaySender();
            smsSender.setMobile(messageVo.getMobile());
            smsSender.setContent(messageVo.getContent());
            boolean sendSucc = false;
            //判断短信类型
            //验证码短信
            if(messageVo.getType() == (byte)SmsType.VERIFICATION.getType()){
                sendSucc = smsSender.send();
            }


            if(!sendSucc){
                return;
            }

            // 异步更新短信表状态为发送成功
            final Integer smsId = messageVo.getSmsId();
            Executor executor = Executors.newSingleThreadExecutor();
            executor.execute(new Runnable() {
                public void run() {
                    SmsQueue smsQueue = new SmsQueue();
                    smsQueue.setSmsId(smsId);
                    smsQueue.setStatus((byte)SmsSendStatus.SEND.getType());
                    smsQueue.setProcessTime(new Date());
                    smsQueueService.updateSmsQueue(smsQueue);
                }
            });

        }
    }
}

4.总结

下面使用一张流程图，来总结Redis消息队列和短信服务。 
这里写图片描述

转载于:https://my.oschina.net/voole/blog/728897

redis java 队列_Java利用Redis实现消息队列
weixin_39964978的博客
02-12 328
packageUtils;importredis.clients.jedis.Jedis;importredis.clients.jedis.JedisPool;importredis.clients.jedis.JedisPoolConfig;importjava.util.List;importjava.util.Map;importjava.util.Set;/*** Created by ...
Java利用Redis实现消息队列
weixin_30908649的博客
05-05 730
应用场景 为什么要用redis?二进制存储、java序列化传输、IO连接数高、连接频繁 一、序列化 　　这里编写了一个java序列化的工具,主要是将对象转化为byte数组,和根据byte数组反序列化成java对象;主要是用到了ByteArrayOutputStream和ByteArrayInputStream;注意:每个需要序列化的对象都要实现Serializable接口;...
技术研究：Redis 实现消息队列
最新发布
技术研究记录
08-13 1233
消息队列应用的三大需求是：1、消息保序；2、重复消息处理；3、消息可靠性保证。对应处理方案是：1、消息数据有序存取；2、消息数据具有全局唯一编号；3、消息数据在未消费完宕机恢复时继续消费，消费完成后被删除。
java redis使用之利用jedis实现redis消息队列
qiezikuaichuan的专栏
09-14 924
http://www.2cto.com/kf/201505/403602.html 应用场景 最近在公司做项目，需要对聊天内容进行存储，考虑到数据库查询的IO连接数高、连接频繁的因素，决定利用缓存做。 从网上了解到redis可以对所有的内容进行二进制的存储，而java是可以对所有对象进行序列化的，序列化的方法会在下面的代码中提供实现。 序列化 这里我编写了一个java序列
Redis 实现消息队列
Mwt258的博客
08-07 3496
【Redis】介绍如何利用redis实现消息队列(超详细)
Java利用Redis实现消息队列的示例代码
08-29
Java利用Redis实现消息队列的示例代码 以下是Java利用Redis实现消息队列的示例代码的知识点总结： 一、序列化 * 序列化是将对象转换为byte数组的过程，Java中可以使用ByteArrayOutputStream和...
Qt 应用Redis 实现消息队列
11-03
本篇文章将详细讲解如何在Qt应用程序中利用Redis来实现一个高效的消息队列，以实现点对点的生产者-消费者模式。 首先，我们需要了解Qt和Redis的基础知识。Qt是一个跨平台的C++图形用户界面库，它提供了丰富的API...
PHP中利用redis实现消息队列处理高并发请求思路详解.rar
09-16
Redis作为一款高性能的键值数据库，常被用于构建消息队列，因为它提供了丰富的数据结构（如列表、集合、通道等）和原子操作，非常适合于实现消息的发布与订阅、入队与出队等操作。 在PHP中，我们可以使用Predis或...
Java使用Redis实现消息队列
zhangximing的博客
02-19 1512
redis实现消息队列时一般使用 list 结构作为队列， rpush 生产消息， lpop 消费消息。当 lpop 没有消息的时候，要适当sleep 一会再重试。若不使用sleep，则可以用指令blpop（该指令在没有消息的时候，它会阻塞住直到消息到来）
Java操作Redis消息队列案例（应用于Socket通信）
09-13
redis 案例。包含， 队列操作， socket通信， 以及 socket 和 redis 配合 redis 案例。包含， 队列操作， socket通信， 以及 socket 和 redis 配合
java redis实现消息队列功能
wuyuanshun的博客
06-30 4698
需求：业务中需要批量处理任务，且需要每个任务间隔一段时间。最好在不同服务器同时运行不影响每个任务间隔。 部署环境：没有mq队列，有redis。
java redis队列_Java实现Redis消息队列
weixin_39926193的博客
02-12 232
这里我使用Redis的发布、订阅功能实现简单的消息队列，基本的命令有publish、subscribe等。在Jedis中，有对应的java方法，但是只能发布字符串消息。为了传输对象，需要将对象进行序列化，并封装成字符串进行处理。使用Redis实现消息队列封装一个消息对象public class Message implements Serializable{private static final...
Java redis实现消息队列
不染心的博客
07-01 7490
文章目录一、单元测试Java多线程二、redis实现消息队列三、java多线程模拟生产者消费者 一、单元测试Java多线程 使用junit测试多线程代码，但是等到程序结束，输出结果不完整，或者是完全没结果，因此，可能是其他线程还没结束，主线程就结束了。 原因： junit在运行时，在主线程结束后就关闭了进程，不会等待各个线程运行结束。 ==解决方法：==①要是要求不高，可以通过thread.sleep()，让主线程暂时休眠（TimeUnit.MILLISECONDS.sleep(2
java redis 消息_java 实现redis消息队列
weixin_29863401的博客
02-18 303
业务场景：由于项目需求需要对接多个PLC设备，获取PLC设备数据，网络传输得数据获取后直接做业务逻辑处理，可能会对数据库造成一定压力，甚至会导致程序崩溃。解决方案：PLC设备数据过来，Netty创建得服务端，处理接收客户端发送得数据，先存入到Redis队列，后台再开启多个线程处理redis队列中得数据。Service层业务代码package com.company.netty.service.re...
在 Java 中使用 redis 的消息队列服务
BASK2312的博客
02-01 4072
关于 redis 我们前面已经讨论过了缓存、分布式锁、分布式唯一标识、LBS服务的用法，这里我们来谈谈利用 redis 来实现一个消息服务。典型的消息服务是一个生产者和消费者模式的服务。一般是有生产者产生消息，将消息发送到队列中。而消息的消费者则监听消息，对消息进行处理。有很多非常优秀的消息队列服务的产品。例如 RabbitMQ、RocketMQ、Kafka 等。这些产品都具备非常高级的功能。可靠性、扩展性都非常的好。但是 redis 自身也能够很简单的实现消息队列的生产者和消费者模式。
使用Redis 实现消息队列
chou_out_man的博客
03-23 6440
一 、为什么要用Redis实现轻量级MQ？ MQ的主要作用： 应用解耦 异步化消息 流量削峰填谷 目前使用比较多的是ActiveMQ 、 RabbitMQ 、 ZeroMQ 、 Kafka 、 MetaMQ 、 RocketMQ等 在业务实现过程中 ， 就算没有大量的流量 ， 解耦和异步化也是处处可用 ， 此时MQ就显得尤为重要 。 但与此同时MQ也是一个蛮重的组件，例如我们如果用Rab...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值