Java Socket编程

一，网络编程中两个主要的问题

一个是如何准确的定位网络上一台或多台主机，另一个就是找到主机后如何可靠高效的进行数据传输。

在TCP/IP协议中IP层主要负责网络主机的定位，数据传输的路由，由IP地址可以唯一地确定Internet上的一台主机。

而TCP层则提供面向应用的可靠（tcp）的或非可靠（UDP）的数据传输机制，这是网络编程的主要对象，一般不需要关心IP层是如何处理数据的。

目前较为流行的网络编程模型是客户机/服务器（C/S）结构。即通信双方一方作为服务器等待客户提出请求并予以响应。客户则在需要服务时向服务器提 出申请。服务器一般作为守护进程始终运行，监听网络端口，一旦有客户请求，就会启动一个服务进程来响应该客户，同时自己继续监听服务端口，使后来的客户也 能及时得到服务。

二，两类传输协议：TCP；UDP

TCP是Tranfer Control Protocol的 简称，是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建 立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送 或接收操作。

UDP是User Datagram Protocol的简称，是一种无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。

比较：

UDP：1，每个数据报中都给出了完整的地址信息，因此无需要建立发送方和接收方的连接。

            2，UDP传输数据时是有大小限制的，每个被传输的数据报必须限定在64KB之内。

           3，UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方

TCP：1，面向连接的协议，在socket之间进行数据传输之前必然要建立连接，所以在TCP中需要连接

                时间。

            2，TCP传输数据大小限制，一旦连接建立起来，双方的socket就可以按统一的格式传输大的  

                    数据。

             3，TCP是一个可靠的协议，它确保接收方完全正确地获取发送方所发送的全部数据。

应用：

1，TCP在网络通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输。但是可靠的传输是要付出代价的，对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽，因此TCP传输的效率不如UDP高。

2，UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序。例如视频会议系统，并不要求音频视频数据绝对的正确，只要保证连贯性就可以了，这种情况下显然使用UDP会更合理一些。

三，基于Socket的java网络编程

1，什么是Socket

网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket。Socket通常用来实现客户方和服务方的连接。Socket是TCP/IP协议的一个十分流行的编程界面，一个Socket由一个IP地址和一个端口号唯一确定。

但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。

2，Socket通讯的过程

Server端Listen(监听)某个端口是否有连接请求，Client端向Server 端发出Connect(连接)请求，Server端向Client端发回Accept（接受）消息。一个连接就建立起来了。Server端和Client 端都可以通过Send，Write等方法与对方通信。

对于一个功能齐全的Socket，都要包含以下基本结构，其工作过程包含以下四个基本的步骤：

　　（1） 创建Socket；

　　（2） 打开连接到Socket的输入/出流；

　　（3） 按照一定的协议对Socket进行读/写操作；

　　（4） 关闭Socket.（在实际应用中，并未使用到显示的close，虽然很多文章都推荐如此，不过在我的程序中，可能因为程序本身比较简单，要求不高，所以并未造成什么影响。）

3，创建Socket

创建Socket

java在包java.net中提供了两个类Socket和ServerSocket，分别用来表示双向连接的客户端和服务端。这是两个封装得非常好的类，使用很方便。其构造方法如下：

　　Socket(InetAddress address, int port);

　　Socket(InetAddress address, int port, boolean stream);

　　Socket(String host, int prot);

　　Socket(String host, int prot, boolean stream);

　　Socket(SocketImpl impl)

　　Socket(String host, int port, InetAddress localAddr, int localPort)

　　Socket(InetAddress address, int port, InetAddress localAddr, int localPort)

　　ServerSocket(int port);

　　ServerSocket(int port, int backlog);

　　ServerSocket(int port, int backlog, InetAddress bindAddr)

　　其中address、host和port分别是双向连接中另一方的IP地址、主机名和端 口号，stream指明socket是流socket还是数据报socket，localPort表示本地主机的端口号，localAddr和 bindAddr是本地机器的地址（ServerSocket的主机地址），impl是socket的父类，既可以用来创建serverSocket又可 以用来创建Socket。count则表示服务端所能支持的最大连接数。例如：学习视频网 http://www.xxspw.com

　　Socket client = new Socket("127.0.01.", 80);

　　ServerSocket server = new ServerSocket(80);

　　注意，在选择端口时，必须小心。每一个端口提供一种特定的服务，只有给出正确的端口，才 能获得相应的服务。0~1023的端口号为系统所保留，例如http服务的端口号为80,telnet服务的端口号为21,ftp服务的端口号为23, 所以我们在选择端口号时，最好选择一个大于1023的数以防止发生冲突。

