网络编程之TCP协议

时间 2020-01-25

标签网络编程 tcp 协议栏目系统网络繁體版

原文原文链接

tcp协议图解java

第二章 TCP通讯程序

2.1 概述

TCP通讯能实现两台计算机之间的数据交互，通讯的两端，要严格区分为客户端（Client）与服务端（Server）。数组

两端通讯时步骤：服务器

服务端程序，须要事先启动，等待客户端的链接。
客户端主动链接服务器端，链接成功才能通讯。服务端不能够主动链接客户端。

在Java中，提供了两个类用于实现TCP通讯程序：网络

客户端：java.net.Socket 类表示。建立Socket对象，向服务端发出链接请求，服务端响应请求，二者创建链接开始通讯。
服务端：java.net.ServerSocket 类表示。建立ServerSocket对象，至关于开启一个服务，并等待客户端的链接。

2.2 Socket类

Socket 类：该类实现客户端套接字，套接字指的是两台设备之间通信的端点。socket

构造方法

public Socket(String host, int port) :建立套接字对象并将其链接到指定主机上的指定端口号。若是指定的host是null ，则至关于指定地址为回送地址。tcp

小贴士：回送地址(127.x.x.x) 是本机回送地址（Loopback Address），主要用于网络软件测试以及本地机进程间通讯，不管什么程序，一旦使用回送地址发送数据，当即返回，不进行任何网络传输。

构造举例，代码以下：oop

Socket client = new Socket("127.0.0.1", 6666);

成员方法

public InputStream getInputStream() ：返回此套接字的输入流。测试
- 若是此Scoket具备相关联的通道，则生成的InputStream 的全部操做也关联该通道。
- 关闭生成的InputStream也将关闭相关的Socket。
public OutputStream getOutputStream() ：返回此套接字的输出流。spa
- 若是此Scoket具备相关联的通道，则生成的OutputStream 的全部操做也关联该通道。
- 关闭生成的OutputStream也将关闭相关的Socket。
public void close() ：关闭此套接字。.net
- 一旦一个socket被关闭，它不可再使用。
- 关闭此socket也将关闭相关的InputStream和OutputStream 。
public void shutdownOutput() ：禁用此套接字的输出流。
- 任何先前写出的数据将被发送，随后终止输出流。

## 2.3 ServerSocket类

ServerSocket类：这个类实现了服务器套接字，该对象等待经过网络的请求。

构造方法

public ServerSocket(int port) ：使用该构造方法在建立ServerSocket对象时，就能够将其绑定到一个指定的端口号上，参数port就是端口号。

构造举例，代码以下：

ServerSocket server = new ServerSocket(6666);

成员方法

public Socket accept() ：侦听并接受链接，返回一个新的Socket对象，用于和客户端实现通讯。该方法会一直阻塞直到创建链接。

2.4 简单的TCP网络程序

TCP通讯分析图解

【服务端】启动,建立ServerSocket对象，等待链接。
【客户端】启动,建立Socket对象，请求链接。
【服务端】接收链接,调用accept方法，并返回一个Socket对象。
【客户端】Socket对象，获取OutputStream，向服务端写出数据。
【服务端】Scoket对象，获取InputStream，读取客户端发送的数据。

到此，客户端向服务端发送数据成功。

自此，服务端向客户端回写数据。

【服务端】Socket对象，获取OutputStream，向客户端回写数据。
【客户端】Scoket对象，获取InputStream，解析回写数据。
【客户端】释放资源，断开链接。

客户端向服务器发送数据

服务端实现：

public class ServerTCP {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动 , 等待链接 .... ");
        // 1.建立 ServerSocket对象，绑定端口，开始等待链接
        ServerSocket ss = new ServerSocket(6666);
        // 2.接收链接 accept 方法, 返回 socket 对象.
        Socket server = ss.accept();
        // 3.经过socket 获取输入流
        InputStream is = server.getInputStream();
        // 4.一次性读取数据
          // 4.1 建立字节数组
        byte[] b = new byte[1024];
          // 4.2 据读取到字节数组中.
        int len = is.read(b)；
        // 4.3 解析数组,打印字符串信息
        String msg = new String(b, 0, len);
        System.out.println(msg);
        //5.关闭资源.
        is.close();
        server.close();
    }
}

客户端实现：

public class ClientTCP {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端 发送数据");
        // 1.建立 Socket ( ip , port ) , 肯定链接到哪里.
        Socket client = new Socket("localhost", 6666);
        // 2.获取流对象 . 输出流
        OutputStream os = client.getOutputStream();
        // 3.写出数据.
        os.write("你好么? tcp ,我来了".getBytes());
        // 4. 关闭资源 .
        os.close();
        client.close();
    }
}

服务器向客户端回写数据

服务端实现：

public class ServerTCP {
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动 , 等待链接 .... ");
        // 1.建立 ServerSocket对象，绑定端口，开始等待链接
        ServerSocket ss = new ServerSocket(6666);
        // 2.接收链接 accept 方法, 返回 socket 对象.
        Socket server = ss.accept();
        // 3.经过socket 获取输入流
        InputStream is = server.getInputStream();
        // 4.一次性读取数据
          // 4.1 建立字节数组
        byte[] b = new byte[1024];
          // 4.2 据读取到字节数组中.
        int len = is.read(b)；
        // 4.3 解析数组,打印字符串信息
        String msg = new String(b, 0, len);
        System.out.println(msg);
          // =================回写数据=======================
          // 5. 经过 socket 获取输出流
           OutputStream out = server.getOutputStream();
          // 6. 回写数据
           out.write("我很好,谢谢你".getBytes());
          // 7.关闭资源.
          out.close();
        is.close();
        server.close();
    }
}

