Java网络编程：TCP的socket编程

深藏阁楼爱情的钟 2022-06-10 12:13 299阅读 0赞

## 一、Java中的网络编程 ##

协议相当于相互通信的程序间达成的一种约定，它规定了分组报文的结构、交换方式、包含的意义以及怎样对报文所包含的信息进行解析，TCP/IP协议族有IP协议、TCP协议和UDP协议。现在TCP/IP协议族中的主要socket类型为流套接字（使用TCP协议）和数据报套接字（使用UDP协议）。

TCP协议提供面向连接的服务，通过它建立的是可靠地连接。Java为TCP协议提供了两个类：Socket类和ServerSocket类。一个Socket实例代表了TCP连接的一个客户端，而一个ServerSocket实例代表了TCP连接的一个服务器端，一般在TCP Socket编程中，客户端有多个，而服务器端只有一个，客户端TCP向服务器端TCP发送连接请求，服务器端的ServerSocket实例则监听来自客户端的TCP连接请求，并为每个请求创建新的Socket实例，由于服务端在调用accept（）等待客户端的连接请求时会阻塞，直到收到客户端发送的连接请求才会继续往下执行代码，因此要为每个Socket连接开启一个线程。

服务器端要同时处理ServerSocket实例和Socket实例，而客户端只需要使用Socket实例。另外，每个Socket实例会关联一个InputStream和OutputStream对象，我们通过将字节写入套接字的OutputStream来发送数据，并通过从InputStream来接收数据。

## 二、使用ServerSocket创建TCP服务器 ##

Java中能接收其他通信实体连接请求的类是ServerSocket，ServerSocket对象用于监听来自客户端Socket连接，如果没有连接，它将一直处于等待状态。  
ServerSocket包含一个监听来自客户端连接请求的方法。

*  Socket accpet()  
    如果接收到一个客户端Socket的连接请求，该方法将返回一个与客户端Socket对应的Socket；否则该方法将一直处于等待状态，线程也被阻塞。
 *  ServerSocket(int port)  
    用指定的端口port来创建一个ServerSocket。该端口应该有一个有效的端口整数值，即0~65535。
 *  ServerSocket(int port, int backlog)  
    增加一个用来改变连接队列长度的参数backlog。
 *  ServerSocket(int port, int backlog, IntetAddress localAddr)  
    在机器存在多个IP地址的情况下，允许通过localAddr参数来指定将ServerSocket绑定到指定的IP地址。

服务端的工作是建立一个通信终端，并被动地等待客户端的连接。典型的TCP服务端执行如下两步操作：  
1、创建一个ServerSocket实例并指定本地端口，用来监听客户端在该端口发送的TCP连接请求；  
2、重复执行：  
1）调用ServerSocket的accept（）方法以获取客户端连接，并通过其返回值创建一个Socket实例；  
2）为返回的Socket实例开启新的线程，并使用返回的Socket实例的I/O流与客户端通信；  
3）通信完成后，使用Socket类的close（）方法关闭该客户端的套接字连接。  
在通常情况下，服务器不应该只接收一个客户端请求，而应该不断地接收来自客户端的所有请求，所以Java程序通常会通过循环不断地调用ServerSocket的accept()方法。如下代码片段所示。

//创建一个ServerSocket，用于监听客户端Socket的连接请求
    ServerSocket ss = new ServerSocket(30000);
    //采用循环不断地接收来自客户端的请求
    while(true)
    {
        //每当接收到客户端Socket的请求时，服务器也对应产生一个Socket
        Socket s = ss.accept();
        //下面就可以使用Socket进行通信了
        ...
    }

上面程序中创建ServerSocket没有指定IP地址，则该ServerSocket将会绑定到本机默认的IP地址。程序中使用30000作为该ServerSocket的端口号，通常推荐使用1024以上的端口，主要是为了避免与其他应用程序的通用端口冲突。

## 三、使用Socket进行通信 ##

客户端通常可使用Socket的构造器来连接到指定服务器，Socket通常可使用如下两个构造器：

*  Socket(InetAddress/String remoteAddress, int port)  
    创建连接到指定远程主机、远程端口的Socket，该构造器没有指定本地地址、本地端口，默认使用本地主机的默认IP地址，默认使用系统动态指定的IP地址。
 *  Socket(InetAddress/String remoteAddress, int port, InetAddress localAddr, int localPort)  
    创建连接到指定远程主机、远程端口的Socket，并指定本地IP地址和本地端口号，适用于本地主机有多个IP地址的情形。  
    上面两个构造器中指定远程主机时既可使用InetAddress来指定，也可直接使用String对象来指定，但程序通常使用String对象(如192.168.1.1)来指定远程IP地址。当本地主机只有一个IP地址时，使用第一个方法更为简单。如下代码所示。  
    客户端向服务器端发送连接请求后，就被动地等待服务器的响应。典型的TCP客户端要经过下面三步操作：  
    1、创建一个Socket实例：构造函数向指定的远程主机和端口建立一个TCP连接；  
    2.通过套接字的I/O流与服务端通信；  
    3、使用Socket类的close方法关闭连接。

