Java 简明教程

Java - Networking

Java Networking

Java networking（或 Java network programming）指的是编写在多设备（计算机）上执行的程序，其中所有设备都使用网络连接在一起。

Java networking (or, Java network programming) refers to writing programs that execute across multiple devices (computers), in which the devices are all connected to each other using a network.

Advantages of Java Networking

Creating server-client applications
Implementing networking protocols
Implement socket programming
Creating web services

Package Used in Networking

J2SE API 的 java.net 包含一组类和接口，用于提供低级通信细节，让您可以编写专注于解决当前问题的程序。

The java.net package of the J2SE APIs contains a collection of classes and interfaces that provide the low-level communication details, allowing you to write programs that focus on solving the problem at hand.

java.net 包提供对两种常见网络协议的支持 −

The java.net package provides support for the two common network protocols −

TCP − TCP stands for Transmission Control Protocol, which allows for reliable communication between two applications. TCP is typically used over the Internet Protocol, which is referred to as TCP/IP.
UDP − UDP stands for User Datagram Protocol, a connection-less protocol that allows for packets of data to be transmitted between applications.

本章对以下两个主题进行了很好的阐述 −

This chapter gives a good understanding on the following two subjects −

Socket Programming − This is the most widely used concept in Networking and it has been explained in very detail.
URL Processing − This would be covered separately. Click here to learn about URL Processing in Java language.

Socket Programming in Java Networking

套接字使用 TCP 在两台计算机之间提供通信机制。客户端程序在其通信端创建套接字，并尝试将该套接字连接到服务器。

Sockets provide the communication mechanism between two computers using TCP. A client program creates a socket on its end of the communication and attempts to connect that socket to a server.

建立连接时，服务器在其通信端创建一个套接字对象。现在，客户端和服务器可以通过向套接字写入和从套接字读取来进行通信。

When the connection is made, the server creates a socket object on its end of the communication. The client and the server can now communicate by writing to and reading from the socket.

java.net.Socket class 表示一个套接字，而 java.net.ServerSocket 类为服务器程序提供了一种侦听客户端并与客户端建立连接的机制。

The java.net.Socket class represents a socket, and the java.net.ServerSocket class provides a mechanism for the server program to listen for clients and establish connections with them.

使用套接字在两台计算机之间建立 TCP 连接时，会发生以下步骤 −

The following steps occur when establishing a TCP connection between two computers using sockets −

The server instantiates a ServerSocket object, denoting which port number communication is to occur on.
The server invokes the accept() method of the ServerSocket class. This method waits until a client connects to the server on the given port.
After the server is waiting, a client instantiates a Socket object, specifying the server name and the port number to connect to.
The constructor of the Socket class attempts to connect the client to the specified server and the port number. If communication is established, the client now has a Socket object capable of communicating with the server.
On the server side, the accept() method returns a reference to a new socket on the server that is connected to the client’s socket.

建立连接后，可以使用 I/O 流进行通信。每个套接字都有一个 OutputStream 和一个 InputStream。客户端的 OutputStream 连接到服务器的 InputStream，客户端的 InputStream 连接到服务器的 OutputStream。

After the connections are established, communication can occur using I/O streams. Each socket has both an OutputStream and an InputStream. The client’s OutputStream is connected to the server’s InputStream, and the client’s InputStream is connected to the server’s OutputStream.

TCP 是一个双向通信协议，因此可以同时通过两个流发送数据。以下是提供实现套接字的完整方法集的有用类。

TCP is a two-way communication protocol, hence data can be sent across both streams at the same time. Following are the useful classes providing complete set of methods to implement sockets.

ServerSocket Class Constructors

服务器应用程序使用 java.net.ServerSocket 类获取端口并侦听客户端请求。

The java.net.ServerSocket class is used by server applications to obtain a port and listen for client requests.

ServerSocket 类有四个构造函数 −

The ServerSocket class has four constructors −