客户端实现：

public class ClientTCP {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端 发送数据");
        // 1.建立 Socket ( ip , port ) , 肯定链接到哪里.
        Socket client = new Socket("localhost", 6666);
        // 2.经过Scoket,获取输出流对象 
        OutputStream os = client.getOutputStream();
        // 3.写出数据.
        os.write("你好么? tcp ,我来了".getBytes());
          // ==============解析回写=========================
          // 4. 经过Scoket,获取 输入流对象
          InputStream in = client.getInputStream();
          // 5. 读取数据数据
          byte[] b = new byte[100];
          int len = in.read(b);
          System.out.println(new String(b, 0, len));
        // 6. 关闭资源 .
          in.close();
        os.close();
        client.close();
    }
}

如下是实际代码
package com.itheima.demo01.TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

TCP通讯的服务器端:接收客户端的请求,读取客户端发送的数据,给客户端回写数据
表示服务器的类:
    java.net.ServerSocket:此类实现服务器套接字。

构造方法:
    ServerSocket(int port) 建立绑定到特定端口的服务器套接字。

服务器端必须明确一件事情,必须的知道是哪一个客户端请求的服务器
因此可使用accept方法获取到请求的客户端对象Socket
成员方法:
    Socket accept() 侦听并接受到此套接字的链接。

服务器的实现步骤:
    1.建立服务器ServerSocket对象和系统要指定的端口号
    2.使用ServerSocket对象中的方法accept,获取到请求的客户端对象Socket
    3.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
    4.使用网络字节输入流InputStream对象中的方法read,读取客户端发送的数据
    5.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
    6.使用网络字节输出流OutputStream对象中的方法write,给客户端回写数据
    7.释放资源(Socket,ServerSocket)

*/
public class TCPServer {

public static void main(String[] args) throws IOException {
    //1.建立服务器ServerSocket对象和系统要指定的端口号
    ServerSocket server = new ServerSocket(8888);
    //2.使用ServerSocket对象中的方法accept,获取到请求的客户端对象Socket
    Socket socket = server.accept();
    //3.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
    InputStream is = socket.getInputStream();
    //4.使用网络字节输入流InputStream对象中的方法read,读取客户端发送的数据
    byte[] bytes = new byte[1024];
    int len = is.read(bytes);
    System.out.println(new String(bytes,0,len));
    //5.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
    OutputStream os = socket.getOutputStream();
    //6.使用网络字节输出流OutputStream对象中的方法write,给客户端回写数据
    os.write("收到谢谢".getBytes());
    //7.释放资源(Socket,ServerSocket)
    socket.close();
    server.close();
}

}
package com.itheima.demo01.TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

TCP通讯的客户端:向服务器发送链接请求,给服务器发送数据,读取服务器回写的数据
表示客户端的类:
    java.net.Socket:此类实现客户端套接字（也能够就叫“套接字”）。套接字是两台机器间通讯的端点。
    套接字:包含了IP地址和端口号的网络单位

构造方法:
    Socket(String host, int port) 建立一个流套接字并将其链接到指定主机上的指定端口号。
    参数:
        String host:服务器主机的名称/服务器的IP地址
        int port:服务器的端口号

成员方法:
    OutputStream getOutputStream() 返回此套接字的输出流。
    InputStream getInputStream() 返回此套接字的输入流。
    void close() 关闭此套接字。

实现步骤:
    1.建立一个客户端对象Socket,构造方法绑定服务器的IP地址和端口号
    2.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
    3.使用网络字节输出流OutputStream对象中的方法write,给服务器发送数据
    4.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
    5.使用网络字节输入流InputStream对象中的方法read,读取服务器回写的数据
    6.释放资源(Socket)
 注意:
    1.客户端和服务器端进行交互,必须使用Socket中提供的网络流,不能使用本身建立的流对象
    2.当咱们建立客户端对象Socket的时候,就会去请求服务器和服务器通过3次握手创建链接通路
        这时若是服务器没有启动,那么就会抛出异常ConnectException: Connection refused: connect
        若是服务器已经启动,那么就能够进行交互了

*/
public class TCPClient {

public static void main(String[] args) throws IOException {
    //1.建立一个客户端对象Socket,构造方法绑定服务器的IP地址和端口号
    Socket socket = new Socket("127.0.0.1",8888);
    //2.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
    OutputStream os = socket.getOutputStream();
    //3.使用网络字节输出流OutputStream对象中的方法write,给服务器发送数据
    os.write("你好服务器".getBytes());

    //4.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
    InputStream is = socket.getInputStream();

    //5.使用网络字节输入流InputStream对象中的方法read,读取服务器回写的数据
    byte[] bytes = new byte[1024];
    int len = is.read(bytes);
    System.out.println(new String(bytes,0,len));

    //6.释放资源(Socket)
    socket.close();

}

}