Android Tcp服务器端

package com.chy.socket;


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


import com.chy.global.GlobalValue;


public class TcpServer {


	private ServerSocket serverSocket = null;
	private List<Socket> clientList = null;
	private OnReceiveListener onReceiveListener = null;
	private ExecutorService executorService = null;


	public interface OnReceiveListener {
		public void onReceive(Socket socket, OutputStream os, byte[] buffer, int len);
	}


	class ReadRunnable implements Runnable {


		private Socket socket = null;
		private InputStream is = null;
		private OutputStream os = null;


		public ReadRunnable(Socket socket) {
			this.socket = socket;
			try {
				is = socket.getInputStream();
				os = socket.getOutputStream();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}


		@Override
		public void run() {
			int len = 0;
			byte[] buffer = new byte[GlobalValue.READ_BLOCK_SIZE];
			while (true) {
				try {
					len = is.read(buffer, 0, GlobalValue.READ_BLOCK_SIZE);
					if (len > 0) {
						if (onReceiveListener != null) {
							onReceiveListener.onReceive(socket, os, buffer, len);
						}
					}
				} catch (IOException ex) {
					ex.printStackTrace();
					break;
				}
			}
			clientList.remove(socket);
			closeClient(socket);
		}


	}


	public TcpServer(int port, OnReceiveListener onReceivedListener) {
		try {
			serverSocket = new ServerSocket(port);
		} catch (IOException ex) {
			ex.printStackTrace();
		}
		if (serverSocket == null) {
			return;
		}
		this.onReceiveListener = onReceivedListener;
		clientList = new ArrayList<Socket>();
		executorService = Executors.newFixedThreadPool(GlobalValue.TCP_MAX_CONNECT_COUNT);
		// 监听线程
		executorService.execute(new Runnable() {
			@Override
			public void run() {
				Socket socket = null;
				while (true) {
					try {
						socket = serverSocket.accept();
						clientList.add(socket);
						executorService.execute(new ReadRunnable(socket));
					} catch (IOException ex) {
						ex.printStackTrace();
						break;
					}
				}
				closeClient(socket);
			}
		});
	}


	public synchronized boolean send(Socket socket, OutputStream os, byte[] buffer) {
		boolean result = false;
		if (os != null) {
			try {
				os.write(buffer);
				os.flush();
				result = true;
			} catch (IOException ex) {
				ex.printStackTrace();
			}
		}
		return result;
	}


	public void closeClient(Socket socket) {
		if (socket == null) {
			return;
		}
		try {
			InputStream is = socket.getInputStream();
			if (is != null) {
				is.close();
			}
			OutputStream os = socket.getOutputStream();
			if (os != null) {
				os.close();
			}
			socket.close();
		} catch (IOException ex) {
			ex.printStackTrace();
		}
	}


	public void close() {
		if (clientList != null) {
			for (Socket socket : clientList) {
				closeClient(socket);
			}
		}
		if (serverSocket != null) {
			try {
				serverSocket.close();
			} catch (IOException ex) {
				ex.printStackTrace();
			}
		}
	}
}