【消息队列开发】 对核心类实现数据库管理

🍃前言

前面实现了相应核心类的创建，今天我们来对这些核心类实现数据库管理

🌳数据库的选择

由于MySQL数据库比较重量级，此处为了使用方便，简化环境，我们采取的数据库是更轻量的数据库——SQLite

一个完整的SQLite数据库，只有一个单独的可执行文件（不到1M），非常轻量

而且SQLite只是一个本地的数据库，这里数据库相当于直接操作本地的硬盘文件，非常方便

🚩如何使用SQLite

在Java中想使用SQLite，不用额外安装，直接使用maven，把SQLite的依赖引入进来，就好了，依赖如下（也可去官网自行下载）：

 <dependency>
     <groupId>org.xerial</groupId>
     <artifactId>sqlite-jdbc</artifactId>
     <version>3.41.0.1</version>
</dependency>

再使用yml格式的配置文件进行配置，配置如下：

spring:
  datasource:
    url: jdbc:sqlite:./data/meta.db
    username:
    password:
    driver-class-name: org.sqlite.JDBC

mybatis:
  mapper-locations: classpath:mapper/**Mapper.xml

注意;

• SQLite是不需要用户名以及密码的，所以这里为空
• ./data/meta.db为你要讲数据库存入到当前硬盘的某个文件里
• 把上述配置完毕后，程序启动就会自动建库了

🎍MetaMapper（数据库接口）

我们对各个核心类型的先提供一些基础的接口，包含创建表的接口，以及增加、删除、查看等接口

接口定义如下;

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

    // 针对上述三个基本概念, 进行 插入 和 删除
    void insertExchange(Exchange exchange);
    List<Exchange> selectAllExchanges();
    void deleteExchange(String exchangeName);
    void insertQueue(MSGQueue queue);
    List<MSGQueue> selectAllQueues();
    void deleteQueue(String queueName);
    void insertBinding(Binding binding);
    List<Binding> selectAllBindings();
    void deleteBinding(Binding binding);
}

🍀实现数据库接口

在以下路劲下进行建表

我们这里通过代码，自动完成建表操作，以及增加、删除、查看操作

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="arg.example.mq.mqserver.mapper.MetaMapper">
    <update id="createExchangeTable" >
        update table if not exists exchange(
            name varchar(50) primary key,
            type int,
            durble boolean,
            autoDelete boolean,
            arguments varchar(1024)
        );
    </update>
    <update id="createQueueTable">
        update table if not exists queue(
            name varchar(50) primary key,
            durble boolean,
            autoDelete boolean,
            arguments varchar(1024)
        );
    </update>
    <update id="createBindingTable" >
        update table if not exists binding(
            exchangeName varchar(50),
            queueName varchar(50),
            bindingkey varchar(256)
        );
    </update>
    <insert id="insertExchange" parameterType="com.example.mq.mqserver.core.Exchange">
        insert into exchange values(#{name}, #{type}, #{durable}, #{autoDelete}, #{arguments});
    </insert>

    <select id="selectAllExchanges" resultType="com.example.mq.mqserver.core.Exchange">
        select * from exchange;
    </select>

    <delete id="deleteExchange" parameterType="java.lang.String">
        delete from exchange where name = #{exchangeName};
    </delete>

    <insert id="insertQueue" parameterType="com.example.mq.mqserver.core.MSGQueue">
        insert into queue values(#{name}, #{durable}, #{exclusive}, #{autoDelete}, #{arguments});
    </insert>

    <select id="selectAllQueues" resultType="com.example.mq.mqserver.core.MSGQueue">
        select * from queue;
    </select>

    <delete id="deleteQueue" parameterType="java.lang.String">
        delete from queue where name = #{queueName};
    </delete>

    <insert id="insertBinding" parameterType="com.example.mq.mqserver.core.Binding">
        insert into binding values(#{exchangeName}, #{queueName}, #{bindingKey});
    </insert>

    <select id="selectAllBindings" resultType="com.example.mq.mqserver.core.Binding">
        select * from binding;
    </select>

    <delete id="deleteBinding" parameterType="com.example.mq.mqserver.core.Binding">
        delete from binding where exchangeName = #{exchangeName} and queueName = #{queueName};
    </delete>
</mapper>

🎄存在问题

现在还存在一个问题

如何实现把arguments这个键值对,和数据库中的字符串类型相互转换呢?

其实关键要点在于, MyBatis在完成数据库操作的时候,会自动的调用到对象的getter和setter方法

1. 比如MyBatis往数据库中写数据,就会调用对象的getter方法,拿到属性的值，再往数据库中写.如果这个过程中,让getArguments得到的结果是String类型的,此时,就可以直接把这个数据写到数据库了.
2. 比如MyBatis从数据库读数据的时候就会调用对象的setter方法,把数据库中读到的结果设置到对象的属性中.

如果这个过程中,让setArguments,参数是-个String , 并且在setArguments内部针对字符串解析,解析成-个Map对象.

我们这里使用ObjectMapper类的writeValueAsString方法将当前map对象解析成json格式的字符串。

再通过readValue方法又转回map对象

最后在我们针对 arguments, 再提供一组 getter setter , 用来去更方便的获取/设置这里的键值对.

该操作我们需要对交换机与队列类都进行改变

交换机类：

    public String getArguments() {
        // 是把当前的 arguments 参数, 从 Map 转成 String (JSON)
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            return objectMapper.writeValueAsString(arguments);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        // 如果代码真异常了, 返回一个空的 json 字符串就 ok
        return "{}";
    }

    // 这个方法, 是从数据库读数据之后, 构造 Exchange 对象, 会自动调用到
    public void setArguments(String argumentsJson) {
        // 把参数中的 argumentsJson 按照 JSON 格式解析, 转成
        // 上述的 Map 对象
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            this.arguments = objectMapper.readValue(argumentsJson, new TypeReference<HashMap<String, Object>>() {});
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }

    // 在这里针对 arguments, 再提供一组 getter setter , 用来去更方便的获取/设置这里的键值对.
    // 这一组在 java 代码内部使用 (比如测试的时候)
    public Object getArguments(String key) {
        return arguments.get(key);
    }

    public void setArguments(String key, Object value) {
        arguments.put(key, value);
    }

    public void setArguments(Map<String, Object> arguments) {
        this.arguments = arguments;
    }

队列类

   public String getArguments() {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            return objectMapper.writeValueAsString(arguments);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return "{}";
    }

    public void setArguments(String argumentsJson) {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            this.arguments = objectMapper.readValue(argumentsJson, new TypeReference<HashMap<String, Object>>() {});
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }

    public Object getArguments(String key) {
        return arguments.get(key);
    }

    public void setArguments(String key, Object value) {
        arguments.put(key, value);
    }

    public void setArguments(Map<String, Object> arguments) {
        this.arguments = arguments;
    }

⭕总结

关于《【消息队列开发】 对核心类实现数据库管理》就讲解到这儿，感谢大家的支持，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下！