原文：http://zetcode.com/java/socket/

Java 套接字教程展示了如何使用套接字在 Java 中进行网络编程。 套接字编程是低级的。 本教程的目的是介绍包括这些低级详细信息的网络编程。 有些高级 API 可能更适合实际任务。 例如，Java 11 引入了HttpClient，而 Spring 具有Webclient。

Java 套接字

在编程中，套接字是网络上运行的两个程序之间的通信端点。 套接字类用于在客户端程序和服务器程序之间创建连接。 Socket代表客户端套接字，ServerSocket代表服务器套接字。

注意：在网络中，“套接字”一词具有不同的含义。 它用于 IP 地址和端口号的组合。

ServerSocket绑定到端口号，这是通过客户端和服务器同意进行通信的唯一 ID。

Socket和ServerSocket用于 TCP 协议。 DatagramSocket和DatagramPacket用于 UDP 协议。

TCP 更可靠，具有大量错误检查并需要更多资源。 HTTP，SMTP 或 FTP 等服务使用它。 UDP 的可靠性要差得多，错误检查的能力也有限，所需资源也更少。 VoIP 等服务使用它。

DatagramSocket是用于发送和接收数据报包的套接字。 数据报包由DatagramPacket类表示。 在数据报套接字上发送或接收的每个数据包都经过单独寻址和路由。 从一台机器发送到另一台机器的多个数据包可能会以不同的方式路由，并且可能以任何顺序到达。

Java 套接字时间客户端

是提供当前时间的服务器。 客户端无需任何命令即可直接连接到服务器，服务器以当前时间作为响应。

注意：时间服务器来来往往，因此我们可能需要在 https://www.ntppool.org/en/ 上找到可用的服务器。

在我们的示例中，我们选择了瑞典的服务器。

com/zetcode/SocketTimeClient.java

  1. package com.zetcode;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.net.Socket;
  7. // time servers come and go; we might need to 
  8. // find a functioning server on https://www.ntppool.org/en/
  10. public class SocketTimeClient {
  12.     public static void main(String[] args) throws IOException {
  14.         var hostname = "3.se.pool.ntp.org";
  15.         int port = 13;
  17.         try (var socket = new Socket(hostname, port)) {
  19.             try (var reader = new InputStreamReader(socket.getInputStream())) {
  21.                 int character;
  22.                 var output = new StringBuilder();
  24.                 while ((character = reader.read()) != -1) {
  26.                     output.append((char) character);
  27.                 }
  29.                 System.out.println(output);
  30.             }
  31.         }
  32.     }
  33. }

该示例连接到时间服务器并接收当前时间。

  1. var hostname = "3.se.pool.ntp.org";
  2. int port = 13;

