datagramsocket

1.Java数据报Datagram通讯 
2.2006-07-14 16:56 
3.8.3.10数据报Datagram通讯 
4. 
5.　　前面在介绍TCP/IP协议的时候，我们已经提到，在TCP/IP协议的传输层除了TCP协议之外还有一个UDP协议，相比而言UDP的应用不如TCP广泛，几个标准的应用层协议HTTP，FTP，SMTP…使用的都是TCP协议。但是，随着计算机网络的发展，UDP协议正越来越来显示出其威力，尤其是在需要很强的实时交互性的场合，如网络游戏，视频会议等，UDP更是显示出极强的威力，下面我们就介绍一下Java环境下如何实现UDP网络传输。 
6. 
7.8.3.11 什么是Datagram 
8. 
9.　　所谓数据报（Datagram）就跟日常生活中的邮件系统一样，是不能保证可靠的寄到的，而面向链接的TCP就好比电话，双方能肯定对方接受到了信息。在本章前面，我们已经对UDP和TCP进行了比较，在这里再稍作小节： 
10. 
11.　　TCP，可靠，传输大小无限制，但是需要连接建立时间，差错控制开销大。 
12.　　UDP，不可靠，差错控制开销较小，传输大小限制在64K以下，不需要建立连接。 
13. 
14.　　总之，这两种协议各有特点，应用的场合也不同，是完全互补的两个协议，在TCP/IP协议中占有同样重要的地位，要学好网络编程，两者缺一不可。 
15. 
16.8.3.12 Datagram通讯的表示方法：DatagramSocket；DatagramPacket 
17. 
18.　　包java.net中提供了两个类DatagramSocket和DatagramPacket用来支持数据报通信，DatagramSocket用于在程序之间建立传送数据报的通信连接， DatagramPacket则用来表示一个数据报。先来看一下DatagramSocket的构造方法： 
19.　　　DatagramSocket（）； 
20.　　　DatagramSocket（int prot）; 
21.　　　DatagramSocket(int port, InetAddress laddr) 
22.　　 
23.　　其中，port指明socket所使用的端口号，如果未指明端口号，则把socket连接到本地主机上一个可用的端口。laddr指明一个可用的本地地址。给出端口号时要保证不发生端口冲突，否则会生成SocketException类例外。注意：上述的两个构造方法都声明抛弃非运行时例外SocketException，程序中必须进行处理，或者捕获、或者声明抛弃。 
24. 
25.用数据报方式编写client/server程序时，无论在客户方还是服务方，首先都要建立一个DatagramSocket对象，用来接收或发送数据报，然后使用DatagramPacket类对象作为传输数据的载体。下面看一下DatagramPacket的构造方法 ： 
26.　　　DatagramPacket（byte buf[],int length）； 
27.　　　DatagramPacket(byte buf[], int length, InetAddress addr, int port); 
28.　　　DatagramPacket(byte[] buf, int offset, int length)； 
29.　　　DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)； 
30. 
31.　　其中，buf中存放数据报数据，length为数据报中数据的长度，addr和port旨明目的地址，offset指明了数据报的位移量。 
32. 
33.　　在接收数据前，应该采用上面的第一种方法生成一个DatagramPacket对象，给出接收数据的缓冲区及其长度。然后调用DatagramSocket 的方法receive()等待数据报的到来，receive()将一直等待，直到收到一个数据报为止。 
34.　　DatagramPacket packet=new DatagramPacket(buf, 256); 
35.　　Socket.receive (packet); 
36. 
37.　　发送数据前，也要先生成一个新的DatagramPacket对象，这时要使用上面的第二种构造方法，在给出存放发送数据的缓冲区的同时，还要给出完整的目的地址，包括IP地址和端口号。发送数据是通过DatagramSocket的方法send()实现的，send()根据数据报的目的地址来寻径，以传递数据报。 
38.　　DatagramPacket packet=new DatagramPacket(buf, length, address, port); 
39.　　Socket.send(packet)； 
40. 
41.在构造数据报时，要给出InetAddress类参数。类InetAddress在包java.net中定义，用来表示一个Internet地址，我们可以通过它提供的类方法getByName（）从一个表示主机名的字符串获取该主机的IP地址，然后再获取相应的地址信息。 
42. 
43.8.3.13 基于UDP的简单的Client/Server程序设计 
44. 
45.　　有了上面的知识，我们就可以来构件一个基于UDP的C/S 网络传输模型 
46. 
47.　1. 客户方程序 QuoteClient.java 
48. 
49.　　import java.io.*; 
50.　　import java.net.*; 
51.　　import java.util.*; 
52.　　public class QuoteClient { 
53.　　　public static void main(String[] args) throws IOException  
54.　　　{ 
55.　　　　if(args.length!=1) {  
56.　　　　//如果启动的时候没有给出Server的名字，那么出错退出 
57.　　　　　System.out.println("Usage:java QuoteClient <hostname>");  
58.　　　　　//打印出错信息 
59.　　　　　return; //返回 
60.　　　　} 
61. 
62.　　　　DatagramSocket socket=new DatagramSocklet();  
63.　　　　//创建数据报套接字 
64. 
65.　　　　Byte[] buf=new byte[256]; //创建缓冲区 
66.　　　　InetAddress address=InetAddress.getByName(args [0]);  
67.//由命令行给出的第一个参数默认为Server的名字，通过它得到Server的IP信息 
68.　　　　DatagramPacket packet=new DatagramPacket (buf, buf.length, address, 4445); 
69.　　　　//创建DatagramPacket对象 
70.　　　　socket.send(packet); //发送 
71.　　　　packet=new DatagramPacket(buf,buf.length);  
72.　　　　//创建新的DatagramPacket对象，用来接收数据报 
73.　　　　socket.receive(packet); //接收 
74.　　　　String received=new String(packet.getData());  
75.　　　　//根据接收到的字节数组生成相应的字符串 
76.　　　　System.out.println("Quote of the Moment:"+received );  
77.　　　　//打印生成的字符串 
78. 
79.　　　　socket.close(); //关闭套接口 
80.　　　} 
81.　} 
82. 
83.　2. 服务器方程序:QuoteServer.java 
84. 
85.　　public class QuoteServer{ 
86.　　　public static void main(String args[]) throws java.io.IOException  
87.　　　{ 
88.　　　　new QuoteServerThread().start();  
89.　　　　//启动一个QuoteServerThread线程 
90.　　　} 
91.　　} 
92. 
93.　3. 程序QuoteServerThread.java 
94. 
95.　　import java.io.*; 
96.　　import java.net.*; 
97.　　import java.util.*; 
98.　　//服务器线程 
99.　　public class QuoteServerThread extends Thread 
100.　　{ 
101.　　protected DatagramSocket socket=null;  
102.　　//记录和本对象相关联的DatagramSocket对象 
103.　　protected BufferedReader in=null;  
104.　　//用来读文件的一个Reader 
105.　　protected boolean moreQuotes=true;  
106.　　//标志变量，是否继续操作 
107. 
108.　　public QuoteServerThread() throws IOException {  
109.　　//无参数的构造函数 
110.　　　　this("QuoteServerThread");  
111.　　　　//以QuoteServerThread为默认值调用带参数的构造函数 
112.　　} 
113.　　public QuoteServerThread(String name) throws IOException { 
114.　　　　super(name); //调用父类的构造函数 
115.　　　　socket=new DatagramSocket(4445);  
116.　　　　//在端口4445创建数据报套接字 
117.　　　　try{ 
118.　　　　　　in= new BufferedReader(new FileReader(" one-liners.txt")); 
119.　　　　　　//打开一个文件，构造相应的BufferReader对象 
120.　　　　}catch(FileNotFoundException e) { //异常处理 
121.　　　　　　System.err.println("Could not open quote file. Serving time instead.");  
122.　　　　　　　//打印出错信息 
123.　　　　} 
124.　　} 
125.　　public void run() //线程主体 
126.　　{ 
127.　　　　while(moreQuotes) { 
128.　　　　　try{ 
129.　　　　　　　byte[] buf=new byte[256]; //创建缓冲区 
130.　　　　　　　DatagramPacket packet=new DatagramPacket(buf,buf.length); 
131.　　　　　　　//由缓冲区构造DatagramPacket对象 
132.　　　　　　　socket.receive(packet); //接收数据报 
133.　　　　　　　String dString=null; 
134.　　　　　　　if(in= =null) dString=new Date().toString();  
135.　　　　　　　//如果初始化的时候打开文件失败了， 
136.　　　　　　　//则使用日期作为要传送的字符串 
137.　　　　　　　else dString=getNextQuote();  
138.　　　　　　　//否则调用成员函数从文件中读出字符串 
139.　　　　　　　buf=dString.getByte();  
140.　　　　　　　//把String转换成字节数组，以便传送 
141. 
142.　　　　　　　InetAddress address=packet.getAddress();  
143.　　　　　　　//从Client端传来的Packet中得到Client地址 
144.　　　　　　　int port=packet.getPort(); //和端口号 
145.　　　　　　　packet=new DatagramPacket(buf,buf.length,address,port);  
146.　　　　　　　//根据客户端信息构建DatagramPacket 
147.　　　　　　　socket.send(packet); //发送数据报 
148.　　　　　　}catch(IOException e) { //异常处理 
149.　　　　　　　e.printStackTrace(); //打印错误栈 
150.　　　　　　　moreQuotes=false; //标志变量置false，以结束循环 
151.　　　　　　} 
152.　　　　} 
153.　　　　socket.close(); //关闭数据报套接字 
154.　　} 
155. 
156.　　protected String getNextQuotes(){  
157.　　//成员函数，从文件中读数据 
158.　　　　String returnValue=null; 
159.　　　　try { 
160.　　　　　　　if((returnValue=in.readLine())= =null) {  
161.　　　　　　　//从文件中读一行，如果读到了文件尾 
162.　　　　　　　in.close( ); //关闭输入流 
163.　　　　　　　moreQuotes=false;  
164.　　　　　　　//标志变量置false，以结束循环 
165.　　　　　　　returnValue="No more quotes. Goodbye.";  
166.　　　　　　　//置返回值 
167.　　　　　　　} //否则返回字符串即为从文件读出的字符串 
168.　　　　}catch(IOEception e) { //异常处理 
169.　　　　　　　returnValue="IOException occurred in server";  
170.　　　　　　　//置异常返回值 
171.　　　　} 
172.　　　　return returnValue; //返回字符串 
173.　　} 
174.} 
175. 
176.　　可以看出使用UDP和使用TCP在程序上还是有很大的区别的。一个比较明显的区别是，UDP的Socket编程是不提供监听功能的，也就是说通信双方更为平等，面对的接口是完全一样的。但是为了用UDP实现C/S结构，在使用UDP时可以使用DatagramSocket.receive()来实现类似于监听的功能。因为receive()是阻塞的函数，当它返回时，缓冲区里已经填满了接受到的一个数据报，并且可以从该数据报得到发送方的各种信息，这一点跟accept()是很相象的，因而可以根据读入的数据报来决定下一步的动作，这就达到了跟网络监听相似的效果。 
177. 
178.  
179. 
180.8.3.14 用数据报进行广播通讯 
181. 
182.　　DatagramSocket只允许数据报发送一个目的地址，java.net包中提供了一个类MulticastSocket，允许数据报以广播方式发送到该端口的所有客户。MulticastSocket用在客户端，监听服务器广播来的数据。 
183. 
184.　　我们对上面的程序作一些修改，利用MulticastSocket实现广播通信。新程序完成的功能是使同时运行的多个客户程序能够接收到服务器发送来的相同的信息，显示在各自的屏幕上。 
185. 
186.　1. 客户方程序:MulticastClient.java 
187. 
188.　　import java.io.*; 
189.　　import java.net.*; 
190.　　import java.util.*; 
191.　　public class MulticastClient { 
192.　　　　public static void main(String args[]) throws IOException 
193.　　　　{ 
194.　　　　　MulticastSocket socket=new MulticastSocket(4446);  
195.　　　　　//创建4446端口的广播套接字 
196.　　　　　InetAddress address=InetAddress.getByName("230.0.0.1");  
197.　　　　　//得到230.0.0.1的地址信息 
198.　　　　　socket.joinGroup(address);  
199.　　　　　//使用joinGroup()将广播套接字绑定到地址上 
200.　　　　　DatagramPacket packet; 
201. 
202.　　　　　for(int i=0;i<5;i++) { 
203.　　　　　　　byte[] buf=new byte[256];  
204.　　　　　　　//创建缓冲区 
205.　　　　　　　packet=new DatagramPacket(buf,buf.length);  
206.　　　　　　　//创建接收数据报 
207.　　　　　　　socket.receive(packet); //接收 
208.　　　　　　　String received=new String(packet.getData());  
209.　　　　　　　//由接收到的数据报得到字节数组， 
210.　　　　　　　//并由此构造一个String对象 
211.　　　　　　　System.out.println("Quote of theMoment:"+received);  
212.　　　　　　　//打印得到的字符串 
213.　　　　　} //循环5次 
214.　　　　　socket.leaveGroup(address);  
215.　　　　　//把广播套接字从地址上解除绑定 
216.　　　　　socket.close(); //关闭广播套接字 
217.　　　} 
218.　} 
219. 
220.　2. 服务器方程序:MulticastServer.java 
221. 
222.　　public class MulticastServer{ 
223.　　　　public static void main(String args[]) throws java.io.IOException  
224.　　　　{ 
225.　　　　　　new MulticastServerThread().start();  
226.　　　　　　//启动一个服务器线程 
227.　　　　} 
228.　　} 
229. 
230.　3. 程序MulticastServerThread.java 
231. 
232.　　import java.io.*; 
233.　　import java.net.*; 
234.　　import java.util.*; 
235.　　public class MulticastServerThread extends QuoteServerThread  
236.　　//从QuoteServerThread继承得到新的服务器线程类MulticastServerThread 
237.　　{ 
238.　　　　Private long FIVE_SECOND=5000; //定义常量，5秒钟 
239.　　　　public MulticastServerThread(String name) throws IOException  
240.　　　　{ 
241.　　　　　　super("MulticastServerThread");  
242.　　　　　　//调用父类，也就是QuoteServerThread的构造函数 
243.　　　　} 
244. 
245.　　　　public void run() //重写父类的线程主体 
246.　　　　{ 
247.　　　　　while(moreQuotes) {  
248.　　　　　//根据标志变量判断是否继续循环 
249.　　　　　　try{ 
250.　　　　　　　　byte[] buf=new byte[256];  
251.　　　　　　　　//创建缓冲区 
252.　　　　　　　　String dString=null; 
253.　　　　　　　　if(in==null) dString=new Date().toString();  
254.　　　　　　　　//如果初始化的时候打开文件失败了， 
255.　　　　　　　　//则使用日期作为要传送的字符串 
256.　　　　　　　　else dString=getNextQuote();  
257.　　　　　　　　//否则调用成员函数从文件中读出字符串 
258.　　　　　　　　buf=dString.getByte();  
259.　　　　　　　　//把String转换成字节数组，以便传送send it 
260.　　　　　　　　InetAddress group=InetAddress.getByName("230.0.0.1");  
261.　　　　　　　　//得到230.0.0.1的地址信息 
262.　　　　　　　　DatagramPacket packet=new DatagramPacket(buf,buf.length,group,4446); 
263.　　　　　　　　//根据缓冲区，广播地址，和端口号创建DatagramPacket对象 
264.　　　　　　　　socket.send(packet); //发送该Packet 
265.　　　　　　　　try{ 
266.　　　　　　　　　　sleep((long)(Math.random()*FIVE_SECONDS));  
267.　　　　　　　　　　//随机等待一段时间，0～5秒之间 
268.　　　　　　　　}catch(InterruptedException e) { } //异常处理 
269.　　　　　　}catch(IOException e){ //异常处理 
270.　　　　　　　　e.printStackTrace( ); //打印错误栈 
271. 
272.　　　　　　　　moreQuotes=false; //置结束循环标志 
273.　　　　　　} 
274.　　　　} 
275.　　　　socket.close( ); //关闭广播套接口 
276.　　　} 
277.　} 
278. 
279.　　至此，Java网络编程这一章已经讲解完毕。读者通过学习，应该对网络编程有了一个清晰的认识，可能对某些概念还不是十分的清楚，还是需要更多的实践来进一步掌握。编程语言的学习不同于一般的学习，及其强调实践的重要性。读者应该对URL网络编程，Socket中的TCP，UDP编程进行大量的练习才能更好的掌握本章中所提到的一些概念，才能真正学到Java网络编程的精髓！ 
280. 
281.　　最后几个小节所举的例子，读者务必要亲自试验一下，如果遇到问题，想办法解决之。最好能根据自己的意图加以改进。这样才能更好的理解这几个程序，理解其中所包含的编程思想。 
282. 
283.本讲小结】 
284. 
285.　　本讲主要讲解了Java环境下的网络编程。因为TCP/IP协议是Java网络编程的基础知识，本讲开篇重点介绍了TCP/IP协议中的一些概念，TCP/IP协议本身是一个十分庞大的系统，用几个小节是不可能讲清楚的。所以我们只是联系实际，讲解了一些最基本的概念，帮助学生理解后面的相关内容。重点有一下几个概念：主机名，IP，端口，服务类型，TCP，UDP。 
286. 
287.　　后续的内容分为两大块，一块是以URL为主线，讲解如何通过URL类和URLConnection类访问WWW网络资源，由于使用URL十分方便直观，尽管功能不是很强，还是值得推荐的一种网络编程方法，尤其是对于初学者特别容易接受。本质上讲，URL网络编程在传输层使用的还是TCP协议。 
288. 
289.　　另一块是以Socket接口和C/S网络编程模型为主线，依次讲解了如何用Java实现基于TCP的C/S结构，主要用到的类有Socket，ServerSocket。以及如何用Java实现基于UDP的C/S结构，还讨论了一种特殊的传输方式，广播方式，这种方式是UDP所特有的，主要用到的类有DatagramSocket , DatagramPacket, MulticastSocket。这一块在Java网络编程中相对而言是最难的（尽管Java在网络编程这方面已经做的够"傻瓜"了，但是网络编程在其他环境下的却是一件极为头痛的事情，再"傻瓜"还是有一定的难度），也是功能最为强大的一部分,读者应该好好研究，领悟其中的思想。 
290. 
291.　　最后要强调的是要学好Java网络编程，Java语言，最重要的还是在于多多练习！