Redis实现聊天功能

最新推荐文章于 2023-11-04 10:16:33 发布
最新推荐文章于 2023-11-04 10:16:33 发布
阅读量875 收藏 1
点赞数
分类专栏： java 文章标签： Redis
原文链接：https://www.cnblogs.com/qlqwjy/p/9784956.html
版权

原文转载自

1.Redis实现一对一的聊天功能(基于lpush和brpop实现)

简单的实现一个用户向另一个用户发送多条信息,实现的思路是:

一对一聊天的思路:(采用Lpush和Brpop实现)
1.消息生产者生产消息到redis中:生产消息的时候根据接收人的userName与消息的类型发送到对应的key，采用lpush发送消息(根据userName生成key)
2.消息的消费者根据userName，从userName的key中消费对应的消息。如果有必要可以将消息写到RDB中避免数据的丢失。(根据userName生成key的规则获取用户对应的消息)
3.消息的内容头部加入发送者，例如原来消息内容是:hello，为了知道消息的发送者可以改为:张三*-*hello(为了获取消息的发送者)

下面直接上代码:

User.java（只有一个userName有用）

package cn.xm.jwxt.bean.system;

import java.util.List;
import java.util.Set;

public class User {
  
    private String username;//用户姓名
public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username == null ? null : username.trim();
    }
}

redis-chat.properties

redis.url=127.0.0.1
redis.port=6379
redis.maxIdle=30
redis.minIdle=10
redis.maxTotal=100
redis.maxWait=20000

Jedis工具类:(返回Jedis连接)

package cn.xm.redisChat.util;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * @Author: qlq
 * @Description
 * @Date: 21:32 2018/10/9
 */
public class JedisPoolUtils {

    private static JedisPool pool = null;

    static {

        //加载配置文件
        InputStream in = JedisPoolUtils.class.getClassLoader().getResourceAsStream("redis-chat.properties");
        Properties pro = new Properties();
        try {
            pro.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //获得池子对象
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxIdle(Integer.parseInt(pro.get("redis.maxIdle").toString()));//最大闲置个数
        poolConfig.setMaxWaitMillis(Integer.parseInt(pro.get("redis.maxWait").toString()));//最大闲置个数
        poolConfig.setMinIdle(Integer.parseInt(pro.get("redis.minIdle").toString()));//最小闲置个数
        poolConfig.setMaxTotal(Integer.parseInt(pro.get("redis.maxTotal").toString()));//最大连接数
        pool = new JedisPool(poolConfig, pro.getProperty("redis.url"), Integer.parseInt(pro.get("redis.port").toString()));
    }

    //获得jedis资源的方法
    public static Jedis getJedis() {
        return pool.getResource();
    }
}

消息生产者：（处理消息头部加上消息的发送者，并且根据接受者的userName生成key）

package cn.xm.redisChat.one2one;

import cn.xm.jwxt.bean.system.User;
import cn.xm.redisChat.util.JedisPoolUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;

/**
 * @Author: qlq
 * @Description 消息生产者(根据消息的)
 * @Date: 23:02 2018/10/13
 */
public class RedisMessageProducer {
    private static final Logger log = LoggerFactory.getLogger(RedisMessageProducer.class);

    /**
     * 发送消息的方法
     *
     * @param sendUser   发送消息的用户
     * @param sendToUser 接收消息的用户
     * @param messages   可变参数返送多条消息
     * @return
     */
    public static boolean sendMessage(User sendUser, User sendToUser, String... messages) {
        Jedis jedis = JedisPoolUtils.getJedis();
        try {
            String key = sendToUser.getUsername() + ":msg";
            //将消息的内容加上消息的发送人以 *-* 分割，不能用增强for循环
            for (int i = 0, length_1 = messages.length; i < length_1; i++) {
                messages[i] = sendUser.getUsername() + "*-*" + messages[i];
            }
            Long lpush = jedis.lpush(key, messages);//返回值是还有多少消息未消费
            log.debug("user {} send message [{}] to {}", sendUser.getUsername(), messages, sendToUser.getUsername());
            log.debug("user {} has {} messages ", sendToUser.getUsername(), lpush);
        } catch (Exception e) {
            log.error("sendMessage error", e);
        } finally {
            jedis.close();
        }
        return true;
    }
}

消息的消费者:(采用线程池获取消息，根据接收消息的userName从对应的key中获取对应的消息，并解析消息的key和发送者和内容)

package cn.xm.redisChat.one2one;

import cn.xm.jwxt.bean.system.User;
import cn.xm.redisChat.util.JedisPoolUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * @Author: qlq
 * @Description 消息的消费者
 * @Date: 23:44 2018/10/13
 */
public class RedisMessageConsumer {
    private static final Logger log = LoggerFactory.getLogger(RedisMessageConsumer.class);

