java中网络编程UDP在线咨询案例（DatagramSocket）

方法1：单线程（单方向发送接收）：

发送端：UdpTalkClient.java

步骤流程：1.使用DatagramSocket 指定端口 创建发送端

                  2.准备数据一定转成字节数组

                  3.封装DatagramSocket包裹，需要指定目的地

                  4.发送包裹

                  5.释放资源

以下为代码案例：

package com.bl.d;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class UdpTalkClient {
	public static void main(String[] args) throws Exception {
		System.out.println("输入端正在运行");
		//使用DatagramSocket 指定端口 创建发送端
		DatagramSocket client = new DatagramSocket(8888);
//		准备数据一定转成字节数组
		while(true) {
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		String Data = reader.readLine();
		byte[] datas = Data.getBytes();
		//封装DatagramSocket包裹，需要指定目的地
		DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6666));
//		发送包裹
		client.send(packet);
		if(Data.equals("Bye")) {
			break;
		}}
//		释放资源
		client.close();
		}
}

接收端：UdpTalkServer.java

步骤流程：1.使用DatagramSocket 创建端口 ，创建接收端；

                  2.分析数据

                  3.准备容器 封装成DatagramPacket 包裹

                  4.阻塞式接收包裹receive（DatagramPacket p）

                  5.释放资源

以下为代码案例：

package com.bl.d;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpTalkServer {
	public static void main(String[] args) throws Exception {
		System.out.println("接收端正在运行");
//		1.使用DatagramSocket 创建端口 ，创建接收端；
		DatagramSocket server = new DatagramSocket(6666);
//		2.//分析数据
		while(true) {
//			3.//准备容器 封装成DatagramPacket 包裹
			byte[] container =new byte[1024*60];
			DatagramPacket packet = new DatagramPacket(container,0,container.length);
//			4.//阻塞式接收包裹receive（DatagramPacket p）
			server.receive(packet);
		byte[] datas = packet.getData();
		int Len = packet.getLength();
		String data = new String(datas,0,Len);
		System.out.println(data);
		if(datas.equals("Bye")) {
			break;
		}
		}
//		释放资源
		server.close();
		}
}

方法2：多线程+面向对象封装（双向发送接收）：

封装案例：TalkSend.java

通过UdpTalkClient.java封装得到如下：

package com.bl.d;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class TalkSend implements Runnable {
	private DatagramSocket client ;
	private BufferedReader reader;
	private String toIP;
	private int toPort;
	public TalkSend(int port,String toIP,int toPort) {
		this.toIP = toIP;
		this.toPort = toPort;
		try {
			client= new DatagramSocket(port);
			reader = new BufferedReader(new InputStreamReader(System.in));
		} catch (SocketException e) {
			e.printStackTrace();
		}
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {

			 
			String Data;
			try {
				Data = reader.readLine();
				byte[] datas = Data.getBytes();
				//封装DatagramSocket包裹，需要指定目的地
				DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress(this.toIP,this.toPort));
//				发送包裹
				client.send(packet);
				if(Data.equals("Bye")) {
					break;
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			}
		client.close();
	}
	
}

封装案例TalkRecive.java

通过UdpTalkServer.java封装得到。

package com.bl.d;

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

public class TalkRecive implements Runnable {
	private DatagramSocket server;
	public TalkRecive(int port) {
		try {
			
			server = new DatagramSocket(port);
		} catch (SocketException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			//准备容器 封装成DatagramPacket 包裹
			byte[] container =new byte[1024*60];
			DatagramPacket packet = new DatagramPacket(container,0,container.length);
			//阻塞式接收包裹receive（DatagramPacket p）
			try {
				byte[] datas = packet.getData();
				int Len = packet.getLength();
				String data = new String(datas,0,Len);
				System.out.println(data);
				if(datas.equals("Bye")) {
					break;
				}
				server.receive(packet);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		
		}
//		释放资源
		server.close();
		}
	}

对象TalkStudents.java（学生）：

创建开启接收和发送端口线程：

package com.bl.d;

public class TalkStudents {
	public static void main(String[] args) {
		new Thread(new TalkRecive(9998)).start();
		new Thread(new TalkSend(2222,"localhost",1111)).start();
	}
}

2222为发送端口，1111为发送目的地端口，9998为接收端口。

对象TalkTeacher.java(老师)：

创建开启接收和发送端口线程：

package com.bl.d;

public class TalkTeacher {
	public static void main(String[] args) {
		new Thread(new TalkRecive(1111)).start();
		new Thread(new TalkSend(4444,"localhost",9998)).start();
		
	}
}

4444为发送端口，9998为发送目的地端口，1111位接收端口。