　　在创建socket时如果发生错误，将产生IOException，在程序中必须对之作出处理。所以在创建Socket或ServerSocket是必须捕获或抛出例外。

4，简单的Client/Server程序

1. 客户端程序

　　import java.io.*;

　　import java.net.*;

　　public class TalkClient {

　　　　public static void main(String args[]) {

　　　　　　try{

　　　　　　　　Socket socket=new Socket("127.0.0.1",4700);

　　　　　　　　//向本机的4700端口发出客户请求

　　　　　　　　BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));

　　　　　　　　//由系统标准输入设备构造BufferedReader对象

　　　　　　　　PrintWriter os=new PrintWriter(socket.getOutputStream());

　　　　　　　　//由Socket对象得到输出流，并构造PrintWriter对象

　　　　　　　　BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));

　　　　　　　　//由Socket对象得到输入流，并构造相应的BufferedReader对象

　　　　　　　　String readline;

　　　　　　　　readline=sin.readLine(); //从系统标准输入读入一字符串

　　　　　　　　while(!readline.equals("bye")){

　　　　　　　　//若从标准输入读入的字符串为 "bye"则停止循环

　　　　　　　　　　os.println(readline);

　　　　　　　　　　//将从系统标准输入读入的字符串输出到Server

　　　　　　　　　　os.flush();

　　　　　　　　　　//刷新输出流，使Server马上收到该字符串

　　　　　　　　　　System.out.println("Client:"+readline);

　　　　　　　　　　//在系统标准输出上打印读入的字符串

　　　　　　　　　　System.out.println("Server:"+is.readLine());

　　　　　　　　　　//从Server读入一字符串，并打印到标准输出上

　　　　　　　　　　readline=sin.readLine(); //从系统标准输入读入一字符串

　　　　　　　　} //继续循环

　　　　　　　　os.close(); //关闭Socket输出流

　　　　　　　　is.close(); //关闭Socket输入流

　　　　　　　　socket.close(); //关闭Socket

　　　　　　}catch(Exception e) {

　　　　　　　　System.out.println("Error"+e); //出错，则打印出错信息

　　　　　　}

　　}

}

　2. 服务器端程序

　　import java.io.*;

　　import java.net.*;

　　import java.applet.Applet;

　　public class TalkServer{

　　　　public static void main(String args[]) {

　　　　　　try{

　　　　　　　　ServerSocket server=null;

　　　　　　　　try{

　　　　　　　　　　server=new ServerSocket(4700);

　　　　　　　　//创建一个ServerSocket在端口4700监听客户请求

　　　　　　　　}catch(Exception e) {

　　　　　　　　　　System.out.println("can not listen to:"+e);

　　　　　　　　//出错，打印出错信息

　　　　　　　　}

　　　　　　　　Socket socket=null;

　　　　　　　　try{

　　　　　　　　　　socket=server.accept();

　　　　　　　　　　//使用accept()阻塞等待客户请求，有客户

　　　　　　　　　　//请求到来则产生一个Socket对象，并继续执行

　　　　　　　　}catch(Exception e) {

　　　　　　　　　　System.out.println("Error."+e);

　　　　　　　　　　//出错，打印出错信息

　　　　　　　　}

　　　　　　　　String line;

　　　　　　　　BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));

　　　　　　　　　//由Socket对象得到输入流，并构造相应的BufferedReader对象

　　　　　　　　PrintWriter os=newPrintWriter(socket.getOutputStream());

　　　　　　　　　//由Socket对象得到输出流，并构造PrintWriter对象

　　　　　　　　BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));

　　　　　　　　　//由系统标准输入设备构造BufferedReader对象

　　　　　　　　System.out.println("Client:"+is.readLine());

　　　　　　　　//在标准输出上打印从客户端读入的字符串

　　　　　　　　line=sin.readLine();

　　　　　　　　//从标准输入读入一字符串

　　　　　　　　while(!line.equals("bye")){

　　　　　　　　//如果该字符串为 "bye"，则停止循环

　　　　　　　　　　os.println(line);

　　　　　　　　　　//向客户端输出该字符串

　　　　　　　　　　os.flush();

　　　　　　　　　　//刷新输出流，使Client马上收到该字符串

　　　　　　　　　　System.out.println("Server:"+line);

　　　　　　　　　　//在系统标准输出上打印读入的字符串

　　　　　　　　　　System.out.println("Client:"+is.readLine());

　　　　　　　　　　//从Client读入一字符串，并打印到标准输出上

　　　　　　　　　　line=sin.readLine();

　　　　　　　　　　//从系统标准输入读入一字符串

　　　　　　　　} 　//继续循环