    /**
     * 参数是初始化线程池子的大小
     */
    private static final ScheduledExecutorService batchTaskPool = Executors.newScheduledThreadPool(2);

    /**
     * 消费消息
     *
     * @param consumerUser 接收消息的用户
     */
    public static void consumerMessage(final User consumerUser) {
        final Jedis jedis = JedisPoolUtils.getJedis();

        //新建一个线程，线程池获取消息
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while (true){
                    List<String> messages = jedis.brpop(0, consumerUser.getUsername() + ":msg");//0是timeout,返回的是一个集合，第一个是消息的key，第二个是消息的内容
                    String key = messages.get(0);//第一个是key
                    String message = messages.get(1);//第二个是消息
                    String sendUserName = message.substring(0, message.indexOf("*-*"));//获取消息的发送者
                    message = message.substring(message.indexOf("*-*")+3);//获取消息内容
                    log.debug("ThreadName is {},user {} consumer message {} ,sended by {}", Thread.currentThread().getName(),consumerUser.getUsername(), message, sendUserName);
                }
            }
        };
        //线程池中获取消息
        //第一个参数是需要执行的任务，第二个参数是第一次的延迟时间，第三个参数是两次执行的时间间隔，第四个参数是时间的单位
        batchTaskPool.scheduleWithFixedDelay(runnable, 3,5, TimeUnit.SECONDS);
    }
}

测试类:(lisi和wangwu消费消息)

package cn.xm.redisChat.one2one;

import cn.xm.jwxt.bean.system.User;

/**
 * @Author: qlq
 * @Description 消息消息
 * @Date: 0:04 2018/10/14
 */
public class ConsumerMessageApp {

    public static void main(String[] args) {
        User sndToUser = new User();
        sndToUser.setUsername("lisi");

        User sndToUser2 = new User();
        sndToUser2.setUsername("wangwu");

        RedisMessageConsumer.consumerMessage(sndToUser);
        RedisMessageConsumer.consumerMessage(sndToUser2);
    }
}

zhangsan给lisi和wangwu发送消息

package cn.xm.redisChat.one2one;

import cn.xm.jwxt.bean.system.User;

/**
 * @Author: qlq
 * @Description 生产消息测试
 * @Date: 23:59 2018/10/13
 */

public class ProducerMessageApp {
    public static void main(String[] args) {
        User sndUser = new User();
        sndUser.setUsername("zhangsan");

        User sndToUser = new User();
        sndToUser.setUsername("lisi");

        User sndToUser2 = new User();
        sndToUser2.setUsername("wangwu");

        RedisMessageProducer.sendMessage(sndUser, sndToUser, "给李四的消息一", "给李四的消息二");
        RedisMessageProducer.sendMessage(sndUser, sndToUser2, "给王五的消息一", "给王五的消息二");
    }
}

1.先启动消费者

2.启动消费者之后

消费者控制台如下:
在这里插入图片描述
生产者控制台如下:
在这里插入图片描述
3.再次启动消费者之后

消费者控制台:
在这里插入图片描述
生产者控制台:
在这里插入图片描述
至此实现了简单的一对一聊天，实际上就是简单的一个用户给另一个用户发送消息。上面采用这种方式实现的即使用户上线也会接受之前未接受的消息。只有BRPOP之后消息才会消失。

实际中可以根据需求进行实际的开发，实际中有消息类型、内容等。

有时间的话可以用kindeditor实现一个简单的一对一web聊天系统，这个功能待完成。==============

2.群聊功能(基于发布/订阅实现)

群聊的思路:采用发布订阅模式实现(publish和subscribe实现)
1.每个channel都有一个频道，每一个channel代表一个群，用户每次订阅这个房间都代表进入这个群，可以发送与接收消息
2.发送者每次发送消息都需要先进入房间，也就是订阅channel，之后可以向该频道发送消息
3.接收者需要先进入房间，也就是订阅channel，然后接收消息

