Socket与TCP/UDP编程

原文

http://blog.csdn.NET/xn4545945/article/details/8098646

http://blog.csdn.Net/qinpeng100423/article/details/8980423

一、简介

套接字（socket）是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议，本地主机的IP地址，本地进程的协议端口，远地主机的IP地址，远地进程的协议端口。创建Socket连接时，可以指定使用的传输层协议，Socket可以支持不同的传输层协议（TCP或UDP），当使用TCP协议进行连接时，该Socket连接就是一个TCP连接。关于Socket的更多内容请参考《Socket基本原理》

二、基于TCP的socket编程

Java中用于TCP协议的socket编程的主要API有：

java.net.ServerSocket是用来创建服务器端的套接字socket。
java.net.Socket是用来创建客户端的套接字socket。
InetAddress（java.net.InetAddress）类：用来表示IP地址。

凡是基于TCP创建的套接字可以叫做流套接字。
 服务器端相当于一个监听器，用来监听端口。
 服务器与客服端之间的通讯都是输入输出流来实现的。
 
服务器端代码如下：

[java] view plain copy

 

1. import java.net.*;  
2. import java.io.*;  
3.    
4. class SocketTCPServer extends Thread//让类继承为线程类  
5. {  
6.     private Socket s;  
7.     SocketTCPServer(Socket s)  
8.     {  
9.         this.s = s;  
10.     }  
11.    
12.     public static void main(String []args)  
13.     {  
14.             server();  
15.     }  
16.    
17.     public void run()//这个就是线程方法了  
18.     {  
19.         try  
20.         {//当然当不想直接发送数据，就会去创建一个带缓冲的流  
21.             OutputStream os=s.getOutputStream();  
22.             BufferedOutputStream bos = new BufferedOutputStream(os);  
23.             //os.write("my name is xuneng!".getBytes());  
24.             bos.write("my name is xuneng!".getBytes());  
25.    
26.             InputStream is=s.getInputStream();  
27.             byte [] buf =new byte[100];//别忘了加new  
28.             int len=is.read(buf);  
29.             System.out.println(new String(buf,0,len));  
30.               
31.             bos.close();  
32.             is.close();  
33.             os.close();  
34.             s.close();  
35.         }  
36.         catch(Exception e)  
37.         {  
38.             e.printStackTrace();  
39.         }  
40.    
41.     }  
42.    
43.     public static void server()//完成之后一定要记得关闭各种流于套接字  
44.     {  
45.         try  
46.         {  
47.             ServerSocket ss = new ServerSocket(8000);//自定义的一个端口  
48.             while(true)//服务器端会老这样启动着。  
49.             {  
50.                 System.out.println("the server is starting .......");  
51.                 Socket s=ss.accept();            //一直等待着接收消息  
52.                 new SocketTCPServer(s).start();//当接受到请求的时候，就返回一个套接字，创建一个线程      
53.             }  
54.         }  
55.         catch(Exception e)  
56.         {  
57.             e.printStackTrace();  
58.         }  
59.    
60.     }  
61.    
62. }  

客户端代码如下：

[java] view plain copy

 

1. import java.net.*;  
2. import java.io.*;  
3.    
4. class SocketTCPClient  
5. {  
6.     private Socket s;  
7.     SocketTCPClient(Socket s)  
8.     {  
9.         this.s = s;  
10.     }  
11.    
12.     public static void main(String []args)  
13.     {  
14.             client();  
15.     }  
16.    
17.     public static void client()  
18.     {  
19.         try  
20.         {  
21.             Socket s = new Socket(InetAddress.getByName("localhost"),8000);//端口号要一致。  
22.    
23.             OutputStream os = s.getOutputStream();  
24.             os.write("Hello World!".getBytes());  
25.    
26.             InputStream is = s.getInputStream();  
27.             byte [] buf = new byte[100];  
28.             int len = is.read(buf);  
29.             System.out.println(new String(buf,0,len));  
30.    
31.             os.close();  
32.             is.close();  
33.             s.close();  
34.    
35.         }  
36.         catch(Exception e)  
37.         {  
38.             e.printStackTrace();  
39.         }  
40.     }  
41. }  

三、基于UDP的socket编程。

1、UDP协议定义
UDP协议的全称是用户数据报，在网络中它与TCP协议一样用于处理数据包。在OSI模型中，在第四层——传输层，处于IP协议的上一层。UDP有不提供数据报分组、组装和不能对数据包的排序的缺点，也就是说，当报文发送之后，是无法得知其是否安全完整到达的。
2、使用UDP的原因
它不属于连接型协议，因而具有资源消耗小，处理速度快的优点，所以通常音频、视频和普通数据在传送时使用UDP较多，因为它们即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。比如我们聊天用的ICQ和OICQ就是使用的UDP协议。在选择使用协议的时候，选择UDP必须要谨慎。在网络质量令人不十分满意的环境下，UDP协议数据包丢失会比较严重。

3、在Java中使用UDP协议编程的相关类
（1）. InetAddress
用于描述和包装一个Internet IP地址。有如下方法返回实例：
getLocalhost()：返回封装本地地址的实例。
getAllByName(String host)：返回封装Host地址的InetAddress实例数组。
getByName(String host)：返回一个封装Host地址的实例。其中，Host可以是域名或者是一个合法的IP地址。
InetAddress.getByAddress(addr)：根据地址串返回InetAddress实例。
InetAddress.getByAddress(host, addr)：根据主机地符串和地址串返回InetAddress实例。

