【編碼】封裝RedisPubSub工具

貓毛·波拿巴發表於2019-05-25
封裝Redis

基本介紹

核心原理：利用Redis的List列表實現，釋出事件對應rpush，訂閱事件對應lpop

問題一：Redis不是自帶Pub/Sub嗎？

redis自帶的pub/sub有兩個問題：

1.如果釋出訊息期間訂閱方沒有連到redis，那麼這條訊息就收不到了，即使重新連線上來也收不到

2.redis內部是用一個執行緒給所有訂閱連線推資料的，V生產> V消費 的情況下還會主動斷開連線，有效能隱患。感興趣的可以多瞭解一下它的原理。

問題二：要實現怎樣一個工具，或者說想要什麼樣的效果？

效果就是得到一個service物件，這個物件有以下兩個重要功能：

1.有個publish方法可以呼叫，用來靈活地釋出訊息。想釋出什麼就釋出什麼，想給哪個topic傳送就給哪個topic傳送。

2.可以預定義一些訂閱者，定義好當收到某個topic的訊息後，該做什麼處理。

編碼內容

（一）介面定義

第一步要做的就是定義介面，一個是釋出介面，我們需要這樣一個介面來發布訊息，訊息內容可以是任何形式的物件

public interface MessagePublisher {
    /**
     * 釋出訊息
     * @param topic 主題
     * @param msg 訊息內容
     */
    void publish(String topic, Object msg);
}

第二個是訂閱介面，我們需要依此實現觀察者模式

public interface MessageConsumer {
    /**
     * 獲取此消費者訂閱的topic
     * @return 訂閱topic
     */
    String getTopic();

    /**
     * 回撥方法，收到訊息後，此方法被觸發
     * @param topic topic
     * @param msg 訊息內容
     */
    void onMessage(String topic, Object msg);
}

第三個就是轉換介面，已知Redis不能直接儲存Java物件，所以必須進行轉換，這裡我們選擇用String形式進行儲存。所以我們需要一個型別轉換工具

public interface Translator {
    /**
     * 將物件序列化為字串
     * @param obj 物件
     * @return 字串
     */
    String serialize(Object obj);

    /**
     * 將字串反序列化為物件
     * @param str 字串
     * @return 物件
     */
    Object deserialize(String str);
}

（二）轉換器實現——JsonTranslator

問題一：取出資料後如何轉換成正確的物件？

在寫入redis的時候同時也寫入該物件的型別資訊，然後取出的時候利用該型別資訊進行轉換即可。

public class JsonTranslator implements Translator {
    private static ObjectMapper MAPPER = new ObjectMapper();
    /**
     * 快取類資訊，優化速度
     */
    private Map<String, Class> classCache = new HashMap<>();

    @Override
    public String serialize(Object obj) {
        Message message = new Message();
        message.setClazz(obj.getClass().getName());
        message.setData(encode(obj));
        return encode(message);
    }

    @Override
    public Object deserialize(String str) {
        Message message = decode(str, Message.class);
        String className = message.getClazz();
        Class clazz = classCache.get(className);
        if(clazz != null)
            return decode(message.getData(), clazz);
        try {
            clazz = Class.forName(className);
            classCache.put(className, clazz);
            return decode(message.getData(), clazz);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }

    }