也就是不管发送消息与接收消息，都需要订阅channel进入房间。用户进入某个房间可以存入到zSet，每次进入某个房间和发送消息先判断是否已经进入某个房间。比如:
房间room1，则channel就是room1,保存其成员的set就是room1members。

总的来说:
　　　　每个房间都是一个channel，进入房间的成员订阅该channel。每个房间的成员保存在一个zset中，key可以定义为roomName+“users”。

用户退出房间的时候需要退出该房间，也就是退订该channel，同时在zset中移除该成员。(退订只能调用JedisPubSub的unsubscribe实现)。

也就是一个房间对应的信息如下:

一个channel，名称为 roomName 发送的群消息到这个channel

一个zset，对应的key为roomName+“users”,保存的是进入该房间的用户，用户退出房间需要借助退出房间的消息以及退订实现

发送群聊消息直接publish消息到该roomName即可。

下面上代码:

RoomUtil 用户进入某个房间与退出某个房间。退出房间需要发出退出房间的信号(也就是发送一条退订的消息)

package cn.xm.redisChat.groupChat;

import cn.xm.jwxt.bean.system.User;
import cn.xm.redisChat.util.JedisPoolUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;

/**
 * @Author: qlq
 * @Description 进入房间的工具类(订阅某个channel，代表进入房间)
 * @Date: 16:15 2018/10/14
 */
public class RoomUtil {

    private static final Logger log = LoggerFactory.getLogger(RoomUtil.class);

    /**
     * 进入房间
     *
     * @param user     用户
     * @param roomName
     */
    public static void enterRoom(User user, String roomName) {
        Jedis jedis = JedisPoolUtils.getJedis();
        String username = user.getUsername();
        Boolean sismember = jedis.sismember(roomName + "users", username);
        if (!sismember) {
            jedis.sadd(roomName + "users", username);
            log.info("{} 已经成功进入房间  {}！", username, roomName);
        } else {
            log.info("{} 已经进入房间，不能重复进入！", username);
        }
    }

    /**
     * 退出房间
     *
     * @param user     用户
     * @param roomName 房间名称
     */
    public static void exitRoom(User user, String roomName) {
        Jedis jedis = JedisPoolUtils.getJedis();
        String username = user.getUsername();
        Boolean sismember = jedis.sismember(roomName + "users", username);
        if (sismember) {
            //从成员组中移除
            jedis.srem(roomName + "users", username);
            //发送退订信号(房间内的成员收到该信号后退订)
            String exitSignal = user.getUsername() + ":exit:" + roomName;
            jedis.publish(roomName, exitSignal);
            log.info("{} 已经发出移除房间  {}的信号！", username, roomName);
        } else {
            log.info("{} 已经不在房间内！", username);
        }
    }

    /**
     * 判断用户是否在某个房间
     *
     * @param user
     * @param roomName
     * @return
     */
    public static boolean userIsInRoom(User user, String roomName) {
        Jedis jedis = JedisPoolUtils.getJedis();
        return jedis.sismember(roomName + "users", user.getUsername());
    }
}

消息生产者:(publish发布消息到指定的channe)

package cn.xm.redisChat.groupChat;

import cn.xm.jwxt.bean.system.User;
import cn.xm.redisChat.util.JedisPoolUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;

/**
 * @Author: qlq
 * @Description 消息生产者
 * @Date: 18:09 2018/10/14
 */
public class MessageProducer {
    private static final Logger log = LoggerFactory.getLogger(MessageProducer.class);

    public static void produceMsg(final User sendUser, String roomName, String... messages) {
        //发送消息
        Jedis jedis = JedisPoolUtils.getJedis();
        for (int i = 0, length_1 = messages.length; i < length_1; i++) {
            String msg = sendUser.getUsername() + "*-*" + messages[i];
            log.debug(msg);
            jedis.publish(roomName, msg);//发送消息
        }
    }
}

消息消费者:

开启线程获取消息，如果收到的是自己退订的信号则自己退出房间(取消订阅该channel)，订阅之后线程会一直阻塞，退订之后才会结束线程,也就是局部线程t会一直阻塞，直到收到退订信号之后才会结束线程(也就不再获取消息)

package cn.xm.redisChat.groupChat;

import cn.xm.jwxt.bean.system.User;
import cn.xm.redisChat.util.JedisPoolUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPubSub;

/**
 * @Author: qlq
 * @Description 消息消费者(订阅频道消费消息)
 * @Date: 16:12 2018/10/14
 */
