网络通信Socket+Protobuf协议

不多说了，直接贴代码

大家好，如果做即时通讯，相信大家对socket也有一定的了解，下面主要是对socket长连接，数据封包解包，外加protobuf的例子，希望能对各位有所帮助

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.locks.ReentrantLock;


import android.content.Context;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.util.Log;


/**
 * socket管理类
 * @author ZengJ
 *
 */
public class IPPushManager{
public static final String tag = IPPushManager.class.getSimpleName();
private String mHostname;
private int mPort;


private PushListener mPushListener;
public static IPPushManager pushManager;


/**
* 写到服务器的处理器
*/
private ReadThread mReadThread;
private HandlerThread mWriteThread;
private HandlerThread mProtocaolThread;
private WriteHandler mWriteHandler;


public static long readWriteBytesCount = 0;


/**
* Socket通道
*/
private Socket mSocket;
private InputStream mInputStream;
private OutputStream mOutputStream;


private ReentrantLock mSockConnectionReentrantLock = new ReentrantLock();


private Context mContext;
private Set<ISocketClient> mListener = new CopyOnWriteArraySet<ISocketClient>();
// 保存每次上传器的对象
private HashMap<Long, UploadFile> mMapUploadFile = new HashMap<Long, UploadFile>();
// 保存每次下载器的对象
private HashMap<Integer, DownloadFile> mMapDownLoadFile = new HashMap<Integer, DownloadFile>();


private IPPushManager(String hostName, int port) {
mHostname = hostName;
mPort = port;
}


public static void init(String hostName, int port) {
if (pushManager == null) {
pushManager = new IPPushManager(hostName, port);
}
}


public static IPPushManager getInstance() {
if (pushManager == null) {
throw new RuntimeException("before call init()");
}
return pushManager;
}


public void addListener(ISocketClient listener) {
if (listener != null) {
mListener.add(listener);
}


}


public void removeListener(ISocketClient listener) {
if (listener != null) {
mListener.remove(listener);
}
}


/**
* 发送消息
* 
* @Title: send
* @Description: TODO
* @return: void
*/
public void send(byte[] request) {
if (mWriteHandler != null) {
mWriteHandler.sendMessage(mWriteHandler.obtainMessage(0, request));
}
}


public void setPushListener(PushListener pushListener) {
mPushListener = pushListener;
}


/**
* 建立连接
* 
* @Title: connect
* @Description: TODO
* @return: void
*/
public void connect(final OnConnectListener listener) {
new Thread() {
public void run() {
mSockConnectionReentrantLock.lock();
try {
if (isConnected()) {
return;
}


// dissConnect();


InetSocketAddress addr = new InetSocketAddress(mHostname,
mPort);
mSocket = new Socket();
mSocket.connect(addr, 10 * 1000);
if (mSocket.isConnected()) {
mSocket.setKeepAlive(true); // 长连接
mSocket.setTcpNoDelay(true);// 数据不作缓冲，立即发送
mSocket.setSoLinger(true, 0);// socket关闭时，立即释放资源
mInputStream = mSocket.getInputStream();
mOutputStream = mSocket.getOutputStream();
// 初始化协议处理器
mProtocaolThread = new HandlerThread(
"IPPush ProtocaolController");
mProtocaolThread.start();


mReadThread = new ReadThread();
mReadThread.setName("IPPush ReadHandlerThread");
mReadThread.start();


mWriteThread = new HandlerThread(
"IPPush WriteHandlerThread");
mWriteThread.start();
mWriteHandler = new WriteHandler(
mWriteThread.getLooper());


if (listener != null) {
listener.onConnectSuccess(IPPushManager.this);
}
} else {
// 连接失败
if (listener != null) {
listener.onConnectFail(new SocketException("连接失败"));
}
}
} catch (Exception e) {
// 连接失败
if (listener != null) {
listener.onConnectFail(e);
}
dissConnect();


} finally {
mSockConnectionReentrantLock.unlock();
}
};
}.start();
}


/**
* 通道是否打开
* 
* @Title: isOpen
* @Description: TODO
* @return
* @return: boolean
*/
public boolean isConnected() {
try {
return mSocket != null && mSocket.isConnected()
&& !mSocket.isInputShutdown()
&& !mSocket.isOutputShutdown();
} catch (Exception e) {
return false;
}
}


public void onPush() {
if (mPushListener != null) {
mPushListener.onPush();
}
}


/**
* 断开连接
* 
* @Title: dissConnect
* @Description: TODO
* @return: void
*/
public void dissConnect() {
try {
if (mInputStream != null) {
mInputStream.close();
mInputStream = null;
}


if (mOutputStream != null) {
mOutputStream.close();
mOutputStream = null;
}


if (mSocket != null) {
mSocket.close();
mSocket = null;
}


if (mWriteHandler != null) {
mWriteHandler.sendEmptyMessage(-1);
mWriteHandler = null;
}


readWriteBytesCount = 0;
} catch (Exception e) {
}
}


private class WriteHandler extends Handler {


public WriteHandler(Looper looper) {
super(looper);
}


@Override
public void handleMessage(Message msg) {
if (msg.what == -1) {
getLooper().quit();
return;
}


if (msg.obj != null && msg.obj instanceof byte[]) {


if