Redis实现多人多聊天室功能

本文为大家分享了redis支持多人多聊天室功能的设计代码，供大家参考，具体内容如下

设计原理

左边的一个数据域,代表两个聊天室,聊天室id分别是827,729

在聊天室827里,有2个人,分别是jason22,jeff24他们分别已经阅读过聊天室内的id为5和6的消息

右边的一个数据域,代表了用户在不同的聊天室,jason22参与了827与729聊天室,在这两个聊天室里,他分别阅读到了id为5和id为10的消息

另外827聊天室内id为5的消息与729聊天室内id为5的消息不一样。

同时还有三个域
msgs:chatid
这是一个zset,有序集合,member是消息体,score是消息id
代表的是某个聊天室内已经发出的消息
另外 这里面存的是有用的消息,已经被所有人都阅读的消息就会被删除

ids:chatid
是一个string型的数据,里面放的是最新的消息的编号(发消息时,自增这个字段,即可获得最新的值)

ids:chat:
是一个string型的数据,里面放的是最新的聊天室的编号(创建聊天室时,自增这个字段)

代码

ok 开始看代码 

public string createchat(jedis conn, string sender, set<string> recipients, string message) { 
//启动的时候redis里是没有ids:chat:这个键的 
//自增之后返回1 
    string chatid = string.valueof(conn.incr("ids:chat:")); 
    return createchat(conn, sender, recipients, message, chatid); 
  } 
 
 
  /** 
  * 
  * @param conn 
  * @param sender 发送消息的人 
  * @param recipients 接受消息的人 
  * @param message 待发送的消息 
  * @param chatid 聊天室的编号 
  * @return 
  */ 
  public string createchat( jedis conn, string sender,  
    set<string> recipients, string message, string chatid){ 
  //自己发的消息 自己也能接受到 
    recipients.add(sender); 
 
 
    transaction trans = conn.multi(); 
    for (string recipient : recipients){ 
  //聊天室的成员 最开始时 都阅读的是0号信息 
      trans.zadd("chat:" + chatid, 0, recipient); 
  //记录每个人参加的聊天室 
      trans.zadd("seen:" + recipient, 0, chatid); 
    } 
    trans.exec(); 
 
 
    return sendmessage(conn, chatid, sender, message); 
  } 
 
 
  public string sendmessage(jedis conn, string chatid, string sender, string message) { 
   
  //锁住聊天室 为啥? 人员变动了咋办 
  //这个acquirelock见上一章 
    string identifier = acquirelock(conn, "chat:" + chatid); 
    if (identifier == null){ 
      throw new runtimeexception("couldn't get the lock"); 
    } 
    try { 
    //给要发布的消息设定一个最新的编号 第一次时 返回的是1 
      long messageid = conn.incr("ids:" + chatid); 
      hashmap<string,object> values = new hashmap<string,object>(); 
      values.put("id", messageid); 
      values.put("ts", system.currenttimemillis()); 
      values.put("sender", sender); 
      values.put("message", message); 
      string packed = new gson().tojson(values); 
       
      //某个聊天室的消息列表 
      //最旧的消息----消息json  
      //默认的zset是按照score的值从小到大排序 
      conn.zadd("msgs:" + chatid, messageid, packed); 
    }finally{ 
      releaselock(conn, "chat:" + chatid, identifier); 
    } 
    return chatid; 
  } 

 发消息现在就ok了,剩下的就是用户去拉取未读的消息了。这个比较麻烦,恩,相当的麻烦 

 @suppresswarnings("unchecked") 
  public list<chatmessages> fetchpendingmessages(jedis conn, string recipient) { 
   
  //获得用户在各个聊天室 已经看到的最新消息的id 
  //有几个聊天室 seenset的size就是几 
    set<tuple> seenset = conn.zrangewithscores("seen:" + recipient, 0, -1); 
    list<tuple> seenlist = new arraylist<tuple>(seenset); 
 
 
    transaction trans = conn.multi(); 
    for (tuple tuple : seenlist){ 
      string chatid = tuple.getelement(); 
      int seenid = (int)tuple.getscore(); 
      //获取每个聊天室里 未读的所有消息 
      //min 和 max 可以是 -inf 和 +inf 
      trans.zrangebyscore("msgs:" + chatid, string.valueof(seenid + 1), "inf"); 
    } 
    //我参加了几个聊天室 results的长度就是几 
    list<object> results = trans.exec(); 
 
 
    //com.google.gson.gson jar包自己下载吧 
    gson gson = new gson(); 
    iterator<tuple> seeniterator = seenlist.iterator(); 
    iterator<object> resultsiterator = results.iterator(); 
 
 
    //用户最后成功拉取的未读消息 存放在chatmessages 
    list<chatmessages> chatmessages = new arraylist<chatmessages>(); 
    list<object[]> seenupdates = new arraylist<object[]>(); 
    list<object[]> msgremoves = new arraylist<object[]>(); 
     
     
    //这个大的while循环 用户参与了几个聊天室 就循环几次 
    while (seeniterator.hasnext()){ 
      tuple seen = seeniterator.next(); 
      set<string> messagestrings = (set<string>)resultsiterator.next(); 
      if (messagestrings.size() == 0){ 
      //没有未读的消息 
        continue; 
      } 
 
 
      //代码运行到这里 
      //说明 我在某个聊天室 还有未读的消息 
      //seedid记录我已经拉取到的消息 初始为0 
      int seenid = 0; 
      //当前处理的是哪个聊天室 
      string chatid = seen.getelement(); 
       
      list<map<string,object>> messages = new arraylist<map<string,object>>(); 
       
      //我在聊天室未读的消息列表 
      for (string messagejson : messagestrings){ 
        map<string,object> message = (map<string,object>)gson.fromjson( 
          messagejson, new typetoken<map<string,object>>(){}.gettype()); 
        int messageid = ((double)message.get("id")).intvalue(); 
 
 
        if (messageid > seenid){ 
          seenid = messageid; 
        } 
        message.put("id", messageid); 
        //加入到成功拉取的列表里 
        messages.add(message); 
      } 
      //更新我在这个聊天室读到的最新消息 
      conn.zadd("chat:" + chatid, seenid, recipient); 
       
      //记录我在某个聊天室读到的最新记录 
      seenupdates.add(new object[]{"seen:" + recipient, seenid, chatid}); 
 
 
      //取出第0个member-score 
      set<tuple> minidset = conn.zrangewithscores("chat:" + chatid, 0, 0); 
      //为啥删除呢? 每个聊天室是一个zset表 第一条记录代表的就是 所有用户至少都读了的消息 
      if (minidset.size() > 0){ 
      tuple tuple=minidset.iterator().next(); 
      system.out.println("要删除的 tuple:"+tuple.getelement()+"--"+tuple.getscore()); 
        msgremoves.add(new object[]{"msgs:" + chatid, tuple.getscore()}); 
      } 
      chatmessages.add(new chatmessages(chatid, messages)); 
    } 
 
 
    trans = conn.multi(); 
    for (object[] seenupdate : seenupdates){ 
      trans.zadd( 
        (string)seenupdate[0], 
        (integer)seenupdate[1], 
        (string)seenupdate[2]); 
    } 
    for (object[] msgremove : msgremoves){ 
      trans.zremrangebyscore( 
        (string)msgremove[0], 0, ((double)msgremove[1]).intvalue()); 
    } 
    trans.exec(); 
 
 
    //返回的是我这次拉取获得的 最新的消息 
    return chatmessages; 
  } 

