JAVA基础学习之UDP网络编程

UDP(UserDatagramProtocol)用户数据报包协议

UDP和TCP位于同一层-传输层，但它对于数据包的顺序错误或重发没有TCP来的可靠。因此，UDP不被应用于那些使用虚电路的面向直接服务.

UDP是一种面向无连接的通信协议。UDP向应用程序提供了一种发送封装的原始IP数据包的方法，并且发送时无需建立连接，不保证可靠数据的传输

特点：面向无连接的数据传输，不可靠的，但效率高。

UDP一次发送的数据不能超过64KB.

UDP编程所需要的类：

DatagramSocket 此类表示用来发送和接收数据报包的套接字

DatagramPacket 此类表示数据报包

DatagramPacket(byte[]buf, intlength, InetAddressaddress, intport)

参数：buf -包数据

length -包长度

address -目的地址

port -目的端口号

写法步骤：

服务器端：创建监听套接字，接受数据包，发送数据包，关闭套接字

客户端： 创建套接字，发送数据包，接受数据包，关闭套接字

DatagramSocket类

DatagramSocket(int port)

创建数据报套接字并将其绑定到本地主机上的指定端口。

DatagramSocket(int port, InetAddress laddr)

创建数据报套接字，将其绑定到指定的本地地址。

DatagramPacket类

构造方法摘要

DatagramPacket(byte[] buf, int length)

构造 DatagramPacket，用来接收长度为 length 的数据包。

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

构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。

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

构造 DatagramPacket，用来接收长度为 length 的包，在缓冲区中指定了偏移量。

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

构造数据报包，用来将长度为 length 偏移量为 offset 的包发送到指定主机上的指定端口号。

DatagramPacket(byte[] buf, int offset, int length, SocketAddress address)

构造数据报包，用来将长度为 length 偏移量为 offset 的包发送到指定主机上的指定端口号。

DatagramPacket(byte[] buf, int length, SocketAddress address)

构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。

一般方法

InetAddress     getAddress()

返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。

byte[]  getData()

返回数据缓冲区。

int getLength()

返回将要发送或接收到的数据的长度。

int getOffset()

返回将要发送或接收到的数据的偏移量。

int getPort()

返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接收到的。

SocketAddress   getSocketAddress()

获取要将此包发送到的或发出此数据报的远程主机的 SocketAddress（通常为 IP 地址 + 端口号）。

void    setAddress(InetAddress iaddr)

设置要将此数据报发往的那台机器的 IP 地址。

void    setData(byte[] buf)

为此包设置数据缓冲区。

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

为此包设置数据缓冲区。

void    setLength(int length)

为此包设置长度。

void    setPort(int iport)

设置要将此数据报发往的远程主机上的端口号。

void    setSocketAddress(SocketAddress address)

设置要将此数据报发往的远程主机的 SocketAddress（通常为 IP 地址 + 端口号）。

示例1：

本例子使用WindowBuilder图形界面进行编写。实现简单的一对一聊天

界面效果：



java代码

package com.ql.Receivers;