（2）. DatagramSocket
用于接收和发送UDP的Socket实例。该类有3个构造函数：
DatagramSocket()：通常用于客户端编程，它并没有特定监听的端口，仅仅使用一个临时的。程序会让操作系统分配一个可用的端口。
DatagramSocket(int port)：创建实例，并固定监听Port端口的报文。通常用于服务端
DatagramSocket(int port, InetAddress localAddr)：这是个非常有用的构建器，当一台机器拥有多于一个IP地址的时候，由它创建的实例仅仅接收来自LocalAddr的报文。
DatagramSocket具有的主要方法如下：
1）receive(DatagramPacket d)：接收数据报文到d中。receive方法产生一个“阻塞”。“阻塞”是一个专业名词，它会产生一个内部循环，使程序暂停在这个地方，直到一个条件触发。
2）send(DatagramPacket dp)：发送报文dp到目的地。
3）setSoTimeout(int timeout)：设置超时时间，单位为毫秒。
4）close()：关闭DatagramSocket。在应用程序退出的时候，通常会主动释放资源，关闭Socket，但是由于异常地退出可能造成资源无法回收。所以，应该在程序完成时，主动使用此方法关闭Socket，或在捕获到异常抛出后关闭Socket。
（3）. DatagramPacket
用于处理报文，它将Byte数组、目标地址、目标端口等数据包装成报文或者将报文拆卸成Byte数组。应用程序在产生数据包是应该注意，TCP/IP规定数据报文大小最多包含65507个，通常主机接收548个字节，但大多数平台能够支持8192字节大小的报文。DatagramPacket类的构建器共有4个：
DatagramPacket(byte[] buf, int length)：将数据包中Length长的数据装进Buf数组，一般用来接收客户端发送的数据。
DatagramPacket(byte[] buf, int offset, int length)：将数据包中从Offset开始、Length长的数据装进Buf数组。
DatagramPacket(byte[] buf, int length, InetAddress clientAddress, int clientPort)：从Buf数组中，取出Length长的数据创建数据包对象，目标是clientAddress地址，clientPort端口,通常用来发送数据给客户端。
DatagramPacket(byte[] buf, int offset, int length, InetAddress clientAddress, int clientPort)：从Buf数组中，取出Offset开始的、Length长的数据创建数据包对象，目标是clientAddress地址，clientPort端口，通常用来发送数据给客户端。
主要的方法如下：
1）getData(): 从实例中取得报文的Byte数组编码。
2）setDate(byte[] buf)：将byte数组放入要发送的报文中。


发送端代码如下：

[java] view plain copy

 

1. import java.net.*;  
2. import java.io.*;  
3. /* 
4. *发送端, 相当于客户端。 
5. */  
6. class SocketUDPSend  
7. {  
8.     public static void main(String[]args)  
9.     {  
10.             sed();  
11.     }  
12.    
13.     public static void sed()  
14.     {  
15.         try  
16.         {  
17.             DatagramSocket ds = new DatagramSocket();  
18.             String str = "haha, my name is xuneng!";  
19.             DatagramPacket dp = new DatagramPacket(str.getBytes(),0,str.length(),  
20.                                                 InetAddress.getByName("localhost"),8600);//发送给本机的地址，端口为8600  
21.                     ds.send(dp);  
22.    
23.             //演示接受返回回来的数据。  
24.             byte[] buf = new byte[100];  
25.             DatagramPacket dp2 = new DatagramPacket(buf,100);//字节数组，长度  
26.             ds.receive(dp2);  
27.             System.out.println(new String(buf,0,dp2.getLength()));  
28.             ds.close();  
29.         }  
30.         catch(Exception e)  
31.         {  
32.             e.printStackTrace();  
33.         }  
34.     }  
35.    
36. }  

接收代码如下：

[java] view plain copy

 

1. import java.net.*;    
2. import java.io.*;    
3. /*  
4. *接受端，也就是服务器端。一直在监听端口。  
5. */    
6. class SocketUDPRecv     
7. {    
8.     public static void main(String[]args)    
9.     {    
10.             recv();    
11.     }    
12.      
13.     public static void recv()        
14.     {    
15.         try    
16.         {    
17.             DatagramSocket ds = new DatagramSocket(8600);    
18.             byte [] buf = new byte[100];    
19.             DatagramPacket dp = new DatagramPacket(buf,100);    
20.             ds.receive(dp);     
21.             System.out.println(new String(buf,0,dp.getLength()));    
22.      
23.         //演示给发送端返回数据,需要发送端去接受    
24.             String str = "Yes , I received!";    
25.             DatagramPacket dp1 = new DatagramPacket(str.getBytes(),str.length(),    
26.                                               dp.getAddress(),dp.getPort());    
27.             ds.send(dp1);    
28.      
29.             ds.close();         
30.         }    
31.         catch(Exception e)    
32.         {    
33.             e.printStackTrace();    
34.         }    
35.     }    
36. }   

结束