网络编程

The world rushes on over the strings of the lingering heart making
the music of sadness.

世界在踌躇之心的琴弦上跑过去，奏出忧郁的乐声。

Java 网络编程

网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。

java.net 包中 J2SE 的 API 包含有类和接口，它们提供低层次的通信细节。你可以直接使用这些类和接口，来专注于解决问题，而不用关注通信细节。

java.net 包中提供了两种常见的网络协议的支持：

• TCP：TCP（英语：Transmission Control Protocol，传输控制协议） 是一种面向连接的、可靠的、基于字节流的传输层通信协议，TCP 层是位于 IP 层之上，应用层之下的中间层。TCP 保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称 TCP / IP。
• UDP：UDP （英语：User Datagram Protocol，用户数据报协议），位于 OSI 模型的传输层。一个无连接的协议。提供了应用程序之间要发送数据的数据报。由于UDP缺乏可靠性且属于无连接协议，所以应用程序通常必须容许一些丢失、错误或重复的数据包。

IP地址

IP地址分类

为了便于寻址以及层次化构造网络，每个IP地址包括两个标识码（ID），即网络ID和主机ID。同一个物理网络上的所有主机都使用同一个网络ID，网络上的一个主机（包括网络上工作站，服务器和路由器等）有一个主机ID与其对应。Internet委员会定义了5种IP地址类型以适合不同容量的网络，即A类~E类。

IPV4与IPV6

公网IP与私网IP

• Public IP : 公共 IP ，经由 INTERNIC 所统一规划的 IP，有这种 IP 才可以连上 Internet ；
• Private IP : 私有 IP 或保留 IP，不能直接连上 Internet 的 IP ，主要用于局域网络内的主机联机规划。

公网IP在全球内是唯一的。也就是说在同一时间一个IP(除了一些特别的IP，如:154.0.0.0等)只代表一能设备，所以通只要找得到IP，也就可以找到特定的设备了。如果A是公网IP，且没有防火墙等Ban连接的话，那么B电脑上的EM就可以找并连接上A了。私网IP是专门给一些局域网内用的。也就是说在网络上是不唯一-的， 公网上是不能通这个私有IP来找到对应的设备的。

以下范围内的IP地址属于内网保留地址，即不是公网IP，而是属于私有IP:

• 10.0.0.0 - 10.255.255.255
• 172.16.0.0 - 172.31.255.255
• 192.168.0.0 - 192. 168.255.255

端口

TCP/IP的传输层用一个16位端口号来标志一个端口（port）。

虽然通信的终点是应用程序，但只要把所传送的报文交到目的主机的某个合适的目的端口，剩下的工作（即最后交付的进程）就由TCP或UDP来完成。

TCP和UDP的首部格式中，它们都有源端口和目的端口这两个重要字段。当传输层收到网络层交上来的传输层报文时，就能够根据其首部中的目的端口号把数据交付应用层的目的应用进程。

两个计算机中的进程要互相通信，不仅必须知道对方的IP地址，而且要知道对方的端口号（为了找到对方计算机中的应用程序）。互联网上的计算机通信是采用客户端-服务器方式。客户端在发起通信请求时，必须先知道对方的服务器的IP地址和端口号。

因此传输层的端口号分为下面的两大类：

服务器端使用的端口号:

熟知端口号或系统端口号：数值为0 ~ 1023。

UDP 知名端口：

TCP 知名端口：

客户端使用的端口号：

数值为49152 ~ 65535

由于这类端口号仅在客户进程运行时才动态选择，因此又叫做短暂端口号。这类端口号留给客户进程选择暂时使用。

当服务器进程收到客户进程的报文时，就知道了客户进程所使用的端口号，因而可以把数据发送给客户进程。

通信结束后，刚才已使用过的客户端口号就不存在了，这个端口号就可以供其他客户进程使用。

常见端口号

1
2
3
4
5
6
7
8
9
10
11

