Redis实现多人多聊天室

本文可作为redis in aciton第六章的读书笔记


功能特性

支持多人多聊天室

设计原理

Redis实现多人多聊天室_第1张图片

左边的一个数据域,代表两个聊天室,聊天室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 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 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 values = new HashMap();
            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 fetchPendingMessages(Jedis conn, String recipient) {
    	
    	//获得用户在各个聊天室 已经看到的最新消息的id
    	//有几个聊天室 seenSet的size就是几
        Set seenSet = conn.zrangeWithScores("seen:" + recipient, 0, -1);
        List seenList = new ArrayList(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 results = trans.exec();


        //com.google.gson.Gson jar包自己下载吧
        Gson gson = new Gson();
        Iterator seenIterator = seenList.iterator();
        Iterator resultsIterator = results.iterator();


        //用户最后成功拉取的未读消息 存放在chatMessages
        List chatMessages = new ArrayList();
        List seenUpdates = new ArrayList();
        List msgRemoves = new ArrayList();
        
        
        //这个大的while循环 用户参与了几个聊天室 就循环几次
        while (seenIterator.hasNext()){
            Tuple seen = seenIterator.next();
            Set messageStrings = (Set)resultsIterator.next();
            if (messageStrings.size() == 0){
            	//没有未读的消息
                continue;
            }


            //代码运行到这里
            //说明 我在某个聊天室 还有未读的消息
            //seedid记录我已经拉取到的消息 初始为0
            int seenId = 0;
            //当前处理的是哪个聊天室
            String chatId = seen.getElement();
            
            List> messages = new ArrayList>();
            
            //我在聊天室未读的消息列表
            for (String messageJson : messageStrings){
                Map message = (Map)gson.fromJson(
                    messageJson, new TypeToken>(){}.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 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([email protected])
 * @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 recipients = new HashSet();
	        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 messageFromBase=conn.zrangeWithScores("msgs:"+chatId, 0, -1);
	        Iterator 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 r1 = c.fetchPendingMessages(conn, "jeff");
	        List r2 = c.fetchPendingMessages(conn, "jenny");
		//当我拉取了joe的未读信息后 就会删除msgs:1里面的信息
		//为什么?想明白了么?
	        List 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 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}
看看还有没



你可能感兴趣的:(Redis,Redis技术相关)