2019-05-06——Java IO Socket

Socket是网络编程的基础。

基本通讯

客户端发送消息，服务端接收消息

/*单向通讯，客户端发送消息，服务端接收消息*/
private static void s1() throws IOException {
    /*创建一个服务端兵监听指定端口*/
    ServerSocket serverSocket = new ServerSocket(9999);
    /*阻塞等到客户端的链接*/
    Socket socket = serverSocket.accept();
    /*获取输入流*/
    InputStream is = socket.getInputStream();
    read(is);
    is.close();
    socket.close();
    serverSocket.close();
}

public static void c1() throws IOException {
    /*创建一个客户端，绑定IP和端口*/
    Socket client = new Socket("localhost",9999);
    client.setTcpNoDelay(true);
    /*获取输出流*/
    OutputStream os = client.getOutputStream();
    write(os);
    os.close();
    client.close();
}

双向通讯

/*双向通讯，服务端接收完客户端发送的消息后，发送消息给客户端*/
public static void s2() throws IOException {
    /*创建一个服务端兵监听指定端口*/
    ServerSocket serverSocket = new ServerSocket(9999);
    /*阻塞等到客户端的链接*/
    Socket socket = serverSocket.accept();
    /*获取输入流*/
    InputStream is = socket.getInputStream();
    read(is);
    /*获取输出流*/
    OutputStream os = socket.getOutputStream();
    write(os);
    is.close();
    os.close();
    socket.close();
    serverSocket.close();
}

public static void c2() throws IOException {
    /*创建一个客户端，绑定IP和端口*/
    Socket client = new Socket("localhost",9999);
    /*获取输出流*/
    OutputStream os = client.getOutputStream();
    write(os);
    client.shutdownOutput();
    InputStream is = client.getInputStream();
    read(is);
    os.close();
    is.close();
    client.close();
}

并行处理

/*增加并行处理的能力，一个线程处理所有的客户端请求，当其中一个客户端阻塞将导致所有客户端请求阻塞*/
public static void s3() throws IOException {
    /*创建一个服务端兵监听指定端口*/
    ServerSocket serverSocket = new ServerSocket(9999);
    /*阻塞等到客户端的链接*/
    while (true){
        Socket socket = serverSocket.accept();
        clientJoin();
        /*获取输入流*/
        InputStream is = socket.getInputStream();
        read(is);
        /*获取输出流*/
        OutputStream os = socket.getOutputStream();
        write(os);
        is.close();
        os.close();
        socket.close();
    }
}

public static void c3() throws IOException {
    for (int i = 0; i<=2; i++){
        /*创建一个客户端，绑定IP和端口*/
        Socket client = new Socket("localhost",9999);
        sleep();
        /*获取输出流*/
        OutputStream os = client.getOutputStream();
        write(os);
        client.shutdownOutput();
        InputStream is = client.getInputStream();
        read(is);
        os.close();
        is.close();
        client.close();
    }
}

并发处理

/*使用一个线程处理一个socket请求*/
public static void s4() throws IOException {
    /*创建线程池*/
    ExecutorService threadPool = new ThreadPoolExecutor(10,50,60, TimeUnit.SECONDS,new LinkedBlockingQueue());
    /*创建一个服务端兵监听指定端口*/
    ServerSocket serverSocket = new ServerSocket(9999);
    /*阻塞等到客户端的链接*/
    while (true){
        Socket socket = serverSocket.accept();
        threadPool.execute(()->{
            try {
                clientJoin();
                /*获取输入流*/
                InputStream is = socket.getInputStream();
                read(is);
                /*获取输出流*/
                OutputStream os = socket.getOutputStream();
                write(os);
                is.close();
                os.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

    }
}

public static void c4() throws IOException {
    for (int i = 0; i<=2; i++){
        /*创建一个客户端，绑定IP和端口*/
        Socket client = new Socket("localhost",9999);
        sleep();
        /*获取输出流*/
        OutputStream os = client.getOutputStream();
        write(os);
        client.shutdownOutput();
        InputStream is = client.getInputStream();
        read(is);
        os.close();
        is.close();
        client.close();
    }
}

server method

    private static void write(OutputStream os) throws IOException {
        os.write("恭喜你成功链接".getBytes("utf-8"));
        os.flush();
    }


    private static void read(InputStream is) throws IOException {
        StringBuilder content = new StringBuilder();
        byte[] data = new byte[1024];
        int size;
        while ((size=is.read(data))!=-1){
            content.append(new String(data,0,size,"utf-8"));
        }
        System.out.println(content.toString());
    }

    private static void clientJoin() {
        System.out.println("新的客户端接入："+ LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss.SSS")));
    }

client method

    private static void read(InputStream is) throws IOException {
        StringBuilder content = new StringBuilder();
        byte[] data = new byte[1024];
        int size;
        while ((size=is.read(data))!=-1){
            content.append(new String(data,0,size,"utf-8"));
        }
        System.out.println(content.toString());
    }

    private static void write(OutputStream os) throws IOException {
        os.write("客户端".getBytes("utf-8"));
        os.flush();
    }


    private static void sleep() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

如何告知对方已发送完命令?
正常来说，客户端打开一个输出流，如果不做约定，也不关闭它，那么服务端永远不知道客户端是否发送完消息，那么服务端会一直等待下去，直到读取超时。所以怎么告知服务端已经发送完消息就显得特别重要。

• 通过Socket关闭
  当Socket关闭的时候，服务端就会收到响应的关闭信号，那么服务端也就知道流已经关闭了，这个时候读取操作完成，就可以继续后续工作。
  缺点：客户端Socket关闭后，将不能接受服务端发送的消息，也不能再次发送消息，如果客户端想再次发送消息，需要重现创建Socket连接
• 通过Socket关闭输出流的方式
  通过socket.shutdownOutput();而不是outputStream.close();如果关闭了输出流，那么相应的Socket也将关闭，和直接关闭Socket一个性质。而调用Socket的shutdownOutput()方法，底层会告知服务端我这边已经写完了，那么服务端收到消息后，就能知道已经读取完消息，如果服务端有要返回给客户的消息那么就可以通过服务端的输出流发送给客户端，如果没有，直接关闭Socket。
  缺点：不能再次发送消息给服务端，如果再次发送，需要重新建立Socket连接
• 通过约定符号
  这种方式的用法，就是双方约定一个字符或者一个短语，来当做消息发送完成的标识，通常这么做就需要改造读取方法。不需要关闭流，当发送完一条命令（消息）后可以再次发送新的命令（消息）。
  缺点：需要额外的约定结束标志，太简单的容易出现在要发送的消息中，误被结束，太复杂的不好处理，还占带宽
• 通过指定长度

---

• https://www.cnblogs.com/yiwangzhibujian/p/7107785.html#q2.2