这是瑞典的时间服务器； 13 端口是白天服务的标准端口。

  1. try (var socket = new Socket(hostname, port)) {

流客户端套接字已创建。 它连接到命名主机上的指定端口号。 使用 Java 的try-with-resources语句自动关闭套接字。

  1. try (var reader = new InputStreamReader(socket.getInputStream())) {

getInputStream()返回此套接字的输入流。 我们从此输入流中读取服务器的响应。 套接字之间的通信以字节为单位； 因此，我们将InputStreamReader用作字节和字符之间的桥梁。

  1. int character;
  2. var output = new StringBuilder();
  4. while ((character = reader.read()) != -1) {
  6.     output.append((char) character);
  7. }
  9. System.out.println(output);

由于响应消息很小，因此我们可以逐个字符地读取它，而对性能的影响很小。

Java 套接字 Whois 客户端

Whois 是基于 TCP 的面向事务的查询/响应协议，被广泛用于向互联网用户提供信息服务。 它用于查询域名或 IP 地址块所有者等信息。

注意：大多数 Whois 服务器仅提供有限的信息（例如，仅针对选定的域名），并且有关域名所有者的信息通常由域名注册机构匿名。

Whois 协议使用端口 43。

com/zetcode/WhoisClientEx.java

  1. package com.zetcode;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  9. // probing whois.iana.org might give the right
  10. // whois server
  12. public class WhoisClientEx {
  14.     public static void main(String[] args) throws IOException {
  16.         var domainName = "example.com";
  17.         var whoisServer = "whois.nic.me";
  18.         int port = 43;
  20.         try (var socket = new Socket(whoisServer, port)) {
  22.             try (var writer = new PrintWriter(socket.getOutputStream(), true)) {
  24.                 writer.println(domainName);
  26.                 try (var reader = new BufferedReader(
  27.                         new InputStreamReader(socket.getInputStream()))) {
  29.                     String line;
  31.                     while ((line = reader.readLine()) != null) {
  33.                         System.out.println(line);
  34.                     }
  35.                 }
  36.             }
  37.         }
  38.     }
  39. }

在该示例中，我们探查了有关域名所有者的信息。

  1. try (var writer = new PrintWriter(socket.getOutputStream(), true)) {
  3.     writer.println(domainName);
  4. ...

我们获得套接字的输出流，并将其包装到PrintWriter中。 PrintWriter会将我们的字符转换为字节。 使用println()，将域名写入流中。 通过套接字的通信被缓冲。 PrintWriter的第二个参数是autoFlush； 如果设置为true，则在每个println()之后将刷新缓冲区。

  1. try (var reader = new BufferedReader(
  2.         new InputStreamReader(socket.getInputStream()))) {
  4.     String line;
  6.     while ((line = reader.readLine()) != null) {
  8.         System.out.println(line);
  9.     }
  10. }

来自服务器的响应被读取并写入控制台。

Java 套接字 GET 请求

在下面的示例中，我们创建一个 GET 请求。 HTTP GET 请求用于检索特定资源。

com/zetcode/JavaSocketGetRequest.java

  1. package com.zetcode;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  9. public class SocketGetRequest {
  11.     public static void main(String[] args) throws IOException {
  13.         try (var socket = new Socket("webcode.me", 80)) {
  15.             try (var wtr = new PrintWriter(socket.getOutputStream())) {
  17.                 // create GET request
  18.                 wtr.print("GET / HTTP/1.1\r\n");
  19.                 wtr.print("Host: www.webcode.me\r\n");
  20.                 wtr.print("\r\n");
  21.                 wtr.flush();
  22.                 socket.shutdownOutput();
  24.                 String outStr;
  26.                 try (var bufRead = new BufferedReader(new InputStreamReader(
  27.                         socket.getInputStream()))) {
  29.                     while ((outStr = bufRead.readLine()) != null) {
  31.                         System.out.println(outStr);
  32.                     }
  34.                     socket.shutdownInput();
  35.                 }
  36.             }
  37.         }
  38.     }
  39. }

该示例从网站检索 HTML 页面。

  1. try (var socket = new Socket("webcode.me", 80)) {

我们在端口 80 上的指定网页上打开一个套接字。HTTP 协议使用端口 80。

  1. try (var wtr = new PrintWriter(socket.getOutputStream())) {

我们将在协议上发布文本命令； 因此，我们为套接字输出流创建一个PrintWriter。 由于我们没有将autoFlush选项设置为true，因此我们需要手动刷新缓冲区。

  1. // create GET request
  2. wtr.print("GET / HTTP/1.1\r\n");
  3. wtr.print("Host: www.webcode.me\r\n");
  4. wtr.print("\r\n");
  5. wtr.flush();

我们创建一个 HTTP GET 请求，该请求检索指定网页的主页。 请注意，文本命令以\r\n（CRLF）字符完成。 这些是必需的通信详细信息，在 RFC 2616 文档中进行了描述。

  1. socket.shutdownOutput();

shutdownOutput禁用此套接字的输出流。 最后必须关闭连接。

  1. try (var bufRead = new BufferedReader(new InputStreamReader(
  2.     socket.getInputStream()))) {

对于服务器响应，我们打开一个套接字输入流，并使用InputStreamReader将字节转换为字符。 我们还缓冲读取操作。

  1. while ((outStr = bufRead.readLine()) != null) {
  3.     System.out.println(outStr);
  4. }

我们逐行读取数据。

  1. socket.shutdownInput();

最后，我们也关闭了输入流。

Java 套接字 HEAD 请求

在下一个示例中，我们使用 Java 套接字创建 HEAD 请求。 HEAD 方法与 GET 方法相同，不同之处在于服务器在响应中不返回消息正文。 它仅返回标头。

com/zetcode/SocketHeadRequest.java

  1. package com.zetcode;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  9. public class SocketHeadRequest {
  11.     public static void main(String[] args) throws IOException {
  13.         var hostname = "webcode.me";
  14.         int port = 80;
  16.         try (var socket = new Socket(hostname, port)) {
  18.             try (var writer = new PrintWriter(socket.getOutputStream(), true)) {
  20.                 writer.println("HEAD / HTTP/1.1");
  21.                 writer.println("Host: " + hostname);
  22.                 writer.println("User-Agent: Console Http Client");
  23.                 writer.println("Accept: text/html");
  24.                 writer.println("Accept-Language: en-US");
  25.                 writer.println("Connection: close");
  26.                 writer.println();
  28.                 try (var reader = new BufferedReader(new InputStreamReader(
  29.                         socket.getInputStream()))) {
  31.                     String line;
  33.                     while ((line = reader.readLine()) != null) {
  35.                         System.out.println(line);
  36.                     }
  37.                 }
  38.             }
  39.         }
  40.     }
  41. }

该示例检索指定网页的标题。

  1. writer.println("HEAD / HTTP/1.1");

我们发出 HEAD 命令。

  1. writer.println("Connection: close");

在 HTTP 协议版本 1.1 中，除非另有声明，否则所有连接均被视为持久连接（保持活动状态）。 通过将选项设置为false，我们通知我们要在请求/响应周期之后完成连接。

Java ServerSocket日期服务器

下面的示例使用ServerSocket创建一个非常简单的服务器。 ServerSocket创建绑定到指定端口的服务器套接字。

com/zetcode/DateServer.java

  1. package com.zetcode;
  3. import java.io.IOException;
  4. import java.io.PrintWriter;
  5. import java.net.ServerSocket;
  6. import java.time.LocalDate;
  8. public class DateServer {
  10.     public static void main(String[] args) throws IOException {
  12.         int port = 8081;
  14.         try (var listener = new ServerSocket(port)) {
  16.             System.out.printf("The started on port %d%n", port);
  18.             while (true) {
  20.                 try (var socket = listener.accept()) {
  22.                     try (var pw = new PrintWriter(socket.getOutputStream(), true)) {
  24.                         pw.println(LocalDate.now());
  25.                     }
  26.                 }
  27.             }
  28.         }
  29.     }
  30. }

该示例创建一个返回当前日期的服务器。 最后必须手动终止该程序。

  1. int port = 8081;
  3. try (var listener = new ServerSocket(port)) {

在端口 8081 上创建一个服务器套接字。

  1. try (var socket = listener.accept()) {

accept()方法监听与此套接字建立的连接并接受它。 该方法将阻塞，直到建立连接为止。

  1. try (var pw = new PrintWriter(socket.getOutputStream(), true)) {
  3.     pw.println(LocalDate.now());
  4. }

我们将当前日期写入套接字输出流。

get_request.py

  1. #!/usr/bin/env python3
  3. import socket
  5. with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
  7.     s.connect(("localhost" , 8081))
  8.     s.sendall(b"GET / HTTP/1.1\r\nHost: localhost\r\nAccept: text/html\r\n\r\n")
  9.     print(str(s.recv(4096),  'utf-8'))

我们有一个 Python 脚本向服务器发出 GET 请求。

  1. $ get_request.py
  2. 2019-07-15

这是输出。

Java 套接字客户端/服务器示例

在下面的示例中，我们有一个服务器和一个客户端。 服务器反转从客户端发送的文本。 这个例子很简单而且很阻塞。 为了改善它，我们需要包括线程。

com/zetcode/ReverseServer.java

  1. package com.zetcode;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.ServerSocket;
  9. // This server communicates only with one client at a time.
  10. // It must disconnect from a client first to communicate
  11. // with another client. It receives a bye command from a client
  12. // to close a connection.
  14. public class ReverseServer {
  16.     public static void main(String[] args) throws IOException {
  18.         int port = 8081;
  20.         try (var serverSocket = new ServerSocket(port)) {
  22.             System.out.println("Server is listening on port " + port);
  24.             while (true) {
  26.                 try (var socket = serverSocket.accept()) {
  28.                     System.out.println("client connected");
  30.                     try (var reader = new BufferedReader(new InputStreamReader(
  31.                                 socket.getInputStream()));
  32.                          var writer = new PrintWriter(socket.getOutputStream(), true)) {
  34.                         String text;
  36.                         do {
  38.                             text = reader.readLine();
  40.                             if (text != null) {
  42.                                 var reversed = new StringBuilder(text).reverse().toString();
  43.                                 writer.println("Server: " + reversed);
  45.                                 System.out.println(text);
  46.                             }
  47.                         } while (!"bye".equals(text));
  49.                         System.out.println("client disconnected");
  50.                     }
  51.                 }
  52.             }
  53.         }
  54.     }
  55. }

ReverseServer将反向字符串发送回客户端。 一次仅与一个客户端通信。 它必须首先与客户端断开连接才能与另一个客户端通信。 它从客户端收到一个bye命令以关闭连接。

  1. try (var reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  2.     var writer = new PrintWriter(socket.getOutputStream(), true)) {

我们有一个套接字输入流，用于读取客户端数据，以及套接字输出流，用于将响应发送回客户端； 输出流和连接已关闭。

  1. do {
  3.     text = reader.readLine();
  5.     if (text != null) {
  7.         var reversed = new StringBuilder(text).reverse().toString();
  8.         writer.println("Server: " + reversed);
  10.         System.out.println(text);
  11.     }
  12. } while (!"bye".equals(text));

为单个客户端创建了一个do-while循环。 我们从客户端读取数据，然后将修改后的内容发送回去。 收到客户端的再见命令后，循环结束。 在此之前，没有其他客户端可以连接到服务器。

com/zetcode/ReverseClient.java

  1. package com.zetcode;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  8. import java.util.Scanner;
  10. // the client must send a bye command to
  11. // inform the server to close the connection
  13. public class ReverseClient {
  15.     public static void main(String[] args) throws IOException {
  17.         var hostname = "localhost";
  18.         int port = 8081;
  20.         try (var socket = new Socket(hostname, port)) {
  22.             try (var writer = new PrintWriter(socket.getOutputStream(), true)) {
  24.                 try (var scanner = new Scanner(System.in)) {
  26.                     try (var reader = new BufferedReader(new InputStreamReader(
  27.                             socket.getInputStream()))) {
  29.                         String command;
  31.                         do {
  33.                             System.out.print("Enter command: ");
  35.                             command = scanner.nextLine();
  37.                             writer.println(command);
  39.                             var data = reader.readLine();
  40.                             System.out.println(data);
  42.                         } while (!command.equals("bye"));
  43.                     }
  44.                 }
  45.             }
  46.         }
  47.     }
  48. }

客户端将文本数据发送到服务器。

  1. do {
  3.     System.out.print("Enter command: ");
  5.     command = scanner.nextLine();
  7.     writer.println(command);
  9.     var data = reader.readLine();
  10.     System.out.println(data);
  12. } while (!command.equals("bye"));

我们从控制台读取输入，并将其发送到服务器。 当我们发送bye命令时，while循环完成，该命令通知服务器可以关闭连接。

Java DatagramSocket示例

UDP 是一种通信协议，它通过网络传输独立的数据包，不保证到达且也不保证传递顺序。 使用 UDP 的一项服务是每日报价（QOTD）。

下面的示例创建一个连接到 QOTD 服务的客户端程序。

com/zetcode/DatagramSocketEx.java

  1. package com.zetcode;
  3. import java.io.IOException;
  4. import java.net.DatagramPacket;
  5. import java.net.DatagramSocket;
  6. import java.net.InetAddress;
  8. // DatagramSocket provides network communication via UDP protocol
  9. // The Quote of the Day (QOTD) service is a member of the Internet protocol
  10. // suite, defined in RFC 865
  12. public class DatagramSocketEx {
  14.     public static void main(String[] args) throws IOException {
  16.         var hostname = "djxmmx.net";
  17.         int port = 17;
  19.         var address = InetAddress.getByName(hostname);
  21.         try (var socket = new DatagramSocket()) {
  23.             var request = new DatagramPacket(new byte[1], 1, address, port);
  24.             socket.send(request);
  26.             var buffer = new byte[512];
  27.             var response = new DatagramPacket(buffer, buffer.length);
  28.             socket.receive(response);
  30.             var quote = new String(buffer, 0, response.getLength());
  31.             System.out.println(quote);
  32.         }
  33.     }
  34. }

该示例从报价服务检索报价并将其打印到终端。

  1. var address = InetAddress.getByName(hostname);

我们从主机名获得 IP 地址。

  1. try (var socket = new DatagramSocket()) {

创建了DatagramSocket。

  1. var request = new DatagramPacket(new byte[1], 1, address, port);

创建了DatagramPacket。 由于 QOTD 服务不需要来自客户端的数据，因此我们发送了一个空的小型数组。 每次发送数据包时，我们都需要指定数据，地址和端口。

  1. socket.send(request);

数据包通过send()发送到其目的地。

  1. var buffer = new byte[512];
  2. var response = new DatagramPacket(buffer, buffer.length);
  3. socket.receive(response);

我们收到来自服务的数据包。

  1. var quote = new String(buffer, 0, response.getLength());
  2. System.out.println(quote);

我们将接收到的字节转换为字符串并打印。

在本教程中，我们创建了带有套接字的网络 Java 程序。 您可能也对相关教程感兴趣： Java HTTP GET/POST 请求教程， Java InputStreamReader教程， Java Servlet 教程和 Java 教程 。

列出所有 Java 教程。