In the [Client/Server] communication mode, the client needs to actively construct a Socket to connect to the server. The construction method has the following overloaded forms:
Socket() Socket(InetAddress address, int port) throws UnknownHostException,IOException Socket(InetAddress address, int port, InetAddress localAddr, int localPort) throws IOException Socket(String host, int port) throws UnknownHostException,IOException Socket(String host, int port, InetAddress localAddr, int localPort) throws IOException Socket(Proxy proxy)
Except for the first constructor without parameters, all other constructors will try to establish a connection with the server. Once the connection is successful, the Socket object will be returned, otherwise an exception will be thrown.
When the client's Socket construction method requests a connection with the server, it may have to wait for a period of time. By default, the Socket constructor will wait until the connection is successful or an exception occurs. When the Socket construction method requests a connection, it may be in a long waiting state due to the transmission speed of the underlying network. If you want to limit the time to wait for a connection, you need to use the first constructor without parameters
Socket socket = new Socket();
SocketAddress remoteAddr = new InetSocketAddress("1ocalhostn", 8000);
// 参数endpoint指定服务器的地址,参数timeout设定的超时时间(ms)
// 如果参数timeout被设为0则表示永远不会超时
socket.connect(remoteAddr, 60000);The above code is used to connect to the server program listening on port 8000 on the local machine, and the maximum time to wait for the connection for one minute. If the connection is successful within one minute, the connect() method returns successfully. If some exception occurs within one minute, the exception will be thrown. If the connection is neither successful nor appears after one minute, Exception, then SocketTimeoutException will be thrown
Except for the construction method without parameters, other construction methods need to set the server's dungeon in the parameters, including The IP or host name of the server, and the port
Socket socket = new Socket();
SocketAddress remoteAddr = new InetSocketAddress("1ocalhostn", 8000);
// 参数endpoint指定服务器的地址,参数timeout设定的超时时间(ms)
// 如果参数timeout被设为0则表示永远不会超时
socket.connect(remoteAddr, 60000);The InetAddress class represents the P address of the host and provides a series of static factory methods for constructing its own instance
// 返回本地主机的IP地址、
InetAddress addr1 = inetAddress.getLocalHost();
// 返回代表 "222.34.57” 的 IPv4 地址
InetAddress addr2 = InetAddress.getByName("222.34.5.7");
// 返同代表 ”2001:DB8:2DE::E13" 的 IPv6 地址
InetAddress addr3 = InetAddress.getByName("2001:DB8:2DE::E13");
// 返回主机名为 "www.javathinker.net" 的 IP 地址
InetAddress addr4 = InetAddress.getByName ("www.javathinker.net");A Socket object contains both the IP address and port information of the remote server and the IP address and port information of the local client. By default, the client's IP address comes from the host where the client program is located, and the client's port is randomly assigned by the operating system. The Socket class also has two constructors that allow you to explicitly set the client's IP address and port
Socket(InetAddress address, int port, InetAddress localAddr, int localPort) throws IOException Socket(String host, int port, InetAddress localAddr, int localPort) throws IOException
If a host belongs to more than two networks at the same time, it may have more than two IP addresses, such as a host The IP address in the Internet network is "222.67,1.34", and the IP address in a LAN is "1125.4.3". It is assumed that the client program on this host wants to communicate with an address on the same bureau network as "112.5.4.4" :8000" server program communication, the client can construct the Socket object as follows
InetAddress remoteAddr = InetAddress.getByName("112.5,4.45");
InetAddress localAddr = InetAddress.getByName("112.5.4.3");
//客户端使用口2345
Socket socket = new Socket(remoteAddr, 8000, localAddr, 2345);When the Socket construction method requests to connect to the server , the following exception may be thrown:
UnknownHostException: The name or IP address of the host cannot be recognized
ConnectException: There is no server process listening for the specified port, or the server process refused to connect
SocketTimeoutException: Timeout waiting for connection
BindException: Unable to bind the Socket object to the specified local IP address or port Binding
In actual applications, some client programs will access remote servers through proxy servers. The proxy server has many functions, such as acting as a firewall for security purposes, or improving access speed, or having permission to access a specific remote server
String proxyIP = "myproxy.abc.oom"; // 代理服务器地址
int proxyPort = 1080; // 代理服务器端口
// 创建代理对象
Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress(proxyIP, proxyPort));
Socket socket new Socket(proxy);
//连接到远程服务器
socket.connect(new InetSocketAddress("www.javathinker.net", 80));The ProxyType class represents the type of proxy server, with the following optional values:
Proxy.Type.SOCKS: In a hierarchical network structure, SOCKS is a proxy type located at the session layer
Proxy.Type.HTTP: In a layered network structure, HTTP is a proxy type located at the application layer
Proxy.Type.DIRECT: Directly connects to the remote server without using a proxy
The InetAddress class represents the IP address of the host. The static factory method of the InetAddress class is getByName() used to construct its own instance
// 返回代表 "222.34.5.7" 的 IPv4 地址
InetAddress addr2 = InetAddress,getByName("222.34.5.7");
// 返回主机名为 "www.javathinker.net" 的 IP 地址
InetAddress addr4 = InetAddress.getByName("www.javathinker.net");InetAddress also provides two methods to obtain the corresponding host name:
getHostname(): First find a match with the IP address from the DNS cache The host name, if it does not exist, is searched through the DNS server. If found, the host name is returned, otherwise the IP address is returned
getCanonicalHostName(): Through DNS The server looks for a host name that matches the IP address, and returns the host name if found, otherwise it returns the IP address
The difference between the above two methods is getHostname() The DNS cache will be searched first to reduce the probability of searching the DNS server and improve search performance. And getCanonicalHostName() always looks up the DNS server to ensure that the latest version of the host name is obtained.
The InetAddress class also provides two methods for testing whether you can connect to a specific host from the local host:
public boolean isReachable(int timeout) throws IOException public boolean isReachable(NefworkInterface interface, int ttl, int timeout) throws IOException
If the remote host responds within the time specified by the parameter timeout (ms), the above method returns true, otherwise returns false, and throws IOException if a network error occurs. The second method also allows a connection to be established from the local network interface specified by the parameters, as well as the TTL (how long an IP packet is allowed to exist before being discarded)
NetworkInterfiace 类表示物理上的网络接口，它有两种构造自身实例的静态工厂方法，这两种方法都声明抛出 SocketException
// 参数 name 指定网络接口的名字，如果不存在与名字对应的网络接口，就返回 null getByName(String name) // 参数 address 指定网络接口的 IP 地址，如果不存在与 IP 地址对应的网络接口，就返回 null getByInetAddress(InetAddress address)
NetworkInterface 类的以下方法用于获取网络接口的信息
// 返回网络接口的名字 public String getName() // 返回和网络接口绑定的所有 IP 地址，返回值为 Enumeration 类型，里面存放了表示 IP 地址的 InetAddress 对象 public Enumeration getInetAddresses()
在一个 Socket 对象中同时包含了远程服务器的 IP 地址和端口信息，以及客户本地的 IP 地址和端口信息。此外，从 Socket 对象中还可以获得输出流和输入流，分别用于向服务器发送数据，以及接收从服务器端发来的数据
以下方法用于获取 Socket 的有关信息
// 获得远程被连接进程的IP地址 getInetAddress() // 获得远程被连接进程的端口 getPort() // 获得本地的IP地址 getLocalAddress() // 获得本地的端口 getLocalPort() // 获得输入流,如果Socket还没有连接,或者已经关团,或者已经通过shutdownInput()方法关闭输入流,那么此方法会抛出IOException getInputStream() // 获得输出流,如果Socket还没有连接,或者已经关闭,或者已经通过shutdownOutput()方法关闭输出流,那么此方法会抛出 IOException getOutputStream()
当客户与服务器的通信结束时，应该及时关闭 Socket，以释放 Socket 占用的包括端口在内的各种资源。Socket 的 close() 方法负责关闭 Socket，如果一个 socket 对象被关闭，就不能再通过它的输入流和输出流进行 IO 操作，否则会导致 IOException
Socket 类提供了三个状态测试方法
// 如果Socket没有关闭，则返回false，否则返回true isClosed() // 如果Socket曾经连接到远程主机，不管当前是否已经关闭，都返回true。如果Socket从未连接到远程主机，就返回false isConnected() // 如果Socket已经与一个本地端口绑定，则返回true，否则返回false isBound()
如果要判断一个 Socket 对象当前是否处于连接状态，可采用以下方式
String isConnected = socket.isConnected() && !socket.isClosed();
进程 A 与进程 B 通过 Socket 通信，假定进程 A 输出数据，进程 B 读入数据，进程 A 如何告诉进程 B 所有数据已经输出完毕呢？有几种处理办法：
如果进程 A 与进程 B 交换的是字符流，并且都一行一行地读写数据，那么可以事先约定以一个特殊的标志作为结束标志，例如以字符串 “bye” 作为结束标志，当进程 A 向进程 B 发送一行字符串 “bye”，进程 B 读到这一行数据后，就停止读取数据
进程 A 先发送一个消息，告诉进程 B 所发送的正文的长度，然后发送正文。进程 B 先获知进程 A 将发送的正文的长度，接下来只要读取该长度的字符或者字节，就停止读取数据
进程 A 发完所有数据后，关闭 Socket，当进程 B 读入了进程 A 发送的所有数据后，再次执行输入流的 read() 方法时，该方法返回 “-1”，如果执行 BufferedReader 的 readLine() 方法，那么该方法返回 null
ByteArrayOutputstream bufferenew = ByteArrayOutputstream();
byte[] buff = new byte[1024);
int len = -1;
while((len = socketIn.read(buff)) != -1) {
buffer.write(buff, 0, len);
}当调用 Socke t的 close() 方法关闭 Socket 后，它的输出流和输入流也都被关闭。有的时候，可能仅仅希望关闭输出流或输入流之一，此时可以采用 Socket 类提供的半关闭方法
shutdownInput() // 关闭输入流 shutdownOutput() // 关团输出流
假定进程 A 执行以下代码，先向进程 B 发送一个字符串，等到进程 B 接收到这个字符串后，进程 A 再调用 Socket 的 shutdownOutput() 方法关闭输出流，接下来进程 A 不允许再输出数据，但是仍可以通过输入流读入数据
// 发出请求信息
String data = ...;
OutputStream socketOut = socket.getOutputStream();
socketOut.write(data.getBytes());
socketOut.flush();
// 读取响应
InputStream socketIn = socket.getInputStream();
if(服务器端返回提示信息，表明已经接收到客户端的所有请求数据)
socket.shutdownOutput(); //关闭输出流
//继续通过socketIn读取数据
...值得注意的是，先后调用 Socket 的 shutdownInput() 和 shutdownOutput() 方法，仅仅关闭了输入流和输出流，并不等价于调用 Socket 的 close() 方法。在通信结束后，仍然要调用 Socket 的 close() 方法，因为只有该方法才会释放 Socket 占用的资源，比如占用的本地端口等
Socket 类还提供了两种状态测试方法，用来判断输入流和输出流是否关闭
public boolean isInputShutdown() // 如果输入流关闭，则返回true，否则返回false public boolean isOutputShutdown() // 如果输出流关闭，则返回true，否则返回false
表示立即发送数据。在默认情况，下发送数据采用 Negale 算法，发送方发送的数据不会立刻被发出，而是先放在缓冲区内，等缓冲区满了再发出。发送完一批数据后，会等待接收方对这批数据的回应，然后发送下一批数据。此算法法适用于发送方需要发送大批量数据并且接收方会及时做出回应的场合，这种算法通过减少传输数据的次数来提高通信效率
如巢发送方持续地发送小批量的数据。并且接收方不一定会立即发送响应数据，那么 Negale 算法会使发送方运行得很慢，对于GU程序，比如网络游戏程序（服务器需要实时跟踪客户端鼠标的移动），这个问题尤其突出
TCP_NODEALY 的默认值为 false，表示采用 Negale 算法，如果调用 setTcpNoDelay(true) 方法，就会关闭 Socket 的缓冲，确保数据被及时发送
if(!socket.getTcpNoDelay())
socket.setTcpNoDelay(true);表示是否允许重用 Socket 所绑定的本地地址。当接收方通过 Socket 的 close() 方法关闭 Socket 时，如果网络上还有发送到这个 Socket 的数据，那么底层的 Socket 不会立刻释放本地端口，而是会等待一段时间，确保接收到了网络上发送过来的延迟数据，再释放端口。Socket 接收到延迟数据后，不会对这些数据做任何处理。Socket 接收延迟数据的目的是，确保这些数据不会被其他碰巧绑定到同样端口的新进程接收到
客户程序一般采用随机端口，因此出现两个客户程序绑定到同样端口的可能性不大。许多服务器程序都使用固定的端口。当服务器程序被关闭后，有可能它的端口还会被占用一段时间，如果此时立刻在同一台主机上重启服务器程序，由于端口已经被占用，使得服务感程序无法绑定到该端口，导致启动失败
为了确保当一个进程关闭了 Socket 后，即便它还没释放端口，同一台主机上的其他进要也可以立刻重用该端口，可以调用 Socke 的 setResuseAddress(ture) 方法
if(!socket.getResuseAddress())
socket.setResuseAddress(true);值得注意的是 socket.setResuseAddress(true) 方法必须在 Socket 还没有被绑定到一个本地端口之前调用，否则执行无效
表示接收数据时的等待超时时间。当通过 Socket 的输入流读数据时，如果还没有数据，就会等待。Socket 类的SO_TIMEOUT 选项用于设定接收数据的等待超时时间，单位为 ms，它的默认值为0，表示会无限等待，永远不会超时
以下代码把接收数据的等待超时时间设为三分钟
if(socket.getTimeout() == 0)
socket.setTimeout(60000 * 3);Socket 的 setTimeout() 方法必须在接收数据之前执行才有效
表示与执行 Socket 的 close() 方法时，是否立即关闭底层的 Socket。在默认情况下执行 Socket 的 close() 方法，该方法会立即返回，但底层的 Socket 实际上并不立即关闭，它会延迟一段时间，直到发送完所有剩余的数据，才会真正关闭 Socket
如果执行以下方法
socket.setSoLinger(true,0);
那么执行 Socket 的 close() 方法，该方法也会立即返回而且底层的 Socket 也会立即关闭，所有未发送完的数据被丢弃
如果执行以下方法
socket.setSoLinger(true,3600);
那么执行 Socket 的 close() 方法，该方法不会立即返回，而是进入阻塞状态，同时，底层的 Socket 会尝试发送剩余的数据。只有满足以下两个条件之一，close() 方法才返回：
底层的 Socket 已经发送完所有的剩余数据
尽管底层的 Socket 还没有发送完所有的剩余数据，但己经阻塞了 3600s，此时 close() 也会返回，未发送的数据被丢弃
表示接收数据的缓冲区的大小。一般说来，传输大的连续的数据块，比如基于 HTTP 或 FTP 的通信，可以使用较大的缓冲区，这可以减少传输数据的次数，提高传输数据的效率。而对于交互式的通信方式，比如 Telnet 和网络游戏，则应该采用小的缓冲区，确保小批量的数据能及时发送给对方
表示发送数据的缓冲区的大小
表示对于长时间处于空闲状态的 Socket，是否要自动把它关团。当 SO_KEEPALIVE 选项为 tue 时，表示底层的 TCP 实现会监视该连接是否有效连接处于空闲状态，即连接的两端没有互相传送数据超过了 2 小时，本地的 TCP 实现发送一个数据包给远程的 Socket，如果远程 Socke 没有返回响应，TCP 实现就会持续尝试发送 11 分钟，直到接收到响应为止。如果在 12 分钟内未收到响应，TCP 实现就会自动关闭本地 Socket，断开连接
SO_KEEPALIVE 选项的默认值为 false，表示 TCP 不会监视连接是否有效，不活动的客户端可能会永久存在下去，而不会注意到服务器已经崩溃
当用户通过邮局发送普通信、挂号信或者快件时，实际上选择了邮局提供的不同的服务。发送普通信的价格最低，但发送速度慢，并且可靠性没有保证。发送挂号信的价格稚高，但可靠性有保证。发送快件的价格最高，发送速度最快，并且可靠性有保证
在 Internet 上传输数据也分为不同的服务类型，它们有不同的定价。用户可以根据自己的需求，选择不同的服务类型。例如发送视频需要较高的带宽，快速到达目的地，以保证接收方看到连续的画面，而发送电子邮件可以使用较低的带宽，延迟几个小时到达目的地也没关系
IP 规定了一些服务类型，用来定性地描述服务的质量，举例如下：
低成本：发送成本低
高可靠性：保证把数据可靠地送达目的地
最高吞吐量：一次可以接收或发送大批量的数据
最小延迟：传输数据的速度快，把数据快速送达目的地
这些服务类型还可以进行组合，例如，可以同时要求获得高可靠性和最小延迟。服务类型存储在 IP 数据包头部的名为 IP_TOS 的 8 位字段中，Socket 类中提供了设置和读取服务类型的方法
// 设置服务类型 public void setTrafficClass(int trafficClass) throws SocketException // 读取服务类型 public int getTrafficClass() throws SocketException
服务类型用 1 字节来表示，取值范围是 0 到 255 之间的整数。这个服务类型数据也会被复制到 TCP 数据包头部的 8 位字段中。，在目前的网络协议中，对这个表示服务类型的字节又做了进一步的细分：
高六位：表示 DSCP 值，即表示不同的服务类型代码号。DSCP 允许最多有 64 种服务类型
低两位：表示 ECN 值，即显式拥塞通知信息
64 个 DSCP 值到底表示什么含义，这是由具体的网络和路由器决定的。下面是比较常见的 DCSP 值：
默认服务类型：000000
加速转发类型：101110，特点是低损耗、低延迟、低抖动
保证转发类型：共 12 个取值，保证以指定速率传送，见下表
类型 | 第1类(最低转发优先) | 第2类 | 第3类 | 第4类(最高转发优先) |
|---|---|---|---|---|
低丢包率 | 001010 | 010010 | 011010 | 100010 |
中丢包率 | 001100 | 010100 | 011100 | 100100 |
高丢包率 | 001110 | 010110 | 011110 | 100110 |
其中第 1 类有最低转发优先级，第 4 类有最高转发优先级。也就是说，当网络出现阻塞时，第 4 类的数据包被优先转发。每一类又包含了 3 个取值，其中低丢包率的服务类型丢弃数据包的概率小，而高丢包率的服务类型丢弃数据包的概率大
加速转发类型比其他服务类型有更高的优先级，例如以下代码使得 Socket 采用加速转发类型来收发数据：
Socket socket = new Socket("www.javathinker.net", 80);
// 0xB8 对应二进制数据 10111000
// 低两位表示显式拥塞通知，取值为 00
socket.setTrafficClass(0xB8);值得注意的是，DCSP 值仅仅为底层的网络实现提供一个参考，有些底层 Socket 实现会忽略 DCSP 值，对它不进行任何处理
从 JDK1.5 开始，为 Socket 类提供了一个 setPerformancePreferences() 方法
public vold setPerformancePreferences (int connectionTime, int latency, int bandwidth)
以上方法的 3 个参数表示网络传输数据的 3 项指标：
connectionTime：表示用最少时间建立连接
latency：表示最小廷迟
bandwidth：表示最高带宽
setPerformancePreferences() 方法被用来设定这 3 项指标之间的相对要性。可以为这些参数赋予任意的整数。这些整数之间的相对大小就决定了相应参数的相对重要性。例如，如果参数 connectionTime 为 2，参数 latency 为 1，而参数 bandwidth 为 3，就表示最高带宽最重要，其次是最少连接时间，最后是最小延迟
值得注意的是 setPerformancePreferences() 方法所做的设置仅仅为底层的网络实现提供一个参考，有些底层 Socket 实现会忽略这一设置，对它不进行任何处理
The above is the detailed content of How to create a Java network programming Socket. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