ok,咱们看看测试代码:

package redisinaction; 
 
 
import java.util.arrays; 
import java.util.hashset; 
import java.util.iterator; 
import java.util.list; 
import java.util.map; 
import java.util.set; 
 
 
import org.junit.beforeclass; 
import org.junit.test; 
 
 
import jedis.redis_in_action.chapter06; 
import jedis.redis_in_action.chapter06.chatmessages; 
import redis.clients.jedis.jedis; 
import redis.clients.jedis.tuple; 
 
 
/**  
 * this class is used for ...  
 * @author dlf([e-mail]) 
 * @version 1.0, 2016年10月17日 下午10:15:58  
 */ 
public class chapter06test { 
  static jedis conn = null; 
  static chapter06 c=null; 
   
  @beforeclass 
  public static void initconn(){ 
    system.out.println("test before"); 
    conn = new jedis("10.150.0.80"); 
    conn.auth("dlf123123"); 
     
    c=new chapter06(); 
  } 
   
 
 
   
  @test 
   public void testmultirecipientmessaging() { 
      system.out.println("\n----- testmultirecipientmessaging -----"); 
      conn.del("ids:chat:", "msgs:1", "ids:1", "seen:joe", "seen:jeff", "seen:jenny"); 
 
 
      system.out.println("let's create a new chat session with some recipients..."); 
      set<string> recipients = new hashset<string>(); 
      recipients.add("jeff"); 
      recipients.add("jenny"); 
      string chatid = c.createchat(conn, "joe", recipients, "message 1"); 
      system.out.println("now let's send a few messages..."); 
      for (int i = 2; i < 5; i++){ 
        c.sendmessage(conn, chatid, "joe", "message " + i); 
      } 
      system.out.println(); 
      system.out.println("看看消息库"); 
      //消息库里的所有消息 
      set<tuple> messagefrombase=conn.zrangewithscores("msgs:"+chatid, 0, -1); 
      iterator<tuple> iterator=messagefrombase.iterator(); 
      while(iterator.hasnext()){ 
        tuple tuple=iterator.next(); 
        system.out.println(tuple.getelement()+"　－－　　"+tuple.getscore()); 
      } 
      system.out.println("and let's get the messages that are waiting for jeff and jenny..."); 
       
       
      list<chatmessages> r1 = c.fetchpendingmessages(conn, "jeff"); 
      list<chatmessages> r2 = c.fetchpendingmessages(conn, "jenny"); 
    //当我拉取了joe的未读信息后 就会删除msgs:1里面的信息 
    //为什么?想明白了么? 
      list<chatmessages> r3 = c.fetchpendingmessages(conn, "joe"); 
      system.out.println("they are the same? " + r1.equals(r2)); 
       
      system.out.println("those messages are:"); 
      for(chatmessages chat : r1){ 
        system.out.println(" chatid: " + chat.chatid); 
        system.out.println("  messages:"); 
        for(map<string,object> message : chat.messages){ 
          system.out.println("   " + message); 
        } 
      } 
 
 
      system.out.println("看看还有没"); 
      messagefrombase=conn.zrangewithscores("msgs:"+chatid, 0, -1); 
       iterator=messagefrombase.iterator(); 
      while(iterator.hasnext()){ 
        tuple tuple=iterator.next(); 
        system.out.println(tuple.getelement()+"　－－　　"+tuple.getscore()); 
      } 
      conn.del("ids:chat:", "msgs:1", "ids:1", "seen:joe", "seen:jeff", "seen:jenny"); 
    } 
   
} 

搞定了,大家不妨把代码复制一份,自己看看
下面的是测试的结果

test before

----- testmultirecipientmessaging -----
let's create a new chat session with some recipients...
now let's send a few messages...

看看消息库
{"sender":"joe","id":1,"message":"message 1","ts":1477276890018}　－－　　1.0
{"sender":"joe","id":2,"message":"message 2","ts":1477276890113}　－－　　2.0
{"sender":"joe","id":3,"message":"message 3","ts":1477276890115}　－－　　3.0
{"sender":"joe","id":4,"message":"message 4","ts":1477276890116}　－－　　4.0
and let's get the messages that are waiting for jeff and jenny...
要删除的 tuple:jenny--0.0
要删除的 tuple:joe--0.0
要删除的 tuple:jeff--4.0
they are the same? true
those messages are:
  chatid: 1
    messages:
      {sender=joe, id=1, message=message 1, ts=1.477276890018e12}
      {sender=joe, id=2, message=message 2, ts=1.477276890113e12}
      {sender=joe, id=3, message=message 3, ts=1.477276890115e12}
      {sender=joe, id=4, message=message 4, ts=1.477276890116e12}
看看还有没

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。