import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.JButton;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class Receiver implements ActionListener {

private JFrame frame;
private JTextField txtStr;
private JTextArea txtArea;
private JButton btnSend, btnEnter;
private JTextField txtYouAddress;

private DatagramSocket receiverSocket, sendSocket;//发送和接收套接字
private JTextField txtMyAddress;

private String youAddress = "127.0.0.2", myAddress = "127.0.0.1";//己方地址和对方地址

/**
* Launch the application.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
Receiver window = new Receiver();
window.frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the application.
*/
public Receiver() {
initialize();
}

/**
* Initialize the contents of the frame.
*/
private void initialize() {
frame = new JFrame();
frame.setBounds(100, 100, 530, 370);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.getContentPane().setLayout(new BorderLayout(0, 0));

JPanel panel = new JPanel();
frame.getContentPane().add(panel);
panel.setLayout(null);

JPanel panel_1 = new JPanel();
panel_1.setBounds(0, 33, 514, 256);
panel.add(panel_1);
panel_1.setLayout(new BorderLayout(0, 0));

JScrollPane scrollPane = new JScrollPane();
panel_1.add(scrollPane);

txtArea = new JTextArea();
scrollPane.setViewportView(txtArea);

JPanel panel_2 = new JPanel();
panel_2.setBounds(0, 288, 514, 44);
panel.add(panel_2);
panel_2.setLayout(null);

JLabel lblNewLabel = new JLabel("\u8BF7\u8F93\u5165\uFF1A");
lblNewLabel.setBounds(10, 18, 54, 15);
panel_2.add(lblNewLabel);

txtStr = new JTextField();
txtStr.setBounds(74, 15, 329, 21);
panel_2.add(txtStr);
txtStr.setColumns(10);

btnSend = new JButton("\u53D1\u9001");
btnSend.setBounds(413, 12, 93, 27);
btnSend.addActionListener(this);
panel_2.add(btnSend);

JPanel panel_3 = new JPanel();
panel_3.setBounds(0, 0, 514, 31);
panel.add(panel_3);
panel_3.setLayout(null);

JLabel lblNewLabel_1 = new JLabel("\u5BF9\u65B9IP\uFF1A");
lblNewLabel_1.setBounds(10, 10, 54, 15);
panel_3.add(lblNewLabel_1);

txtYouAddress = new JTextField();
txtYouAddress.setText("127.0.0.1");
txtYouAddress.setBounds(65, 7, 152, 21);
panel_3.add(txtYouAddress);
txtYouAddress.setColumns(10);

JLabel lblNewLabel_2 = new JLabel("\u60A8\u7684IP\uFF1A");
lblNewLabel_2.setBounds(234, 10, 54, 15);
panel_3.add(lblNewLabel_2);

txtMyAddress = new JTextField();
txtMyAddress.setText("127.0.0.1");
txtMyAddress.setBounds(282, 7, 152, 21);
panel_3.add(txtMyAddress);
txtMyAddress.setColumns(10);

btnEnter = new JButton("\u786E\u5B9A");
btnEnter.setBounds(440, 6, 64, 23);
btnEnter.addActionListener(this);
panel_3.add(btnEnter);
}

@Override
public void actionPerformed(ActionEvent e) {
// 按钮处理
if (e.getSource() == btnSend) { //发送
String string = txtStr.getText().trim();
send(string);
}
if(e.getSource() == btnEnter){ //连接
if(!"".equals(txtMyAddress.getText().trim()) && !"".equals(txtYouAddress.getText().trim())){
myAddress = txtMyAddress.getText().trim();
youAddress = txtYouAddress.getText().trim();
connect(myAddress); //封装的连接方法
}else{
txtArea.setText(txtArea.getText() + "发送目的地址或自己地址不能为空！");
}
}
}

/**
* 封装的连接方法
* @param address 己方地址，用于接收数据包
*/
public void connect(String address) {
SocketAddress mAddress = new InetSocketAddress(address, 8888);

try {
receiverSocket = new DatagramSocket(mAddress);//实例化接收套接字
sendSocket = new DatagramSocket();//实例化发送套接字
} catch (SocketException e) {
e.printStackTrace();
}
new ReceiverThread(receiverSocket).start();//将接收放入线程中，不断接收数据
}

/**
* 用于接收消息的线程
* @author qinlang
*
*/
class ReceiverThread extends Thread {
DatagramSocket socket;
public ReceiverThread(DatagramSocket socket){
this.socket = socket;
}

@Override
public void run() {
while(true){
DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);//定义并实例化接收对象
try {
socket.receive(packet);//接收数据包
} catch (IOException e) {
e.printStackTrace();
}
txtArea.setText(txtArea.getText() + "\n" + new String(packet.getData(), 0, packet.getLength()));//显示数据包内容
}
}
}

/**
* 用于发送数据包的方法
* @param str
*/
public void send(String str){
InetAddress address = null;//定义发送至的地址
try {
address = InetAddress.getByName(youAddress);//实例化地址
} catch (UnknownHostException e1) {
e1.printStackTrace();
}
DatagramPacket packet = new DatagramPacket(str.getBytes(), str.getBytes().length, address, 8888);//定义并实例化数据包
try {
sendSocket.send(packet);//发送数据包
txtArea.setText(txtArea.getText() + "\n已发送...");
} catch (IOException e) {
e.printStackTrace();
}
}
}

示例2：

本例子使用WindowBuilder图形界面进行编写。实现简单的多对多聊天

界面效果：



java代码：

客户端

package com.ql.talkM2M;

