黑马程序员—网络编程_while (-1 != (length = is.read(buffer, 0, buffer.l-CSDN博客

本文链接：https://blog.csdn.net/mgStefanie/article/details/8821270

------- android培训、java培训、期待与您交流！ ----------

Java 网络编程

网络编程的目的：直接或间接地通过网络协议与其他计算机进行通讯。

　　网络编程中有两个主要的问题：

　　1.如何准确地定位网络上一台或多台主机。

　　2.找到主机后如何可靠高效地进行数据传输。

　　目前较为流行的网络编程模型是客户端/服务器（C/S）结构。

　　即通信双方一方作为服务器等待客户提出请求并予以相应。客户则在需要服务时向服务器提出申请。

服务器始终运行，监听网络端口，一旦有客户请求，就会启动一个服务线程来响应该客户，同时自己继续监听服务窗口，使后来的客户也能及时得到服务。

IP地址

　　IP网络中每台主机都必须有一个唯一的IP地址，IP地址是一个逻辑地址。

　　英特网上的IP地址具有全球唯一性。

　　32位，四个字节，常用点分十进制的格式表示。

　　例如：192.168.0.200

协议

　　为进行网络中的数据交换（通信）而建立的规则、标准或约定。（=语义+语法+规则）。

　　不同层具有各自不同的协议。

ISO/OSI七层参考模型

　　网络体系结构解决异质性问题采用的是分层的方法——把复杂的网络互联问题划分为若干个较小的、单一的问题，在不同层上予以解决。

　　OSI(Open System Interconnection)参考模型将网络的不同功能划分为7层：

　　应用层：处理网络应用

　　表示层：数据表示

　　会话层：主机间通信

　　传输层：端到端的连接

　　网络层：寻址和最短路径

　　数据链路层：介质访问（接入）

　　物理层：二进制传输

通信实体的对等层之间不允许直接通信，各层之间是严格的单向依赖，上层（Service user）使用下层提供的服务，下层（Service provider）向上层提供服务。

　　对等层通信的实质：对等层实体之间虚拟通信，下层向上层提供服务，实际通信在最底层完成。

OSI各层所使用的协议：

　　应用层：Telnet、FTP、HTTP、DNS、SMTP、POP3

　　传输层：TCP、UDP

　　TCP：面向连接的可靠的传输协议。

　　UDP：是无连接的，不可靠的传输协议。

　　网络层：IP、ICMP、IGMP

端口

　　在互联网上传输的数据都包含有用来识别目的地的IP地址和端口号。

　　IP地址用来标识网络上的计算机，而端口号用来指明该计算机上的应用程序。

　　端口是一种抽象的软件结构（包括一些数据结构和I/O缓冲区）。

　　应用程序通过系统调用与某端口建立连接（binding）后，传输层传给该端口的数据都被相应的进程所接收，相应进程发给传输层的数据都通过该端口输出。

　　端口用一个整数型标识符来表示，即端口号。

　　端口号跟协议相关，TCP/IP传输层的两个协议TCP和UDP是完全独立的两个软件模块，因此各自的端口号也相互独立，端口通常称为协议端口（protocol port），简称端口。

端口使用一个16位的数字来表示，它的范围是0~65535，1024以下的端口号保留给预定义的服务。例如，http使用80端口。

数据封装

　　一台计算机要发送数据到另一台计算机，数据首先必须打包，打包的过程称为封装。

　　封装就是在数据前面加上特定的协议头部。

　　OSI参考模型中，对等层协议之间的交换的信息单元称为协议数据单元（PDU, Protocol Data Unit）。

　　OSI参考模型中的每一层都要依靠下一层提供的服务。

　　为了提供服务，下层把上层的PDU作为本层的数据封装，然后加入本层的头部（和尾部）。头部中含有完成数据传输所需的控制信息。

　　这样，数据自上而下递交的过程实际上就是不断封装的过程。到达目的地后自下而上递交的过程就是不断拆封的过程。由此可知，在物理线路上传输的数据，其外面实际上被包封了多层“信封”。

两类传输协议：TCP,UDP

TCP

　　TCP是Transfer Control Protocol（传输控制协议）的简称，是一种面向连接的保证可靠传输的协议。

　　在TCP/IP协议中，IP层主要负责网络主机的定位，数据传输的路由，由IP地址可以唯一确定Internet上的一台主机。而TCP层则提供面向应用的可靠的或非可靠的数据传输机制，这是网络编程的主要对象，一般不需要关心IP层是如何处理数据的。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建立连接，以便在TCP协议的基础上进行通信。当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送或接收操作。TCP是一个基于连接的协议，它能够提供两台计算机之间的可靠的数据流。HTTP、FTP、Telnet等应用都需要这种可靠的通信通道。

UDP

　　UDP是User Datagram Protocol的简称，是一种无连接的协议。

　　UDP是从一台计算机向另一台计算机发送称为数据报的独立数据包的协议，该协议并不保证数据报是否能正确地到达目的地，它是一个非面向连接的协议。每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达时间以及内容的正确性都是不能保证的。

TCP和UDP的比较

　　使用UDP时，每个数据报中都给出了完整的地址信息，因此无需建立发送方和接收方的连接。对于TCP协议，由于它是一个面向连接的协议，在socket之间进行数据传输之前必然要建立连接，所以在TCP中多了一个连接建立的时间。使用UDP传输数据时是有大小限制的，每个被传输的数据报必须限定在64KB之内。TCP没有这方面的限制，一旦连接建立起来，双方的socket就可以按统一的格式传输大量的数据。

　　UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方。

　　TCP是一个可靠的协议，它确保接收方完全正确地获取发送方所发送的全部数据。

　　可靠的传输是要付出代价的，对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽。因此TCP传输的效率不如UDP高。

　　TCP在网路通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输。

相比之下UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序。

　　此处推荐书籍《TCP/IP详解》，分三卷。

TCP/IP模型

　　TCP/IP模型包括四个层次：

　　应用层

　　传输层

　　网络层

　　网络接口

　　TCP/IP与OSI参考模型的对应关系：

JDK中的网络类

　　通过java.net包中的类，java程序能够使用TCP或UDP协议在互联网上进行通讯。

　　Java通过扩展已有的流式输入/输出接口和增加在网络上建立输入/输出对象特性这两个方法支持TCP/IP。

　　Java支持TCP和UDP协议族。

　　TCP用于网络的可靠的流式输入/输出。

　　UDP支持更简单的、快速的、点对点的数据报模式。

创建和使用URL访问网络上的资源

URL(Uniform Resource Locator)是统一资源定位符的简称，它表示Internet上某一资源的地址。

通过URL我们可以访问Internet上的各种网络资源，比如最常见的WWW, FTP站点。浏览器通过解析给定的URL可以在网络上查找相应的文件或其他资源。在目前使用最为广泛的TCP/IP中对于URL中主机名的解析也是协议的一个标准，即所谓的域名解析服务。使用URL进行网络编程，不需要对协议本身有太多的了解，功能也比较弱，相对而言是比较简单的。

URL组成

　　一个URL包括两个主要部分：

　　协议标识符：HTTP, FTP, File等。

　　资源名字：主机名，文件名，端口号，引用。

创建URL

　　在Java程序中，可以创建表示URL地址的URL对象。

　　URL对象表示一个绝对的URL地址，但URL对象可用绝对URL、相对URL和部分URL构建。

创建URL的代码如下，如果创建失败会抛出异常：

try

     {

        URL myURL = new URL("http://www.google.com.tw/");

     }

     catch (MalformedURLException e)

     {

        //exception handler code here

     }

获得URL对象的各个属性

　　URL类中有各种用于获取属性的方法：

　　getProtocol

　　getHost

　　getPort

　　getFile

　　getRef

　　例子程序如下：获取URL对象属性

package com.example.network;

import java.net.MalformedURLException;
import java.net.URL;
public class URLTest01
{
   public static void main(String[] args)
   { 
      try
       {
           URL myURL = new URL("http://java.sun.com:80/docs/books/tutorial/index.html#DOWN");         
           String protocal = myURL.getProtocol();
           String host = myURL.getHost();
           String file = myURL.getFile();
           int port = myURL.getPort();
           String ref = myURL.getRef();
           System.out.println(protocal + ", " + host + ", " +file + "," + port + ", " +ref);
       }catch (MalformedURLException e){
           // exception handler code here
       }
    }
}

创建和使用URL访问网上资源

　　为获得URL的实际比特或内容信息，用它的openConnection()方法从它创建一个URLConnection对象，与调用URL对象相关，它返回一个URLConnection对象。它可能引发IOException异常.

　　URLConnection是访问远程资源属性的一般用途的类。如果你建立了与远程服务器之间的连接，你可以在传输它到本地之前用URLConnection来检查远程对象的属性。这些属性由HTTP协议规范定义并且仅对用HTTP协议的URL对象有意义。

　　URL和URLConnection类对于希望建立与HTTP服务器的连接来获取信息的简单程序来说是非常好的。

　　例子程序UrlConnection01，建立连接，从连接对象获取输入流，然后读入，再写出到文件中去。

package com.example.network;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
public class UrlConnection01
{
    public static void main(String[] args) throws Exception
    {
        URL url = new URL("http://www.baidu.com/");
        // 打开连接
        URLConnection conn = url.openConnection();
        // 得到输入流
        InputStream is = conn.getInputStream();
        // 关于IO流的用法和写法一定要熟悉
        OutputStream os = new FileOutputStream("d:\\baidu.txt");
        byte[] buffer = new byte[2048];
        int length = 0;
        while (-1 != (length = is.read(buffer, 0, buffer.length)))
        {
            os.write(buffer, 0, length);
        }
        is.close();
        os.close();
    }
}

也可以直接从URL对象获取输入流，见例子程序UrlConnection02。

package com.example.network;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
public class UrlConnection02
{
    public static void main(String[] args) throws Exception
    {
        URL url = new URL("http://www.baidu.com/");
        // // 打开连接
        // URLConnection conn = url.openConnection();
        //
        // // 得到输入流
        // InputStream is = conn.getInputStream();
        // 另一种得到输入流的方法:通过url直接获取
        InputStream is = url.openStream();
        // 关于IO流的用法和写法一定要熟悉
        OutputStream os = new FileOutputStream("d:\\baidu.txt");
        byte[] buffer = new byte[2048];
        int length = 0;
        while (-1 != (length = is.read(buffer, 0, buffer.length)))
        {
            os.write(buffer, 0, length);
        }
        is.close();
        os.close();
    }
}

查看源代码可以看到内部实现机制是一样的：

public final InputStream openStream() throws java.io.IOException 
　　{
        return openConnection().getInputStream();
    }

程序代码UrlConnection03用字符流的方式读取网站内容显示在控制台上。　

package com.example.network;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
public class UrlConnection03
{
    public static void main(String[] args) throws Exception
    {
        URL url = new URL("http://www.google.com.tw/");
        BufferedReader br = new BufferedReader(new InputStreamReader(
                url.openStream()));
        String line = null;
        while (null != (line = br.readLine()))
        {
            System.out.println(line);
        }
        br.close();
    }
}

InetAddress类
　　InetAddress类用来封装我们前面讨论的数字式的IP地址和该地址的域名。你通过一个IP主机名与这个类发生作用，IP主机名比它的IP地址用起来更简便更容易理解。InetAddress类内部隐藏了地址数字。
InetAddress类中的工厂方法
　　InetAddress类没有明显的构造函数。为生成一个InetAddress对象，必须运用一个可用的工厂方法。工厂方法（factory method）仅是一个类中静态方法返回一个该类实例的约定。对于InetAddress，三个方法:getLocalHost()、getByName()以及getAllByName()可以用来创建InetAddress的实例。getLocalHost()仅返回象征本地主机的InetAddress对象。本机地址还为localhost,127.0.0.1，这三个地址都是一回事。getByName()方法返回一个传给它的主机名的InetAddress。如果这些方法不能解析主机名，它们引发一个UnknownHostException异常。在Internet上，用一个名称来代表多个机器是常有的事。getAllByName()工厂方法返回代表由一个特殊名称分解的所有地址的InetAddresses类数组。在不能把名称分解成至少一个地址时，它将引发一个UnknownHostException异常。

实例程序：

package com.example.network;
import java.net.InetAddress;
public class InetAddressTest01
{
    public static void main(String[] args) throws Exception
    {
        InetAddress address = InetAddress.getLocalHost();
        System.out.println(address);
        // 输出：机器名/IP地址
        // 如username-PC/10.4.16.131
        // 通过域名得到IP地址
        address = InetAddress.getByName("www.sohu.com");
        System.out.println(address);
        // 输出：域名/IP地址
    }
}

使用TCP/IP的套接字（Socket）进行通信

套接字Socket的引入

　　为了能够方便地开发网络应用软件，由美国伯克利大学在Unix上推出了一种应用程序访问通信协议的操作系统用调用socket（套接字）。

　　socket的出现，使程序员可以很方便地访问TCP/IP，从而开发各种网络应用的程序。

　　随着Unix的应用推广，套接字在编写网络软件中得到了极大的普及。后来，套接字又被引进了Windows等操作系统中。Java语言也引入了套接字编程模型。

什么是Socket？

Socket是连接运行在网络上的两个程序间的双向通讯的端点。使用Socket进行网络通信的过程服务器程序将一个套接字绑定到一个特定的端口，并通过此套接字等待和监听客户的连接请求。客户程序根据服务器程序所在的主机名和端口号发出连接请求。

如果一切正常，服务器接受连接请求。并获得一个新的绑定到不同端口地址的套接字。（不可能有两个程序同时占用一个端口）。客户和服务器通过读写套接字进行通讯。

使用ServerSocket和Socket实现服务器端和客户端的Socket通信。

　　其中：

　　左边ServerSocket类的构造方法可以传入一个端口值来构建对象。　accept()方法监听向这个socket的连接并接收连接。它将会阻塞直到连接被建立好。连接建立好后它会返回一个Socket对象。连接建立好后，服务器端和客户端的输入流和输出流就互为彼此，即一端的输出流是另一端的输入流。

总结：使用ServerSocket和Socket实现服务器端和客户端的Socket通信

　　(1)建立Socket连接

　　(2)获得输入/输出流

　　(3)读/写数据

　　(4)关闭输入/输出流

　　(5)关闭Socket

通信程序测试

　　建立服务器端和客户端如下：

//TcpServer

package com.example.network;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer
{
    public static void main(String[] args) throws Exception
    {
        // 创建服务器端的socket对象
        ServerSocket ss = new ServerSocket(5000);
        // 监听连接
        Socket socket = ss.accept();
        // 直到连接建立好之后代码才会往下执行
        System.out.println("Connected Successfully!");
    }
}

//TcpClient

package com.example.network;
import java.net.Socket;
public class TcpClient
{
    public static void main(String[] args) throws Exception
    {
        Socket socket = new Socket("127.0.0.1", 5000);
    }
}

然后先运行服务器端，再运行客户端，可以看到，运行客户端之后输出服务器端的后续代码。表明连接建立后才会往下执行。

一个比较简陋的通信程序：

package com.example.network;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServer
{
    public static void main(String[] args) throws Exception
    {
        // 创建服务器端的socket对象
        ServerSocket ss = new ServerSocket(5000);
        // 监听连接
        Socket socket = ss.accept();
        // 直到连接建立好之后代码才会往下执行
        System.out.println("Connected Successfully!");
        // 获得服务器端的输入流，从客户端接收信息
        InputStream is = socket.getInputStream();
        // 服务器端的输出流，向客户端发送信息
        OutputStream os = socket.getOutputStream();
        byte[] buffer = new byte[200];
        int length = 0;
        length = is.read(buffer);
        String str = new String(buffer, 0, length);
        System.out.println(str);
        // 服务器端的输出
        os.write("Welcome".getBytes());
        // 关闭资源
        is.close();
        os.close();
        socket.close();
    }
}

package com.example.network;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class TcpClient
{
    public static void main(String[] args) throws Exception
    {
        Socket socket = new Socket("127.0.0.1", 5000);
        // 客户端的输出流
        OutputStream os = socket.getOutputStream();
        // 将信息写入流,把这个信息传递给服务器
        os.write("hello world".getBytes());
        // 从服务器端接收信息
        InputStream is = socket.getInputStream();
        byte[] buffer = new byte[200];
        int length = is.read(buffer);
        String str = new String(buffer, 0, length);
        System.out.println(str);
        // 关闭资源
        is.close();
        os.close();
        socket.close();
    }
}

先运行服务器，再运行客户端。之后可以在服务器和客户端的控制台上进行输入操作，另一端将会收到输入的信息并输出。

使用线程实现服务器端与客户端的双向通信
　　用两个线程，一个线程专门用于处理服务器端的读，另一个线程专门用于处理服务器端的写。
　　客户端同理。
　　代码如下，程序共有六个类。
　　服务器端和其输入输出线程：

//MainServer

package com.example.network;
import java.net.ServerSocket;
import java.net.Socket;
public class MainServer
{
    public static void main(String[] args) throws Exception
    {
        ServerSocket serverSocket = new ServerSocket(4000);
        while (true)
        {
            // 一直处于监听状态,这样可以处理多个用户
            Socket socket = serverSocket.accept();
            // 启动读写线程
            new ServerInputThread(socket).start();
            new ServerOutputThread(socket).start();
        }
    }
}

//ServerInputThread

package com.example.network;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
public class ServerInputThread extends Thread
{
    private Socket socket;
    public ServerInputThread(Socket socket)
    {
        super();
        this.socket = socket;
    }
    @Override
    public void run()
    {
        try
        {
            // 获得输入流
            InputStream is = socket.getInputStream();
            while (true)
            {
                byte[] buffer = new byte[1024];
                int length = is.read(buffer);
                String str = new String(buffer, 0, length);
                System.out.println(str);
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

//ServerOutputThread

package com.example.network;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;

public class ServerOutputThread extends Thread
{
    private Socket socket;
    public ServerOutputThread(Socket socket)
    {
        super();
        this.socket = socket;
    }
    @Override
    public void run()
    {
        try
        {
            OutputStream os = socket.getOutputStream();
            while (true)
            {
                BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
                String line = reader.readLine();
                os.write(line.getBytes());
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

客户端和其输入输出线程（其输入输出线程和服务器端的完全一样）：

//MainClient

package com.example.network;
import java.net.Socket;
public class MainClient
{
    public static void main(String[] args) throws Exception
    {
        Socket socket = new Socket("127.0.0.1", 4000);
        new ClientInputThread(socket).start();
        new ClientOutputThread(socket).start();
    }
}

//lientInputThread

package com.example.network;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
public class ClientInputThread extends Thread
{
    private Socket socket;
    public ClientInputThread(Socket socket)
    {
        super();
        this.socket = socket;
    }
    @Override
    public void run()
    {
        try
        {
            // 获得输入流
            InputStream is = socket.getInputStream();
            while (true)
            {
                byte[] buffer = new byte[1024];
                int length = is.read(buffer);
                String str = new String(buffer, 0, length);
                System.out.println(str);
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

//ClientOutputThread 

package com.example.network;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
public class ClientOutputThread extends Thread
{
    private Socket socket;
    public ClientOutputThread(Socket socket)
    {
        super();
        this.socket = socket;
    }
    @Override
    public void run()
    {
        try
        {
            OutputStream os = socket.getOutputStream();
            while (true)
            {
                BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
                String line = reader.readLine();
                os.write(line.getBytes());
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

经测试成功。即从服务器端控制台输入，可以从客户端接收到并输出；也可以反过来，从客户端控制台输入，那么服务器端会同时输出。

多个客户端的程序实验
　　可以启动多个客户端，同时与服务器进行交互。这里还是采用上面的MainServer和MainClient及其输入输出线程代码。
　　这部分做实验的时候需要使用命令行，因为Eclipse里面每次Run的时候都会重新启动程序，即想要Run第二个客户端的时候总是先关闭第一个客户端（因为它们运行的是同一个程序），这样，即只能有一个客户端存在。
　　在命令行运行的方法如下：
　　因为源文件带有包名，所以编译采用：
　　javac –d . 源文件名.java
　　注意d和.之间有一个空格。
　　可以使用通配符编译所有的源文件，即使用：
　　javac –d . *.java
　　编译之后执行：
　　java 完整包名+类名
　　先启动服务器程序，之后新开命令行窗口启动客户端程序，结果如下：

（一个客户端时交互正常）

（多个客户端交互异常）

经实验，发现在一个服务器多个客户端的情况下，客户端可以流畅地向服务器发送信息，但是当服务器发送信息时，就会出现问题，并不是每一个客户端都能收到信息。
　　如图中，当服务器发送语句时，第一个客户端收到了（并且是发送后多按下一个回车才收到），第二个客户端没有收到。
　　后面试验了几个语句都是这样：

实现服务器支持多客户机通信
　　服务器端的程序需要为每一个与客户机连接的socket建立一个线程，来解决同时通信的问题。
　　服务器端应该管理一个socket的集合。
　　即要完成一个功能完善的客户端和服务器通信程序，代码还是需要进一步完善的。

使用无连接的数据报（UDP）进行通信

什么是Datagram？
　　数据报是网上传输的独立数据包，数据报是否能正确地到达目的地，到达的时间，顺序，内容的正确性均没有保障。
　　Java中使用Datagram与DatagramPacket类。
　　DatagramSocket类利用UDP协议来实现客户与服务器的Socket。
　　send()发送数据报。
　　receive()接收数据报。

可以用写信寄信的例子来类比UDP通信。此时DatagramPacket就相当于一个包装了信封的信件。填好地址和接收人之后，就可以寄出去。

简单的UDP通讯实例：

//UdpUnit1
package com.example.network;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UdpUnit1
{
    public static void main(String[] args) throws Exception
    {
        DatagramSocket datagramSocket = new DatagramSocket();
        // 构造数据报的包
        String str = "Hello World";
        // 用了public DatagramPacket(byte buf[], int length,InetAddress address,
        // int port)形式
        DatagramPacket packet = new DatagramPacket(str.getBytes(),str.length(),InetAddress.getByName("localhost"), 7000);
        // 发送数据包
        datagramSocket.send(packet);
        // 接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet2 = new DatagramPacket(buffer, 100);
        datagramSocket.receive(packet2);
        // 输出接收到的数据
        System.out.println(new String(buffer, 0, packet2.getLength()));
        datagramSocket.close();
    }
}

//UdpUnit2
package com.example.network;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class UdpUnit2
{
    public static void main(String[] args) throws Exception
    {
        DatagramSocket socket = new DatagramSocket(7000);
        // 收信息
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 1024);
        // 接收
        socket.receive(packet);
        // 输出
        System.out.println(new String(buffer, 0, packet.getLength()));
        // 返回信息
        String str = "Welcome！";
        DatagramPacket packet2 = new DatagramPacket(str.getBytes(),str.length(), packet.getAddress(), packet.getPort());// 这里填入发送方的信息
        socket.send(packet2);
        socket.close();
    }
}

运行时首先运行UdpUnit2，因为它开始时是在等待接收；然后运行UdpUnit1，它向UdpUnit2发送了“Hello World”的信息，UdpUnit2接收到信息后，返回“Welcome！”。

------- android培训、java培训、期待与您交流！ ----------