java基础知识【第19期】-- 网络编程

导读:

本篇是JAVA基础系列的第20篇，今天我们梳理java网络编程的相关知识点。计算机网络是通过传输介质、通信设施和网络通信协议，把分散在不同地点的计算机设备互连起来的，实现资源共享和数据传输的系统。网络编程就是编写程序使互联网的两个（或多个）设备（如计算机）之间进行数据传输。

1.网络体系结构

计算机网络分为网络协议和网络体系结构

通过网络发送数据是一项复杂的操作，必须仔细地协调网络的物理特性以及所发送数据的逻辑特征。通过网络将数据从一台主机发送到另外的主机，这个过程是通过计算机网络通信来完成。

网络通信的不同方面被分解为多个层，层与层之间用接口连接。通信的双方具有相同的层次，层次实现的功能由协议数据单元（PDU）来描述。不同系统中的同一层构成对等层，对等层之间通过对等层协议进行通信，理解批次定义好的规则和约定。每一层表示为物理硬件（即线缆和电流）与所传输信息之间的不同抽象层次。在理论上，每一层只与紧挨其上和其下的层对话。将网络分层，这样就可以修改甚至替换某一层的软件，只要层与层之间的接口保持不变，就不会影响到其他层。

计算机网络体系结构是计算机网络层次和协议的集合，网络体系结构对计算机网络实现的功能，以及网络协议、层次、接口和服务进行了描述，但并不涉及具体的实现。接口是同一节点内相邻层之间交换信息的连接处，也叫服务访问点（SAP）。

计算机网络层次模型

世界上第一个网络体系结构由IBM公司提出（1974年，SNA），以后其他公司也相继提出自己的网络体系结构。为了促进计算机网络的发展，国际标准化组织ISO在现有网络的基础上，提出了不基于具体机型、操作系统或公司的网络体系结构，称为开放系统互连参考模型，即OSI/RM（Open System Interconnection Reference Model）。

ISO制定的OSI参考模型过于庞大、复杂招致了许多批评。与此相对，美国国防部提出了TCP/IP协议栈参考模型，简化了OSI参考模型，由于TCP/IP协议栈的简单，获得了广泛的应用，并成为后续因特网使用的参考模型。

2.OSI参考模型

OSI模型把网络通信的工作分为7层，分别是物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。

• 物理层

  物理层处于OSI的最底层，是整个开放系统的基础。物理层涉及通信信道上传输的原始比特流（bits），它的功能主要是为数据端设备提供传送数据的通路以及传输数据。

• 数据链路层

  数据链路层的主要任务是实现计算机网络中相邻节点之间的可靠传输，把原始的、有差错的物理传输线加上数据链路协议以后，构成逻辑上可靠的数据链路。需要完成的功能有链路管理、成帧、差错控制以及流量控制等。其中成帧是对物理层的原始比特流进行界定，数据链路层也能够对帧的丢失进行处理。

• 网络层

  网络层涉及源主机节点到目的主机节点之间可靠的网络传输，它需要完成的功能主要包括路由选择、网络寻址、流量控制、拥塞控制、网络互连等。

• 传输层

  传输层起着承上启下的作用，涉及源端节点到目的端节点之间可靠的信息传输。传输层需要解决跨越网络连接的建立和释放，对底层不可靠的网络，建立连接时需要三次握手，释放连接时需要四次挥手。　　

• 会话层和表示层

  会话层的主要功能是负责应用程序之间建立、维持和中断会话，同时也提供对设备和结点之间的会话控制，协调系统和服务之间的交流，并通过提供单工、半双工和全双工3种不同的通信方式，使系统和服务之间有序地进行通信。

  表示层关心所传输数据信息的格式定义，其主要功能是把应用层提供的信息变换为能够共同理解的形式，提供字符代码、数据格式、控制信息格式、加密等的统一表示。

• 应用层

  应用层为OSI的最高层，是直接为应用进程提供服务的。其作用是在实现多个系统应用进程相互通信的同时，完成一系列业务处理所需的服务。

3.TCP/IP参考模型

TCP/IP，即Transmission Control Protocol/Internet Protocol的简写，中译名为传输控制协议/因特网互联协议，是Internet最基本的协议，Internet国际互联网络的基础。

