项目实战 — 消息队列（8）{网络通信设计②}

‍️小艺的学习旅途

已于 2023-08-13 19:26:07 修改

阅读量609

点赞数

分类专栏：项目实战 — 消息队列文章标签：网络消息队列项目 java

于 2023-08-13 18:40:37 首次发布

本文链接：https://blog.csdn.net/qq_52136076/article/details/132259032

版权

项目实战 — 消息队列专栏收录该内容

11 篇文章 0 订阅

订阅专栏

🎄 编写waitResult(）和putRetuens()方法

一、客户端设计

🍅 1、设计三个核心类

三个核心类：

（1）ConnectoonFactory连接工厂：这个类，持有服务器的地址，主要功能是创建出连接Connectiond对象

（2）Connection：表示一个TCP连接，持有Socket对象，写入请求/读取响应，管理多个Channel对象

（3）Channel：表示一个逻辑上的连接。当前设定的交互模型，一个TCP连接是可以进行复用的，一个客户端可以有多个模块，每个模块都可以和brokerServer之间建立“逻辑上的连接”（channel）,但是这几个模块的channel之间是互相不影响的。同时还需要提供一系列的方法，与服务器提供的核心API进行对应。

先创建这三个核心的类

在包mqclient中创建这三个类。

@Data
public class ConnectionFactory {
//    BrokerServer的ip地址
    private String host;
//    BrokerServer端口号
    private int port;

    public Connection newConnection(){
        Connection connection = new Connection(host,port);
        return connection;
    }
}

@Data
public class Connection {
    private Socket socket = null;

//    需要管理多个channel，使用哈希表把若干个channel组织起来
    private ConcurrentHashMap<String ,Channel> channelMap = new ConcurrentHashMap<>();

    private InputStream inputStream;
    private OutputStream outputStream;
    private DataInputStream dataInputStream;
    private DataOutputStream dataOutputStream;
    private ExecutorService callbackPool = null;

    public Connection(String host,int port) throws IOException {
        socket = new Socket(host,port);
        inputStream = socket.getInputStream();
        outputStream = socket.getOutputStream();
        dataInputStream = new DataInputStream(inputStream);
        dataOutputStream = new DataOutputStream(outputStream);
    }
    
//    使用该方法分别处理，当前响应是一个针对控制请求的响应，还是服务器推送的响应
    private void dispatchResponse(Response response) throws IOException, ClassNotFoundException, MqException {
    //TODO
    }

        //    发送请求
    public void writeRequest(Request request) throws IOException {
//        TODO
    }

    
        //    读取响应
    public Response readResponse() throws IOException {
//        TODO
    }

//    通过这个方法,再connection中创建出一个channel

    public Channel createChannel(){
    // TODO
        return channel;
    }
//    关闭connection
   public void close() {
        //TODO
    }
}

@Data
public class Channel {
    private String channelId;
//    当前channel属于哪个连接
    private Connection connection;
//    用来存储后续客户端收到的服务器的响应
    private ConcurrentHashMap<String, BasicReturns> basicReturnsMap = new ConcurrentHashMap<>();
//    如果当前的Channel订阅了某个队列，此处就需要记录对应的回调是什么
//    当该队列的消息返回回来的时候，就调用回调
//    约定一个channel值能有一个回调
    private Consumer consumer = null;

    public Channel(String channelId, Connection connection) {
        this.channelId = channelId;
        this.connection = connection;
    }


//    这个方法主要和服务器进行交互，
//    目的是为了告知服务器，此处客户端创建了新的channel
    public boolean createChannel() {
//        TODO
        return true;
    }


    //    使用该方法阻塞等待服务器的响应
    private BasicReturns waitResult(String rid) {
        return null;
    }

//    关闭channel,给服务器发送一个type == 0x2的请求
    public boolean close() throws IOException {
        //TODO
        return null;
    }


//创建核心的API方法
}

🍅 2、完善Connection类

这里完成发送请求、读取响应、创建channel、处理响应、关闭连接

🎄 读取请求和响应、创建channel

//    发送请求
   public void writeRequest(Request request) throws IOException {
        dataOutputStream.writeInt(request.getType());
        dataOutputStream.writeInt(request.getLength());
        dataOutputStream.write(request.getPayload());
        dataOutputStream.flush();
        System.out.println("[Connection] 发送请求! type=" + request.getType() + ", length=" + request.getLength());
    }

    //    读取响应
    public Response readResponse() throws IOException {
        Response response = new Response();
        response.setType(dataInputStream.readInt());
        response.setLength(dataInputStream.readInt());
        byte[] payload = new byte[response.getLength()];
        int n = dataInputStream.read(payload);
        if (n != response.getLength()) {
            throw new IOException("读取的响应数据不完整!");
        }
        response.setPayload(payload);
        System.out.println("[Connection] 收到响应! type=" + response.getType() + ", length=" + response.getLength());
        return response;
    }


//    通过这个方法,再connection中创建出一个channel
//    此处的createChannel()方法在后面channel类中编写以后，会抛异常，这里大家写完channel之后回过来手动抛一下
    public Channel createChannel() {    //throws IOException
        String channelId = "C-" + UUID.randomUUID();
        Channel channel = new Channel(channelId,this);
//        把channel对象放到Connection管理的channel的哈希表中
        channelMap.put(channelId,channel);
//        同时也需要把“创建channel”的这个消息也告诉服务器
        boolean ok = channel.createChannel();
        if (!ok){
//            创建channel失败
//            删除hash表中的键值对
            channelMap.remove(channelId);
            return null;
        }
        return channel;
    }

🎄 添加扫描线程

在构造方法中，添加一个扫描线程，使用该线程，不停的从socket中读取响应，再将这个响应交给对应的channnel。

   public Connection(String host,int port) throws IOException {
        socket = new Socket(host,port);
        inputStream = socket.getInputStream();
        outputStream = socket.getOutputStream();
        dataInputStream = new DataInputStream(inputStream);
        dataOutputStream = new DataOutputStream(outputStream);

        callbackPool = Executors.newFixedThreadPool(4);

        //        创建一个扫描线程
//        该线程负责不停的从socket中读取响应数据，然后把这个响应数据再交给对应的channel负责处理
        Thread t = new Thread(() -> {
            try {
                while (!socket.isClosed()) {
                    Response response = readResponse();
                    dispatchResponse(response);
                }
            } catch (SocketException e) {
                // 连接正常断开的. 此时这个异常直接忽略.
                System.out.println("[Connection] 连接正常断开!");
            } catch (IOException | ClassNotFoundException | MqException e) {
                System.out.println("[Connection] 连接异常断开!");
                e.printStackTrace();
            }
        });
        t.start();
    }