Java TCP实验：Vert.x服务端 + Socket客户端

Java TCP实验：Vert.x服务端 + Socket客户端

Socket客户端可实现Vert.x TCP客户端没有的同步阻塞。

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Vertx;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.net.NetServer;

public class VertxServer extends AbstractVerticle {
    @Override
    public void start() {
        NetServer server = vertx.createNetServer();
        server.connectHandler(socket -> {
            socket.handler(buffer -> {
                System.out.println("Recive:" + buffer.toString());
                socket.write(Buffer.buffer("VertxServer"));
                // 注意，放在executeBlocking中，必须加上future.complete();否则会使服务端给客户端发送失败
                /*vertx.executeBlocking(future -> {
                    socket.write(Buffer.buffer("LongConnection.VertxServer"));
                    future.complete();
                }, asyncResult -> {
                });*/
            });
            socket.closeHandler(close -> System.out.println("Client Out"));
        });
        server.listen(33323, "127.0.0.1", res -> {
            if (res.succeeded()) {
                System.out.println("Server Started");
            }
        });
    }

    public static void main(String[] args) {
        Vertx.vertx().deployVerticle(new VertxServer());
    }
}

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

public class SocketClient {
    public static void main(String[] args) {
        String message = "SocketClient";
        try (Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 33323);
             OutputStream outputStream = socket.getOutputStream();
             PrintWriter printWriter = new PrintWriter(outputStream)) {
            printWriter.write(message);
            printWriter.flush();
            socket.shutdownOutput();
            String response = "";
            InputStream inputStream;
            try {
                inputStream = socket.getInputStream();
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                String lineMessage;
                while ((lineMessage = bufferedReader.readLine()) != null) {
                    response += lineMessage;
                }

                System.out.println("Recive:" + response);
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上为短连接，长连接如下，修改客户端，控制台可测试：

package LongConnection;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class SocketClientByBytes {
    private static Socket socket;
    private static PrintWriter printWriter;
    private static InetAddress inetAddress;
    private static int port = 33323;

    static {
        try {
            inetAddress = InetAddress.getByName("127.0.0.1");
            socket = new Socket(inetAddress, port);
            printWriter = new PrintWriter(socket.getOutputStream());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static String getResponse(String message){
        try {
            printWriter.write(message);
            printWriter.flush();
            InputStream inputStream = socket.getInputStream();
            while(inputStream.available() == 0);
            String response = ByteUtil.switchInputStreamToString(inputStream);
            System.out.println(response);
            return response;
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            getResponse(scanner.next());
        }
    }
}

package LongConnection;

import java.io.IOException;
import java.io.InputStream;

public class ByteUtil {
    private static final int BUFFER_SIZE = 1024;

    public static String switchInputStreamToString(InputStream inputStream) throws IOException {
        byte[] bytes = new byte[BUFFER_SIZE];
        byte[] totalBytes = new byte[0];
        int inputStreamBytesLenth = inputStream.available();
        int bufferSize = inputStreamBytesLenth / BUFFER_SIZE;
        int endBytesLength = inputStreamBytesLenth - bufferSize * BUFFER_SIZE;
        for(int i = 0;i < bufferSize;i++){
            // 如果输入流里的字节被读取结束，再次读取不会返回0，而是会被阻塞
            inputStream.read(bytes);
            totalBytes = byteMerge(totalBytes, bytes);
        }

        if(endBytesLength > 0){
            inputStream.read(bytes);
            bytes = subBytes(bytes, 0, endBytesLength);
            totalBytes = byteMerge(totalBytes, bytes);
        }

        return new String(totalBytes);
    }

    private static byte[] subBytes(byte[] b,int off,int length){
        byte[] b1 = new byte[length];
        System.arraycopy(b, off, b1, 0, length);
        return b1;
    }

    private static byte[] byteMerge(byte[] byte_1, byte[] byte_2){
        byte[] byte_3 = new byte[byte_1.length+byte_2.length];
        // System.arraycopy(原数组, 原数组被复制部分的起始索引, 新的数组, 新数组被粘贴部分的起始索引, 原数组被复制部分的长度)
        // System.arraycopy如果复制引用，称为浅复制，反之，为深复制
        System.arraycopy(byte_1, 0, byte_3, 0, byte_1.length);
        System.arraycopy(byte_2, 0, byte_3, byte_1.length, byte_2.length);
        return byte_3;
    }
}