　　　　　　　　os.close(); //关闭Socket输出流

　　　　　　　　is.close(); //关闭Socket输入流

　　　　　　　　socket.close(); //关闭Socket

　　　　　　　　server.close(); //关闭ServerSocket

　　　　　　}catch(Exception e){

　　　　　　　　System.out.println("Error:"+e);

　　　　　　　　//出错，打印出错信息

　　　　　　}

　　　　}

　　}

5，支持多客户的client/server程序

前面的Client/Server程序只能实现Server和一个客户的对话。在实际应用 中，往往是在服务器上运行一个永久的程序，它可以接收来自其他多个客户端的请求，提供相应的服务。为了实现在服务器方给多个客户提供服务的功能，需要对上 面的程序进行改造，利用多线程实现多客户机制。服务器总是在指定的端口上监听是否有客户请求，一旦监听到客户请求，服务器就会启动一个专门的服务线程来响 应该客户的请求，而服务器本身在启动完线程之后马上又进入监听状态，等待下一个客户的到来。

标签:  android,  java

原文链接： http://www.cnblogs.com/linzheng/archive/2011/01/23/1942328.html

一个项目看java TCP/IP Socket编程(1.3版)

前一段时间刚做了个java程序和网络上多台机器的c程序通讯的项目，遵循的是TCP/IP协议，用到了java的Socket编程。网络通讯是java的强项，用TCP/IP协议可以方便的和网络上的其他程序互通消息。 

先来介绍下网络协议： 
    TCP/IP 
        Transmission Control Protocol 传输控制协议 
        Internet Protocol 互联网协议 
    UDP 
        User Datagram Protocol 用户数据协议 

连接协议： 
    分为： 
    面向连接协议: Connection Oriented Protocol 
    非连接协议: Connectionless Protocol 

    1).面向连接协议是指两台电脑在传输数据前，先会建立一个专属的连接。就如电信局的交换机会为打电话双方提供专属连接一样。 
    Internet上的面向连接协议就是TCP/IP 
    特点：确认回应；分组序号；流量控制。 
    TCP/IP属于可靠性传输，适合不容许有传输错误的网络程序设计使用 

    2).非连接协议：无专属连接，无分组，容错，距离短，可同时对多台电脑进行数据传输 
    Internet上的非连接协议就是UDP 

    TCP在网络通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输。相比之下UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序。 


Socket 是程序与网络间的一种接口，大部分网络应用程序都是点对点的，所谓点就是服务器端和客户端所执行的程序。Socket是用来接收和传送分组的一个端点。 

java的Socket编程要用到java.net包，最常用的是net包下的6个类：InetAddress(互联网协议 (IP) 地址)类，Socket(套接字)类，ServerSocket(套接字服务器)类，DatagramSocket(发送和接收数据报包的套接字)类，DatagramPacket(数据报包)类，MulticastSocket(多播数据报套接字类用于发送和接收 IP 多播包)类，其中InetAddress、Socket、ServerSocket类是属于TCP面向连接协议，DatagramSocket、DatagramPacket和MulticastSocket类则属于UDP非连接协议的传送类。 

本项目因为使用TCP/IP协议，主要用到Socket和ServerSocket类 

项目代码如下 

Java代码  