    private String encode(Object obj) {
        try {
            return MAPPER.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    private <T> T decode(String str, Class<T> clazz) {
        try {
            return (T) MAPPER.readValue(str, Message.class);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Data
    class Message { //儲存類資訊，是為了反序列化能夠得到正確型別的物件
        /**
         * 類名（含路徑）
         */
        private String clazz;
        /**
         * 序列化後的物件
         */
        private String data;
    }
}

（三）核心實現——RedisPubSub

問題一：Redis配置如何處理？

我們將Redis的配置與這個MQ解耦，讓使用者配置連線池後再注入進來即可。

問題二：如何知道要監聽哪些topic？

我們把容器中的Consumer實現類都注入進來，就可以通過getTopic方法得到總共需要監聽哪些topic。

問題三：如何進行監聽？

每個需要監聽的topic開一個執行緒進行監聽，監聽方法就是迴圈呼叫blpop。

問題四：監聽到訊息後如何進行通知？

當得到topic的訊息的時候，就回撥訂閱此topic的consumer的onMessage方法。

問題五：如何啟動和關閉監聽？

我們給MQ類提供兩個方法start和stop。在注入容器的時候指明這兩個分別是init和destroy方法，這樣它就能隨著容器啟動和停止了。

public class RedisPubSub implements MessagePublisher{
    //外部注入資訊
    private JedisPool jedisPool;
    private List<MessageConsumer> consumerList;
    /**
     * 物件和字串的轉換器，預設使用JsonTranslator
     */
    private Translator translator = new JsonTranslator();

    //內部資訊
    /**
     * key:topic
     * value:此topic的訂閱者
     */
    private Map<String, List<MessageConsumer>> subcribeInfo;
    private List<MessageListener> listeners;


    public void setJedisPool(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    public void setConsumerList(List<MessageConsumer> consumerList) {
        this.consumerList = consumerList;
        subcribeInfo = new HashMap<>();
        String topic;
        List<MessageConsumer> topicConsumers;
        //注入消費者後，整理好訂閱情況
        for(MessageConsumer consumer : consumerList) {
            topic = consumer.getTopic();
            topicConsumers = subcribeInfo.get(topic);
            if(topicConsumers == null) {
                topicConsumers = new ArrayList<>();
                subcribeInfo.put(topic, topicConsumers);
            }
            topicConsumers.add(consumer);
        }
    }

    public void setTranslator(Translator translator) {
        this.translator = translator;
    }

    public void publish(String topic, Object msg) {
        Jedis jedis = jedisPool.getResource();
        jedis.rpush(topic,translator.serialize(msg));
        jedis.close();
    }

    public void start() {
        MessageListener listener;
        //每個topic開一個監聽執行緒進行監聽
        for(String topic : subcribeInfo.keySet()) {
           listener = new MessageListener(topic, subcribeInfo.get(topic));
           listener.start();
           listeners.add(listener);
        }
    }

    public void stop() {
        //關閉所有監聽器
        for(MessageListener listener: listeners) {
            listener.stop();
        }
    }


    public class MessageListener implements Runnable {
        /**
         * 此監聽器監聽的topic
         */
        private String topic;
        /**
         * 此topic的消費者
         */
        private List<MessageConsumer> consumers;
        /**
         * 繫結執行緒
         */
        private Thread t;

        public MessageListener(String topic, List<MessageConsumer> consumers) {
            this.topic = topic;
            this.consumers = consumers;
        }

        /**
         * 將資料反序列化
         * @param msg 字串訊息
         * @return 訊息物件
         */
        public  Object deserialize(String msg) {
            return translator.deserialize(msg);
        }

        public void run() {
            String msg;
            Object obj;
            //從池中抓取一個連線用來監聽redis佇列
            Jedis jedis = jedisPool.getResource();
            while(!Thread.interrupted()) {
                msg = jedis.blpop(1, topic).get(1);
                obj = deserialize(msg);
                //收到訊息後告知所有消費者
                for(MessageConsumer consumer:consumers) {
                    consumer.onMessage(topic, obj);
                }
            }
            jedis.close(); //訂閱結束後釋放資源
        }

        public void start() {
            t = new Thread(this);
            t.start();
        }

        public void stop() { //利用中斷打斷執行緒的執行
            t.interrupt();
        }
    }

}

使用案例

（一）定義好Consumer，注入為容器bean

@Component
public class TestConsumer implements MessageConsumer {
    @Override
    public void onMessage(String topic, Object message) {
        System.out.println((SomeObject)message);
    }

    @Override
    public String getTopic() {
        return "test";
    }
}

由於Ttranslator會將物件轉換好，所以只要將Object強制轉換成指定型別即可使用。

（二）全域性配置

@Configuration
public class TestConfig {

    @Bean
    public JedisPool jedisPool() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(20);
        jedisPoolConfig.setMaxIdle(5);
        jedisPoolConfig.setMinIdle(1);
        return new JedisPool(jedisPoolConfig, "127.0.0.1", 6379, 2000, "123456");
    }

    @Bean(value = "rediMQ", initMethod = "start", destroyMethod = "stop")
    @Autowired
    public RedisPubSub redisPubSub(List<MessageConsumer> consumers, JedisPool jedisPool) {
        RedisPubSub redisPubSub = new RedisPubSub();
        redisPubSub.setJedisPool(jedisPool);
        redisPubSub.setConsumerList(consumers);
        return redisPubSub;
    }
}

@Autowired 配合方法引數的List<MessageConsumer> 就可以得到容器中所有的Consumer。

（三）引入使用

@Service
public class SomeService {
    @Autowired
    private MessagePublisher publisher;
    
    public void someOperation() {
        publisher.publish("test", new SomeObject());
    }
}

只需要以MessagePublisher介面的身份引入就可以了。

相關文章