Java Socket编程

Socket：

两个Java应用程序可通过一个双向的网络通信连续实现数据交换，这个双向链路的一端称为一个Socket。

 

Socket通常用来实现client-server连接。

 

Java.NET包中定义的两个类socket和ServerSocket，分别用来实现双向连接的client和server端（像qq那样，互相通信）。

 

建立连接时所需要的寻址信息为远程计算机的IP地址和端口号（port number）。

 

TCPSocket模型：

 

 

过程：

一个Server端多个Client端：

一端和另一段说话一端说一端听：

server端：

[java] view plain copy
 
 print?
  1. import java.net.*;  
  2.   
  3. //一端和另外一端说话，一端说一端听。  
  4.   
  5. /* 1 java Socket编程步骤。 
  6.  
  7.  * 2 Socket/ServerSocker类用法。 
  8.  
  9.  * 3 通过Socket对象可以获取通信对方Socket的信息。 
  10.  
  11.  * 
  12.  
  13.  */  
  14.   
  15. import java.io.*;  
  16.   
  17. public class  TestServer   
  18.   
  19. {  
  20.   
  21.    
  22.   
  23.         public static void main(String[] args)   
  24.   
  25.        {  
  26.   
  27.            try  
  28.   
  29.             {  
  30.   
  31.                //在服务器端建立自己的一个插座口。  
  32.   
  33.                  ServerSocket s = new ServerSocket(8888);  
  34.   
  35.               while(true)  
  36.   
  37.              {  
  38.   
  39.                     //接受来自客户端的请求。  
  40.   
  41.                        Socket s1 = s.accept();  
  42.   
  43.                     //写入到Client的管道（流）  
  44.   
  45.                        OutputStream os = s1.getOutputStream();  
  46.   
  47.                    //在管道上加上一层保障。也就是形成双层管道。  
  48.   
  49.                       DataOutputStream dos = new DataOutputStream(os);  
  50.   
  51.                  //和客户端通话，写入到客户端。  
  52.   
  53.                     //字符串hello ip地址，端口号。  
  54.   
  55.                     //客户端这样可以从服务器端读出了。  
  56.   
  57.                       dos.writeUTF("Hello" + s1.getInetAddress() + "port#" + s1.getPort()+ " bye-bye!");  
  58.       
  59.    
  60.   
  61.                    dos.close();  
  62.   
  63.                    s1.close();  
  64.   
  65.    
  66.   
  67.                }  
  68.   
  69.          }  
  70.   
  71.    
  72.   
  73.           catch(IOException e)  
  74.   
  75.           {  
  76.     
  77.               e.printStackTrace();  
  78.   
  79.               System.out.println("程序运行出错：" + e);  
  80.   
  81.            }  
  82.   
  83.       }    
  84.   
  85. }  
  86.   
  87.    
  88.   
  89. getInetAddress()得到ip地址的超集，包含ip地址也可以包括其他的地址。  
  90.   
  91. .getPort() 得到端口号。  
  92.   
  93. server端写入到client端。  


 

Client端：

Client端从server端读取：

 

[java] view plain copy
 
 print?
  1. import java.net.*;  
  2.   
  3. import java.io.*;  
  4.   
  5.    
  6.   
  7. /*1 java Socket编程。 
  8.  
  9.  *2 Socket/ServerSocket类用法。 
  10.  
  11.  *3 通过Socket对象可以获取通信对方Socket信息。 
  12.  
  13.  */  
  14.   
  15. public class  TCPClient   
  16.   
  17. {  
  18.   
  19.    
  20.   
  21. public static void main(String[] args)   
  22.   
  23. {  
  24.   
  25. try  
  26.   
  27. {  
  28.   
  29.          //建立客户端的那个“插座接口”，并且通过构造方法和服务器端的那个接口相连接。  
  30.   
  31.            Socket s1 = new Socket("127.0.0.1",8888);  
  32.   
  33.         //读来自服务器端的数据流。  
  34.   
  35.            InputStream is = s1.getInputStream();  
  36.   
  37.        //DataInputStream 需要套接在InputStream上。  
  38.   
  39.          DataInputSteam dis = new DataInputStream(is);  
  40.   
  41.       //进行读出来自服务器端的数据流。通过UTF编码读出。  
  42.   
  43.         System.out.println(dis.readUTF());  
  44.   
  45.       //关闭管道。  
  46.   
  47.        dis.close();  
  48.   
  49.       //关闭socket接口通信。  
  50.   
  51.    
  52.   
  53.       s1.close();  
  54.   
  55.    
  56.   
  57.       }catch(ConnectException connExc)//捕捉到不同的异常进行不同的处理。  
  58.   
  59.        {  
  60.   
  61.           connExc.printStackTrace();  
  62.   
  63.         System.err.println("服务器链接失败！");  
  64.   
  65.    
  66.   
  67.         }catch(IOException e)  
  68.   
  69.      {  
  70.   
  71.              e.printStackTrace():  
  72.   
  73.       }  
  74.   
  75.   }  
  76.   
  77.    
  78.   
  79. }  
  80.   
  81.    

 

结果如下：

 

 

 

接通后两端都说都听：

server端：