public class MessageConsumer {
    private static final Logger log = LoggerFactory.getLogger(MessageConsumer.class);

    public static void consumerMsg(final User user, final String roomName) {
        if (!RoomUtil.userIsInRoom(user, roomName)) {
            RoomUtil.enterRoom(user, roomName);
        }

        final Jedis jedis = JedisPoolUtils.getJedis();
        //新建一个线程，线程池获取消息
        Thread t = new Thread() {
            @Override
            public void run() {
                jedis.subscribe(new JedisPubSub() {
                    @Override
                    public void onMessage(String channel, String message) {
                        //如果收到退订信号就退订频道
                        String exitSignal = user.getUsername() + ":exit:" + roomName;
                        if (exitSignal.equals(message)) {
                            unsubscribe(channel);
                            log.info("============" + exitSignal + "============,channel->{}", channel);
                        } else if (!message.contains(":exit:")) {
                            log.info("{} consume msg:{},room is->{}", user.getUsername(), message, channel);
                        }
                    }

                    @Override
                    public void unsubscribe(String... channels) {
                        log.info("==============unsubscribe {}========", channels);
                        super.unsubscribe(channels);
                    }
                }, roomName);
            }
        };
        t.start();
    }
}

测试类:

package cn.xm.redisChat.groupChat;

import cn.xm.jwxt.bean.system.User;
import org.junit.Test;

/**
 * @Author: qlq
 * @Description
 * @Date: 21:46 2018/10/14
 */
public class MsgProduceApp {
    public static void main(String[] args) {
        String roomName1 = "room1", roomName2 = "room2";
        User sendUser = new User();
        sendUser.setUsername("zhangsan");

        MessageProducer.produceMsg(sendUser, roomName1, "消息一", "消息二");
        MessageProducer.produceMsg(sendUser, roomName2, "消息一一", "消息二二");
    }

    /**
     * 将用户lisi移除房间2
     */
    @Test
    public void fun2() {
        User user = new User();
        user.setUsername("lisi");
        RoomUtil.exitRoom(user, "room2");
    }
}

package cn.xm.redisChat.groupChat;

import cn.xm.jwxt.bean.system.User;

/**
 * @Author: qlq
 * @Description
 * @Date: 18:19 2018/10/14
 */
public class MsgConsumeApp {

    public static void main(String[] args) {
        String roomName1 = "room1", roomName2 = "room2";
        User sendUser = new User();
        sendUser.setUsername("lisi");
        User sendUser2 = new User();
        sendUser2.setUsername("wangwu");

        MessageConsumer.consumerMsg(sendUser, roomName1);
        MessageConsumer.consumerMsg(sendUser, roomName2);

        MessageConsumer.consumerMsg(sendUser2, roomName2);
    }
}

测试过程如下:

1.先调用MsgConsumeApp订阅房间
在这里插入图片描述
2.调用MsgProduceApp生产消息

生产者控制台:
在这里插入图片描述
消费者控制台:
在这里插入图片描述
3.调用fun2 退出房间:

消费者控制台:
在这里插入图片描述
4.再次调用生产者生产消息:(lisi不接收房间2的消息)
在这里插入图片描述
至此完成了群聊功能，实际上群聊还可以用线程池处理接收消息的线程，暂时用远程的Thread处理。

