基于订阅/发布模式的简易聊天室实现（java+redis）

对于本篇博文主要从以下两部分介绍简易聊天室的实现：
1.介绍redis发布订阅模式
2.java代码实现订阅发布模式

一、redis发布订阅模式
redis订阅分为订阅频道和订阅模式
1.订阅频道
打开一个客户端1，订阅电影直播频道：
127.0.0.1:6379> subscribe "movie::live::room"
在电影直播频道发布信息A
127.0.0.1:6379> publish movie::live::room "Does someone like snow white?"
在消息发布后，订阅消息的客户端1就会收到发布的信息。如果我们想要订阅多个频道，可以使用订阅模式。

2.订阅模式
重新打开一个启客户端2，并订阅有关电影的模式：
127.0.0.1:6379> psubscribe "movie*"
此时在电影直播频道重新发布消息A,客户端1和客户端2都会收到发布的消息。
如果在电影历史频道发布消息B，
127.0.0.1:6379> publish movie::history::room "Does someone like snow white?"
此时只有客户端2会收到消息。
订阅模式支持* 、? 、 []三种模式
*匹配后面所有的字符
?匹配一个字符
[]匹配中括号里的字符 h[eo]llo 匹配hello和hollo

二、java代码实现订阅发布模式
接下来使用Jedis实现一个简单的聊天室
我们用redis作为服务转发，所以没有服务端代码，只需要写客户端就可以了：
定义客户端,功能比较简单，进入房间提示、离开房间提示、在房间说话:

package redis.publishandsubscribe;

import java.util.Scanner;

import redis.RedisUtil;

public class Client {
    private String name ;
    private ChatSubscribe roomSubListerner;

    public Client(){
        roomSubListerner = new ChatSubscribe();
    }

    public void setName(String name){
        this.name =name;
    }
    public String getName(){
        return name;
    }
    /* 进入房间*/
    public void subscribe(final String[] room){
        ChatSubscribe roomSub = roomSubListerner;
        roomSub.setClientName(name);
        roomSub.setRoom(room);
        RedisUtil.subscribe(room, roomSub);
    }
    /* 退出房间*/
    public void unSubscribe(final String[] room){
        roomSubListerner.unsubscribe(room);
    }
    /*说话*/
    public void say(final String room,String message){
        RedisUtil.publish(room, name+" say:"+message);
    }
}

在上面的代码中有一个ChatSubscribe的类，该类为聊天室的动作监听类，在这个类中我们只定义订阅频道、取消订阅频道、接收消息方法：

package redis.publishandsubscribe;

import redis.RedisUtil;
import redis.clients.jedis.JedisPubSub;

public class ChatSubscribe  extends JedisPubSub{
    /*成员名字*/
    private String clientName;
    /*房间名*/
    private String[] room;

    public String getClientName() {
        return clientName;
    }

    public void setClientName(String clientName) {
        this.clientName = clientName;
    }

    public String[] getRoom() {
        return room;
    }

    public void setRoom(String[] room) {
        this.room = room;
    }

    @Override
    public void onUnsubscribe(String channel, int subscribedChannels) {
        //do nothing
    }

    @Override
    public void onSubscribe(String channel, int subscribedChannels) {
        RedisUtil.publish( channel,clientName+ "进入房间");
    }

    @Override
    public void onPUnsubscribe(String pattern, int subscribedChannels) {
    }

    @Override
    public void onPSubscribe(String pattern, int subscribedChannels) {
    }

    @Override
    public void onPMessage(String pattern, String channel, String message) {
    }

    @Override
    public void onMessage(String channel, String message) {
        System.out.println("收到来自"+channel+"房间的消息："+message);
    }
    @Override
    public void unsubscribe(String... channels) {
        for(String c : channels)
            RedisUtil.publish(c, clientName+"离开房间");
        super.unsubscribe(channels);
    }
}

接下来redis通用类的编写：

package redis;

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

public class RedisUtil {

    private static JedisPool jedisPool;

    private RedisUtil(){
    }
    static {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxIdle(5);
        poolConfig.setMinIdle(1);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setNumTestsPerEvictionRun(10);
        poolConfig.setTimeBetweenEvictionRunsMillis(60000);
        poolConfig.setMaxWaitMillis(10000);

        jedisPool = new JedisPool(poolConfig,"127.0.0.1",6379);
    }

    private static void returnResource(Jedis jedis) {
        jedisPool.returnResource(jedis);
    }
    /*发布消息*/
    public static void publish(String channel, String message){
        Jedis jedis = null ;
        try{
            jedis = jedisPool.getResource();
            jedis.publish(channel, message);
        }catch(Exception e){
            System.out.println(e);
        }finally{
                returnResource(jedis);
        }
    };
    /*订阅房间*/
    public static void subscribe(String[] room, JedisPubSub pubSub){
        Jedis jedis = null ;
        try{
            jedis = jedisPool.getResource();
            jedis.subscribe(pubSub , room);
        }catch(Exception e){
            System.out.println(e);
        }finally{
            returnResource(jedis);
        }
    }
}

最后是主函数启动客户端了:

    public static void main(String[] args) throws InterruptedException {
        final Client client = new Client();
        client.setName("Mark");
        final String[] rooms = {"movie::live::room"};
        new Thread(new Runnable() {
            @Override
            public void run() {
//              String[] rooms = {"peter::live::room","Bob::live::room"};
                client.subscribe(rooms);
            }
        }).start();
        Thread.sleep(3000);
        while(true){
            System.out.print("say something:");
            Scanner scanner = new Scanner(System.in);
            String message = scanner.nextLine(); 
            if("quit".equals(message)){
                break;
            }else{
                client.say(rooms[0], message);
                System.out.println();
            }
        }
        String[] unSubRoom ={"movie::live::room"}; 
        client.unSubscribe(unSubRoom);
    }

到此，一个简单的聊天室编写完成。