仿RabbitMQ实现消息队列

@Data
public class Exchange {
    //交换机的身份标识(唯一)
    private String name;
    //交换机类型 direct fanout topic
    private ExchangeType type = ExchangeType.DIRECT;
    //表示该交换机是否要持久化存储. true 表示需要持久化. false 表示不需要持久化
    private boolean durable = false;
    //如果当前交换机，无客户端使用，就自动删除
    private boolean autoDelete = false;
    //表示创建交换机时指定的一些额外的参数选项
    private Map<String,Object> arguments = new HashMap<>();
}

此处省略 arguments 存储数据库时的Json转换，只需要使用 ObjectMapper即可实现。关于交换机的类型，此次主要实现了以下三种：DIRECT、FANOUT、TOPIC。并使用枚举类定义：

public enum ExchangeType {
    DIRECT(0),
    FANOUT(1),
    TOPIC(2);

    private final int type;

    private ExchangeType(int type){
        this.type = type;
    }

    public int getType() {
        return type;
    }
}

3.2 创建队列实体类（MSGQueue）

name	durable	exclusive	autoDelete	arguments	consumerEnvList	consumerSeq
队列标识	是否持久化	是否独占	是否自动删除	额外参数选项	当前订阅的消费者列表	记录当前取到第几个消费者

@Data
public class MSGQueue {
    //表示队列的身份标识
    private String name;
    //表示队列是否持久化 true:需要持久化 false:不需要持久化
    private boolean durable = false;
    //表示是否独占，true:独占 false:都可以使用
    private boolean exclusive = false;
    //表示无客户端使用是，是否自动删除
    private boolean autoDelete = false;
    //表示扩展参数
    private Map<String,Object> arguments = new HashMap<>();
    //当前队列都有哪些消费者订阅了.
    private List<ConsumerEnv> consumerEnvList = new ArrayList<>();
    //记录当前取到的第几个消费者,方便实现轮询策略
    private AtomicInteger consumerSeq = new AtomicInteger(0);
}

3.3 创建绑定实体类（Binding）

exchangeName	queueName	bindingKey
交换机名字	队列名字	绑定(和 routingKey匹配)

@Data
public class Binding {
    // 交换机名字
    private String exchangeName; 
    //队列名字
    private String queueName;
    // 只在交换机类型为 TOPIC 时才有效. ⽤于和消息中的 routingKey 进⾏匹配
    private String bindingKey;
}

3.4 创建消息实体类（Message）

消息存储为二进制形式，因此对消息的存储需要进行序列化处理，所以 Message 类要实现Serializable 接口。

basicProperties	body	offsetBeg	offsetEnd	isValid
消息的属性	消息的正文	消息开头在文件中的偏移量	消息末尾在文件中的偏移量	是否有效

@Data
public class Message implements Serializable {
    private BasicProperties basicProperties = new BasicProperties();
    private byte[] body;

    //辅助属性,后续消息要存储在文件中
    //一个文件存储很多消息 [offsetBeg, offsetEnd)
    private transient long offsetBeg = 0;//消息数据的开头距离文件开头的位置偏移(字节)
    private transient long offsetEnd = 0;//消息数据的结尾距离文件开头的位置偏移(字节)
    private byte isValid = 0x1;//表示该消息在文件中是否是有效的消息,逻辑删除, 0x1:有效 0x0:无效

    //创建一个工厂方法,让工厂方法去封装一下创建 Message 对象的过程
    //这个方法创建的 Message 会自动生成一个唯一的 MessageId
    public static Message createMessageWithId(String routingKey,BasicProperties basicProperties,byte[] body){
        Message message = new Message();
        if(basicProperties != null){
            message.setBasicProperties(basicProperties);
        }
        //此处生成的 MessageId 以 "M-" 为前缀, 方便区分
        message.setMessageId("M-" + UUID.randomUUID());
        message.setRoutingKey(routingKey);
        message.body = body;
        return message;
    }
    public String getMessageId(){
        return basicProperties.getMessageId();
    }
    public void  setMessageId(String messageId){
        basicProperties.setMessageId(messageId);
    }
    public String getRoutingKey(){
        return basicProperties.getRoutingKey();
    }
    public void setRoutingKey(String routingKey){
        basicProperties.setRoutingKey(routingKey);
    }
    public int getDeliverMode(){
        return basicProperties.getDeliverMode();
    }
    public void setDeliverMode(int deliverMode){
        basicProperties.setDeliverMode(deliverMode);
    }
}

对于消息的属性，使用一个实体类去表示：

messageId	routingKey	deliverMode
消息的唯一身份标识	和(bindingKey匹配)	是否持久化