//创建连接到本机、30000端口的Socket
    Socket s = new Socket("127.0.0.1", 30000);
    //下面就可以使用Socket进行通信
    ...

## 四、实例 ##

### 1、服务端Server ###

package com.kang.socket;
    
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class Server {
        
        public static void main(String[] args) throws Exception {
            // 服务端在20006端口监听客户端请求的TCP连接
            ServerSocket server = new ServerSocket(20006);
            System.out.println("服务端已经开始监听----");
            Socket client = null;
            boolean f = true;
            while (f) {
       //循环监听
                // 等待客户端的连接
                client = server.accept();
                System.out.println("与客户端连接成功！");
                // 为每个客户端连接开启一个线程
                new Thread(new ServerThread(client)).start();
            }
            server.close();
        }
    }

服务端的多线程处理如下：

package com.kang.socket;
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.net.Socket;
    
    /**
     * 该类为多线程类，用于服务端
     */
    public class ServerThread implements Runnable {
        
    
        private Socket client = null;
    
        public ServerThread(Socket client) {
            this.client = client;
        }
    
        @Override
        public void run() {
            try {
                // 获取Socket的输出流，用来向客户端发送数据
                PrintStream out = new PrintStream(client.getOutputStream());
                // 获取Socket的输入流，用来接收从客户端发送过来的数据
                BufferedReader buf = new BufferedReader(new InputStreamReader(client.getInputStream()));
                boolean flag = true;
                while (flag) {
                    // 接收从客户端发送过来的数据
                    String str = buf.readLine();
                    if ("bye".equals(str)) {
       // 读到bye字符串时退出循环
                        flag = false;
                    } else {
                        // Thread.sleep(20000);
                        // 将接收到的字符串前面加上“Server回复”，发送到对应的客户端
                        out.println("Server回复:" + str);
                    }
                }
                out.close();
                client.close();
                System.out.println("关闭连接");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    }

### 2、客户端Client ###

为了模拟Server的多线程实现，这里编写两个Client

package com.kang.socket;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.net.Socket;
    import java.net.SocketTimeoutException;
    
    public class Client1 {
        
        public static void main(String[] args) throws IOException, InterruptedException {
            // 客户端请求与本机在20006端口建立TCP连接
            Socket client = new Socket("127.0.0.1", 20006);
            client.setSoTimeout(10000);
            // 获取键盘输入
            BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
            // 获取Socket的输出流，用来发送数据到服务端
            PrintStream out = new PrintStream(client.getOutputStream());
            // 获取Socket的输入流，用来接收从服务端发送过来的数据
            BufferedReader buf = new BufferedReader(new InputStreamReader(client.getInputStream()));
            boolean flag = true;
            while (flag) {
                System.out.print("输入信息：");
                String str = input.readLine();
                // 发送数据到服务端
                out.println(str);
                if ("bye".equals(str)) {
                    flag = false;
                } else {
                    try {
                        // 从服务器端接收数据有个时间限制（系统自设，也可以自己设置client.setSoTimeout(10000);），超过了这个时间，便会抛出该异常
                        String echo = buf.readLine();
                        System.out.println(echo);
                    } catch (SocketTimeoutException e) {
                        System.out.println("Time out, No response");
                    }
                }
            }
            input.close();
            if (client != null) {
                // 如果构造函数建立起了连接，则关闭套接字，如果没有建立起连接，自然不用关闭
                client.close(); // 只关闭socket，其关联的输入输出流也会被关闭
            }
        }
    }

package com.kang.socket;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.net.Socket;
    import java.net.SocketTimeoutException;
    
    public class Client2 {
        
        public static void main(String[] args) throws IOException {
            // 客户端请求与本机在20006端口建立TCP连接
            Socket client = new Socket("127.0.0.1", 20006);
            client.setSoTimeout(10000);
            // 获取键盘输入
            BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
            // 获取Socket的输出流，用来发送数据到服务端
            PrintStream out = new PrintStream(client.getOutputStream());
            // 获取Socket的输入流，用来接收从服务端发送过来的数据
            BufferedReader buf = new BufferedReader(new InputStreamReader(client.getInputStream()));
            boolean flag = true;
            while (flag) {
                System.out.print("输入信息：");
                String str = input.readLine();
                // 发送数据到服务端
                out.println(str);
                if ("bye".equals(str)) {
                    flag = false;
                } else {
                    try {
                        // 从服务器端接收数据有个时间限制（系统自设，也可以自己设置），超过了这个时间，便会抛出该异常
                        String echo = buf.readLine();
                        System.out.println(echo);
                    } catch (SocketTimeoutException e) {
                        System.out.println("Time out, No response");
                    }
                }
            }
            input.close();
            if (client != null) {
                // 如果构造函数建立起了连接，则关闭套接字，如果没有建立起连接，自然不用关闭
                client.close(); // 只关闭socket，其关联的输入输出流也会被关闭
            }
        }
    }