【Java 网络编程】TCP 数据传输示例 ( 客户端参数设置 | 服务器端参数设置 | ByteBuffer 存放读取数据类型 )

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
/**
 * TCP 客户端
 */
public class Client {
    public static void main(String[] args) {
        try {
            //I. 创建 Socket 对象并绑定本地端口
            //1. 创建空的 Socket 对象 , 方便之后设置参数
            Socket socket = new Socket();
            //2. 绑定本地端口
            socket.bind(new InetSocketAddress(Inet4Address.getLocalHost(), 8887));
            System.out.println("客户端 Socket 创建完毕");
            //II. 设置 Socket 对象参数 , 注意这些参数只能在客户端没有连接服务器的时候设置 , 连接服务器之后设置是无效的
            //1. 设置从 Socket 对象输入流中读取数据的阻塞等待超时时间
            //      当与 Socket 对象关联的 InputStream 输入流执行 read() 操作时 , 其阻塞时间为这个超时时间
            //      如果超过了该时间还没有收到任何数据 , 就会抛出异常
            socket.setSoTimeout(3000);
            //2. 设置是否可以复用 Socket 绑定的地址和端口号
            //      Socket 连接在建立时 , 会使用之前绑定本地的 IP 地址和端口号
            //      这个端口号在使用之后 , 2 分钟之内不允许再次使用
            //      进行了该设置之后 , 可以在连接关闭之后 , 马上使用该本地 IP 地址和端口号
            socket.setReuseAddress(true);
            //3. 设置是否开启 Nagle 算法 , Nagle 算法会导致多次发送的少量数据合并 , 即沾包情况出现
            //      在需要低延迟传输的情况下是需要关闭该算法的 , 该算法会导致数据沾包情况出现
            socket.setTcpNoDelay(true);
            //4. 在长时间 ( 2 小时 ) 没有数据交互 , 是否需要发送心跳包确认连接
            socket.setKeepAlive(true);
            //5. 调用 Socket 对象的 close 方法之后的处理方式
            //   1> 默认情况 : false , 0
            //      如果 boolean on 设置成false , 不处理连接的缓存数据 , 调用 close 会立刻关闭连接
            //      系统底层会操作输出流发送剩余缓存数据 , 将缓冲区中的数据发送给连接对方
            //      如果设置 false 不会产生阻塞操作
            //   2> setSoLinger( true , 20 ) 情况 :
            //      如果设置 boolean on 参数为 true , int linger 参数设置一个大于等于 0 的参数
            //      那么在关闭的时候 , 阻塞 linger 毫秒 , 之后缓冲区如果还有数据 , 就会被丢弃
            //      直接向连接对方发送结束命令 , 无需经过超时等待
            //   3> setSoLinger( true , 0 ) 情况 :
            //      如果设置成 0 , 那么其后果是不阻塞 , 也不让系统接管输出流
            //      立刻丢弃缓冲区数据 , 向对方发送 RST 命令
            socket.setSoLinger(true, 10);
            //6. 设置紧急数据是否内敛 , 默认情况时 false 关闭的
            //      紧急数据 : 紧急数据是 Socket 对象通过调用 sendUrgentData 发送出去的数据
            //                该方法参数是一个 int 值 , 仅有最低的 8 位是有效的
            socket.setOOBInline(true);
            //7. 设置发送接收缓冲区大小
            socket.setReceiveBufferSize(64 * 1024 * 1024);
            socket.setSendBufferSize(64 * 1024 * 1024);
            //8. 设置性能参数 : ① 连接时长 , ② 最低延迟 , ③ 带宽
            //      设置的值不是具体的参数 , 而是连接的性能权重 , 对哪个性能要求比较高 ;
            //      上面的延迟和带宽的性能是互斥的 , 低延迟新能好 , 带宽性能就差
            socket.setPerformancePreferences(0, 2, 0);
            System.out.println("客户端 Socket 参数设置完毕");
            //III. 连接服务器
            //1. 连接到服务器端的 8888 端口 , 设置连接超时 3000 毫秒
            socket.connect(new InetSocketAddress(Inet4Address.getLocalHost(), 8888), 3000);
            System.out.println("客户端 Socket 连接服务器完毕");
            //IV. 数据发送与接收
            //1. 获取输出流和输入流
            OutputStream outputStream = socket.getOutputStream();
            InputStream inputStream = socket.getInputStream();
            //2. 使用 ByteBuffer 向 byte[] 数组中存储数据
            byte[] buffer = new byte[256];
            ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);
            //3. 向数组写入 byte 类型数据
            byteBuffer.put((byte) 0x01);
            //4. 向数组中写入 short 类型数据
            byteBuffer.putShort((short) 1);
            //5. 向数组中写入 int 类型数据
            byteBuffer.putInt(1);
            //6. 向数组中写入 char 类型数据
            byteBuffer.putChar('a');
            //7. 向数组中写入 boolean 类型数据
            //      此处使用 byte 类型模拟 , true 为 1, false 为 0
            boolean bool = true;
            byteBuffer.put((byte) (bool ? 1 : 0));
            //8. 向数组中写入 long 类型数据
            byteBuffer.putLong((long)1);
            //9. 向数组中写入 float 类型数据
            byteBuffer.putFloat(3.14f);
            //10. 向数组中写入 double 类型数据
            byteBuffer.putDouble(3.14);
            //11. 向数组中写入 String 类型数据
            //      先把 String 字符串转为 byte[] 数组, 在放入 byteBuffer 中
            byteBuffer.put("Hello World".getBytes());
            //12. 将 byte[] 数据发送到服务器端
            outputStream.write(buffer, 0, byteBuffer.position() + 1);
            System.out.println("客户端 Socket 将各种类型数据发送到了服务器端");
            //13. 接收服务器端反馈的数据
            int readLen = inputStream.read(buffer);
            System.out.println("客户端 Socket 接收到服务器端数据 " + readLen + " 字节");
            //V. 释放资源
            //1. 关闭输入输出流
            outputStream.close();
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Inet4Address;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
/**
 * TCP 服务器端
 */
public class Server {
    public static void main(String[] args) {
        try {
            //I. 设置服务器套接字
            //1. 创建服务器端 , 注意创建一个空的服务器套接字 , 一遍后面设置更详细的参数
            ServerSocket serverSocket = new ServerSocket();
            System.out.println("服务器端端 ServerSocket 创建完毕");
            //2. 设置从 Socket 对象输入流中读取数据的阻塞等待超时时间
            //      当与 Socket 对象关联的 InputStream 输入流执行 read() 操作时 , 其阻塞时间为这个超时时间
            //      如果超过了该时间还没有收到任何数据 , 就会抛出异常
            serverSocket.setSoTimeout(30000);
            //3. 设置是否可以复用 Socket 绑定的地址和端口号
            //      Socket 连接在建立时 , 会使用之前绑定本地的 IP 地址和端口号
            //      这个端口号在使用之后 , 2 分钟之内不允许再次使用
            //      进行了该设置之后 , 可以在连接关闭之后 , 马上使用该本地 IP 地址和端口号
            serverSocket.setReuseAddress(true);
            //4. 设置发送接收缓冲区大小
            serverSocket.setReceiveBufferSize(64 * 1024 * 1024);
            //5. 设置性能参数 : ① 连接时长 , ② 最低延迟 , ③ 带宽
            //      设置的值不是具体的参数 , 而是连接的性能权重 , 对哪个性能要求比较高 ;
            //      上面的延迟和带宽的性能是互斥的 , 低延迟新能好 , 带宽性能就差
            serverSocket.setPerformancePreferences(0, 2, 0);
            System.out.println("服务器端端 ServerSocket 设置完毕");
            //6. 绑定本地端口 , 只有绑定了本地端口 , 服务器端套接字才能正式工作
            //      服务器端才算是正式创建完毕
            //      上面的设置一定要在绑定接口之前设置完毕 , 之后在设置 serverSocket 是无效的
            serverSocket.bind(new InetSocketAddress(Inet4Address.getLocalHost(), 8888), 88);
            System.out.println("服务器端端 ServerSocket 绑定 8888 端口完毕");
            //II. 等待服务器端连接
            //1. 服务器端阻塞 , 等待客户端连接服务器端的 8888 端口号
            Socket clientSocket = serverSocket.accept();
            //2. 创建客户端异步处理线程 , 处理服务器端与该客户端之间的交互 , 创建之后直接启动线程即可
            ClientHandler clientHandler = new ClientHandler(clientSocket);
            clientHandler.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 客户端异步处理线程
     *  每当有客户端连接服务器 , 就开启一个线程处理与该客户端之间的交互
     */
    private static class ClientHandler extends Thread {
        /**
         * 客户端线程
         */
        private Socket clientSocket;
        public ClientHandler(Socket clientSocket) {
            this.clientSocket = clientSocket;
        }
        @Override
        public void run() {
            super.run();
            System.out.println("客户端 : " + clientSocket.getInetAddress() + " 连接到服务器端");
            try {
                //I. 获取数据交互的输入流 , 输出流 , 及缓冲区
                //1. 从客户端 Socket 中获取与客户端进行数据交互的输入输出流
                OutputStream outputStream = clientSocket.getOutputStream();
                InputStream inputStream = clientSocket.getInputStream();
                //2. 从客户端读取数据 , 并使用 ByteBuffer 读取其中各种类型的数据
                byte[] buffer = new byte[256];
                int readCount = inputStream.read(buffer);
                ByteBuffer byteBuffer = ByteBuffer.wrap(buffer, 0, readCount);
                //II. 按照顺序读取存放的数据
                //注意 : 要按照存放的顺序读取
                //1. 读取 byte 类型数据
                byte var_byte = byteBuffer.get();
                System.out.println("① byte 类型数据 : " + var_byte);
                //2. 读取 short 类型数据
                short var_short = byteBuffer.getShort();
                System.out.println("② short 类型数据 : " + var_short);
                //3. 读取 int 类型数据
                int var_int = byteBuffer.getInt();
                System.out.println("③ int 类型数据 : " + var_int);
                //4. 读取 char 类型数据
                char var_char = byteBuffer.getChar();
                System.out.println("④ char 类型数据 : " + var_char);
                //5. 读取 short 类型数据
                boolean var_boolean = byteBuffer.get() == 1;
                System.out.println("⑤ boolean 类型数据 : " + var_boolean);
                //6. 读取 long 类型数据
                long var_long = byteBuffer.getLong();
                System.out.println("⑥ long 类型数据 : " + var_long);
                //7. 读取 float 类型数据
                float var_float = byteBuffer.getFloat();
                System.out.println("⑦ float 类型数据 : " + var_float);
                //8. 读取 double 类型数据
                double var_double = byteBuffer.getDouble();
                System.out.println("⑧ double 类型数据 : " + var_double);
                //9. 读取 short 类型数据
                int start = byteBuffer.position();
                String var_string = new String(buffer, start, readCount - start - 1);
                System.out.println("⑨ String 类型数据 : " + var_string);
                //III. 将接收的数据再发送回去, 并关闭连接
                outputStream.write(buffer, 0, readCount);
                outputStream.close();
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 连接关闭
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("客户端与服务器端交互完成");
                }
            }
        }
    }
}

服务器端端 ServerSocket 创建完毕
服务器端端 ServerSocket 设置完毕
服务器端端 ServerSocket 绑定 8888 端口完毕

客户端 Socket 创建完毕
客户端 Socket 参数设置完毕
客户端 Socket 连接服务器完毕
客户端 Socket 将各种类型数据发送到了服务器端
客户端 Socket 接收到服务器端数据 42 字节

服务器端端 ServerSocket 创建完毕
服务器端端 ServerSocket 设置完毕
服务器端端 ServerSocket 绑定 8888 端口完毕
客户端 : /192.168.87.2 连接到服务器端
① byte 类型数据 : 1
② short 类型数据 : 1
③ int 类型数据 : 1
④ char 类型数据 : a
⑤ boolean 类型数据 : true
⑥ long 类型数据 : 1
⑦ float 类型数据 : 3.14
⑧ double 类型数据 : 3.14
⑨ String 类型数据 : Hello World
客户端与服务器端交互完成