java网络编程之UDP通讯

详细介绍了java中的网络通信机制，尤其是UDP协议，通过对UDP的基本使用进行举例说明如何使用UDP进行数据的发送接收，并举了两个小demo说明UDP的使用注意事项。

UDP协议原理图解：

UDP协议：需要借助于InetAddress来获取设备的IP地址，以及姓名

 import java.io.IOException;
 import java.net.Inet4Address;
 import java.net.InetAddress;
 import java.net.UnknownHostException;

 public class InetAddressDemo {
     public static void main(String[] args) throws IOException {
         // InetAddress address = InetAddress.getByName("10.129.123.23");
         InetAddress address = InetAddress.getByName("ooo-PC");
         // InetAddress address = InetAddress.getByName("lpp-PC");

         // 获取该ip地址对象的IP地址和主机名
         String name = address.getHostName();
         String ip = address.getHostAddress();

         System.out.println(name);
         System.out.println(ip);
     }
 }

 /*
  * 网络通讯三要素：
  *     1.IP地址:InetAddress 网络中设备的标识，不易记忆，可用主机名；
  *     2.端口号:用于标识进程的逻辑地址，不同进程的标识传输协议通讯的规则；用于标识进程的逻辑地址，不同进程的标识，
  *    有效端口：0~65535，其中0~1024系统使用或保留端口。
  *     3.常见协议：TCP，UDP。
  */

 /*
  * UDP协议
  * 将数据源和目的封装成数据包中，不需要建立连接；
  * 每个数据报的大小在限制在64k；
  * 因无连接，是不可靠协议；
  * 不需要建立连接，速度快
  */

 /*
  * Socket套接字：
  * 网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的  标识符套接字。
  * Socket原理机制：通信的两端都有Socket。
  * 网络通信其实就是Socket间的通信。
  * 数据在两个Socket间通过IO传输。
  */

 //第一部分代码是接收端，一般是先开接收端的代码，再开发送端
 //接收端代码的创建步骤如下：
 /*
  * UDP协议接收数据：
  * 1.创建接收端socket对象
  * 2.创建一个数据包（接收数据的容器）
  * 3.调用socket的对象的接收方法接收数据
  * 4.解析数据，并显示在控制台
  * 5.释放资源
  */

 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
 import java.net.SocketException;

 /*
  * 对于里面创建对象的部分进行优化直接链式编程
  * java.net.BindException: Address already in use: Cannot bind
  * 该端口已经被使用了，有可能是第二次调用或者第一次调用的时候该端口被其它程序使用。
  */
 public class ReceiveDemo {
     public static void main(String[] args) throws IOException {
         // 创建接收端数socket对象,指定端口。
         DatagramSocket ds = new DatagramSocket(10086);
         // 接收数据
         byte[] buf = new byte[1024];
         // int length = buf.length;
         DatagramPacket dp = new DatagramPacket(buf, buf.length);
         ds.receive(dp); // 将接受的数据放进dp数据报包中
         // 解析数据，获取IP地址以及数据报包中的内容
         // InetAddress address = dp.getAddress();
         // String ip = address.getHostAddress();
         // byte[] bys = dp.getData();
         // int len = dp.getLength(); // 数据报包的实际长度

         String ip = dp.getAddress().getHostAddress();
         String s = new String(dp.getData(), 0, dp.getLength());

         System.out.println(ip + ":--" + s);

         // 释放资源
         ds.close();

     }
 }

 //----------------------------------------
 //下面是发送端的代码，与上面分开在两个类

 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
 import java.net.SocketException;

 public class SendDemo {
     public static void main(String[] args) throws IOException {
         // 发送端socket对象
         DatagramSocket ds = new DatagramSocket();

         // 数据打包
         byte[] bys = "java".getBytes();
         // int len = bys.length;
         // InetAddress address = InetAddress.getByName("lpp-PC");
         // int port = 10086;

         DatagramPacket dp = new DatagramPacket(bys, bys.length,
                 InetAddress.getByName("lpp-PC"), 10086);

         // 发送数据
         ds.send(dp);

         // 释放资源
         ds.close();
     }
 }

 /*
 * 多线程实现在一个代码里面姐发送又接受数据
 * 在发送端从键盘录入数据，一直读到886结束数据的录入发送，键盘录入一句就接受一句，接收端一直开着等着数据的发送。
 */

 //首先是main方法

 import java.io.IOException;
 import java.net.DatagramSocket;
 import java.net.SocketException;

 /*
  * 通过多线程
  */
 public class chatRoomDemo {
     public static void main(String[] args) throws IOException {
         // 接收端，发送端socket
         DatagramSocket dsSend = new DatagramSocket();
         DatagramSocket dsReceive = new DatagramSocket(10086);

         SendThread st = new SendThread(dsSend);
         ReceiveThread rt = new ReceiveThread(dsReceive);

         // 线程开启
         Thread sendThread = new Thread(st);
         Thread receiverThread = new Thread(rt);

         sendThread.start();
         receiverThread.start();
     }
 }

 //--------------------------------------------
 //接收端线程的创建
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;

 public class ReceiveThread implements Runnable {
     private DatagramSocket ds;

     public ReceiveThread(DatagramSocket ds) {
         // 通过构造方法进行初始化
         this.ds = ds;
     }

     @Override
     public void run() {
         // TODO Auto-generated method stub
         while (true) {
             try {
                 byte[] buf = new byte[1024];
                 DatagramPacket dp = new DatagramPacket(buf, buf.length);
                 ds.receive(dp);

                 String ip = dp.getAddress().getHostAddress();

                 String s = new String(dp.getData(), 0, dp.getLength());

                 System.out.println(ip + "--->" + s);
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
 }

 //---------------------------------------
 //发送端线程的创建

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;

 public class SendThread implements Runnable {
     private DatagramSocket ds;

     public SendThread(DatagramSocket ds) {
         this.ds = ds;
     }

     @Override
     public void run() {
         // TODO Auto-generated method stub
         try {
             BufferedReader br = new BufferedReader(new InputStreamReader(
                     System.in));
             String line = null;
             while ((line = br.readLine()) != null) {
                 if ("886".equals(line)) {
                     break;
                 }
                 byte[] buf = line.getBytes();
                 DatagramPacket dp = new DatagramPacket(buf, buf.length,
                         InetAddress.getByName("lpp-PC"), 10086);

                 ds.send(dp);
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
         // //释放资源
         // ds.close();
     }

 }