android Socket长连接及多客户端管理

一、简介

最近在做一个项目，需要用到socket 。具体功能为：在同一wifi下，一个手机作为服务器端，另一个（或多个）手机作为客户端，客户端自动获取服务器的ip，通过socket建立常连接，用客户端手机发送指令控制服务器端的手机。

二、分析：

1、服务器端：

（1）首先服务器端需要告诉同wifi下的客户端自己的ip，所以使用UDP广播，可见我的上一篇文章：http://blog.csdn.net/suyiyang888/article/details/21446655

（2）服务端需要开启多线程任务，与多个客户端保持常连接。

2、客户端：

（1）使用udp，接收服务器发送过来的ip和端口号

（2）使用socket建立连接

（3）开启心跳测试，判断连接是否断开

3、完整项目下载地址：http://download.csdn.net/detail/suyiyang888/7061259

三、具体实现：

1、服务器端

（1）使用后台服务，创建类SocketService，因为要随时接收客户端的信息，所以使用service更好一些，这个类主要实现的功能有：开启UDP广播，定时向同网段发送自己的ip地址、端口号和测试字符串；开启socket等待客户端的连接，并对多客户端进行管理。

public class SocketService extends Service {
private UDPSocketBroadCast mBroadCast;
private ServersSocket mServersSocket;
@Override
public IBinder onBind(Intent intent) {
// TODO Auto-generated method stub
return null;
}
@Override
public void onCreate() {
// TODO Auto-generated method stub
super.onCreate();
try {
String ip = ConnectionManager.getLocalIP();
if (ip != null && !"".equals(ip)) {
Info.SERVERSOCKET_IP = ip;
mBroadCast = UDPSocketBroadCast.getInstance();
mServersSocket = ServersSocket.getInstance();
mBroadCast.startUDP(Info.SERVERSOCKET_IP,
Info.SERVERSOCKET_PORT);
mServersSocket.startServer(clientData);
} else {
Toast.makeText(getApplicationContext(), "请检查网络设置",
Toast.LENGTH_LONG).show();
stopSelf();
}
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 客户端数据在这里处理
*/
private ClientDataCallBack clientData = new ClientDataCallBack() {
@Override
public void getClientData(int connectMode, String str) {
switch (connectMode) {
case Info.CONNECT_SUCCESS:// 连接成功
sendCast(Info.CONNECT_SUCCESS, str);
break;
case Info.CONNECT_GETDATA:// 传输数据
sendCast(Info.CONNECT_SUCCESS, str);
break;
case Info.CONNECT_FAIL:
sendCast(Info.CONNECT_FAIL, str);
break;
}
}
private void sendCast(int flag, String str) {
Intent intent = new Intent();
intent.putExtra("flag", flag);
intent.putExtra("str", str);
intent.setAction("updata");
sendBroadcast(intent);
}
};
}

（2）UDP发送广播类UDPSocketBroadCast，上一篇文章已经介绍，这里不再详细解说

public class UDPSocketBroadCast {
/**
* .要使用多点广播,需要让一个数据报标有一组目标主机地址,其思想便是设置一组特殊网络地址作为多点广播地址,第一个多点广播地址都被看作是一个组
* ,当客户端需要发送
* .接收广播信息时,加入该组就可以了.IP协议为多点广播提供这批特殊的IP地址,这些IP地址范围是224.0.0.0---239.255
* .255.255
* ,其中224.0.0.0为系统自用.下面BROADCAST_IP是自己声明的一个String类型的变量,其范围但是前面所说的IP范围
* ,比如BROADCAST_IP="224.224.224.225"
*/
private static final String BROADCAST_IP = "224.224.224.225";
private static final int BROADCAST_PORT = 8681;
private static byte[] sendData;
private boolean isStop = false;
private static UDPSocketBroadCast broadCast = new UDPSocketBroadCast();
private MulticastSocket mSocket = null;
private InetAddress address = null;
private DatagramPacket dataPacket;
private UDPSocketBroadCast() {
}
/**
* 单例
*
* @return
*/
public static UDPSocketBroadCast getInstance() {
if (broadCast == null) {
broadCast = new UDPSocketBroadCast();
}
return broadCast;
}
/**
* 开始发送广播
*
* @param ip
*/
public void startUDP(String ip, int port) {
sendData = ("IAMZTSERVERSOCKET" + "-" + ip + "-" + port).getBytes();
ShowLogManager.outputDebug("tag", ip+";"+port);
new Thread(UDPRunning).start();
}
/**
* 停止广播
*/
public void stopUDP() {
isStop = true;
destroy();
}
/**
* 销毁缓存的数据
*/
public void destroy() {
broadCast = null;
mSocket = null;
address = null;
dataPacket = null;
sendData = null;
}
/**
* 创建udp数据
*/
private void CreateUDP() {
try {
mSocket = new MulticastSocket(BROADCAST_PORT);
mSocket.setTimeToLive(1);// 广播生存时间0-255
address = InetAddress.getByName(BROADCAST_IP);
mSocket.joinGroup(address);
dataPacket = new DatagramPacket(sendData, sendData.length, address,
BROADCAST_PORT);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 两秒发送一次广播
*/
private Runnable UDPRunning = new Runnable() {
@Override
public void run() {
while (!isStop) {
if (mSocket != null) {
try {
mSocket.send(dataPacket);
Thread.sleep(5 * 1000);// 发送一次停5秒
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
CreateUDP();
}
}
}
};
}

（3）客户端管理类ClientSocketManager，可实现客户端的连接，断开管理

 *多客户端列表、线程、活跃度管理类 这个程序可设置限制客户端的个数，使用setLimit(boolean isLimit)和setLimitNum(int limitNum)设置，默认五个客户端

 * 使用map来存储，使用客户端ip作为唯一的key
public class ClientSocketManager {
private static ClientSocketManager mSocketManager;
private Map<String, Socket> socketList = new HashMap<String, Socket>();// 保存客户端列表
private Map<String, Thread> threadList = new HashMap<String, Thread>();// 保存线程列表
private Map<String, Integer> actionFrequency = new HashMap<String, Integer>();// 标记每个socket的使用情况，但客户端过多时，优先关闭活动量小的客户端
private boolean isLimit = false;
private int limitNum = 5;
private ClientSocketManager() {
}
/**
* 单例模式
*
* @return
*/
public static ClientSocketManager getInstence() {
if (mSocketManager == null) {
mSocketManager = new ClientSocketManager();
}
return mSocketManager;
}
/**
* 获取当前限制状态
*
* @return
*/
public boolean isLimit() {
return isLimit;
}
/**
* 设置是否增加限制
*
* @param isLimit
*/
public void setLimit(boolean isLimit) {
this.isLimit = isLimit;
}
public int getLimitNum() {
return limitNum;
}
/**
* 设置客户端限制的个数
*
* @return
*/
public void setLimitNum(int limitNum) {
this.limitNum = limitNum;
}
/**
* 增加客户端socket
*
* @param key使用socket客户端的ip保证不重复
* ,限制客户端limitNum个以内,当多于limitNum个时会根据
* @param mSocket
* @return
*/
public boolean putSocket(String key, Socket mSocket, Thread thread) {
ShowLogManager.outputDebug("tag", "ClientSocketManager add client:"
+ key);
if (socketList != null && threadList != null) {
if (socketList.get(key) != null) {// 是否是重复的数据
removeItem(key);
}
if (socketList.size() >= limitNum && threadList.size() >= limitNum
&& isLimit) {
String minKey = getMinSocket();// 大于
removeItem(minKey);
}
addItem(key, mSocket, thread);//增加一个客户端
return true;
}
return false;
}
/**
* 增加一个客户端
*
* @param key
* @param mSocket
* @param thread
*/
private void addItem(String key, Socket mSocket, Thread thread) {
socketList.put(key, mSocket);
threadList.put(key, thread);
actionFrequency.put(key, 0);
}
/**
* 删除一个客户端
*
* @param key
*/
private void removeItem(String key) {
socketList.remove(key);
threadList.get(key).interrupt();// 线程断掉
threadList.remove(key);// 在列表中去掉
actionFrequency.remove(key);
}
/**
* 删除客户端连接
*
* @param key
* @return
*/
public boolean removeSocket(String key) {
ShowLogManager.outputDebug("t
da74
ag", "ClientSocketManager remove client:"
+ key);
if (socketList != null && threadList != null) {
try {
socketList.get(key).close();
threadList.get(key).interrupt();
} catch (IOException e) {
e.printStackTrace();
}
removeItem(key);
return true;
}
return false;
}
/**
* 清除数据
*/
public void closeSocket() {
// 断开所有的socket
for (Map.Entry<String, Socket> map : socketList.entrySet()) {
try {
if (map.getValue() != null) {
map.getValue().close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
// 停止所有的线程
for (Map.Entry<String, Thread> map : threadList.entrySet()) {
if (map.getValue() != null && map.getValue().isAlive()) {
map.getValue().interrupt();
}
}
socketList = null;
threadList = null;
actionFrequency = null;
mSocketManager = null;
}
/**
* 用ip获得某个socket客户端
*
* @param key
* @return
*/
public Socket getSocket(String key) {
if (mSocketManager != null && socketList != null) {
return socketList.get(key);
}
return null;
}
/**
* 返回key对应的线程
*
* @param key
* @return
*/
public Thread getThread(String key) {
if (threadList != null && mSocketManager != null) {
return threadList.get(key);
}
return null;
}
/**
* 获得当前客户端个数，出错时返回-1
*
* @return
*/
public int getClientNum() {
if (socketList != null) {
return socketList.size();
}
return -1;
}
/**
* 返回当前列表的所有socket的ip
*
* @return
*/
public List<String> getSocketIPList() {
List<String> list = new ArrayList<String>();
if (socketList != null) {
for (Map.Entry<String, Socket> map : socketList.entrySet()) {
list.add(map.getKey());
}
return list;
}
return null;
}
/**
* 当客户端有有效的数据更新的时候把活动量增加
*
* @param key
*/
public void setFrequency(String key) {
if (actionFrequency != null) {
Integer ins = actionFrequency.get(key);
ins++;
actionFrequency.put(key, ins);
}
}
/**
* 获得数据传输量最小的客户端的IP
*
* @return
*/
public String getMinSocket() {
int cont = 10000;
String minSocketIP = "";
for (Map.Entry<String, Integer> map : actionFrequency.entrySet()) {
if (map.getValue() < cont) {
cont = map.getValue();
minSocketIP = map.getKey();
}
}
return minSocketIP;
}
}
（4）seriverSocket常连接管理类类ServersSocket，实现客户端的连接，客户端的心跳测试的回应等功能

public class ServersSocket {
private static ServersSocket socketServer = null;
private ServerSocket serverSocket = null;
private ClientSocketManager mClientSocketManager;
private boolean allThreadStop = false;// 所有线程循环条件，当需要停止所有线程的时候把这个标志置为true
private boolean stopFlag = false;// 接收客户端信息线程的标志位，当false时，一直等待客户端输入
private static long time = 0;// 与timeflag一起判断客户端意外退出时造成的无限接收空情况
private static int timeFlag = 0;//
private Handler mHandler = null;
private ServersSocket() {
}
/**
* 单例
*
* @return
*/
public synchronized static ServersSocket getInstance() {
if (socketServer == null) {
socketServer = new ServersSocket();
}
return socketServer;
}
/**
* 启动socketserver port端口号
*/
public void startServer(final ClientDataCallBack callBack) {
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
int flag = msg.what;
String str = (String) msg.obj;
callBack.getClientData(flag, str);
}
};
try {
mClientSocketManager = ClientSocketManager.getInstence();
mClientSocketManager.setLimit(true);// 设置限制最大客户端数
mClientSocketManager.setLimitNum(6);// 设置最大客户端数为6
serverSocket = new ServerSocket(Info.SERVERSOCKET_PORT);
ShowLogManager.outputDebug("tag", "Create ServerSocket success!");
new Thread(waitClientConnection).start();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 停止socket连接
*/
public void stopServer() {
stopFlag = true;
allThreadStop = true;
clear();
}
/**
* 清除所有数据
*/
private void clear() {
if (mClientSocketManager != null) {
mClientSocketManager.closeSocket();
}
if (serverSocket != null) {
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
socketServer = null;
}
/**
* 服务端
*
* @return
*/
public ServerSocket getServerSocket() {
return serverSocket;
}
/**
* 等待客户端连接
*
* @return
*/
private Runnable waitClientConnection = new Runnable() {
@Override
public void run() {
while (!stopFlag && !allThreadStop) {
if (serverSocket != null) {
try {
ShowLogManager.outputDebug("tag",
"serverSocket waiting!");
Socket mSocket = serverSocket.accept();
MyThread thread = new MyThread(mSocket);
thread.start();// 有新客户端连接进来，有几个开几个线程
mClientSocketManager.putSocket(mSocket.getInetAddress()
.getHostAddress(), mSocket, thread);// 添加到客户端管理类中
} catch (IOException e) {
e.printStackTrace();
}
} else {
ShowLogManager.outputDebug("tag", "serverSocket is null!");
}
}
ShowLogManager.outputDebug("tag",
"Wating Thread is exit! and stopFlag:" + stopFlag);
}
};
/**
* 接收客户端数据
*/
private class MyThread extends Thread {
private Socket mSocket;
MyThread(Socket mSocket) {
this.mSocket = mSocket;
}
@Override
public void run() {
super.run();
InputStream mInputStream = null;
OutputStream outStream = null;
if (mSocket != null) {
boolean stopFlags = false;// 循环标志置为不停止
try {
mInputStream = mSocket.getInputStream();// 获得输入流
outStream = mSocket.getOutputStream();// 获得输出流
String clientIP = mSocket.getInetAddress().getHostAddress();// 获得客户端IP
sendMessages(Info.CONNECT_SUCCESS, clientIP);// 连接成功的回调
while (!stopFlags && !allThreadStop) {
byte[] buf = new byte[10240];
mInputStream.read(buf);// 读取客户端数据
// 当客户端非正常退出时，会无线发送空包，因此加入判断，避免造成无限接收空包
if (time != 0
&& System.currentTimeMillis() - time < 200
&& timeFlag > 5) {// 说明客户端断开，应断掉这个线程
stopFlags = true;
time = 0;
timeFlag = 0;
mClientSocketManager.removeSocket(clientIP);// 在管理列表中去除这个客户端的所有信息
sendMessages(Info.CONNECT_FAIL, clientIP);// 客户端退出回调IP
continue;
} else if (time != 0
&& System.currentTimeMillis() - time >= 200) {// 偶尔一次空包，数据清零
timeFlag = 0;
} else if (time != 0) {// 确定是空包，把空包计数器增加
timeFlag++;
}
time = System.currentTimeMillis();
String str = new String(buf, "utf-8").trim();// 转码
if (str != null && !"".equals(str) && !" ".equals(str)) {
if ("IHAVEQUIT".equals(str)) {// 客户端正常退出时发送过来的数据
mClientSocketManager.removeSocket(clientIP);// 在管理列表中去除这个客户端的所有信息
sendMessages(Info.CONNECT_FAIL, clientIP);// 客户端退出回调
} else if ("IAMINTHETEST".equals(str)) {// 客户端的心跳测试
outStream.write("YOUSTAYONLINE"
.getBytes("utf-8"));
outStream.flush();
} else {// 正常的数据传输
sendMessages(Info.CONNECT_GETDATA, str);
mClientSocketManager.setFrequency(clientIP);// 此客户端活动量增加，用来记录次客户端的活动量
}
}
buf = null;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (mInputStream != null) {
try {
mInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
/**
* 需回调数据
*
* @param flag
* @param message
*/
private void sendMessages(int flag, String message) {
Message msg = mHandler.obtainMessage();
msg.what = flag;
msg.obj = message;
mHandler.sendMessage(msg);// 连接成功回调客户端IP
}
}
/**
* 客户端数据回调接口
*
* @author thinkpad
*
*/
public interface ClientDataCallBack {
public void getClientData(int connectMode, String str);
}
}

2、客户端：

客户端在这里做的事情比较少，主要是接收服务端的ip和端口号，开启心跳测试的线程等

（1）UDP接收广播类，接收服务端的ip和端口号，接收到以后就断开这个广播，避免造成资源浪费和耗电。

public class UDPSocketBroadCast {
private final String BROADCAST_IP = "224.224.224.225";
private final int BROADCAST_PORT = 8681;
private byte[] getData = new byte[1024];
private boolean isStop = false;
private MulticastSocket mSocket = null;
private InetAddress address = null;
private DatagramPacket dataPacket;
private Thread mUDPThread = null;
private UDPDataCallBack mCallBack = null;
/**
* 开始接收广播
*
* @param ip
*/
public void startUDP(UDPDataCallBack mCallBack) {
this.mCallBack = mCallBack;
mUDPThread = new Thread(UDPRunning);
mUDPThread.start();
}
/**
* 重新启动，当接收到udp后会停掉广播，再次需要时使用reStartUDp()启动
*
* @param ip
*/
public void reStartUDP() {
Log.d("tag", "UDP is reStart!");
mUDPThread = null;
isStop = false;
mUDPThread = new Thread(UDPRunning);
mUDPThread.start();
}
/**
* 停止广播
*/
public void stopUDP() {
isStop = true;
mUDPThread.interrupt();
}
/**
* 创建udp数据
*/
private void CreateUDP() {
try {
mSocket = new MulticastSocket(BROADCAST_PORT);
mSocket.setTimeToLive(1);// 广播生存时间0-255
address = InetAddress.getByName(BROADCAST_IP);
mSocket.joinGroup(address);
dataPacket = new DatagramPacket(getData, getData.length, address,
BROADCAST_PORT);
Log.d("tag", "udp is create");
} catch (IOException e) {
e.printStackTrace();
}
}
private Runnable UDPRunning = new Runnable() {
final Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
String result = (String) msg.obj;
mCallBack.mCallback(result);
Log.d("tag", "handler get data:" + result);
}
};
@Override
public void run() {
CreateUDP();
Message msg = handler.obtainMessage();
while (!isStop) {
if (mSocket != null) {
try {
mSocket.receive(dataPacket);
String mUDPData = new String(getData, 0,
dataPacket.getLength());
/**
* 确定是否是这个客户端发过来的数据
*/
if (mUDPData != null
&& "IAMZTSERVERSOCKET".equals(mUDPData
.split("-")[0])) {
msg.obj = mUDPData;
handler.sendMessage(msg);
isStop = true;
}
} catch (IOException e) {
e.printStackTrace();
}
} else {
msg.obj = "error";
handler.sendMessage(msg);
}
}
}
};
public interface UDPDataCallBack {
public void mCallback(String str);
}
}

（2）socket常连接管理类，当udp接收到服务端的ip和端口号，并验证是正确的情况下，开启线程，建立常连接，并另起一个线程，单独进行心跳测试。如果心跳测试判断连接断开，会重启udp接收服务端的最新ip和端口号。

public class SocketClientManager {
/**
* 单例对象模式，不同的Activity共享同一个ScoketClientMgr
*/
private static SocketClientManager instance = null;
private Socket clientSocket = null;
private OutputStream outStream = null;
private InputStream inStream = null;
private String serverIP = "";
private int port = 0;
public boolean isStop = false;
private SocketClientCallBack callBack;
public synchronized static SocketClientManager getInstance() {
if (instance == null) {
instance = new SocketClientManager();
}
return instance;
}
/**
* 通过这方法回调数据
*
* @param callBack
*/
public void getSocketMessage(SocketClientCallBack callBack) {
this.callBack = callBack;
}
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
callBack.callBack(msg.what);
}
};
/**
* 创建客户端
*
* @param serverIP
* @param port
*/
public void startClientScoket(String serverIP, int port) {
this.serverIP = serverIP;
this.port = port;
isStop = false;
this.clientSocket = null;
this.outStream = null;
this.inStream = null;
new Thread(runSocket).start();
Log.d("tag", "clientSocket is create");
}
private Runnable runSocket = new Runnable() {
@Override
public void run() {
if (clientSocket == null) {
try {
clientSocket = new Socket(serverIP, port);
outStream = clientSocket.getOutputStream();
inStream = clientSocket.getInputStream();
new Thread(runHeartbeat).start();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
};
/**
* 心跳测试线程
*/
private Runnable runHeartbeat = new Runnable() {
@Override
public void run() {
while (!isStop) {
SendMessage("IAMINTHETEST");
byte[] buf = new byte[10240];
try {
inStream.read(buf);// 读取服务器端数据
String res = new String(buf, 0, buf.length, "utf-8").trim();
Log.d("tag", "return :" + res);
if ("".equals(res)) {// 当服务器接收空包时说明断开了
isStop = true;
Message msg = mHandler.obtainMessage();
msg.what = 1;// 与服务器断开
mHandler.sendMessage(msg);// 知道断开后发送消息
} else {
Thread.sleep(10 * 1000);// 正常
}
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
/**
* 客户端正常退出调用这个方法
*/
public void clientQuit() {
SendMessage("IHAVEQUIT");
}
/**
* 发送数据
*
* @param strMsg
* @return
*/
public boolean SendMessage(String strMsg) {
if (clientSocket == null) {
return false;
}
byte[] msgBuffer = null;
try {
msgBuffer = strMsg.getBytes("UTF-8");
outStream.write(msgBuffer);
outStream.flush();
Log.d("tag", "send message is:" + strMsg);
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return true;
}
public void Close() {
CloseSocket();
}
private void CloseSocket() {
isStop = true;
try {
if (clientSocket != null) {
clientSocket.close();
clientSocket = null;
}
} catch (IOException e) {
e.printStackTrace();
}
}
public interface SocketClientCallBack {
public void callBack(int what);
}
}

以上便是我自己完成的同wifi下使用socket建立常连接的思路和部分代码。