TCP/IP协议是一个开放的网络协议簇，它的名字主要取自最重要的网络层IP协议和传输层TCP协议。TCP/IP协议定义了电子设备如何连入因特网，以及数据如何在它们之间传输的标准。TCP/IP参考模型采用4层的层级结构，每一层都呼叫它的下一层所提供的协议来完成自己的需求，这4个层次分别是：网络接口层、网络层（IP层）、传输层（TCP层）、应用层。

• 网络接口层

  TCP/IP协议对网络接口层没有给出具体的描述，网络接口层对应着OSI参考模型的物理层和数据链路层

• 网络层（IP层）

  网络层是整个TCP/IP协议栈的核心。它的功能是把分组发往目标网络或主机。同时，为了尽快地发送分组，可能需要沿不同的路径同时进行分组传递。因此，分组到达的顺序和发送的顺序可能不同，这就需要上层必须对分组进行排序。网络层除了需要完成路由的功能外，也可以完成将不同类型的网络（异构网）互连的任务。除此之外，互联网层还需要完成拥塞控制的功能。

• 传输层（TCP层）

  TCP层负责在应用进程之间建立端到端的连接和可靠通信，它只存在与端节点中。TCP层涉及两个协议，TCP和UDP。其中，TCP协议提供面向连接的服务，提供按字节流的有序、可靠传输，可以实现连接管理、差错控制、流量控制、拥塞控制等。UDP协议提供无连接的服务，用于不需要或无法实现面向连接的网络应用中。

• 应用层

  应用层为Internet中的各种网络应用提供服务。

4.网络通信协议

网络通信协议：通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。

OSI参考模型和TCP/IP模型在不同的层次中有许多不同的网络协议，如图所示：

5.IP地址

IP地址：指互联网协议地址（Internet Protocol Address），俗称IP。IP地址用来给一个网络中的计算机设备做唯一的编号。假如我们把“个人电脑”比作“一台电话”的话，那么“IP地址”就相当于“电话号码”。

A、B、C三类地址所包含的主机数量：

• A类主要分配给大量主机而局域网络数量较少的大型网络

• B类主要分配给国际性大公司和政府机构

• C类主要分配给小公司校园网研究机构等

• D类主要分配给特殊用途，例如广播地址

• E类暂时保留

6.IP地址分类

• IPv4：是一个32位的二进制数，通常被分为4个字节，表示成a.b.c.d 的形式，例如192.168.65.100 。其中a、b、c、d都是0~255之间的十进制整数，那么最多可以表示42亿个。

• IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。

  为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成ABCD:EF01:2345:6789:ABCD:EF01:2345:6789，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。

常用命令

• 查看本机IP地址，在控制台输入：

 ipconfig

• 检查网络是否连通，在控制台输入：

 ping 空格 IP地址
 ping 220.181.57.216

特殊的IP地址

• 本机IP地址：127.0.0.1、localhost 。

7.端口号

网络的通信，本质上是两个进程（应用程序）的通信。每台计算机都有很多的进程，那么在网络通信时，如何区分这些进程呢？

如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的进程（应用程序）了。

• 端口号：用两个字节表示的整数，它的取值范围是0~65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

利用协议+IP地址+端口号 三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互。

8.InetAddress

IP地址是IP使用的32位（IPv4）或者128位（IPv6）位无符号数字，它是传输层协议TCP，UDP的基础。InetAddress是Java对IP地址的封装，几乎所有的Java网络相关的类都和它有关系

Java提供了InetAddress类来代表IP地址，InetAddress下还有2个子类：Inet4Address、Inet6Address,它们分别代表Internet Protocol version 4（IPv4）地址和Internet Protocol version 6（IPv6）地址，不过这两个子类不常用。此外，InetAddress类没有提供构造器，而是提供了如下两个静态方法来获取InetAddress实例：

• getByName（String host）：根据主机获取对应的InetAddress对象。

• getByAddress（byte[] addr）：根据原始IP地址来获取对应的InetAddress对象。

示例代码:

 public static void main(String[] args) {
     String host = null;//主机名
     try {
         //获得当前本地主机的IP地址
         InetAddress ia = InetAddress.getLocalHost();
         System.out.println("当前本地主机：" + ia);
         //根据机器名获得相应的主机地址（如果网络上有该机器名的话）
         host = "localhost";
         ia = InetAddress.getByName(host);
         System.out.println("Host Address = " + ia.getHostAddress());
         System.out.println("Host Name = " + ia.getHostName());
         System.out.println("Is Loopback Address = "
                            + ia.isLoopbackAddress());//是否本地回环地址
         //根据域名，通过DNS域名解析，获得相应服务的主机地址
         host = "www.163.com";
         ia = InetAddress.getByName(host);
         System.out.println("网易服务器主机：" + ia);
    } catch (UnknownHostException ex) {
         System.out.println("error:Not find!!!");
    }
 }
 }