1. package com.sse.monitor.serv;  
2.   
3. import java.io.DataInputStream;  
4. import java.io.IOException;  
5. import java.io.InputStream;  
6. import java.io.OutputStream;  
7. import java.io.BufferedOutputStream;  
8.   
9. import java.net.Socket;  
10. import java.net.UnknownHostException;  
11. import java.util.ArrayList;  
12.   
13. import com.sse.monitor.bean.Message;  
14. import com.sse.monitor.bean.MessageHead;  
15. import com.sse.monitor.bean.ResponseMessage;  
16. import com.sse.monitor.form.ListenerInvoke;  
17. import com.sse.monitor.form.MainForm;  
18. import com.sse.monitor.util.SwingUtils;  
19.   
20. /** 
21.  * Socket套接字工厂，对外接口是静态方法 SocketFactory.request(String, String, String, int)  
22.  * Copyright: Copyright (c) 2008  
23.  * Company: conserv 
24.  * @author cuishen 
25.  * @version 1.3 
26.  */  
27. public class SocketFactory {  
28.     private Socket socket = null;  
29.     private String targetIpAddress = null;  
30.     private int targetPort = 0;  
31.     private static SocketFactory sf = new SocketFactory();  
32.   
33.     public SocketFactory() {  
34.     }  
35.   
36.     /** 
37.      * 建立一条TCP/IP连接 
38.      * @param targetIpAddress String 目标ip地址 
39.      * @param targetPort String 目标端口 
40.      * @throws IOException 
41.      */  
42.     private void connect(String targetIpAddress, int targetPort) throws IOException {  
43.         setTargetIpAddress(targetIpAddress);  
44.         setTargetPort(targetPort);  
45.         if(socket == null)  
46.             socket = new Socket(targetIpAddress, targetPort);  
47.     }  
48.   
49.     /** 
50.      * 这是对外接口。发送命令，接收反馈和接收message放两个线程， 
51.      * 发送命令并接收反馈是短连接，所以每次执行成功后，将销毁socket并终止线程， 
52.      * 接收message是长连接，所以可能会new出n个线程，建议对接收message的线程做缓存 
53.      * @param commandType String 命令类型 
54.      * @param commandContent String 命令内容 
55.      * @param targetIP String 目标ip 
56.      * @param targetPort int 目标端口 
57.      */  
58.     public static void request(String commandType, String commandContent, String targetIP, int targetPort) {  
59.         if (commandType.equalsIgnoreCase(MessageFactory.SCAN_COMMAND)) {  
60.             sf.new GetMessageSocketThread(commandType, commandContent, targetIP, targetPort);  
61.         } else {  
62.             sf.new RequestSocketThread(commandType, commandContent, targetIP, targetPort);  
63.         }  
64.     }  
65.   
66.     /** 
67.      * 发送请求 
68.      * @param commandType String 命令类型 
69.      * @param commandContent String 命令内容 
70.      * @param targetIp String 目标ip 
71.      */  
72.     private void sendRequest(String commandType, String commandContent, String targetIp) {  
73.         OutputStream os = null;  
74.         BufferedOutputStream bs = null;  
75.         try {  
76.             os = socket.getOutputStream();  
77.             bs = new BufferedOutputStream(os);  
78.             char[] message = MessageFactory.makeRequestMessage(targetIp, commandType, commandContent, MessageFactory.COMMAND_TRADE_CODE, MessageFactory.RIGHT_COMMAND, MessageFactory.MESSAGE_END_FLAG);  
79.             for (int i = 0; i < message.length; i++)  
80.                 bs.write(new String(message).getBytes(), i, 1);  
81.             bs.flush();  
82.             SwingUtils.appendLog(MainForm.jTextArea, "发送请求：'" + commandType + "' '" + commandContent + "' '" + targetIp + "'", ReadConfig.commandStateShowLineCount);  
83.         } catch (IOException e) {  
84.             SwingUtils.appendLog(MainForm.jTextArea, "Error!!! 发送请求：'" + commandType + "' '" + commandContent + "' '" + targetIp + "'失败！！ " + e.getMessage(), ReadConfig.commandStateShowLineCount);  
85.             e.printStackTrace();  
86.         } catch (Exception e) {  
87.             e.printStackTrace();  
88.         } finally {  
89.         }  
90.     }  
91.   
92.     /** 
93.      * 获得反馈 
94.      *  
95.      * @return 如果成功获得反馈，则返回true；否则返回false 
96.      */  
97.     private boolean getResponse() {  
98.         InputStream is = null;  
99.         DataInputStream di = null;  
100.         boolean returnFlag = false;  
101.         try {  
102.             is = socket.getInputStream();  
103.             di = new DataInputStream(is);  
104.             byte[] temp = new byte[1];  
105.             int flag = 0;  
106.             ArrayList tempByteList = new ArrayList();  
107.             int i = 0;  
108.             while (flag != -1) {  
109.                 i++;  
110.                 flag = di.read(temp = new byte[1]);  
111.                 if (flag != -1)  
112.                     tempByteList.add(temp);  
113.                 if (i == 38)  
114.                     break;  
115.             }  
116.             if (i == 1) {  
117.                 SwingUtils.Error("未收到response!!!");  
118.                 return false;  
119.             }  
120.             MessageHead messageHead = MessageFactory.readHead(tempByteList);  
121.   
122.             SwingUtils.appendLog(MainForm.jTextArea, "收到 response", ReadConfig.commandStateShowLineCount);  
123.   
124.             tempByteList = new ArrayList();  
125.             i = 0;  
126.             while (flag != -1) {  
127.                 i++;  
128.                 flag = di.read(temp = new byte[1]);  
129.                 if (flag != -1)  
130.                     tempByteList.add(temp);  
131.                 if (i == 26)  
132.                     break;  
133.             }  
134.             byte[] length = new byte[4];  
135.             di.read(length);  
136.             int len = Integer.parseInt(new String(length, MessageFactory.DEFAULT_CHAR_SET).trim());  
137.             flag = 0;  
138.             for (int j = 0; j < (len + 37); j++) {  
139.                 flag = di.read(temp = new byte[1]);  
140.                 if (flag == -1)  
141.                     break;  
142.                 tempByteList.add(temp);  
143.             }  
144.   
145.             ResponseMessage rm = MessageFactory.readResponseMessage(tempByteList, len);  
146.   
147.             if (messageHead.getErrorCode().equals(MessageFactory.SUCCESS))  
148.                 returnFlag = true;  
149.             else  
150.                 SwingUtils.Error("errorCode: " + messageHead.getErrorCode() + "; content: " + rm.getCommandContent());  
151.         } catch (IOException e) {  
152.             e.printStackTrace();  
153.         } finally {  
154.         }  
155.         return returnFlag;  
156.     }  
157.   
158.     /** 
159.      * 分发消息的方法,将消息按进程名发送到对应的消息缓存  
160.      * 
161.      * 消息缓存ListenerInvoke.messageMap，key = machineName + 
162.      * '|' + programName + '|' + processId, value = messageList 
163.      * 存放messageMap里面的键名的List -- ListenerInvoke.messageMapKeyList 
164.      * 进程状态缓存ListenerInvoke.processStateMap, key = machineName + '|' + 
165.      * programName + '|' + processId, value = String 
166.      *  
167.      * @param message Message 
168.      */  
169.     private void distributeMess(Message message) {  
170.         String machineName = message.getMachineName();  
171.         String programName = message.getProgramName();  
172.         String processId = message.getProcessId();  
173.         String content = message.getContent();  
174.         String key = machineName + '|' + programName + '|' + processId;  
175.         key = key.trim();  
176.         ArrayList messageList = null;  
177.         if (ListenerInvoke.messageMap.get(key) == null) {  
178.             synchronized (ListenerInvoke.messageMap) {  
179.                 if (ListenerInvoke.messageMap.get(key) == null) {  
180.                     messageList = new ArrayList();  
181.                     messageList.add(content);             
182.                     ListenerInvoke.messageMap.put(key, messageList);  
183.                 }  
184.             }  
185.         } else {  
186.             messageList = (ArrayList) ListenerInvoke.messageMap.get(key);  
187.             synchronized (messageList) {  
188.                 if (ListenerInvoke.messageMap.get(key) != null) {  
189.                     messageList.add(content);  
190.                     if (!ReadConfig.threadDeleteMessCacheOrFIFO  
191.                             && messageList.size() >= ReadConfig.messageCacheSizeLimit)  
192.                         messageList.remove(0);  
193.                 }  
194.             }  
195.         }  
196.         if (!ListenerInvoke.messageMapKeyList.contains(key)) {  
197.             synchronized (ListenerInvoke.messageMapKeyList) {  
198.                 if (!ListenerInvoke.messageMapKeyList.contains(key))  
199.                     ListenerInvoke.messageMapKeyList.add(key);  
200.             }  
201.         }  
202.     }  
203.   
204.     /** 
205.      * 接收message 
206.      * @return Message 
207.      */  
208.     private boolean getMessage() {  
209.         InputStream is = null;  
210.         DataInputStream di = null;  
211.         Message message = null;  
212.         try {  
213.             if (this.socket == null)  return false;  
214.             is = this.socket.getInputStream();  
215.             if (is == null)  return false;  
216.             di = new DataInputStream(is);  
217.             byte[] temp = new byte[1];  
218.             int flag = 0;  
219.             ArrayList tempByteList = new ArrayList();  
220.             int i = 0;  
221.             while (flag != -1) {  
222.                 i++;  
223.                 flag = di.read(temp = new byte[1]);  
224.                 if (flag != -1)  
225.                     tempByteList.add(temp);  
226.                 if (i == 38)  
227.                     break;  
228.             }  
229.             if (i == 1)  return false;  
230.   
231.             tempByteList = new ArrayList();  
232.             i = 0;  
233.             while (flag != -1) {  
234.                 i++;  
235.                 flag = di.read(temp = new byte[1]);  
236.                 if (flag != -1)  
237.                     tempByteList.add(temp);  
238.                 if (i == 74)  
239.                     break;  
240.             }  
241.             byte[] length = new byte[4];  
242.             di.read(length);  
243.             int len = Integer.parseInt(new String(length,  
244.                     MessageFactory.DEFAULT_CHAR_SET).trim());  
245.             flag = 0;  
246.             for (int j = 0; j < len; j++) {  
247.                 flag = di.read(temp = new byte[1]);  
248.                 if (flag == -1)  
249.                     break;  
250.                 tempByteList.add(temp);  
251.             }  
252.             message = MessageFactory.readMessage(tempByteList, len);  
253.             SwingUtils.appendLog(MainForm.jTextArea, "收到新 Message",  
254.                     ReadConfig.commandStateShowLineCount);  
255.             distributeMess(message);// 分发message  
256.         } catch (IOException e) {  
257.             e.printStackTrace();  
258.         } finally {  
259.         }  
260.         return true;  
261.     }  
262.   
263.     /** 
264.      * 负责发送请求接收反馈的内部线程类，每new一个RequestSocketThread线程， 
265.      * 就new一个socket，建立一条专属连接，成功接收反馈后将销毁socket，终止线程。 
266.      * 将发送请求，接收反馈放进内部线程处理，是为了防止套接字阻塞造成主线程挂死。 
267.      * @author cuishen 
268.      * @version 1.2 
269.      */  
270.     class RequestSocketThread implements Runnable {  
271.         private SocketFactory socketFactory;  
272.         private String commandType = null;  
273.         private String commandContent = null;  
274.         private String targetIP = null;  
275.         Thread t;  
276.   
277.         public RequestSocketThread(String commandType, String commandContent, String targetIP, int targetPort) {  
278.             this.socketFactory = new SocketFactory();  
279.             try {  
280.                 this.socketFactory.connect(ReadConfig.targetIpAddress, ReadConfig.targetPort);  
281.             } catch (UnknownHostException e) {  
282.                 SwingUtils.Error("主机 IP 地址无法确定,无法建立连接！ targetIP=" + ReadConfig.targetIpAddress + ", targetPort=" + ReadConfig.targetPort);  
283.                 e.printStackTrace();  
284.             } catch (IOException e) {  
285.                 SwingUtils.Error("访问被拒绝，无法建立连接，请检查网络！ targetIP=" + ReadConfig.targetIpAddress + ", targetPort=" + ReadConfig.targetPort);  
286.                 e.printStackTrace();  
287.             }  
288.             this.commandType = commandType;  
289.             this.commandContent = commandContent;  
290.             this.targetIP = targetIP;  
291.             t = new Thread(this);  
292.             t.start();  
293.         }  
294.   
295.         public void run() {  
296.             this.socketFactory.sendRequest(commandType, commandContent, targetIP);  
297.             this.socketFactory.getResponse();  
298.             stopThread();  
299.         }  
300.   
301.         public void stopThread() {  
302.             try {  
303.                 this.commandType = null;  
304.                 this.commandContent = null;  
305.                 this.targetIP = null;  
306.                 socketFactory.closeSocket();  
307.                 socketFactory = null;  
308.                 this.t.join(100);  
309.             } catch (InterruptedException e) {  
310.                 e.printStackTrace();  
311.             } finally {  
312.                 t = null;  
313.             }  
314.         }  
315.     }  
316.   
317.     /** 
318.      * 负责接收message的内部线程类，每new一个GetMessageSocketThread线程， 
319.      * 就new一个socket，建立一条专属TCP/IP连接，getMessage是长连接，所以建议 
320.      * 将该线程放入缓存方便管理 
321.      * @author cuishen 
322.      * @version 1.2 
323.      */  
324.     class GetMessageSocketThread implements Runnable {  
325.         private SocketFactory socketFactory;  
326.         private String commandType = null;  
327.         private String commandContent = null;  
328.         private String targetIP = null;  
329.         Thread t;  
330.         private boolean flag = false;  
331.         private boolean ifGetResponse = true;  
332.         private boolean ifGetMessage = true;  
333.         private boolean ifSendRequest = true;  
334.         private boolean ifCycle = true;  
335.   
336.         public GetMessageSocketThread(String commandType, String commandContent, String targetIP, int targetPort) {  
337.               
338.             this.socketFactory = new SocketFactory();  
339.             try {  
340.                 this.socketFactory.connect(ReadConfig.targetIpAddress, ReadConfig.targetPort);  
341.             } catch (UnknownHostException e) {  
342.                 SwingUtils.Error("主机 IP 地址无法确定,无法建立连接！ targetIP="  
343.                         + ReadConfig.targetIpAddress + ", targetPort="  
344.                         + ReadConfig.targetPort);  
345.                 e.printStackTrace();  
346.             } catch (IOException e) {  
347.                 SwingUtils.Error("访问被拒绝，无法建立连接，请检查网络！ targetIP="  
348.                         + ReadConfig.targetIpAddress + ", targetPort="  
349.                         + ReadConfig.targetPort);  
350.                 e.printStackTrace();  
351.             }  
352.             this.commandType = commandType;  
353.             this.commandContent = commandContent;  
354.             this.targetIP = targetIP;  
355.             t = new Thread(this);  
356.             t.start();  
357.         }  
358.   
359.         public void run() {  
360.             while (ifCycle) {  
361.                 if (ifSendRequest) {  
362.                     this.socketFactory.sendRequest(commandType, commandContent, targetIP);  
363.                     ifSendRequest = false;  
364.                 }  
365.                 if (ifGetResponse) {  
366.                     flag = socketFactory.getResponse();  
367.                     ifGetResponse = false;  
368.                 }  
369.                 if (flag && ifGetMessage && socketFactory.socket != null) {  
370.                     if (!socketFactory.getMessage()) {  
371.                         try {  
372.                             Thread.sleep(ReadConfig.getMessageThreadSleep);  
373.                         } catch (InterruptedException e) {  
374.                             e.printStackTrace();  
375.                         }  
376.                     }  
377.                 }  
378.             }  
379.         }  
380.   
381.         public void stopThread() {  
382.             try {  
383.                 this.commandType = null;  
384.                 this.commandContent = null;  
385.                 this.targetIP = null;  
386.                 ifGetMessage = false;  
387.                 ifCycle = false;  
388.                 socketFactory.closeSocket();  
389.                 socketFactory = null;  
390.                 this.t.join(100);  
391.             } catch (InterruptedException e) {  
392.                 e.printStackTrace();  
393.             } finally {  
394.                 t = null;  
395.             }  
396.         }  
397.     }  
398.   
399.     /** 
400.      * 关闭套接字 
401.      */  
402.     private void closeSocket() {  
403.         try {  
404.             if (!socket.isClosed())  
405.                 socket.close();  
406.             socket = null;  
407.         } catch (IOException e) {  
408.             e.printStackTrace();  
409.         }  
410.     }  
411.   
412.     /** 
413.      * @return the targetIpAddress 
414.      */  
415.     public String getTargetIpAddress() {  
416.         return targetIpAddress;  
417.     }  
418.   
419.     /** 
420.      * @param targetIpAddress 
421.      *            the targetIpAddress to set 
422.      */  
423.     public void setTargetIpAddress(String targetIpAddress) {  
424.         this.targetIpAddress = targetIpAddress;  
425.     }  
426.   
427.     /** 
428.      * @return the targetPort 
429.      */  
430.     public int getTargetPort() {  
431.         return targetPort;  
432.     }  
433.   
434.     /** 
435.      * @param targetPort 
436.      *            the targetPort to set 
437.      */  
438.     public void setTargetPort(int targetPort) {  
439.         this.targetPort = targetPort;  
440.     }  
441.   
442. }  