@Data
public class BasicProperties implements Serializable {
    //消息的唯一身份标识,使用 UUID 作为 messageId
    private String messageId;
    /**
     * 如果当前的交换机类型是 DIRECT, 此时 routingKey 就表示要转发的队列名
     * 如果当前的交换机类型是 FANOUT, 此时 routingKey 无意义(不使用)
     * 如果当前的交换机类型是 TOPIC,  此时 routingKey 就表示和 bindingKey 进行匹配
     */
    private String routingKey;
    //表示消息是否持久化, 1: 不持久化; 2: 持久化
    private int deliverMode = 1;
}

四、数据库操作

对于 Exchange, MSGQueue, Binding, 需要使⽤数据库进⾏持久化保存，这里使用 SQLite 进行存储，直接去 Maven 中央仓库复制依赖到项目的POM文件，再配置数据库文件即可。

SQLite 只是把数据单纯的存储到⼀个⽂件中，因此在这里设定存储到 “./data/meta.db”文件。

实现创建表以及数据库操作（这里不再展示具体的SQL语句）

@Mapper
public interface MetaMapper {
    //三个核心建表方法
    void createExchangeTable();
    void createQueueTable();
    void createBindingTable();

    //针对上述三个基本概念进行插入和删除
    void insertExchange(Exchange exchange);
    List<Exchange> selectAllExchanges();
    void deleteExchange(@Param("exchangeName") String exchangeName);

    void insertQueue(MSGQueue queue);
    List<MSGQueue> selectAllQueues();
    void deleteQueue(@Param("queueName") String queueName);


    void insertBinding(Binding binding);
    List<Binding> selectAllBindings();
    void deleteBinding(Binding binding);

}

五、封装对数据库的操作

创建 DataBaseManager 类，通过这个类来封装针对数据库的操作。

public class DataBaseManager {
    //数据库初始化
    public void init(){...}
    //删除数据库
    public void deleteDB(){...}
    //判断数据库是否存在
    private boolean checkDBExists(){...}
    //建表操作
    private void createTable(){...}
    //创建默认数据，RabbitMQ 里默认也带有一个 匿名 的交换机，类型是 DIRECT
    private void createDefaultData(){...}

    //交换机的数据库操作:增删查
    public void insertExchange(Exchange exchange){...}
    public void deleteExchange(String exchangeName){...}
    public List<Exchange> selectAllExchanges(){...}

    //队列的数据库操作:增删查
    public void insertQueue(MSGQueue queue){...}
    public void deleteQueue(String queueName){...}
    public List<MSGQueue> selectAllQueues(){...}

    //Binding的数据库操作:增删查
    public void insertBinding(Binding binding){...}
    public void deleteBinding(Binding binding){...}
    public List<Binding> selectAllBindings(){...}
}

六、消息的存储设计

6.1 设计思路及设定

设计思路：消息需要在硬盘上存储，考虑到对于消息的操作并不需要复杂的增删改查，而⽂件的操作效率比数据库会高很多，因此这里设定，用文件来管理消息。

同时，因为队列用来存储消息，因此这里约定：

给每个队列分配⼀个目录，目录的名字为 data + 队列名，形如：./data/queueName
该目录中包含两个固定名字的⽂件:

queue_data.txt 消息数据⽂件, 用来保存消息内容。

queue_stat.txt 消息统计⽂件, 用来保存消息统计信息。（消息总个数/t有效消息数），这样设计主要时考虑到后续进行垃圾回收，方便判断进行GC的时机。

6.2 设定存储消息的格式

消息数据文件以二进制的形式存储在 queue_data.txt 文件中，为了方便进行消息的读取，这里进行这样的设定：

每个消息分成两个部分：前四个字节, 表示 Message 对象的长度(字节数)，后面若干字节，表示 Message 内容，消息和消息之间首尾相连。同时每个 Message 基于 Java 标准库进行序列化。 Message 对象中的 offsetBeg 和 offsetEnd 正是⽤来描述每个消息体所在的位置。

6.3 实现消息序列化工具

对于实现消息序列化，首先 Message 实体类要实现 Serializable 接口，接下来需要借助ByteArrayOutputStream 和 ObjectOutputStream 实现消息的序列化和反序列化：

public class BinaryTool {
    /**
     * 把对象序列化成一个字节数组
     * @param object
     * @return
     */
    public static byte[] toBytes(Object object) throws IOException {
        // 这个流对象相当于一个变长的字节数组,
        // 可以把 object 对象序列化的数据逐步写入导 byteArrayOutputStream 中,
        // 再统一转成 byte[]
        try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()){
            try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream)){
                // 此处的 writeObject 就会把 object 进行序列化,生成的字节数据就会写入到 objectOutputStream
                // objectOutputStream 又关联到了 byteArrayOutputStream,最终结果写入到 byteArrayOutputStream 里
                objectOutputStream.writeObject(object);
            }
            return byteArrayOutputStream.toByteArray();
        }
    }

    /**
     * 把一个字节数组反序列化成一个对象
     * @param data
     * @return
     */
    public static Object fromBytes(byte[] data) throws IOException, ClassNotFoundException {
        Object object = null;
        try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(data)){
            try (ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream)){
                object = objectInputStream.readObject();
            }
        }
        return object;
    }
}