9.协议分类

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

三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。

• TCP：传输控制协议 (Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。

  在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”。

  • 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。

  • 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。

  • 第三次握手，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所示。

    

    完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。

• UDP：用户数据报协议(User Datagram Protocol)。UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

  由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。

  但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。

10.TCP通信

TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端（Server）。

两端通信时步骤：

1. 服务端程序，需要事先启动，等待客户端的连接。

2. 客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。

在Java中，提供了两个类用于实现TCP通信程序：

1. 客户端：java.net.Socket 类表示。创建Socket对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。

2. 服务端：java.net.ServerSocket 类表示。创建ServerSocket对象，相当于开启一个服务，并等待客户端的连接。

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

• 服务器实例化一个 ServerSocket 对象，表示通过服务器上的端口通信。

• 服务器调用 ServerSocket 类的 accept() 方法，该方法将一直等待，直到客户端连接到服务器上给定的端口。

• 服务器正在等待时，一个客户端实例化一个 Socket 对象，指定服务器名称和端口号来请求连接。

• Socket 类的构造函数试图将客户端连接到指定的服务器和端口号。如果通信被建立，则在客户端创建一个 Socket 对象能够与服务器进行通信。

• 在服务器端，accept() 方法返回服务器上一个新的 socket 引用，该 socket 连接到客户端的 socket。

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

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

ServerSocket 类的方法

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

ServerSocket 类有四个构造方法：

序号	方法描述
1	public ServerSocket(int port) throws IOException 创建绑定到特定端口的服务器套接字。
2	public ServerSocket(int port, int backlog) throws IOException 利用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口号。
3	public ServerSocket(int port, int backlog, InetAddress address) throws IOException 使用指定的端口、侦听 backlog 和要绑定到的本地 IP 地址创建服务器。
4	public ServerSocket() throws IOException 创建非绑定服务器套接字。

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

ServerSocket 类的常用方法：

序号	方法描述
1	public int getLocalPort()  返回此套接字在其上侦听的端口。
2	public Socket accept() throws IOException 侦听并接受到此套接字的连接。
3	public void setSoTimeout(int timeout)  通过指定超时值启用/禁用 SO_TIMEOUT，以毫秒为单位。
4	public void bind(SocketAddress host, int backlog) 将 ServerSocket 绑定到特定地址（IP 地址和端口号）。

Socket 类的方法

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

Socket 类有五个构造方法.

序号	方法描述
1	public Socket(String host, int port) throws UnknownHostException, IOException. 创建一个流套接字并将其连接到指定主机上的指定端口号。
2	public Socket(InetAddress host, int port) throws IOException 创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
3	public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException. 创建一个套接字并将其连接到指定远程主机上的指定远程端口。
4	public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException. 创建一个套接字并将其连接到指定远程地址上的指定远程端口。
5	public Socket() 通过系统默认类型的 SocketImpl 创建未连接套接字

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

常用方法。

序号	方法描述
1	public void connect(SocketAddress host, int timeout) throws IOException 将此套接字连接到服务器，并指定一个超时值。
2	public InetAddress getInetAddress()  返回套接字连接的地址。
3	public int getPort() 返回此套接字连接到的远程端口。
4	public int getLocalPort() 返回此套接字绑定到的本地端口。
5	public SocketAddress getRemoteSocketAddress() 返回此套接字连接的端点的地址，如果未连接则返回 null。
6	public InputStream getInputStream() throws IOException 返回此套接字的输入流。
7	public OutputStream getOutputStream() throws IOException 返回此套接字的输出流。
8	public void close() throws IOException 关闭此套接字。

客户端向服务器发送数据示例代码：

 //服务端实现：
 public class ServerTCP {
     public static void main(String[] args) throws IOException {
         System.out.println("服务端启动 , 等待连接 .... ");
         // 1.创建 ServerSocket对象，绑定端口，开始等待连接
         ServerSocket ss = new ServerSocket(6666);
         // 2.接收连接 accept 方法, 返回 socket 对象.
         Socket server = ss.accept();
         // 3.通过socket 获取输入流
         InputStream is = server.getInputStream();
         // 4.一次性读取数据
         // 4.1 创建字节数组
         byte[] b = new byte[1024];
         // 4.2 据读取到字节数组中.
         int len = is.read(b)；
             // 4.3 解析数组,打印字符串信息
             String msg = new String(b, 0, len);
         System.out.println(msg);
         //5.关闭资源.
         is.close();
         server.close();
    }
 }
 //客户端实现
 public class ClientTCP {
     public static void main(String[] args) throws Exception {
         System.out.println("客户端 发送数据");
         // 1.创建 Socket ( ip , port ) , 确定连接到哪里.
         Socket client = new Socket("localhost", 6666);
         // 2.获取流对象 . 输出流
         OutputStream os = client.getOutputStream();
         // 3.写出数据.
         os.write("你好么? tcp ,我来了".getBytes());
         // 4. 关闭资源 .
         os.close();
         client.close();
    }
 }

服务器向客户端回写数据示例代码：

 //服务端实现：
 public class ServerTCP {
     public static void main(String[] args) throws IOException {
         System.out.println("服务端启动 , 等待连接 .... ");
         // 1.创建 ServerSocket对象，绑定端口，开始等待连接
         ServerSocket ss = new ServerSocket(6666);
         // 2.接收连接 accept 方法, 返回 socket 对象.
         Socket server = ss.accept();
         // 3.通过socket 获取输入流
         InputStream is = server.getInputStream();
         // 4.一次性读取数据
         // 4.1 创建字节数组
         byte[] b = new byte[1024];
         // 4.2 据读取到字节数组中.
         int len = is.read(b)；
             // 4.3 解析数组,打印字符串信息
             String msg = new String(b, 0, len);
         System.out.println(msg);
         // =================回写数据=======================
         // 5. 通过 socket 获取输出流
         OutputStream out = server.getOutputStream();
         // 6. 回写数据
         out.write("我很好,谢谢你".getBytes());
         // 7.关闭资源.
         out.close();
         is.close();
         server.close();
    }
 }
 //客户端实现:
 public class ClientTCP {
     public static void main(String[] args) throws Exception {
         System.out.println("客户端 发送数据");
         // 1.创建 Socket ( ip , port ) , 确定连接到哪里.
         Socket client = new Socket("localhost", 6666);
         // 2.通过Scoket,获取输出流对象
         OutputStream os = client.getOutputStream();
         // 3.写出数据.
         os.write("你好么? tcp ,我来了".getBytes());
         // ==============解析回写=========================
         // 4. 通过Scoket,获取 输入流对象
         InputStream in = client.getInputStream();
         // 5. 读取数据数据
         byte[] b = new byte[100];
         int len = in.read(b);
         System.out.println(new String(b, 0, len));
         // 6. 关闭资源 .
         in.close();
         os.close();
         client.close();
    }
 }

11.UDP通信

UDP 是 User Datagram Protocol 的简称， 中文名是用户数据报协议，是一个简单的面向数据报的传输层协议，在网络中用于处理数据包，是一种无连接的协议。UDP不提供可靠性的传输，它只是把应用程序传给 IP 层的数据报发送出去，但是并不能保证它们能到达目的地。由于 UDP 在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快。

【UDP的特点】：

• 每个分组都携带完整的目的地址；

• 发送数据之前不需要建立链接；

• 不对数据包的顺序进行检查，不能保证分组的先后顺序；

• 不进行分组出错的恢复和重传；

• 不保证数据传输的可靠性。

在网络质量令人十分不满意的环境下，UDP 协议数据包丢失会比较严重。但是由于 UDP 的特性：它不属于连接型协议，因而具有资源消耗小，处理速度快的优点，所以通常音频、视频和普通数据在传送时使用 UDP 较多，因为它们即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。比如我们聊天用的 ICQ 和 QQ 就是使用的 UDP。

在Java中，基于UDP协议实现网络通信的类有三个：

• 用于表达通信数据的数据报类DatagramPacket

• 用于进行端到端通信的类DatagramSocket

• 用于广播通信的类MulticastSocket

点到点通信：类DatagramSocket

构造方法

• public DatagramSocket()

• public DatagramSocket(int port)          //在指定的端口通信

• public DatagramSocket(int port, InetAddress laddr)   //在指定的地点运行

• 这三个方法都将抛出例外SocketException，程序中需要捕获处理。

最主要的方法——发送与接收数据报

• public void receive(DatagramPacket p)

• public void send(DatagramPacket p)

• 这两个方法都将抛出例外IOException，程序中需要捕获处理。

其他方法

• public void connect(InetAddress address, int port)  //与指定的机器通信，有连接

• public void disconnect()   //关闭与指定机器的连接

• public void close()  //关闭Socket

数据报：类DatagramPacket

构造方法

• public DatagramPacket(byte[] buf, int length)

• public DatagramPacket(byte[] buf, int offset, int length)

• //这两个方法用于描述接收数据报

• public DatagramPacket(byte[] buf, int length, InetAddress address, int port)

• public DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)