import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.JButton;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class Sender implements ActionListener{

private JFrame frame;
private JTextField txtName;
private JTextField txtServerAddress;
private JTextField txtStr;
private JButton btnConnect, btnSend;
private JTextArea textArea;

private DatagramSocket socket;//套接字
private DatagramPacket packet;//数据包

private String name; //昵称
private Thread thread;//用于接收的线程

/**
* Launch the application.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
Sender window = new Sender();
window.frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the application.
*/
public Sender() {
initialize();
}

/**
* Initialize the contents of the frame.
*/
private void initialize() {
frame = new JFrame();
frame.addWindowListener(new WindowAdapter() {//程序关闭通知所有在线的用户
@Override
public void windowClosing(WindowEvent e) {
if(thread != null){
send("退出了...");
}
}
});
frame.setBounds(100, 100, 536, 354);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JPanel panel = new JPanel();
frame.getContentPane().add(panel, BorderLayout.CENTER);
panel.setLayout(null);

JPanel panel_1 = new JPanel();
panel_1.setBounds(0, 0, 520, 37);
panel.add(panel_1);
panel_1.setLayout(null);

JLabel lblNewLabel = new JLabel("\u6635\u79F0\uFF1A");
lblNewLabel.setBounds(263, 10, 44, 15);
panel_1.add(lblNewLabel);

txtName = new JTextField();
txtName.setBounds(305, 7, 131, 21);
panel_1.add(txtName);
txtName.setColumns(10);

btnConnect = new JButton("连接");
btnConnect.setBounds(446, 6, 64, 23);
btnConnect.addActionListener(this);
panel_1.add(btnConnect);

JLabel lblNewLabel_1 = new JLabel("\u670D\u52A1\u5668IP\uFF1A");
lblNewLabel_1.setBounds(10, 10, 64, 15);
panel_1.add(lblNewLabel_1);

txtServerAddress = new JTextField();
txtServerAddress.setText("127.0.0.1");
txtServerAddress.setBounds(74, 7, 179, 21);
panel_1.add(txtServerAddress);
txtServerAddress.setColumns(10);

JPanel panel_2 = new JPanel();
panel_2.setBounds(0, 279, 520, 37);
panel.add(panel_2);
panel_2.setLayout(null);

JLabel lblNewLabel_2 = new JLabel("\u8BF7\u8F93\u5165\uFF1A");
lblNewLabel_2.setBounds(10, 12, 54, 15);
panel_2.add(lblNewLabel_2);

txtStr = new JTextField();
txtStr.setBounds(57, 9, 362, 21);
panel_2.add(txtStr);
txtStr.setColumns(10);

btnSend = new JButton("\u53D1\u9001");
btnSend.setEnabled(false);
btnSend.setBounds(427, 8, 83, 23);
btnSend.addActionListener(this);
panel_2.add(btnSend);

JPanel panel_3 = new JPanel();
panel_3.setBounds(0, 37, 520, 242);
panel.add(panel_3);
panel_3.setLayout(new BorderLayout(0, 0));

JScrollPane scrollPane = new JScrollPane();
panel_3.add(scrollPane);

textArea = new JTextArea();
scrollPane.setViewportView(textArea);
}

@Override
public void actionPerformed(ActionEvent e) {
//按钮按键处理
if(e.getSource() == btnConnect){ //连接
if("连接".equals(btnConnect.getText())){//按钮上的文字显示“连接”，表示没有连接，点击连接
if("".equals(txtServerAddress.getText()) || "".equals(txtName.getText().trim())){
textArea.setText(textArea.getText() + "请输入服务器IP或昵称!\n");
}else{
connect();//封装的连接方法
btnConnect.setText("断开");//连接按钮改变文字
thread = new Thread(new IN(socket));//将接收放入线程中，不断接收数据包
thread.start();
btnSend.setEnabled(true);//发送按钮使能
}
}else if("断开".equals(btnConnect.getText())){//按钮上的文字显示“断开”，表示正在连接，点击断开
if(e.getSource() == btnConnect){
send("退出了...");//断开了连接，表明已下线
if(thread != null){
thread.stop();//销毁线程
btnSend.setEnabled(false);//发送使否
}
btnConnect.setText("连接");//连接按钮改变文字
}
}
}

if(e.getSource() == btnSend){ //发送
String string = txtStr.getText().trim();
send(string);//封装的发送方法
}
}

/**
* 连接方法
*/
public void connect(){
try {
socket = new DatagramSocket();//实例化套接字
name = txtName.getText().trim();
String str = name + "：上线了...";
String address = "";
address = txtServerAddress.getText().trim();//得到服务器ip
//连接上服务器，发送一次数据，通知服务器上的所有用户
packet = new DatagramPacket(str.getBytes(),str.getBytes().length, new InetSocketAddress(address, 8888));
socket.send(packet);
textArea.setText(textArea.getText() + "\n已连接...");
} catch (SocketException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

/**
* 为接收开启单独的线程，不断接收数据
* @author qinlang
*
*/
class IN implements Runnable {
private DatagramSocket socket;

public IN(DatagramSocket socket) {
this.socket = socket;
}

@Override
public void run() {
byte[] b = new byte[1024];//一次读取数据大小
DatagramPacket packet2 = new DatagramPacket(b, b.length);// 用来接收的包裹
String value = "";
while (true) {
try {
socket.receive(packet2);//接收数据
value = new String(b, 0, packet2.getLength());//将数据分割读取
textArea.setText(textArea.getText() + "\n" + value);
} catch (IOException e) {
break;
}
}
}
}

/**
* 发送数据的方法
* @param data
*/
public void send(String data){
try {
packet.setData((name + ":" + data).getBytes());//设置数据（发送的数据和昵称），转换成字节流
socket.send(packet);//发送数据
textArea.setText(textArea.getText() + "\n您：" + data);
} catch (IOException e) {
e.printStackTrace();
}
}
}

服务器

package com.ql.talkM2M;

import java.io.BufferedReader;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketAddress;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.List;

/**
* 服务器端，可看做只转发数据的服务器，也可以当客户端发送数据
* @author qinlang
*
*/
public class Server {

/**
* @param args
*/
public static void main(String[] args) {
DatagramSocket socket = null;
DatagramPacket packet = null;
List<SocketAddress> addresses;//存放所有用户地址的集合
try {
socket = new DatagramSocket(8888);
packet = new DatagramPacket(new byte[1024], 1024);
socket.receive(packet);//接收一次自己的数据
} catch (SocketException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
addresses = new ArrayList<SocketAddress>();
addresses.add(packet.getSocketAddress()); //将自己的地址加入集合

new Thread(new INReceiver(socket, addresses)).start();//启动接收线程
//发送线程没有启动，因为只做转发功能，服务器不需要发送自己的数据
}

}

/**
* 发送数据线程，此方法用于服务器对连接在服务器上的用户发数据
* @author qinlang
*
*/
class OUTReceiver implements Runnable {
BufferedReader br;
DatagramPacket packet;// 数据 地址
DatagramSocket socket;
List<SocketAddress> addresses;

public OUTReceiver(BufferedReader br, DatagramPacket packet,
DatagramSocket socket, List<SocketAddress> addresses) {
this.br = br;
this.packet = packet;
this.socket = socket;
this.addresses = addresses;
}

@Override
public void run() {
while (true) {//死循环，不断发送数据
try {
String data = br.readLine();//按行读取数据
packet.setData((Thread.currentThread().getName() + data).getBytes());
// 同一个数据,把所有在线的人都发一遍
for (SocketAddress socketAddress : addresses) {
packet.setSocketAddress(socketAddress);
socket.send(packet);
}
// 建议你不要把服务器关掉
} catch (IOException e) {
e.printStackTrace();
}

}
}
}

/**
* 接收数据线程
* @author qinlang
*
*/
class INReceiver implements Runnable {
private DatagramSocket socket;
private List<SocketAddress> addresses;

public INReceiver(DatagramSocket socket, List<SocketAddress> addresses) {
this.socket = socket;
this.addresses = addresses;
}

@Override
public void run() {
byte[] b = new byte[1024];
DatagramPacket packet = new DatagramPacket(b, b.length);// 用来接收的包裹
String value = "";
while (true) {
try {
socket.receive(packet);//接收数据

SocketAddress myadd = packet.getSocketAddress();// 得到发数据过来的地址
// 同一个数据,把所有在线的人都发一遍
for (SocketAddress socketAddress : addresses) {
if (socketAddress.equals(myadd))//如果是自身，则跳过
continue;
packet.setSocketAddress(socketAddress);
socket.send(packet);
}
// 第一次来的时候,把这个地址添加到地址集合里面去
if (!addresses.contains(myadd))
addresses.add(myadd);

if (value.equalsIgnoreCase("esc"))//如果退出了，把地址从集合中移除
addresses.remove(myadd);
} catch (IOException e) {
e.printStackTrace();
}
}
}
}