关于java:Socket-TCP快速入门

6次阅读

共计 6905 个字符，预计需要花费 18 分钟才能阅读完成。

英语：Transmission Control Protocol，缩写为 TCP。
TCP 是 传输控制协议 ；是一种 面向连贯 的、牢靠的 、 基于字节流 的传输层通信协议，由 IETF 的 RFC 793 定义。
与 UDP 一样，实现第四层传输层所指定的性能与职责。
和 UDP 最大的区别是须要连贯的，三次握手四次挥手，校验机制保障了数据传输的稳定性和可靠性。

三次握手、四次挥手。
具备校验机制、牢靠、稳固的数据传输。

聊天音讯传输、推送。
单人语音视频聊天。
简直 UDP 能做的都能做，但要思考复杂性、性能问题。
TCP 无奈进行播送多播的操作。
无奈搜寻，搜寻只能 UDP 来做。

socket()：创立一个客户端 Socket。
bind()：绑定一个 Socket 到一个本地地址和端口上。
accept()：服务器端承受一个新的连贯。
write()：把数据写入到 Socket 输入流。
read()：从 Socket 输出流中读取数据。

三次握手：

第一次握手：客户端发送带有 SYN 标记的连贯申请报文段，而后进入 SYN_SEND 状态，期待服务端确认。
第二次握手 ：服务端承受到客户端的 SYN 报文段后，须要发送 ACK 信息对这个 SYN 报文段进行确认。同时，还要发送本人的 SYN 申请信息。服务端会将上述信息放到一个报文段(SYN+ACK 报文段) 中，一并发送给客户端，此时服务端进入 SYN_RECV 状态。
第三次握手：客户端接管到服务端的 SYN+ACK 报文段后，会向服务端发送 ACK 确认报文段，这个报文段发送结束后，客户端和服务端都进入 ESTABLEISHED 状态，实现 TCP 三次握手。

四次挥手：

当被动方收到被动方的 FIN 报文告诉时，它仅仅示意被动方没有数据再发送给被动方了。但未必被动方所有的数据都残缺的发送给了被动方，所以被动方不会马上敞开 SOCKET, 它可能还须要发送一些数据给被动方后，再发送 FIN 报文给被动方，通知被动方批准敞开连贯，所以这里的 ACK 报文和 FIN 报文少数状况下都是离开发送的。

原理：

第一次挥手：Client 发送一个 FIN，用来敞开 Client 到 Server 的数据传送，Client 进入 FIN_WAIT_1 状态。
第二次挥手：Server 收到 FIN 后，发送一个 ACK 给 Client，确认序号为收到序号 +1（与 SYN 雷同，一个 FIN 占用一个序号），Server 进入 CLOSE_WAIT 状态。
第三次挥手：Server 发送一个 FIN，用来敞开 Server 到 Client 的数据传送，Server 进入 LAST_ACK 状态。
第四次挥手：Client 收到 FIN 后，Client 进入 TIME_WAIT 状态，接着发送一个 ACK 给 Server，确认序号为收到序号 +1，Server 进入 CLOSED 状态，实现四次挥手。

校验和
发送的数据包的二进制相加而后取反，目标是检测数据在传输过程中的任何变动。如果收到报文段的测验和有过错，TCP 将抛弃这个报文段和不确认收到此报文段。
确认应答与序列号
TCP 给发送的 每一个包进行编号 ，接管方 对数据包进行排序，把有序数据传送给应用层。
超时重传
当TCP 收回一个段后，它启动一个定时器，期待目标端确认收到这个报文段。如果不能及时收到一个确认，将重发这个报文段。
流量管制
TCP 连贯的每一方都有固定大小的缓冲空间，TCP 的接收端只容许发送端发送接收端缓冲区能接收的数据。当接管方来不及解决发送方的数据，能提醒发送方升高发送的速率，避免包失落。TCP 应用的流量控制协议是可变大小的滑动窗口协定。
拥塞管制
当网络拥塞时，缩小数据的发送。

利用数据被宰割成 TCP 认为最适宜发送的数据块。

TCP 的接收端会 抛弃反复的数据。

排序、组装流程

因为数据传输的程序可能是不肯定的，所以在此两头会进行排序。

数据包失落，进行重传

连贯中断

当连贯中断后，须要进行重连、而后从新进行重传。

一对多传输流程

public class Server {
    private static final int PORT = 20000;