• //这两个方法用于发送数据报

获取数据——获取接收数据报中的信息

• public InetAddress getAddress()

• public byte[] getData()

• public int getLength()

• public int getOffset()

• public int getPort()

设置数据——设置发送数据报中的信息

• setAddress(InetAddress iaddr)

• setPort(int iport)

• setData(byte[] buf)

• setData(byte[] buf, int offset, int length)

• setLength(int length)

点对点通信步骤

点到点通信----发送端

1. 创建数据报socket对象

   DatagramSocket  s = new DatagramSocket();

   发送端报文socket对象不需要指定端口号,由系统分配

2. 提供数据，封装打包

   byte[] bs = "我出牌：王炸! ".getBytes();

   DatagramPacket dp =new  DatagramPacket(bs,bs.length, InetAddress.getByName("127.0.0.1"), 8899);

   定义数据报对象,依次传入：待发送的数据（byte数组类型）、数组长度、inetaddress封装的接收方ip，接收方的端口

3. 使用send发送数据库s.send(dp);

4. 关闭网络连接资源 s.close();

点到点通信----接收端

1. 建立udp socket，设置接收端口

   DatagramSocket ds = new DatagramSocket(8899);

2. 定义接收数据的报文对象

   byte [] bbuf = new byte [1024];//要足够大

   DatagramPacket dp = new DatagramPacket(bbuf,bbuf.length);