Yang_薛
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring集成redis实现聊天室功能
02-17
spring集成redis，实现订阅、发布消息聊天室网页群聊功能。
springboot+websocket+redis实现聊天室
08-05
springboot+websocket+redis实现聊天室功能，可以实现私聊和群聊(并支持发送图片)
Redis创始人开源最小聊天服务器，仅200行代码，几天功夫已获2.8K Star！
程序猿DD
11-04 445
中午时候，在里聊起关于Redis创始人的一些趣事，比如离开Redis之后，去写科幻小说之类的。因为好奇科幻小说，TJ君就去搜索了一下。结果一搜，发现Redis作者最近居然又搞了个新活儿！
java基于Redis及WebSocket实现聊天室(一)
CJD的博客
04-16 4853
基于Redis及WebSocket的聊天室 在线测试地址： http://123.206.50.156:8763/hi?name=XXXXX
java基于Redis及WebSocket实现聊天室(二)
CJD的博客
04-16 1909
基于Redis及WebSocket的聊天室 在线测试地址： http://123.206.50.156:8763/hi?name=XXXXX
java聊天功能（集群）redis订阅发布实现
翎墨袅
10-24 1041
java聊天（集群）
Redis实现多人多聊天室功能
09-09
主要为大家详细介绍了Redis实现多人多聊天室功能,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
IM-Server:基于SSH+Redis+MySQL的IM即时聊天系统实现
05-26
IM-Server基于SSH+Redis+MySQL的IM即时聊天系统实现依赖与开发环境说明Maven工程， IDE：IDEAMySQL: 5.7Redis: 5.0.4如果需要使用离线推送服务，需要在个推开通推送服务，然后更新配置文件中与个推相关的配置信息...
Python django4.0实现简易聊天室（channels、channels-redis）
08-02
channels-redis有redis环境依赖，需要提前安装redis环境且版本>=5.0（可百度安装教程） python环境3.8、以及虚拟环境安装自行安装（建议安装虚拟环境） 有虚拟环境进入虚拟环境执行如下命令： pip install -r ...
WebSocket聊天室实现J-IM+SpringBoot+Zookeeper+Redis
06-10
J-IM 是用JAVA语言,基于t-io开发的轻量、高性能、单机支持几十万至百万在线用户IM，主要目标降低即时通讯门槛，快速打造低成本接入在线...已实现：群组、图片、红包等扩展功能。群聊审核、公告、禁言开关、系统广播等。
swoole+thinkphp+redis+mysql实现单聊群聊功能
01-29
thinkphp5.1+swoole2.0+redis+php7+mysql 开发单聊、群聊 使用swoole websocket 协议 前端使用js （浏览器手机模式或者手机上体验更佳） 体验地址：http://chat.daxueshenghome.com 账号：三国里边的人物(诸葛亮、...
Springboot+websocket 实现多人聊天室/单人聊天
10-11
这是一个简单使用websocket实现多人聊天室，单人聊天室的demo，里面使用的是最原始的websocket的方法，附有客户端界面可以直接跑起来发送消息看效果。 该项目对应刚刚接触websocket技术是比较有用的。 2019-10-11的...
springboot+security+jwt+redis 实现微信小程序登录及token权限鉴定.zip
最新发布
03-10
社交属性强：小程序可以无缝嵌入微信生态，支持分享至聊天窗口、朋友圈等社交场景，有利于用户间的传播和裂变增长。 丰富接口能力：提供丰富的API接口，可调用微信支付、位置服务、用户身份识别等多种功能，方便...
基于swoole实现多人聊天室
01-21
本文实例为大家分享了swoole创建多人多房间聊天室的具体代码，供大家参考，具体内容如下 核心的swoole代码 基本的cs(client-sercer)结构不变,这里利用的是redis的哈希和set来储存和分组;从而达到了分组,统计,定时推...
nodejs聊天室，redis存储，sokect通信
07-03
nodejs聊天室，redis存储，sokect通信。实现功能。弹幕（所有人可见）。在线用户实时推送。实时聊天。提示消息被阅读。显示未读消息数量。注册登录。
75行Java Redis实时聊天室 还带界面！
QuKinX
08-17 329
直接上图！ 用的是Redis的订阅功能 上代码！ package com.qukin.chatroom; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPubSub; import javax.swing.*; import javax.swing.text.DefaultCaret; import java.awt.*; import java.text.SimpleDateFormat; import java.ut
PHP 微信小程序 WebSocket MySQL Redis实现聊天功能
amateur12的博客
04-18 4153
1.Mysql 实现离线消息池。如果一个用户不在线，则其他用户发送给他的消息暂时存储在mysql。待该用户上线时，再从离线消息池取出发送。 2.Redis 实现每个连接websocket的服务都唯一绑定一个用户。通过用户账号 = fd 存到redis中。 微信小程序： websocket.php代码： <?php //创建WebSocket Server对象，监听0.0.0.0:9501端口 $ws = new Swoole\WebSocket\Server('0.0.0...
redis 实现对聊天数据的缓存机制
懒得停下脚步
05-19 4795
import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concu
springboot+redis实现简单网站聊天功能
07-09
### 回答1： Spring Boot 是一个开箱即用的 Java 开发框架，...通过这样的方式，我们就可以使用Spring Boot和Redis实现简单的网站聊天功能了。当有用户发送消息时，消息将被发送到Redis服务器，并可以被其他用户获取。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值