Sr.No.	Method & Description
1	public ServerSocket(int port) throws IOException Attempts to create a server socket bound to the specified port. An exception occurs if the port is already bound by another application.
2	public ServerSocket(int port, int backlog) throws IOException Similar to the previous constructor, the backlog parameter specifies how many incoming clients to store in a wait queue.
3	public ServerSocket(int port, int backlog, InetAddress address) throws IOException Similar to the previous constructor, the InetAddress parameter specifies the local IP address to bind to. The InetAddress is used for servers that may have multiple IP addresses, allowing the server to specify which of its IP addresses to accept client requests on.
4	public ServerSocket() throws IOException Creates an unbound server socket. When using this constructor, use the bind() method when you are ready to bind the server socket.

如果 ServerSocket 构造函数未引发异常，则表示应用程序已成功绑定到指定端口并已准备好接受客户端请求。

If the ServerSocket constructor does not throw an exception, it means that your application has successfully bound to the specified port and is ready for client requests.

ServerSocket Class Methods

以下是 ServerSocket 类的部分常用方法：

Following are some of the common methods of the ServerSocket class −

Sr.No.	Method & Description
1	public int getLocalPort() Returns the port that the server socket is listening on. This method is useful if you passed in 0 as the port number in a constructor and let the server find a port for you.
2	public Socket accept() throws IOException Waits for an incoming client. This method blocks until either a client connects to the server on the specified port or the socket times out, assuming that the time-out value has been set using the setSoTimeout() method. Otherwise, this method blocks indefinitely.
3	public void setSoTimeout(int timeout) Sets the time-out value for how long the server socket waits for a client during the accept().
4	public void bind(SocketAddress host, int backlog) Binds the socket to the specified server and port in the SocketAddress object. Use this method if you have instantiated the ServerSocket using the no-argument constructor.

当 ServerSocket 调用 accept() 时，该方法在客户端连接之前不会返回。在客户端连接后，ServerSocket会在未指定端口上创建新的 Socket，并返回对该新 Socket 的引用。在客户端和服务器间建立 TCP 连接后，便可开始通信。

When the ServerSocket invokes accept(), the method does not return until a client connects. After a client does connect, the ServerSocket creates a new Socket on an unspecified port and returns a reference to this new Socket. A TCP connection now exists between the client and the server, and communication can begin.

Socket Class Constructors

java.net.Socket 类表示客户端和服务器用于彼此通信的套接字。客户端通过实例化来获取 Socket 对象，而服务器则通过 accept() 方法的返回值来获取 Socket 对象。

The java.net.Socket class represents the socket that both the client and the server use to communicate with each other. The client obtains a Socket object by instantiating one, whereas the server obtains a Socket object from the return value of the accept() method.

Socket 类有五个构造函数供客户端用于连接到服务器 -

The Socket class has five constructors that a client uses to connect to a server −

Sr.No.	Method & Description
1	public Socket(String host, int port) throws UnknownHostException, IOException. This method attempts to connect to the specified server at the specified port. If this constructor does not throw an exception, the connection is successful and the client is connected to the server.
2	public Socket(InetAddress host, int port) throws IOException This method is identical to the previous constructor, except that the host is denoted by an InetAddress object.
3	public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException. Connects to the specified host and port, creating a socket on the local host at the specified address and port.
4	public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException. This method is identical to the previous constructor, except that the host is denoted by an InetAddress object instead of a String.
5	public Socket() Creates an unconnected socket. Use the connect() method to connect this socket to a server.

当 Socket 构造器返回时，它不仅仅实例化一个 Socket 对象，而且实际上尝试连接到指定的服务器和端口。

When the Socket constructor returns, it does not simply instantiate a Socket object but it actually attempts to connect to the specified server and port.

Socket Class Methods

此处列出 Socket 类中的一些感兴趣的方法。请注意，客户端和服务器都有一个 Socket 对象，因此客户端和服务器都可以调用这些方法。

