‍️藿香正气水

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

一、客户端设计

1、设计三个核心类

2、完善Connection类

读取请求和响应、创建channel

添加扫描线程

处理不同的响应

关闭连接

3、完善Channel类

编写createChannel()

编写waitResult(）和putRetuens()方法

编写其他核心API

交换机

队列

绑定

发布消息

订阅消息

确认消息

二、客户端测试

1、准备工作和收尾工作

2、测试connection

3、测试channnel的创建

4、测试交换机

5、测试队列

6、测试绑定

一、客户端设计

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 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 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();
    }

处理不同的响应

使用该方法分别处理两种不同的响应，当前响应是一个针对控制请求的响应，还是服务器推送的响应。

private void dispatchResponse(Response response) throws IOException, ClassNotFoundException, MqException {
        if (response.getType() == 0xc) {
//            服务器推送来的消息数据
        SubScribeReturns subScribeReturns = (SubScribeReturns) BinaryTool.fromBytes(response.getPayload());

//            根据channelId找到对用的channel对象
             Channel channel = channelMap.get(subScribeReturns.getChannelId());
            if (channel == null) {
                throw new MqException("[Connection] 该消息对应的 channel 在客户端中不存在! channelId =" + channel.getChannelId());
            }
            callbackPool.submit(() -> {
                try {
                    channel.getConsumer().handleDelivery(subScribeReturns.getConsumerTag(), subScribeReturns.getBasicProperties(),
                            subScribeReturns.getBody());
                } catch (MqException | IOException e) {
                    e.printStackTrace();
                }
            });
        } else {
//            当前响应是针对控制请求的响应
            BasicReturns basicReturns = (BasicReturns) BinaryTool.fromBytes(response.getPayload());
//            把这个结果放到对应的channel的hash表中
            Channel channel = channelMap.get(basicReturns.getChannelId());
            if (channel == null) {
                throw new MqException("[Connection] 该消息对应的 channel 在客户端中不存在! channelId =" + channel.getChannelId());
            }
            channel.putReturns(basicReturns);
        }
    }

关闭连接

public void close() {
        //        关闭connection，释放持有的资源
        try {
            callbackPool.shutdownNow();
            channelMap.clear();
            inputStream.close();
            outputStream.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3、完善Channel类

编写createChannel()

// 这个方法主要和服务器进行交互，
// 目的是为了告知服务器，此处客户端创建了新的channel

//    这个方法主要和服务器进行交互，
//    目的是为了告知服务器，此处客户端创建了新的channel
    public boolean createChannel() throws IOException {
//        对于创建channel来说，payload就是一个basicArguments
        BasicArguments basicArguments=  new BasicArguments();
        basicArguments.setChannelId(channelId);
//        rid表示这次请求的id
        basicArguments.setRid(generateRid());
        byte[] payload = BinaryTool.toBytes(basicArguments);

        Request request = new Request();
        request.setType(0x1);
        request.setLength(payload.length);
        request.setPayload(payload);

//       发送构造出的请求
        connection.writeRequest(request);
//        等待服务器的响应
        BasicReturns basicReturns = waitResult(basicArguments.getRid());
        return basicReturns.isOk();
    }


    private String generateRid(){
        return "R-" + UUID.randomUUID().toString();
    }

编写waitResult(）和putRetuens()方法

putRetuents()是为了将返回的响应放到对用的哈希表中

    public void putReturns(BasicReturns basicReturns) {
        basicReturnsMap.put(basicReturns.getRid(),basicReturns);
        synchronized (this){
//            当前不知道有多少个线程在等待上面的响应
//            把多有的等待的线程都唤醒
            notifyAll();
        }
    }

waitResult()方法的作用是为了阻塞等待服务器的响应。以下举例说明：

如下，假如有3个channel，按照123的顺序发送了请求，所以应该是请求1先等待响应1，然后再是2和3。

但是，现在有一个情况，服务器这边是多线程并发处理请求，服务器处理每个请求的时间不一样，返回响应的顺序也就不一样。

如下图，channel1等待的是响应1，但是先返回的响应却是2和3。响应1还没来，请求1就一直等。请求1，没等到，后面的2和3也就拿不到响应

$项目实战 — 消息队列（8）{网络通信设计②}_第1张图片$

所以，为了解决这个问题，就创建了basicReturnsMap，将socket中收到的所有响应数据放到这个在前面创建的basicReturnsMap哈希表中。客户端的的请求，就可以不断的从这个哈希表中寻找是否存在和自己匹配的响应。

如果存在，就把相应取走；不存在，就继续等待。

这个waitResult()方法就是，当请求对应的响应不再哈希表中时，就阻塞等待。

//    使用该方法阻塞等待服务器的响应
    private BasicReturns waitResult(String rid) {
        BasicReturns basicReturns = null;
        while ((basicReturns = basicReturnsMap.get(rid)) == null){
//            如果查询结果为null，说明响应没来
//            此时就需要阻塞等待
//            此处加锁是为了保证wait/notify的是同一个对象
            synchronized (this){
                try {
                    wait();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
//        读取成功之后,把这个响应从哈希表中删除掉
        basicReturnsMap.remove(rid);
        return basicReturns;
    }