3. 使用receive阻塞式接收ds.receive(dp);

4. 关闭资源ds.close();

实例代码:

 //发送端：
 
 public class SendData {
     private DatagramSocket ds;// UDP的连接对象
 
     private DatagramPacket dp;// UDP的发送接收数据对象
 
     private InetAddress addr;// 目标地址
 
     public static final int PORT = 1024;// 目标机器端口
 
     // 构造方法
     public SendData(String target) throws Exception {
         // 发送的目标地址
         addr = InetAddress.getByName(target);
         /*
  * 创建DatagramSocket对象，注意该连接不带目标地址 目标地址信息在DatagramPacket对象中。
  */
         ds = new DatagramSocket();
    }
 
     // 发送数据
     public void go() throws Exception {
         byte[] buff;//存放数据的字节数组
         for(;;){
             Thread.sleep(1000);//每一秒发送一次数据
             System.out.println("Sending...");
             String now = (new Date()).toString();
             buff = now.getBytes();//把日期时间字符串放入字节数组中
             //建立要发送的数据报，包含要发送的数据，数据的大小，目标地址、端口
             dp = new DatagramPacket(buff,buff.length,addr,PORT);
             ds.send(dp);//使用DatagramSocket对象发送数据
        }
    }
 
     public static void main(String[] args) throws Exception{
         SendData sd = new SendData("localhost");
         sd.go();//发送数据
    }
 }
 //接收端:
 
 public class ReciveData {
     private DatagramSocket ds;// UDP的连接对象
 
     private DatagramPacket dp;// UDP的发送接收数据对象
 
     // 接收数据
     public void go() throws Exception {
         byte[] buff = new byte[100];// 存放数据的字节数组
         String data;// 接收的数据
         // 创建DatagramSocket对象，从指定的端口号接收数据。
         ds = new DatagramSocket(SendData.PORT);
         // 建立要接收的数据报，用于存放要接收的数据，数据的大小
         dp = new DatagramPacket(buff, buff.length);
         for (;;) {
             ds.receive(dp);//使用DatagramSocket对象接收数据
             data = new String(dp.getData());//获得数据转换成字符串
             System.out.println("从" + dp.getAddress() + "接收到的日期时间字符串：" + data);
        }
    }
 
     public static void main(String[] args) throws Exception {
         ReciveData rd = new ReciveData();
         rd.go();//接收数据
    }
 
 }