    public static void main(String[] args) throws IOException {ServerSocket server = createServerSocket();
        initServerSocket(server);
        // 绑定到本地端口上
        server.bind(new InetSocketAddress(Inet4Address.getLocalHost(), PORT), 50);
        System.out.println("服务器准备就绪～");
        System.out.println("服务器信息：" + server.getInetAddress() + "P:" + server.getLocalPort());
        // 期待客户端连贯
        for (; ;) {
            // 失去客户端
            Socket client = server.accept();
            // 客户端构建异步线程
            ClientHandler clientHandler = new ClientHandler(client);
            // 启动线程
            clientHandler.start();}

    }

    private static ServerSocket createServerSocket() throws IOException {
        // 创立根底的 ServerSocket
        ServerSocket serverSocket = new ServerSocket();
        // 绑定到本地端口 20000 上，并且设置以后可容许期待链接的队列为 50 个
        //serverSocket = new ServerSocket(PORT);
        // 等效于下面的计划，队列设置为 50 个
        //serverSocket = new ServerSocket(PORT, 50);
        // 与下面等同
        // serverSocket = new ServerSocket(PORT, 50, Inet4Address.getLocalHost());
        return serverSocket;
    }

    private static void initServerSocket(ServerSocket serverSocket) throws IOException {
        // 是否复用未齐全敞开的地址端口
        serverSocket.setReuseAddress(true);
        // 等效 Socket#setReceiveBufferSize
        serverSocket.setReceiveBufferSize(64 * 1024 * 1024);
        // 设置 serverSocket#accept 超时工夫
        // serverSocket.setSoTimeout(2000);
        // 设置性能参数：短链接，提早，带宽的绝对重要性
        serverSocket.setPerformancePreferences(1, 1, 1);
    }

    /**
     * 客户端音讯解决
     */
    private static class ClientHandler extends Thread {
        private Socket socket;

        ClientHandler(Socket socket) {this.socket = socket;}

        @Override
        public void run() {super.run();
            System.out.println("新客户端连贯：" + socket.getInetAddress() + "P:" + socket.getPort());
            try {
                // 失去套接字流
                OutputStream outputStream = socket.getOutputStream();
                InputStream inputStream = socket.getInputStream();
                byte[] buffer = new byte[256];
                int readCount = inputStream.read(buffer);
                ByteBuffer byteBuffer = ByteBuffer.wrap(buffer, 0, readCount);
                // byte
                byte be = byteBuffer.get();
                // char
                char c = byteBuffer.getChar();
                // int
                int i = byteBuffer.getInt();
                // bool
                boolean b = byteBuffer.get() == 1;
                // Long
                long l = byteBuffer.getLong();
                // float
                float f = byteBuffer.getFloat();
                // double
                double d = byteBuffer.getDouble();
                // String
                int pos = byteBuffer.position();
                String str = new String(buffer, pos, readCount - pos - 1);
                System.out.println("收到数量：" + readCount + "数据：" + be + "\n" + c + "\n" + i + "\n" + b + "\n" + l + "\n" + f + "\n" + d + "\n" + str + "\n");
                outputStream.write(buffer, 0, readCount);
                outputStream.close();
                inputStream.close();} catch (Exception e) {System.out.println("连贯异样断开");
            } finally {
                // 连贯敞开
                try {socket.close();
                } catch (IOException e) {e.printStackTrace();
                }
            }
            System.out.println("客户端已退出：" + socket.getInetAddress() + "P:" + socket.getPort());
        }
    }
}

public class Client {
    private static final int PORT = 20000;
    private static final int LOCAL_PORT = 20001;

    public static void main(String[] args) throws IOException {Socket socket = createSocket();
        initSocket(socket);
        // 链接到本地 20000 端口，超时工夫 3 秒，超过则抛出超时异样
        socket.connect(new InetSocketAddress(Inet4Address.getLocalHost(), PORT), 3000);
        System.out.println("已发动服务器连贯，并进入后续流程～");
        System.out.println("客户端信息：" + socket.getLocalAddress() + "P:" + socket.getLocalPort());
        System.out.println("服务器信息：" + socket.getInetAddress() + "P:" + socket.getPort());
        try {
            // 发送接收数据
            todo(socket);
        } catch (Exception e) {System.out.println("异样敞开");
        }
        // 开释资源
        socket.close();
        System.out.println("客户端已退出～");

    }