Some methods of interest in the Socket class are listed here. Notice that both the client and the server have a Socket object, so these methods can be invoked by both the client and the server.

Sr.No.	Method & Description
1	public void connect(SocketAddress host, int timeout) throws IOException This method connects the socket to the specified host. This method is needed only when you instantiate the Socket using the no-argument constructor.
2	public InetAddress getInetAddress() This method returns the address of the other computer that this socket is connected to.
3	public int getPort() Returns the port the socket is bound to on the remote machine.
4	public int getLocalPort() Returns the port the socket is bound to on the local machine.
5	public SocketAddress getRemoteSocketAddress() Returns the address of the remote socket.
6	public InputStream getInputStream() throws IOException Returns the input stream of the socket. The input stream is connected to the output stream of the remote socket.
7	public OutputStream getOutputStream() throws IOException Returns the output stream of the socket. The output stream is connected to the input stream of the remote socket.
8	public void close() throws IOException Closes the socket, which makes this Socket object no longer capable of connecting again to any server.

InetAddress Class Methods

此类表示互联网协议 (IP) 地址。在进行套接字编程时，您可能需要使用以下有用方法：

This class represents an Internet Protocol (IP) address. Here are following usefull methods which you would need while doing socket programming −

Sr.No.	Method & Description
1	static InetAddress getByAddress(byte[] addr) Returns an InetAddress object given the raw IP address.
2	static InetAddress getByAddress(String host, byte[] addr) Creates an InetAddress based on the provided host name and IP address.
3	static InetAddress getByName(String host) Determines the IP address of a host, given the host’s name.
4	String getHostAddress() Returns the IP address string in textual presentation.
5	String getHostName() Gets the host name for this IP address.
6	static InetAddress InetAddress getLocalHost() Returns the local host.
7	String toString() Converts this IP address to a String.

Example of Java Networking

Implementing Socket Client in Java

以下 GreetingClient 是一个客户端程序，它使用套接字连接到服务器并发送问候语，然后等待响应。

The following GreetingClient is a client program that connects to a server by using a socket and sends a greeting, and then waits for a response.

// File Name GreetingClient.java
import java.net.*;
import java.io.*;

public class GreetingClient {

   public static void main(String [] args) {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try {
         System.out.println("Connecting to " + serverName + " on port " + port);
         Socket client = new Socket(serverName, port);

         System.out.println("Just connected to " + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out = new DataOutputStream(outToServer);

         out.writeUTF("Hello from " + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in = new DataInputStream(inFromServer);

         System.out.println("Server says " + in.readUTF());
         client.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Implementing Socket Server in Java

以下 GreetingServer 程序是一个服务器应用程序示例，它使用 Socket 类监听命令行参数指定的端口号上的客户端—

The following GreetingServer program is an example of a server application that uses the Socket class to listen for clients on a port number specified by a command-line argument −

// File Name GreetingServer.java
import java.net.*;
import java.io.*;

public class GreetingServer extends Thread {
   private ServerSocket serverSocket;

   public GreetingServer(int port) throws IOException {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }

   public void run() {
      while(true) {
         try {
            System.out.println("Waiting for client on port " +
               serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();

            System.out.println("Just connected to " + server.getRemoteSocketAddress());
            DataInputStream in = new DataInputStream(server.getInputStream());

            System.out.println(in.readUTF());
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress()
               + "\nGoodbye!");
            server.close();

         } catch (SocketTimeoutException s) {
            System.out.println("Socket timed out!");
            break;
         } catch (IOException e) {
            e.printStackTrace();
            break;
         }
      }
   }

   public static void main(String [] args) {
      int port = Integer.parseInt(args[0]);
      try {
         Thread t = new GreetingServer(port);
         t.start();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

编译客户端和服务器，然后按以下方式启动服务器—

Compile the client and the server and then start the server as follows −

$ java GreetingServer 6066
Waiting for client on port 6066...

按照以下步骤检查客户端程序 −

Check the client program as follows −

Output

$ java GreetingClient localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!