Java---Socket编程UDP/TCP

socket方便了应用程序访问通讯协议TCP/IP 。

• socket是作为通讯链入的端点。我们可以吧 套接字看成是 电话机，有了套接字，才有了 通讯的工具。我们可以吧 IP地址看成是 电话号码， 端口号看成是 分机号。

 

1、基于TCP的socket编程。

•  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. }  

2、基于UDP的socket编程。 

创建流程如下：

•   java.net. DatagramSocket（数据电报套接字）。

•   java.net. DatagramPacket（数据电报包，里面包含了发送的信息）。

•  基于UDP的套接字就是 数据报套接字。

•  两个都要先构造好相应的数据包。

•   在DatagramPacket包中的函数  int getLength() 返回 实际接受的字节数 ，  byte[] getData() 返回 接受到的数据 。

•   要想 接受端 给发送端 回信息 ，就需要 知道发送端 的 ＩＰ地址 InetAddress getAddress() 和 发送端 进程所绑定的 端口号 int getPort() 。

•   数据报套接字发送成功之后，就相当于建立了一个虚连接，双方可以发送数据。

 

发送端代码如下：

[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. }  

转载: http://blog.csdn.net/xn4545945/article/details/8098646