一、内存数据管理

1.1、需求分析

当前已经使用数据库管理了交换机、绑定、队列，又使用数据文件管理了消息.

最后还使用一个类将上述两部分整合在了一起，对上层提供统一的一套接口.

但对于 MQ 来说，是以内存存储数据为主，硬盘存储数据为辅（硬盘数据主要是为了持久化保存，重启之后，数据不丢失）.

接下来就需要使用内存来管理上述数据~~

这里我们主要使用 ConcurrentHashMap 来进行数据管理（主要是因为线程安全问题）.

交换机：使用 ConcurrentHashMap，key 是 name，value 是 Exchange 对象。

队列：使用 ConcurrentHashMap，key 是 name，value 是 MSGQueue 对象。

绑定：使用嵌套的 ConcurrentHashMap，key 是 exchangeName，value 是一个 ConcurrentHashMap（key 是 queueName，value 是 Binding 对象）。

消息：使用 ConcurrentHashMap，key 是 messageId ，value 是 Message 对象。

队列和消息的关联关系：使用嵌套的 ConcurrentHashMap，key 是 queueName，value 是一个 LinkedList（每个元素是一个 Message 对象）。

表示 “未被确认” 的消息：使用嵌套的 ConcurrentHashMap，key 是 queueName，value 是 ConcurrentHashMap（key 是 messageId，value 是 Message 对象，后续实现消息确认的逻辑，需要根据 ack 响应的内容，会提供一个确认的 messageId，根据这个 messageId 来把上述结构中的 Message 对象找到并移除）。

Ps：此处实现的 MQ，支持两种应答模式的 ACK

自动应答：消费者取了元素，整个消息就算是被应答了，此时整个消息就可以被干掉了。
手动应答：消费者取了元素，这个消息不算被应答，需要消费者主动再调用一个 basicAck 方法，此时才认为是真正应答了，才能删除这个消息。

1.2、实现 MemoryDataCenter 类

1.2.1、ConcurrentHashMap 数据管理

这里就是用 ConcurrentHashMap 来对上述数据进行统一内存管理.

    //key 是 exchangeName, value 是 Exchange 对象private ConcurrentHashMap<String, Exchange> exchangeMap = new ConcurrentHashMap<>();//key 是 queueName, value 是 MSGQueue 对象private ConcurrentHashMap<String, MSGQueue> queueMap = new ConcurrentHashMap<>();//第一个 key 是 exchangeName，第二个 key 是 queueNameprivate ConcurrentHashMap<String, ConcurrentHashMap<String, Binding>> bindingsMap = new ConcurrentHashMap<>();//key 是 messageId ，value 是 Message 对象private ConcurrentHashMap<String, Message> messageMap = new ConcurrentHashMap<>();//key 是 queueName ， value 是 Message 的链表private ConcurrentHashMap<String, LinkedList<Message>> queueMessageMap = new ConcurrentHashMap<>();// 第一个 key 是 queueName， 第二个 key 是 messageIdprivate ConcurrentHashMap<String, ConcurrentHashMap<String, Message>> queueMessageWaitAckMap = new ConcurrentHashMap<>();

1.2.2、封装交换机操作

主要就是对 exchangeMap 插入、获取、删除交换机.

public void insertExchange(Exchange exchange) {exchangeMap.put(exchange.getName(), exchange);System.out.println("[MemoryDataCenter] 新交换机添加成功! exchangeName=" + exchange.getName());}public Exchange getExchange(String exchangeName) {return exchangeMap.get(exchangeName);}public void deleteExchange(String exchangeName) {exchangeMap.remove(exchangeName);System.out.println("[MemoryDataCenter] 交换机删除成功! exchangeName=" + exchangeName);}

1.2.3、封装队列操作

主要就是对 queueMap 插入、获取、删除队列.

    public void insertQueue(MSGQueue queue) {queueMap.put(queue.getName(), queue);System.out.println("[MemoryDataCenter] 新队列添加成功! queueName=" + queue.getName());}public MSGQueue getQueue(String queueName) {return queueMap.get(queueName);}public void deleteQueue(String queueName) {queueMap.remove(queueName);System.out.println("[MemoryDataCenter] 队列删除成功! queueName=" + queueName);}