七、实现文件管理消息

创建 MessageFileManager 类，这个类主要去实现消息统计文件的读写、消息数据文件的读写、创建存储消息的文件、消息的垃圾回收等等。

下面这段代码是 MessageFileManager 的基础代码，实现文件的读写和垃圾回收都需要调用下面的方法：

public class MessageFileManager {
    //定义一个内部类,来表示该队列的统计信息
    static public class Stat{
        public int totalCount; // 总消息数量
        public int validCount; // 有效消息数量
    }

    public void init(){

    }
    //约定消息文件所在的目录和文件名
    // 所在路径及文件名: ./data/队列名/queue_data.txt(消息数据文件)
    //                ./data/队列名/queue_stat.txt(消息统计文件)
    /**
     * 这个方法用来获取指定队列对应的消息文件所在路径
     * @param queueName
     * @return
     */
    private String getQueueDir(String queueName){
        return "./data/" + queueName;
    }

    /**
     * 这个方法用来获取该队列的消息数据文件路径
     * @param queueName
     * @return
     */
    private String getQueueDataPath(String queueName){
        return getQueueDir(queueName) + "/queue_data.txt";
    }

    /**
     * 这个方法用来获取指定队列的消息统计文件的路径
     * @param queueName
     * @return
     */
    private String getQueueStatPath(String queueName){
        return getQueueDir(queueName) + "/queue_stat.txt";
    }

7.1 读取消息统计文件

private Stat readStat(String queueName){
        Stat stat = new Stat();
        try (InputStream inputStream = new FileInputStream(getQueueStatPath(queueName))){
            Scanner scanner = new Scanner(inputStream);
            stat.totalCount = scanner.nextInt();
            stat.validCount = scanner.nextInt();
            return stat;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

7.2 写消息统计文件

    private void writeStat(String queueName, Stat stat){
        // 使用 PrintWriter 写文件
        try (OutputStream outputStream = new FileOutputStream(getQueueStatPath(queueName))){
            PrintWriter printWriter = new PrintWriter(outputStream);
            printWriter.write(stat.totalCount + "\t" + stat.validCount);
            printWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

7.3 创建队列对应的文件和目录

public void createQueueFiles(String queueName) throws IOException {
        //1.创建队列对应的消息目录
        File baseDir = new File(getQueueDir(queueName));
        if(!baseDir.exists()){
           boolean success =  baseDir.mkdirs();
           if(!success){
               throw new IOException("创建目录失败! baseDir :" + baseDir.getAbsolutePath());
           }
        }
        //2.创建消息数据文件
        File queueDataFile = new File(getQueueDataPath(queueName));
        if(!queueDataFile.exists()){
            boolean success = queueDataFile.createNewFile();
            if(!success){
                throw new IOException("创建消息数据文件失败! queueDataFile: " + queueDataFile.getAbsolutePath());
            }
        }
        //3.创建消息统计文件
        File queueStatFile = new File(getQueueStatPath(queueName));
        if(!queueStatFile.exists()){
            boolean success = queueStatFile.createNewFile();
            if(!success){
                throw new IOException("创建消息统计文件失败! queueStatFile: " + queueStatFile.getAbsolutePath());
            }
        }
        //4.给消息统计文件设置初始值
        Stat stat = new Stat();
        stat.totalCount = 0;
        stat.validCount = 0;
        writeStat(queueName,stat);
    }

7.4 删除队列对应的文件和目录

public void destroyQueueFiles(String queueName) throws IOException {
        //先删除文件,再删除目录
        File queueDataFile = new File(getQueueDataPath(queueName));
        boolean success1 = queueDataFile.delete();

        File queueStatFile = new File(getQueueStatPath(queueName));
        boolean success2 = queueStatFile.delete();

        File baseDir = new File(getQueueDir(queueName));
        boolean success3 = baseDir.delete();
        if(!success1 || !success2 || !success3){
            //删除失败
            throw new IOException("删除队列目录和消息文件失败! baseDir: " + baseDir.getAbsolutePath());
        }
    }

7.5 判断队列的目录和消息文件是否存在

    public boolean checkFileExists(String queueName){
        //判断队列的 消息数据文件 和 消息统计文件 是否都存在
        File queueDataFile = new File(getQueueDataPath(queueName));
        File queueStatFile = new File(getQueueStatPath(queueName));
        if(queueDataFile.exists() && queueStatFile.exists()){
            return true;
        }
        return false;
    }