以上是Socket编程，ServerSocket在项目里没有用到，但是我也写了个包装类供参考 

Java代码  

1. package com.sse.monitor.serv;  
2.   
3. import java.io.IOException;  
4. import java.net.ServerSocket;  
5. import java.net.Socket;  
6.   
7. /** 
8.  * 服务器套接字工厂 
9.  * Copyright: Copyright (c) 2008 
10.  * @author cuishen 
11.  * @version 1.0 
12.  */  
13. public class ServerSocketFactory {  
14.     private static ServerSocket server;  
15.     private static Socket client;  
16.     private boolean ifRunServer = true;  
17.       
18.     public void runServer(int port) throws IOException {  
19.         //本地建立一个套接字服务器，等待其他机器访问  
20.         server = new ServerSocket(port);  
21.         System.out.println("Socket Server Start...");  
22.         new ServerThread();  
23.     }  
24.       
25.   
26.     class ServerThread implements Runnable {  
27.         Thread t;  
28.           
29.         public ServerThread() {  
30.             t = new Thread(this);  
31.             t.start();  
32.         }  
33.   
34.         public void run() {  
35.             try {  
36.                 while(ifRunServer) {  
37.                     if(client == null) client = server.accept();  
38.                     if(client != null) //getMessage();  
39.                     Thread.sleep(ReadConfig.serverThreadSleep);  
40.                 }  
41.             } catch (InterruptedException e) {  
42.                 e.printStackTrace();  
43.             }   
44.             catch (IOException e) {  
45.                 e.printStackTrace();  
46.             }  
47.         }  
48.         public void stopThread() {  
49.             try {  
50.                 ifRunServer = false;  
51.                 this.t.join(100);  
52.             } catch (InterruptedException ex) {  
53.                 System.out.println("socket服务器线程终止异常！！！");  
54.             } finally {  
55.                 t = null;  
56.             }  
57.         }  
58.     }  
59. }  

