Java socket 编程

转载出处：http://blog.csdn.net/ns_code/article/details/14105457

TCP的Java支持

     协议相当于相互通信的程序间达成的一种约定，它规定了分组报文的结构、交换方式、包含的意义以及怎样对报文所包含的信息进行解析，TCP/IP协议族有IP协议、TCP协议和UDP协议。现在TCP/IP协议族中的主要socket类型为流套接字（使用TCP协议）和数据报套接字（使用UDP协议）。

    TCP协议提供面向连接的服务，通过它建立的是可靠地连接。Java为TCP协议提供了两个类：Socket类和ServerSocket类。一个Socket实例代表了TCP连接的一个客户端，而一个ServerSocket实例代表了TCP连接的一个服务器端，一般在TCP Socket编程中，客户端有多个，而服务器端只有一个，客户端TCP向服务器端TCP发送连接请求，服务器端的ServerSocket实例则监听来自客户端的TCP连接请求，并为每个请求创建新的Socket实例，由于服务端在调用accept（）等待客户端的连接请求时会阻塞，直到收到客户端发送的连接请求才会继续往下执行代码，因此要为每个Socket连接开启一个线程。服务器端要同时处理ServerSocket实例和Socket实例，而客户端只需要使用Socket实例。另外，每个Socket实例会关联一个InputStream和OutputStream对象，我们通过将字节写入套接字的OutputStream来发送数据，并通过从InputStream来接收数据。

TCP连接的建立步骤

  客户端向服务器端发送连接请求后，就被动地等待服务器的响应。典型的TCP客户端要经过下面三步操作：  

   1、创建一个Socket实例：构造函数向指定的远程主机和端口建立一个TCP连接；

   2.通过套接字的I/O流与服务端通信；

   3、使用Socket类的close方法关闭连接。

  服务端的工作是建立一个通信终端，并被动地等待客户端的连接。典型的TCP服务端执行如下两步操作：

     1、创建一个ServerSocket实例并指定本地端口，用来监听客户端在该端口发送的TCP连接请求；

     2、重复执行：

           1）调用ServerSocket的accept（）方法以获取客户端连接，并通过其返回值创建一个Socket实例；

           2）为返回的Socket实例开启新的线程，并使用返回的Socket实例的I/O流与客户端通信；

           3）通信完成后，使用Socket类的close（）方法关闭该客户端的套接字连接。

TCP Socket Demo

     下面给出一个客户端服务端TCP通信的Demo，该客户端在20006端口请求与服务端建立TCP连接，客户端不断接收键盘输入，并将其发送到服务端，服务端在接收到的数据前面加上“echo”字符串，并将组合后的字符串发回给客户端，如此循环，直到客户端接收到键盘输入“bye”为止。

     客户端代码如下：  

[java]  view plain copy

1. package zyb.org.client;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStreamReader;  
6. import java.io.PrintStream;  
7. import java.net.Socket;  
8. import java.net.SocketTimeoutException;  
9.   
10. public class Client1 {  
11.     public static void main(String[] args) throws IOException {  
12.         //客户端请求与本机在20006端口建立TCP连接   
13.         Socket client = new Socket("127.0.0.1", 20006);  
14.         client.setSoTimeout(10000);  
15.         //获取键盘输入   
16.         BufferedReader input = new BufferedReader(new InputStreamReader(System.in));  
17.         //获取Socket的输出流，用来发送数据到服务端    
18.         PrintStream out = new PrintStream(client.getOutputStream());  
19.         //获取Socket的输入流，用来接收从服务端发送过来的数据    
20.         BufferedReader buf =  new BufferedReader(new InputStreamReader(client.getInputStream()));  
21.         boolean flag = true;  
22.         while(flag){  
23.             System.out.print("输入信息：");  
24.             String str = input.readLine();  
25.             //发送数据到服务端    
26.             out.println(str);  
27.             if("bye".equals(str)){  
28.                 flag = false;  
29.             }else{  
30.                 try{  
31.                     //从服务器端接收数据有个时间限制（系统自设，也可以自己设置），超过了这个时间，便会抛出该异常  
32.                     String echo = buf.readLine();  
33.                     System.out.println(echo);  
34.                 }catch(SocketTimeoutException e){  
35.                     System.out.println("Time out, No response");  
36.                 }  
37.             }  
38.         }  
39.         input.close();  
40.         if(client != null){  
41.             //如果构造函数建立起了连接，则关闭套接字，如果没有建立起连接，自然不用关闭  
42.             client.close(); //只关闭socket，其关联的输入输出流也会被关闭  
43.         }  
44.     }  
45. }  

      服务端需要用到多线程，这里单独写了一个多线程类，代码如下： 

[java]  view plain copy

1. package zyb.org.server;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.InputStreamReader;  
5. import java.io.PrintStream;  
6. import java.net.Socket;  
7.   
8. /** 
9.  * 该类为多线程类，用于服务端 
10.  */  
11. public class ServerThread implements Runnable {  
12.   
13.     private Socket client = null;  
14.     public ServerThread(Socket client){  
15.         this.client = client;  
16.     }  
17.       
18.     @Override  
19.     public void run() {  
20.         try{  
21.             //获取Socket的输出流，用来向客户端发送数据  
22.             PrintStream out = new PrintStream(client.getOutputStream());  
23.             //获取Socket的输入流，用来接收从客户端发送过来的数据  
24.             BufferedReader buf = new BufferedReader(new InputStreamReader(client.getInputStream()));  
25.             boolean flag =true;  
26.             while(flag){  
27.                 //接收从客户端发送过来的数据  
28.                 String str =  buf.readLine();  
29.                 if(str == null || "".equals(str)){  
30.                     flag = false;  
31.                 }else{  
32.                     if("bye".equals(str)){  
33.                         flag = false;  
34.                     }else{  
35.                         //将接收到的字符串前面加上echo，发送到对应的客户端  
36.                         out.println("echo:" + str);  
37.                     }  
38.                 }  
39.             }  
40.             out.close();  
41.             client.close();  
42.         }catch(Exception e){  
43.             e.printStackTrace();  
44.         }  
45.     }  
46.   
47. }  

    服务端处理TCP连接请求的代码如下：

[java]  view plain copy

1. package zyb.org.server;  
2.   
3. import java.net.ServerSocket;  
4. import java.net.Socket;  
5.   
6. public class Server1 {  
7.     public static void main(String[] args) throws Exception{  
8.         //服务端在20006端口监听客户端请求的TCP连接  
9.         ServerSocket server = new ServerSocket(20006);  
10.         Socket client = null;  
11.         boolean f = true;  
12.         while(f){  
13.             //等待客户端的连接，如果没有获取连接  
14.             client = server.accept();  
15.             System.out.println("与客户端连接成功！");  
16.             //为每个客户端连接开启一个线程  
17.             new Thread(new ServerThread(client)).start();  
18.         }  
19.         server.close();  
20.     }  
21. }