计算机网络课程设计利用java实现UDP协议.doc

计算机网络课程设计
利用java 实现UDP协议
系 别
计算机与通信工程学院
专 业
计算机科学与技术
学 号
4110415
姓 名
张振
指导教师
王聪
2014年7月4日
1. 需求分析
程序是如何通过网络进行相互通信的呢？各个孤立的工作站或主机用物理链路相连在一起，组成数据链路,从而达到资源共享和通信的目的，就形成网络。通信是人与人之间同过某种媒体进行的信息交流与传递.网络通信一般指网络协议。当今网络协议有很多，其中基本最常用的就是TCP/IP 协议族。UDP协议就是属于TCP/IP协议族中的协议。在网络中它与TCP协议一样用于处理数据包.在OSI模型中,UDP协议在第四层——传输层，处于IP协议的上一层。与TCP相比，UDP有不提供数据报分组、组装和不能对数据包的排序的缺点，也就是说，当报文发送之后,是无法得知其是否安全完整到达的.
本文利用Java语言网络编程的思想，编写UDP协议程序，实现UDP协议在网络中所要完成的功能。在Java语言为实现程序的相互通信提供了许多有用的抽象应用程序接口（API， Application Programming Interface），这类应用程序接口被称为套接字(sockets).
因此，本文UDP协议的编程所需要用到的接口就是套接字.
2. 实验环境
开发环境： 个人PC+win8。1+myeclipse 10
3. 实验原理以及相关内容
3。1 UDP简介
UDP 是User Datagram Protocol的简称，中文全称是用户数据包协议,是一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务.在网络中它与TCP协议一样用于处理数据包。在OSI模型中，UDP协议在第四层——传输层，处于IP协议的上一层.与TCP相比，UDP有不提供数据报分组、组装和不能对数据包的排序的缺点，也就是说，当报文发送之后，是无法得知其是否安全完整到达的。UDP用来支持那些需要在计算机之间传输数据的网络应用。包括网络视频会议系统在内的众多的客户/服务器模式的网络应用都需要使用UDP协议。
3。2 使用UDP原因
UDP协议从问世至今已经被使用了很多年,虽然其最初的光彩已经被一些类似协议所掩盖，但是即使是在今天,UDP仍然不失为一项非常实用和可行的网络传输层协议。这是因为UDP 有以下特点：
（1)UDP是一个无连接协议，传输数据之前源端和终端不建立连接，当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。
（2)由于传输数据不建立连接,因此也就不需要维护连接状态，包括收发状态等，因此一台服务机可同时向多个客户机传输相同的消息。
(3)UDP信息包的标题很短，只有8个字节，相对于TCP的20个字节信息包的额外开销很小
（4）吞吐量不受拥挤控制算法的调节,只受应用软件生成数据的速率、传输带宽、源端和终端主机性能的限制。
（5）UDP使用尽最大努力交付，即不保证可靠交付，因此主机不需要维持复杂的链接状态表（这里面有许多参数）。
（6)UDP是面向报文的。发送方的UDP对应用程序交下来的报文,在添加首部后就向下交付给IP层。既不拆分，也不合并，而是保留这些报文的边界，因此，应用程序需要选择合适的报文大小。
3.3 UDP套接字
UDP协议提供了一种不同于TCP协议的端到端服务.实际上UDP协议只实现两个功能：
(1).在IP协议的基础上添加了另一层地址（端口）；
(2）.对数据传输过程中可能产生的数据错误进行了检测,并抛弃已经损坏的数据。
由于其简单性,UDP套接字具有一些与我们之前所看到的TCP套接字不同的特征.例如,UDP套接字在使用前不需要进行连接。TCP协议与电话通信相似，而UDP协议则与邮件通信相似：你寄包裹或信件时不需要进行“连接”，但是你得为每个包裹和信件指定目的地址。类似的,每条信息（即数据报文，datagram)负载了自己的地址信息，并与其他信息相互独立.在接收信息时,UDP套接字扮演的角色就像是一个信箱,从不同地址发送来的信件和包裹都可以放到里面。一旦被创建,UDP套接字就可以用来连续地向不同的地址发送信息，或从任何地址接收信息。
UDP套接字与TCP套接字的另一个不同点在于他们对信息边界的处理方式不同：UDP套接字将保留边界信息。这个特性使应用程序在接受信息时，从某些方面来说比使用TCP套接字更简单。最后一个不同点是，UDP协议所提供的端到端传输服务是尽力而为(best—effort)的，即UDP套接字将尽可能地传送信息，但并不保证信息一定能成功到达目的地址，而且信息到达的顺序与其发送顺序不一定一致（就像通过邮政部门寄信一样)。因此,使用了UDP套接字的程序必须准备好处理信息的丢失和重排.
4. 实验内容
4.1 流程图
UDP应用程序原理图
UDP应用程序流程图
4.2 实例解析
3。3.1 UDP服务器端
UDP服务器要执行以下三步：
(1）.创建一个DatagramSocket实例，指定本地端口号，并可以选择指定本地地址。此时，服务器已经准备好从任何客户端接收数据报文。
（2）.使用DatagramSocket类的receive（）方法老接收一个DatagramPacket实例。当receive（) 方法返回时，数据报文就包含了客户端的地址与端口，这样我们就知道回复信息该发送到什么地方。
(3）。使用DatagramSocket类的send()和receive（)方法发送和接收DatagramPacket实例，进行通信。
//服务器类UDPServerBean。java
package UDP；
import java。io.＊；
import java。net.＊；
public class UDPServerBean {
private DatagramSocket dSocket;
private int ClientPort；
private int ServerPort;
private InetAddress ServerIP；
private InetAddress ClientIP；
private String content;
// 无参构造函数
public UDPServerBean（) throws SocketException，UnknownHostException {
ClientPort = 1111;
ServerPort = 1001;
content = ""；
ClientIP = InetAddress。getLocalHost（);
ServerIP = InetAddress.getLocalHost（);
dSocket = new DatagramSocket（ServerPort)；
}
// 信息发送函数，将接收到的信息发回给用户
public void sendToClient(） throws IOException{
byte［］ Buffer = （"服务器已经收到：\n ”+content）。getBytes();
// 将要发送的信息给Buffer变量
DatagramPacket dPacket = new DatagramPacket(Buffer，Buffer.length,getClientIP（)，getClientPort（））；
//创建DatagramPacket对象dPacket，并设置客户机的IP地址与端口号
dSocket.send（dPacket)； //发送信息
｝
// 以下全是UDPServerBean类的各个成员变量的get和set方法
public InetAddress getServerIP() {
return ServerIP；
｝
public void setServerIP(InetAddress serverIP） throws Exception {
ServerIP = serverIP；
｝
public DatagramSocket getdSocket（) {
return dSocket；
｝
public void setdSocket（DatagramSocket dSocket） ｛
this。dSocket = dSocket;
}
public int getClientPort(） ｛
return ClientPort；
}
public void setClientPort(int clientPort） ｛
ClientPort = clientPort;
｝
public int getServerPort（) {
return ServerPort;
}
public void setServerPort(int serverPort） throws SocketException {
ServerPort = serverPort；
｝
public String getContent（) ｛
return content；
｝
public void setContent(String content) {
this。content = content；
｝
public InetAddress getClientIP（） {
return ClientIP;
}
public void setClientrIP(InetAddress clientIP） ｛
ClientIP = clientIP；
}
}
//服务器端代码，UDPServer。java
package UDP；
import java.awt。＊;
import java。awt。event.*；
import java.io。*；
import java。net。＊；
import javax.swing。＊；
public class UDPServer extends JApplet{
private UDPServerBean server；
private Thread thread;
private JTextField jtf_ServerPort = new JTextField（10）;
private JButton jbt_Strat = new JButton（”启动”）；
private JButton jbt_Exit= new JButton（”退出")；
private JTextArea jta_Server = new JTextArea（）;
public UDPServer（) {
JPanel jplServer11 = new JPanel（);
jplServer11.add（new JLabel(”服务器端口：”)）；
jplServer11.add（jtf_ServerPort）；
JPanel jplServer21= new JPanel(）；
jplServer21.add(jbt_Strat）；
jplServer21。add(jbt_Exit)；
JPanel jplServer0= new JPanel（）；
jplServer0。setLayout(new GridLayout(2，1）);
jplServer0。add（jplServer11,BorderLayout.NORTH)；
jplServer0。add(jplServer21)；
add(jplServer0，BorderLayout.NORTH）；
add（new JScrollPane（jta_Server),BorderLayout.CENTER）；
// 使用线程
thread = new Thread(new Runnable()｛
public void run() ｛
receiveForemClient(); //调用发送函数
｝
｝）；
//启动按钮事件
jbt_Strat。addActionListener(new ActionListener（）｛
public void actionPerformed（ActionEvent e） {
int serPort = Integer。parseInt(jtf_ServerPort。getText()）； // 从jtf_ServerPort文本区中取服务器的端口号
try {
server = new UDPServerBean(); //创建服务器UDPServerBean的类对象
server.setServerPort（serPort)； //将取得的服务器端口serPort给server对象
jta_Server。setText（"设置服务器端口为 ”+jtf_ServerPort。getText()+” 服务器开启。。。\n")； // 将服务器端设置好的信息显示在jta_Server文本域中
thread.start(）； //启动线程
} catch （SocketException e2) ｛
e2。printStackTrace（）；
}catch (UnknownHostException e1) {
e1。printStackTrace()；
｝ catch （Exception e1) ｛
e1.printStackTrace（）；
｝
}
})；
// 退出按钮的触发事件
jbt_Exit。addActionListener（new ActionListener（) ｛
public void actionPerformed(ActionEvent e） {
System。exit(0）;
｝
}）；
｝
// 接收客户端的信息，并将接收到的信息发回给客户机
public void receiveForemClient（）{
String rec_str = null;
byte［］ Buffer = new byte [1024］;
try {
server。setdSocket（new DatagramSocket(server.getServerPort(），server.getServerIP（））); // server对象调用setdSocket（）函数，创建新Socket对象（此时服务器端口号为设定的端口号）
} catch (SocketException e） {
e。printStackTrace（）；
}
DatagramPacket dPacket = new DatagramPacket(Buffer,Buffer.length); //创建DatagramPacket对象dPacket
while（true）{ // 用循环监听信息接收
try ｛
server.getdSocket(）.receive(dPacket）； //接受信息，将接收到的信息存放在dPacket对象中
rec_str = new String（dPacket.getData（）,0，dPacket.getLength（））; //取出dPacket对象中接收到的信息
server。setClientPort(dPacket。getPort（））； // 将dPacket对象中包含的客户机的端口号给server对象
server.setClientrIP（dPacket。getAddress（）)； // 将dPacket对象中包含的客户机的IP给server对象
server。setContent（rec_str); // 将接收的信息给server对象
jta_Server.setText(jta_Server.getText()+"收到IP地址为 "+server.getClientIP()+"，端口为 "+server.getClientPort(）+” 的客户机的信息有：\n ”+rec_str+"\n"）； // 将客户机的信息与接收的信息显示在jta_Server文本域中
server。sendToClient（)； //将信息发送回去
} catch (IOException e) {
e。printStackTrace(）；
｝
}
}
}
UDP客户端
UDP客户端首先向被动等待联系的服务器端发送一个数据报文。一个典型的UDP客户端主要执行以下三步:
（1）。创建一个DatagramSocket实例,可以选择对本地地址和端口号进行设置。
(2）。使用DatagramSocket类的 send（）和 receive（)方法来发送和接收DatagramPacket实例，进行通信。
(3)。通信完成后，使用DatagramSocket类的close（)方法来销毁该套接字。
// 客户端类 UDPClientBean。java
package UDP；
import java。io。＊；
import 。＊；
class UDPClientBean｛
private DatagramSocket dSocket;
private int ServerPort；
private int ClientPort;
private InetAddress ServerIP；
private InetAddress ClientIP；
private String content；
//无参构造函数
public UDPClientBean() throws SocketException，UnknownHostException ｛
ServerPort = 1001；
ClientPort =1111;
content = ””;
ClientIP = InetAddress。getLocalHost();
ServerIP = InetAddress.getLocalHost（）;
dSocket new DatagramSocket(ClientPort）；
}
// 信息发送函数
public void sendToServer(） throws IOException{
byte[］ Buffer = getContent()。getBytes(）； //将要发送的信息给Buffer变量
DatagramPacket dPacket = new DatagramPacket（Buffer,Buffer.length,getServerIP(),getServerPort()）;
// 创建DatagramPacket对象dPacket，并指定要发送对象的服务器的IP地址与端口号
dSocket。send（dPacket)； // dSocket对象调用send函数发送信息
setContent(""）；
}
// 信息接收函数
public String receiveFromServer（) throws IOException｛
byte［] buffer = new byte［1024];
DatagramPacket dPacket = new DatagramPacket(buffer，buffer.length);
// 创建DatagramPacket对象dPacket
dSocket.receive（dPacket)； // dSocket对象调用receive函数接收信息
String receive_str = new String(dPacket.getData（),0,dPacket.getLength（)）;
return receive_str； // 返回接收到的信息
}
// 下面都是UDPClientBean类的各个成员变量的get和set方法
public DatagramSocket getdSocket() ｛
return dSocket;
｝
public void setdSocket（DatagramSocket dSocket) ｛
this.dSocket = dSocket;
}
public int getServerPort（) ｛
return ServerPort;
}
public void setServerPort（int serverPort) ｛
ServerPort = serverPort;
｝
public String getContent(） {
return content；
｝
public void setContent(String content） {
this。content = content；
｝
public InetAddress getServerIP(） ｛
return ServerIP；
}
public void setServerIP（InetAddress serverIP) {
ServerIP = serverIP；
}
public int getClientPort(） {
return ClientPort；
｝
public void setClientPort(int clientPort） ｛
ClientPort = clientPort;
｝
public InetAddress getClientIP() ｛
return ClientIP；
｝
public void setClientIP(InetAddress clientIP) {
ClientIP = clientIP;
}
}
// 客户端代码,UDPClient.java
package UDP;
import java.awt.*；
import java。awt.event.＊；
import java.io.*;
import java。net。＊；
import javax。swing.＊；
public class UDPClient extends JApplet ｛
private String content；
private UDPClientBean client;
private JTextField jtf_ServerIP = new JTextField（10)；
private JTextField jtf_ServerPort = new JTextField(10）；
private JTextField jtf_ClientPort = new JTextField（10）；
private JButton jbt_Set new JButton("设置")；
private JTextArea jta_ClientShow = new JTextArea（);
private JTextArea jta_ClientInput = new JTextArea（)；
private JButton jbt_Send= new JButton（”发送”)；
private JButton jbt_Exit= new JButton("退出”）;
public UDPClient(）{
JPanel jplClient11 = new JPanel（）;
jplClient11。setLayout（new GridLayout（3,2))；
jplClient11。add(new JLabel(”客户端端口："));
jplClient11.add（jtf_ClientPort）;
jplClient11.add(new JLabel(”服务器地址:”）)；
jplClient11.add(jtf_ServerIP)；
jplClient11.add(new JLabel("服务器端口:"））；
jplClient11.add（jtf_ServerPort);
JPanel jplClient10= new JPanel(）；

jplClient10。add（jplClient11);
jplClient10。add（jbt_Set）；
JPanel jplClient21 = new JPanel();
jplClient21.add(jbt_Send）；
jplClient21.add(jbt_Exit);
JPanel jplClient31 = new JPanel(）;
jplClient31.setLayout(new GridLayout（2,1）)；
jplClient31.add（new JScrollPane（jta_ClientShow)）；
jplClient31.add(new JScrollPane(jta_ClientInput)）;
add（jplClient10，BorderLayout。NORTH）；
add(jplClient31,BorderLayout.CENTER);
add（jplClient21,BorderLayout.SOUTH）；
// 设置按钮触发事件
jbt_Set。addActionListener（new ActionListener()｛
public void actionPerformed(ActionEvent e） ｛
try ｛
client = new UDPClientBean（); //创建UDPClientBean对象
int cliPort = Integer.parseInt（jtf_ClientPort.getText()）；
//将客户机端口从jtf_ServerPort文本域中取出
client.setClientPort（cliPort）; //将取出的cliPort给client对象的ClientPort成员变量
String serIP = jtf_ServerIP.getText（); // 将服务器IP从jtf_ServerIP文本域中取出
int serPort = Integer。parseInt(jtf_ServerPort.getText（)）; //将服务器端口从jtf_ServerPort文本域中取出
client.setdSocket(new DatagramSocket(client。getClientPort（)，client。getClientIP(）)）; // client对象调用setdSocket(）函数，创建新Socket对象（此时客户机端口号为设定的端口号)
client.setServerIP(InetAddress.getByName(serIP））；
//将取出的serIP给client对象的ServerIP成员变量
client.setServerPort（serPort); //将取出的serPort给client对象的ServerPort成员变量
jta_ClientShow.setText(”将信息发送到IP为 "+jtf_ServerIP。getText（)+” 端口为 ”+jtf_ServerPort.getText（)+" 的服务器上。\n"）； // 将信息发送的对象的服务器的信息显示在jta_ClientShow区域中
｝ catch (SocketException e2） ｛
e2。printStackTrace()；
} catch （UnknownHostException e1) ｛
e1。printStackTrace（）;
｝catch (Exception e1） {
e1。printStackTrace（);
｝
}
｝）；
// 发送按钮触发事件
jbt_Send。addActionListener（new ActionListener(）{
public void actionPerformed(ActionEvent e） {
client。setContent(””）;
content = jta_ClientInput。getText(); //取jta_ClientInput文本区域中要发送的信息
client.setContent（content)； //将取出的信息给client对对象的content成员变量
jta_ClientShow。setText（jta_ClientShow.getText(）+"客户机发送:"+content+”\n")； // 将要发送的信息显示在jta_ClientShow区域框中
jta_ClientInput。setText(null）; //将jta_ClientInput文本区域置空
String receive_str = null；
try {
client.sendToServer（）； // client对象调用信息发送函数
｝ catch (IOException e1) ｛
jta_ClientShow.setText(jta_ClientShow.getText（）+”数据发送失败\n”);
e1.printStackTrace（);
}
try ｛
receive_str = client。receiveFromServer()； // client对象调用信息接收函数，并将结果返回给receive_str变量
jta_ClientShow。setText(jta_ClientShow.getText()+receive_str+”\n")；
// 将收到的信息显示在jta_ClientShow区域框中
} catch （IOException e1) {
jta_ClientShow.setText(jta_ClientShow。getText（）+”数据接收失败\n”）；
e1。printStackTrace()；
}
｝
｝)；
// 退出按钮触发事件
jbt_Exit。addActionListener(new ActionListener(） ｛
public void actionPerformed（ActionEvent e） ｛
client。getdSocket()。close（);
System.exit(0）；
}
}）；
｝
｝
5. 实验结果与分析
运行3。2。1中服务器端代码与3。2.2中的客户端代码，可以得到下面的结果:
(1）。 在服务器端,设置服务器的端口,启动服务器；当客户机有信息发过来的时候，服务器就可以监听到；
(2). 在客户端,设置客户端的端口号，并指定将要发送信息的服务器端的IP地址与端口号；在下面的文本框中输入要发送的信息.
6. 实验总结
在经过相应的课程如《计算机网络》《计算机网络编程》《操作系统》等课程的系统学习之后,可以说对计算机网络已经是耳目能熟了，所有的有关计算机网络的基础知识、基本理论、基本方法和结构体系,我都基本掌握了，但这些似乎只是纸上谈兵，倘若将这些理论性极强的东西搬上实际上应用，那我想我肯定会是无从下手,一窍不通.自认为已经掌握了一定的计算机网络理论知识在这里只能成为空谈。于是在坚信“实践是检验真理的唯一标准”下，认为只有把从书本上学到的理论应用于实际的网络设计操作中去,才能真正掌握这门知识。
7. 参考文献
[1]《计算机网络实验指导》。张建忠。清华大学出版社
[2］《计算机网络》。谢希仁.电子工业出版社
［3］ 杜佳荣，马建红,腾振宇.Java网络编程技术与实践[M]。北京：清华大学出版社，2008