1.2.4、封装绑定操作

这里值得注意的是加锁逻辑，并不是加了锁就一定安全，也不是说不加锁就一定不安全，如果这段代码前后逻辑性很强，需要打包成一个原子性的操作，那就可以进行加锁，如果不是那么强的因果，就没必要，因为加锁也是需要开销的，加锁之后的锁竞争更是一个时间消耗。

    public void insertBinding(Binding binding) throws MqException {
//        ConcurrentHashMap<String, Binding> bindingMap = bindingsMap.get(binding.getExchangeName());
//        if(bindingMap == null) {
//            bindingMap = new ConcurrentHashMap<>();
//            bindingsMap.put(binding.getExchangeName(), bindingMap);
//        }//上面这段逻辑可以用以下代码来替换ConcurrentHashMap<String, Binding> bindingMap = bindingsMap.computeIfAbsent(binding.getExchangeName(),k -> new ConcurrentHashMap<>());synchronized(bindingMap) {//再根据 queueName 查一下，只有不存在的时候才能插入，存在就抛出异常if(bindingMap.get(binding.getQueueName()) != null) {throw new MqException("[MemoryDataCenter] 绑定已经存在! exchangeName=" + binding.getExchangeName() +", queueName=" + binding.getQueueName());}bindingMap.put(binding.getQueueName(), binding);}System.out.println("[MemoryDataCenter] 新绑定添加成功！exchangeName=" + binding.getExchangeName() +", queueName=" + binding.getQueueName());}/*** 获取绑定有两个版本* 1.根据 exchangeName 和 queueName 确定唯一一个 Binding* 2.根据 exchangeName 获取到所有的 Binding* @param exchangeName* @param queueName* @return*/public Binding getBinding(String exchangeName, String queueName) throws MqException {ConcurrentHashMap<String, Binding> bindingMap = bindingsMap.get(exchangeName);if(bindingMap == null) {throw new MqException("[MemoryDataCenter] 绑定不存在！exchangeName=" + exchangeName +", queueName=" + queueName);}return bindingMap.get(queueName);}public ConcurrentHashMap<String, Binding> getBindings(String exchangName) {return bindingsMap.get(exchangName);}public void deleteBinding(Binding binding) throws MqException {ConcurrentHashMap<String, Binding>  bindingMap = bindingsMap.get(binding.getExchangeName());//这里操作不是很关键，因此可以不用加锁(加锁不一定就安全，也不是说不加锁就一定不安全，要结合实际场景)//如果这段代码前后逻辑性很强，需要打包成一个原子性的操作，那就可以进行加锁，如果不是那么强的因果，就没必要，因为加锁也是需要开销的，加锁之后的锁竞争更是一个时间消耗if(bindingMap == null) {throw new MqException("[MemoryDataCenter] 绑定不存在！exchangeName=" + binding.getExchangeName() +", queueName=" + binding.getQueueName());}bindingMap.remove(binding.getQueueName());System.out.println("[MemoryDataCenter] 绑定删除成功！exchangeName=" + binding.getExchangeName() +", queueName=" + binding.getQueueName());}

1.2.5、封装消息操作

这里值得注意的是 LinkedList 是线程不安全的，要特殊处理.

    /*** 添加消息* @param message*/public void addMessage(Message message) {messageMap.put(message.getMessageId(), message);System.out.println("[MemoryDataCenter] 新消息添加成功！messageId=" + message.getMessageId());}/*** 根据 id 查询消息* @param messageId*/public Message selectMessage(String messageId) {return messageMap.get(messageId);}/*** 根据 id 删除消息* @param messageId*/public void removeMessage(String messageId) {messageMap.remove(messageId);System.out.println("[MemoryDataCenter] 消息被移除！messageId=" + messageId);}/*** 发送消息到指定队列* @param message*/public void sendMessage(MSGQueue queue, Message message) {//先根据队列名字找到指定的链表LinkedList<Message> messages = queueMessageMap.computeIfAbsent(queue.getName(), k -> new LinkedList<>());//LinkedList 是线程不安全的synchronized (messages) {messages.add(message);}//这里把消息在消息中心也插入一下。即使 message 在消息中心存在也没关系//因为相同的 messageId 对应的 message 的内容一定是一样的(服务器不会修改 Message 的内容)addMessage(message);System.out.println("[MemoryDataCenter] 消息被投递到队列当中！messageId=" + message.getMessageId());}/*** 从队列中取消息* @param queueName* @return*/public Message pollMessage(String queueName) {LinkedList<Message> messages = queueMessageMap.get(queueName);if(messages == null) {return null;}synchronized (messages) {if(messages.size() == 0) {return null;}//链表中有消息就进行头删Message currentMessage = messages.remove(0);System.out.println("[MemoryDataCenter] 消息从队列中取出! messageId=" + currentMessage.getMessageId());return currentMessage;}}/*** 获取指定队列的消息个数* @param queueName* @return*/public int getMessageCount(String queueName) {LinkedList<Message> messages = queueMessageMap.get(queueName);if(messages == null) {return 0;}synchronized (messages) {return messages.size();}}

1.2.6、封装未确认消息操作

“未被确认” 的消息：使用嵌套的 ConcurrentHashMap，key 是 queueName，value 是 ConcurrentHashMap（key 是 messageId，value 是 Message 对象，后续实现消息确认的逻辑，需要根据 ack 响应的内容，会提供一个确认的 messageId，根据这个 messageId 来把上述结构中的 Message 对象找到并移除）。

    /*** 添加未确认的消息* @param queueName* @param message*/public void addMessageWaitAck(String queueName, Message message) {ConcurrentHashMap<String, Message> messageHashMap = queueMessageWaitAckMap.computeIfAbsent(queueName,k -> new ConcurrentHashMap<>());messageHashMap.put(message.getMessageId(), message);System.out.println("[MemoryDataCenter] 消息进入待确认队列！messageId=" + message.getMessageId());}/*** 删除未确认的消息* @param messageId*/public void removeMessageWaitAck(String queueName, String messageId) {ConcurrentHashMap<String, Message> messageHashMap = queueMessageWaitAckMap.get(queueName);if(messageHashMap == null) {return;}messageHashMap.remove(messageId);System.out.println("[MemoryDataCenter] 消息从待确认队列中删除！messageId=" + messageId);}public Message getMessageWaitAck(String queueName, String messageId) {ConcurrentHashMap<String, Message> messageHashMap = queueMessageWaitAckMap.get(queueName);if(messageHashMap == null) {return null;}return messageHashMap.get(messageId);}

1.2.7、封装恢复数据操作

从硬盘上读取数据，把硬盘中之前持久化存储的各个维度的数据都恢复到内存中.

public void recovery(DiskDataCenter diskDataCenter) throws IOException, MqException, ClassNotFoundException {//1.先清空之前所有的数据exchangeMap.clear();queueMap.clear();bindingsMap.clear();messageMap.clear();queueMessageMap.clear();//2.恢复所有的交换机数据List<Exchange> exchanges = diskDataCenter.selectAllExchanges();for(Exchange exchange : exchanges) {exchangeMap.put(exchange.getName(), exchange);}//3.恢复所有的队列数据List<MSGQueue> queues = diskDataCenter.selectAllQueue();for(MSGQueue queue : queues) {queueMap.put(queue.getName(), queue);}//4.恢复所有绑定数据List<Binding> bindings = diskDataCenter.selectAllBindings();for(Binding binding : bindings) {ConcurrentHashMap<String, Binding> bindingMap = bindingsMap.computeIfAbsent(binding.getExchangeName(),k -> new ConcurrentHashMap<>());bindingMap.put(binding.getQueueName(), binding);}//5.恢复所有的消息数据for(MSGQueue queue : queues) {LinkedList<Message> messages = diskDataCenter.loadAllMessagesFromQueue(queue.getName());queueMessageMap.put(queue.getName(), messages);//遍历所有的队列，根据每个队列名字。来恢复所有消息for(Message message : messages) {messageMap.put(message.getMessageId(), message);}}}