21端口：FTP 文件传输服务
22端口：SSH 端口
23端口：TELNET 终端仿真服务
25端口：SMTP 简单邮件传输服务
53端口：DNS 域名解析服务
80端口：HTTP 超文本传输服务
110端口：POP3 “邮6局协议版本3”使用的端口
443端口：HTTPS 加密的超文本传输服务
8080端口：Tomcat
3306端口：Mysql
1521端口: Oracle

Socket 编程

端口号与IP地址的组合，得出一个网络套接字：Socket，所以说一些网络编程也被称为Socket编程

套接字使用TCP提供了两台计算机之间的通信机制。 客户端程序创建一个套接字，并尝试连接服务器的套接字。

当连接建立时，服务器会创建一个 Socket 对象。客户端和服务器现在可以通过对 Socket 对象的写入和读取来进行通信。

java.net.Socket 类代表一个套接字，并且 java.net.ServerSocket 类为服务器程序提供了一种来监听客户端，并与他们建立连接的机制。

以下步骤在两台计算机之间使用套接字建立TCP连接时会出现：

• 服务器实例化一个 ServerSocket 对象，表示通过服务器上的端口通信。
• 服务器调用 ServerSocket 类的 accept() 方法，该方法将一直等待，直到客户端连接到服务器上给定的端口。
• 服务器正在等待时，一个客户端实例化一个 Socket 对象，指定服务器名称和端口号来请求连接。
• Socket 类的构造函数试图将客户端连接到指定的服务器和端口号。如果通信被建立，则在客户端创建一个 Socket 对象能够与服务器进行通信。
• 在服务器端，accept() 方法返回服务器上一个新的 socket 引用，该 socket 连接到客户端的 socket。

连接建立后，通过使用 I/O 流在进行通信，每一个socket都有一个输出流和一个输入流，客户端的输出流连接到服务器端的输入流，而客户端的输入流连接到服务器端的输出流。

TCP 是一个双向的通信协议，因此数据可以通过两个数据流在同一时间发送

ServerSocket 类的方法

服务器应用程序通过使用 java.net.ServerSocket 类以获取一个端口,并且侦听客户端请求。

ServerSocket 类有四个构造方法：

创建非绑定服务器套接字。 如果 ServerSocket 构造方法没有抛出异常，就意味着你的应用程序已经成功绑定到指定的端口，并且侦听客户端请求。

这里有一些 ServerSocket 类的常用方法：

Socket 类的方法

java.net.Socket 类代表客户端和服务器都用来互相沟通的套接字。客户端要获取一个 Socket 对象通过实例化 ，而 服务器获得一个 Socket 对象则通过 accept() 方法的返回值。

Socket 类有五个构造方法.

当 Socket 构造方法返回，并没有简单的实例化了一个 Socket 对象，它实际上会尝试连接到指定的服务器和端口。

下面列出了一些感兴趣的方法，注意客户端和服务器端都有一个 Socket 对象，所以无论客户端还是服务端都能够调用这些方法。

InetAddress 类的方法

这个类表示互联网协议(IP)地址。下面列出了 Socket 编程时比较有用的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

import java.net.InetAddress; 
import java.net.UnknownHostException; 
//IP 这个东西，怎么用Java对象表示 
public class InetAddressTest { 
  public static void main(String[] args) { 
    try {
    //获得IP地址 
    InetAddress inetAddresses1 = InetAddress.getByName("192.168.8.123"); 
    System.out.println(inetAddresses1); 
    InetAddress inetAddresses2 = InetAddress.getByName("www.baidu.com"); 
    System.out.println(inetAddresses2); 
    //获取本地IP 
    InetAddress inetAddresses3 = InetAddress.getByName("127.0.0.1"); 
    System.out.println(inetAddresses3); 
    InetAddress inetAddresses4 = InetAddress.getByName("localhost"); 
    System.out.println(inetAddresses4); 
    InetAddress inetAddresses5 = InetAddress.getLocalHost(); 
    System.out.println(inetAddresses5); 
    //getHostName 
    System.out.println(inetAddresses2.getHostName()); 
    //getHostAddress 
    System.out.println(inetAddresses2.getHostAddress()); 
    //Canonical : 规范的 S
    ystem.out.println(inetAddresses2.getCanonicalHostName()); 
    } catch (UnknownHostException e) { 
    e.printStackTrace(); 
    } 
  } 
}