[java] view plain copy
 
 print?
  1. import java.net.*;  
  2.   
  3. //两端都说两端都听，但是要有顺序，这和当时的传呼机感觉类似。  
  4.   
  5. /* 1 java Socket编程步骤。 
  6.  
  7.  * 2 Socket/ServerSocker类用法。 
  8.  
  9.  * 3 通过Socket对象可以获取通信对方Socket的信息。 
  10.  
  11.  * 
  12.  
  13.  */  
  14.   
  15. import java.io.*;  
  16.   
  17.    
  18.   
  19. public class  TestSocketServer   
  20.   
  21. {  
  22.   
  23.    
  24.   
  25.           public static void main(String[] args)   
  26.   
  27.            {  
  28.   
  29.                 InputStream in = null;  
  30.   
  31.                 OutputStream out = null;  
  32.   
  33.                 try  
  34.   
  35.                 {  
  36.   
  37.                     //在服务器端建立自己的一个插座口。  
  38.   
  39.                         ServerSocket ss = new ServerSocket(5888);  
  40.   
  41.    
  42.   
  43.                    //接受来自客户端的请求。  
  44.   
  45.                      Socket socket = ss.accept();  
  46.   
  47.                  //得到来自客户端写入的数据。  
  48.   
  49.                      in = socket.getInputStream();  
  50.   
  51.                 //服务器端输出流对象。  
  52.   
  53.                     out = socket.getOutputStream();  
  54.   
  55.                //捆绑在两个管子上的传输管。  
  56.   
  57.                     DataOutputStream dos = new DataOutputStream(out);  
  58.   
  59.                  DataInputStream dis = new DataInputStream(in);  
  60.   
  61.    
  62.   
  63.               //定义从客户端读出的字符串。  
  64.   
  65.                  String s = null  
  66.   
  67.             //如果读出的不为空的话。向客户单发出本机的ip地址和连接的端口号。  
  68.   
  69.               if((s=dis.readUTF())!=null)  
  70.   
  71.              {  
  72.   
  73.                  System.out.println(s);  
  74.   
  75.                  System.out.println("from:" +socket.getInetAddress());  
  76.   
  77.                  System.out.println("port: " + socket.getPort());  
  78.   
  79.              }  
  80.   
  81.               //向客户端写入。  
  82.   
  83.                   dos.writeUTF("hi,hello");  
  84.   
  85.              //关闭流对象。  
  86.   
  87.                 dis.close();  
  88.   
  89.              dos.close();  
  90.   
  91.    
  92.   
  93.             socket.close();  
  94.   
  95.    
  96.   
  97.    
  98.   
  99.         }  
  100.   
  101.    
  102.   
  103.              catch(IOException e)  
  104.   
  105.              {  
  106.   
  107.                  e.printStackTrace();  
  108.   
  109.                   System.out.println("程序运行出错：" + e);  
  110.   
  111.               }  
  112.   
  113.       }  
  114.   
  115.    
  116.   
  117. }  


 

 Client端：

[java] view plain copy
 
 print?
  1. import java.net.*;  
  2.   
  3. import java.io.*;  
  4.   
  5.    
  6.   
  7. /*1 java Socket编程。 
  8.  
  9.  *2 Socket/ServerSocket类用法。 
  10.  
  11.  *3 通过Socket对象可以获取通信对方Socket信息。 
  12.  
  13.  */  
  14.   
  15. public class  TestSocketClient   
  16.   
  17. {  
  18.   
  19.    
  20.   
  21.           public static void main(String[] args)   
  22.   
  23.           {  
  24.   
  25.                  InputStream is = null;  
  26.   
  27.                  OutputStream os = null;  
  28.   
  29.                  try  
  30.   
  31.                  {  
  32.   
  33.                     //建立客户端的那个“插座接口”，并且通过构造方法和服务器端的那个接口相连接。  
  34.   
  35.                         Socket socket = new Socket("localhost",5888);  
  36.   
  37.                      is = socket.getInputStream();  
  38.   
  39.                      os = socket.getOutputStream();  
  40.   
  41.                      DataInputStream dis = new DataInputStream(is);  
  42.   
  43.                      DataOutputStream dos = new DataOutputStream(os);  
  44.   
  45.    
  46.   
  47.                  //写入.  
  48.   
  49.                  dos.writeUTF("hey");  
  50.   
  51.                  String s = null;  
  52.   
  53.                  if((s=dis.readUTF())!=null)  
  54.   
  55.                  {  
  56.   
  57.                           System.out.println(s);  
  58.   
  59.    
  60.   
  61.                  }  
  62.   
  63.                     dos.close();  
  64.   
  65.                     dis.close();  
  66.   
  67.                     socket.close();  
  68.   
  69.    
  70.   
  71.    
  72.   
  73.              }catch(UnknownHostException e)//捕捉到不同的异常进行不同的处理。  
  74.   
  75.                {  
  76.   
  77.                            e.printStackTrace();  
  78.   
  79.    
  80.   
  81.              }catch(IOException e)  
  82.   
  83.             {  
  84.   
  85.                      e.printStackTrace();  
  86.   
  87.               }  
  88.   
  89.         }  
  90.   
  91.    
  92.   
  93. }  


 

 

点对点的通信：

就像qq那样同时可以说同时可以听，可以一边说一边听，像打电话一样。

就不在这里列出了。

posted @ 2016-11-23 21:15  天涯海角路  阅读(213)  评论(0)    收藏  举报