http://cuishen.iteye.com/blog/242842

Java Socket实战之二 多线程通信

http://blog.youkuaiyun.com/kongxx/article/details/7259465

上一篇文章说到怎样写一个最简单的Java Socket通信，但是在上一篇文章中的例子有一个问题就是Server只能接受一个Client请求，当第一个Client连接后就占据了这个位置，后续Client不能再继续连接，所以需要做些改动，当Server没接受到一个Client连接请求之后，都把处理流程放到一个独立的线程里去运行，然后等待下一个Client连接请求，这样就不会阻塞Server端接收请求了。每个独立运行的程序在使用完Socket对象之后要将其关闭。具体代码如下：

[java]  view plain copy print ?

1. package com.googlecode.garbagecan.test.socket.sample2;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStreamReader;  
6. import java.io.PrintWriter;  
7. import java.net.ServerSocket;  
8. import java.net.Socket;  
9.   
10. public class MyServer {  
11.     public static void main(String[] args) throws IOException {  
12.         ServerSocket server = new ServerSocket(10000);  
13.           
14.         while (true) {  
15.             Socket socket = server.accept();  
16.             invoke(socket);  
17.         }  
18.     }  
19.       
20.     private static void invoke(final Socket client) throws IOException {  
21.         new Thread(new Runnable() {  
22.             public void run() {  
23.                 BufferedReader in = null;  
24.                 PrintWriter out = null;  
25.                 try {  
26.                     in = new BufferedReader(new InputStreamReader(client.getInputStream()));  
27.                     out = new PrintWriter(client.getOutputStream());  
28.   
29.                     while (true) {  
30.                         String msg = in.readLine();  
31.                         System.out.println(msg);  
32.                         out.println("Server received " + msg);  
33.                         out.flush();  
34.                         if (msg.equals("bye")) {  
35.                             break;  
36.                         }  
37.                     }  
38.                 } catch(IOException ex) {  
39.                     ex.printStackTrace();  
40.                 } finally {  
41.                     try {  
42.                         in.close();  
43.                     } catch (Exception e) {}  
44.                     try {  
45.                         out.close();  
46.                     } catch (Exception e) {}  
47.                     try {  
48.                         client.close();  
49.                     } catch (Exception e) {}  
50.                 }  
51.             }  
52.         }).start();  
53.     }  
54. }  

下面是Client程序代码：

[java]  view plain copy print ?

1. package com.googlecode.garbagecan.test.socket.sample2;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.InputStreamReader;  
5. import java.io.PrintWriter;  
6. import java.net.Socket;  
7.   
8. public class MyClient {  
9.     public static void main(String[] args) throws Exception {  
10.         Socket socket = new Socket("localhost", 10000);  
11.         BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
12.         PrintWriter out = new PrintWriter(socket.getOutputStream());  
13.         BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));  
14.   
15.         while (true) {  
16.             String msg = reader.readLine();  
17.             out.println(msg);  
18.             out.flush();  
19.             if (msg.equals("bye")) {  
20.                 break;  
21.             }  
22.             System.out.println(in.readLine());  
23.         }  
24.         socket.close();  
25.     }  
26. }  

测试，首先运行MyServer类，然后运行两个MyClient类，然后分别在每个MyClient的提示符下输入字符串，就可以看到Server可以分别接收处理每个Client的请求了。