/*
输出结果：
/192.168.8.123
www.baidu.com/182.61.200.6
/127.0.0.1
localhost/127.0.0.1
GMagic-Pro.local/127.0.0.1
www.baidu.com
182.61.200.6
182.61.200.6
*/

InetSocketAddress类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import java.net.InetSocketAddress; 
public class InetSocketAddressTest { 
  public static void main(String[] args) { 
    InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1",8080);
    InetSocketAddress socketAddress2 = new InetSocketAddress("localhost",9000); 		
    System.out.println(socketAddress.getHostName()); 
    System.out.println(socketAddress.getAddress()); 
    System.out.println(socketAddress.getPort()); 
    System.out.println(socketAddress2.getHostName()); 
    System.out.println(socketAddress2.getAddress()); //返回地址 
    System.out.println(socketAddress2.getPort()); //返回端口 
  } 
}

/*
返回结果：
localhost
localhost/127.0.0.1
8080
localhost
localhost/127.0.0.1
9000
*/

实例

Socket 客户端实例

如下的 GreetingClient 是一个客户端程序，该程序通过 socket 连接到服务器并发送一个请求，然后等待一个响应。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// 文件名 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("连接到主机：" + serverName + " ，端口号：" + port);
         Socket client = new Socket(serverName, port);
         System.out.println("远程主机地址：" + 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("服务器响应： " + in.readUTF());
         client.close();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

Socket 服务端实例

如下的GreetingServer 程序是一个服务器端应用程序，使用 Socket 来监听一个指定的端口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

// 文件名 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("等待远程连接，端口号为：" + serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            System.out.println("远程主机地址：" + server.getRemoteSocketAddress());
            DataInputStream in = new DataInputStream(server.getInputStream());
            System.out.println(in.readUTF());
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("谢谢连接我：" + 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.run();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

先启动服务端：

1
2
3

$ javac GreetingServer.java 
$ java GreetingServer 6066
等待远程连接，端口号为：6066...

在启动服务端：

1
2
3
4
5
6

$ javac GreetingClient.java 
$ java GreetingClient localhost 6066
连接到主机：localhost ，端口号：6066
远程主机地址：localhost/127.0.0.1:6066
服务器响应： 谢谢连接我：/127.0.0.1:6066
Goodbye!

网络通信协议

网络通信协议：

网络通信协议是一种网络通用语言，为连接不同操作系统和不同硬件体系结构的互联网络引提供通信支持，是一种网络通用语言。

通信协议分层的思想

在制定协议时，把复杂成份分解成一些简单的成份，再将他们复合起来。最常用的复合方式是层次方

式，即同层间可以通信，上一层调用下一层，而与再下一层不发生关系。各层互不影响，利于系统的开

发和扩展。

网络通信协议由三要素

• 语义，解释控制信息每个部分的意义。它规定了需要发出何种控制信息，以及完成的动作与做出什么样的响应。
• 语法，用户数据与控制信息的结构与格式，以及数据出现的顺序。
• 时序，对事件发生顺序的详细说明。

TCP/IP协议簇

传输层协议中有两个非常重要的协议：

• 用户传输协议 TCP （Transmission Control Protocol）
• 用户数据报协议UDP（User Datagram Protocol）

Tcp/IP 以其两个主要协议：

• 传输控制协议：TCP
• 网络互联协议：IP

实际上是一组协议，包括多个具有不同功能且互为关联的协议。

IP（Internet Protocol）协议是网络层的主要协议，支持网间互联的数据通信。

TCP/IP协议模型从更实用的角度出发，形成了高效的四层体系结构，即物理链路层，IP层，传输层和应用层。

UPD与TCP区别

UDP

特点

1. 面向无连接首先 UDP 是不需要和 TCP一样在发送数据前进行三次握手建立连接的，想发数据就可以开始发送了。并且也只是数据报文的搬运工，不会对数据报文进行任何拆分和拼接操作。

   具体来说就是：

   • 在发送端，应用层将数据传递给传输层的 UDP 协议，UDP 只会给数据增加一个 UDP 头标识下是 UDP 协议，然后就传递给网络层了
   • 在接收端，网络层将数据传递给传输层，UDP 只去除 IP 报文头就传递给应用层，不会任何拼接操作

   2. 有单播，多播，广播的功能

      UDP 不止支持一对一的传输方式，同样支持一对多，多对多，多对一的方式，也就是说 UDP 提供了单播，多播，广播的功能。

2. UDP是面向报文的

   发送方的UDP对应用程序交下来的报文，在添加首部后就向下交付IP层。UDP对应用层交下来的报文，既不合并，也不拆分，而是保留这些报文的边界。因此，应用程序必须选择合适大小的报文

3. 不可靠性

   首先不可靠性体现在无连接上，通信都不需要建立连接，想发就发，这样的情况肯定不可靠。并且收到什么数据就传递什么数据，并且也不会备份数据，发送数据也不会关心对方是否已经正确接收到数据了。

• 两个十六位的端口号，分别为源端口（可选字段）和目标端口
• 整个数据报文的长度
• 整个数据报文的检验和（IPv4 可选 字段），该字段用于发现头部信息和数据中的错误

• 沟通简单，不需要大量的数据结构，处理逻辑和包头字段
• 轻信他人。它不会建立连接，但是会监听这个地方，谁都可以传给它数据，它也可以传给任何人数据，甚至可以同时传给多个人数据。
• 愣头青，做事不懂变通。不会根据网络的情况进行拥塞控制，无论是否丢包，它该怎么发还是怎么发

主要应用场景

• 需要资源少，网络情况稳定的内网，或者对于丢包不敏感的应用，比如 DHCP 就是基于 UDP 协议的。
• 不需要一对一沟通，建立连接，而是可以广播的应用。因为它不面向连接，所以可以做到一对多，承担广播或者多播的协议。
• 需要处理速度快，可以容忍丢包，但是即使网络拥塞，也毫不退缩，一往无前的时候

TCP

特点

1. 面向连接

   面向连接，是指发送数据之前必须在两端建立连接。建立连接的方法是“三次握手”，这样能建立可靠的连接。建立连接，是为数据的可靠传输打下了基础。

2. 仅支持单播传输

   每条TCP传输连接只能有两个端点，只能进行点对点的数据传输，不支持多播和广播传输方式。

3. 面向字节流

   TCP不像UDP一样那样一个个报文独立地传输，而是在不保留报文边界的情况下以字节流方式进行传输。

4. 可靠传输

   对于可靠传输，判断丢包，误码靠的是TCP的段编号以及确认号。TCP为了保证报文传输的可靠，就给每个包一个序号，同时序号也保证了传送到接收端实体的包的按序接收。然后接收端实体对已成功收到的字节发回一个相应的确认(ACK)；如果发送端实体在合理的往返时延(RTT)内未收到确认，那么对应的数据（假设丢失了）将会被重传。

5. 提供拥塞控制

   当网络出现拥塞的时候，TCP能够减小向网络注入数据的速率和数量，缓解拥塞

6. TCP提供全双工通信

   TCP允许通信双方的应用程序在任何时候都能发送数据，因为TCP连接的两端都设有缓存，用来临时存放双向通信的数据。当然，TCP可以立即发送一个数据段，也可以缓存一段时间以便一次发送更多的数据段（最大的数据段大小取决于MSS）

• 首先，源端口和目标端口是不可少的；
• 接下来是包的序号。主要是为了解决乱序问题；
• 确认序号。发出去的包应该有确认，这样能知道对方是否收到，如果没收到就应该重新发送，这个解决的是不丢包的问题；
• 状态位。SYN 是发起一个链接，ACK 是回复，RST 是重新连接，FIN 是结束连接。因为 TCP 是面向连接的，因此需要双方维护连接的状态，这些状态位的包会引起双方的状态变更；
• 窗口大小，TCP 要做流量控制，需要通信双方各声明一个窗口，标识自己当前的处理能力。

TCP 的三次握手

TCP 四次挥手

总结