    private static Socket createSocket() throws IOException {
        /*
        // 无代理模式，等效于空构造函数
        Socket socket = new Socket(Proxy.NO_PROXY);
        // 新建一份具备 HTTP 代理的套接字，传输数据将通过 www.baidu.com:8080 端口转发
        Proxy proxy = new Proxy(Proxy.Type.HTTP,
                new InetSocketAddress(Inet4Address.getByName("www.baidu.com"), 8800));
        socket = new Socket(proxy);
        // 新建一个套接字，并且间接链接到本地 20000 的服务器上
        socket = new Socket("localhost", PORT);
        // 新建一个套接字，并且间接链接到本地 20000 的服务器上
        socket = new Socket(Inet4Address.getLocalHost(), PORT);
        // 新建一个套接字，并且间接链接到本地 20000 的服务器上，并且绑定到本地 20001 端口上
        socket = new Socket("localhost", PORT, Inet4Address.getLocalHost(), LOCAL_PORT);
        socket = new Socket(Inet4Address.getLocalHost(), PORT, Inet4Address.getLocalHost(), LOCAL_PORT);
        */
        Socket socket = new Socket();
        // 绑定到本地 20001 端口
        socket.bind(new InetSocketAddress(Inet4Address.getLocalHost(), LOCAL_PORT));

        return socket;
    }

    private static void initSocket(Socket socket) throws SocketException {
        // 设置读取超时工夫为 2 秒
        socket.setSoTimeout(2000);
        // 是否复用未齐全敞开的 Socket 地址，对于指定 bind 操作后的套接字无效
        socket.setReuseAddress(true);
        // 是否开启 Nagle 算法
        socket.setTcpNoDelay(true);
        // 是否须要在长时无数据响应时发送确认数据（相似心跳包），工夫大概为 2 小时
        socket.setKeepAlive(true);
        // 对于 close 敞开操作行为进行怎么的解决；默认为 false，0
        // false、0：默认状况，敞开时立刻返回，底层零碎接管输入流，将缓冲区内的数据发送实现
        // true、0：敞开时立刻返回，缓冲区数据摈弃，间接发送 RST 完结命令到对方，并无需通过 2MSL 期待
        // true、200：敞开时最长阻塞 200 毫秒，随后按第二状况解决
        socket.setSoLinger(true, 20);
        // 是否让紧急数据内敛，默认 false；紧急数据通过 socket.sendUrgentData(1); 发送
        socket.setOOBInline(true);
        // 设置接管发送缓冲器大小
        socket.setReceiveBufferSize(64 * 1024 * 1024);
        socket.setSendBufferSize(64 * 1024 * 1024);
        // 设置性能参数：短链接，提早，带宽的绝对重要性
        socket.setPerformancePreferences(1, 1, 0);
    }

    private static void todo(Socket client) throws IOException {
        // 失去 Socket 输入流
        OutputStream outputStream = client.getOutputStream();
        // 失去 Socket 输出流
        InputStream inputStream = client.getInputStream();
        byte[] buffer = new byte[256];
        ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);
        // byte
        byteBuffer.put((byte) 126);
        // char
        char c = 'a';
        byteBuffer.putChar(c);
        // int
        int i = 2323123;
        byteBuffer.putInt(i);
        // bool
        boolean b = true;
        byteBuffer.put(b ? (byte) 1 : (byte) 0);
        // Long
        long l = 298789739;
        byteBuffer.putLong(l);
        // float
        float f = 12.345f;
        byteBuffer.putFloat(f);
        // double
        double d = 13.31241248782973;
        byteBuffer.putDouble(d);
        // String
        String str = "Hello 你好！";
        byteBuffer.put(str.getBytes());
        // 发送到服务器
        outputStream.write(buffer, 0, byteBuffer.position() + 1);
        // 接管服务器返回
        int read = inputStream.read(buffer);
        System.out.println("收到数量：" + read);
        // 资源开释
        outputStream.close();
        inputStream.close();}
}

正文完

java

发表至： java

2020-11-03

0

缓存雪崩、缓存穿透、缓存更新了解多少？

关于java:linux系统安装nginx

关于java:Java文件操作必备技能10个小技巧让你快速掌握

关于java:Spring-Boot-项目设计业务操作日志功能写得太好了

关于云原生-cloud-native:想成为全栈工程师要做到哪几点

关于java:Socket-TCP快速入门

Socket – TCP 疾速入门

TCP 是什么

TCP 的机制

TCP 能做什么

TCP 外围 API 解说

客户端创立流程

服务端创立流程

三次握手、四次挥手

TCP 传输可靠性

TCP 数据发送流程

TCP 根底数据传输案例代码

站内搜索

关于java:​Socket-TCP快速入门

Socket – TCP 疾速入门

TCP 是什么

TCP 的机制

TCP 能做什么

TCP 外围 API 解说

客户端创立流程

服务端创立流程

三次握手、四次挥手

TCP 传输可靠性

TCP 数据发送流程

TCP 根底数据传输案例代码

站内搜索

关于java:Socket-TCP快速入门