android_与C# socket服务端通信例子源码下载

【实例截图】

【核心代码】

服务端：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Net.Sockets;
using System.Net;
using System.IO;
using System.Web.Script.Serialization;

namespace SocketServer
{
    public class SocketHost
    {
        private IDictionary<Socket, byte[]> socketClientSesson = new Dictionary<Socket, byte[]>();

        public int Port { get; set; }

        public void Start()
        {
            var socketThread = new Thread(() =>
            {
                Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPEndPoint iep = new IPEndPoint(IPAddress.Any, this.Port);

                //绑定到通道上
                socket.Bind(iep);

                //侦听
                socket.Listen(6);

                //通过异步来处理
                socket.BeginAccept(new AsyncCallback(Accept), socket);

            });

            socketThread.Start();

            Console.WriteLine("服务器已启动");
        }

        private void Accept(IAsyncResult ia)
        {
            Socket socket = ia.AsyncState as Socket;
            var client = socket.EndAccept(ia);

            socket.BeginAccept(new AsyncCallback(Accept), socket);

            byte[] buf = new byte[1024];
            this.socketClientSesson.Add(client, buf);

            try
            {
                client.BeginReceive(buf, 0, buf.Length, SocketFlags.None, new AsyncCallback(Receive), client);
                string sessionId = client.Handle.ToString();
                Console.WriteLine("客户端({0})已连接", sessionId);
            }
            catch (Exception ex)
            {
                Console.WriteLine("监听请求时出错：\r\n"   ex.ToString());
            }
        }

        private void Receive(IAsyncResult ia)
        {
            var client = ia.AsyncState as Socket;

            if (client == null || !this.socketClientSesson.ContainsKey(client))
            {
                return;
            }

            int count = client.EndReceive(ia);

            byte[] buf = this.socketClientSesson[client];

            if (count > 0)
            {
                try
                {
                    client.BeginReceive(buf, 0, buf.Length, SocketFlags.None, new AsyncCallback(Receive), client);
                    string context = Encoding.UTF8.GetString(buf, 0, count);
                    Console.WriteLine("接收的数据为:", context);

                    this.Response(client, context);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("接收的数据出错:\r\n{0}", ex.ToString());
                }
            }
            else
            {
                try
                {
                    string sessionId = client.Handle.ToString();
                    client.Disconnect(true);
                    this.socketClientSesson.Remove(client);
                    Console.WriteLine("客户端({0})已断开", sessionId);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("客户端已断开出错"   ex.ToString());
                }
            }
        }

        private void Response(Socket sender, string context)
        {
            SocketRequest request = null;
            JavaScriptSerializer jss = new JavaScriptSerializer();
            request = jss.Deserialize(context, typeof(SocketRequest)) as SocketRequest;

            if (request == null)
            {
                return;
            }

            var typeName = "SocketServer."   request.Method   "ResponseManager, SocketServer";
            Console.WriteLine("反射类名为："   typeName);

            Type type = Type.GetType(typeName);
            if (type == null)
            {
                return;
            }

            var manager = Activator.CreateInstance(type) as IResponseManager;
            manager.Write(sender, this.socketClientSesson.Select(s => s.Key).ToList(),
                request.Param as IDictionary<string, object>);
        }
    }
}

客户端：

package ld.socket;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import android.os.Handler;
import android.os.Message;
import android.util.Log;

public class SocketClient {

	private static Socket client;

	private static SocketClient instance = null;

	public static SocketClient getInstance() {
		if (instance == null) {

			synchronized (ChartInfo.class) {
				if (instance == null) {
					try {
						ChartInfo chartInfo = ChartInfo.getInstance();
						client = new Socket(chartInfo.getIp(), chartInfo
								.getPort());
						instance = new SocketClient();
					} catch (UnknownHostException e) {
						// TODO Auto-generated catch block
					} catch (IOException e) {
						// TODO Auto-generated catch block
					}
				}
			}
		}
		return instance;
	}

	private SocketClient() {
		this.initMap();
		this.startThread();
	}

	private void initMap() {
		this.handlerMap = new HashMap<String, Handler>();
	}

	public void close() {
		try {
			client.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			//e.printStackTrace();
		}
		instance = null;
	}
	
	private void startThread() {
		Thread thread = new Thread() {
			@Override
			public void run() {

				while (true) {
					if (client == null || !client.isConnected()) {
						continue;
					}

					BufferedReader reader;
					try {
						reader = new BufferedReader(new InputStreamReader(
								client.getInputStream()));
						String line = reader.readLine();
						Log.d("initSocket", "line:"   line);
						if (line.equals("")) {
							continue;
						}

						JSONObject json = new JSONObject(line);
						String method = json.getString("Method");
						Log.d("initSocket", "method:"   method);
						if (method.equals("")
								|| !handlerMap.containsKey(method)) {
							Log.d("initSocket", "handlerMap not method");
							continue;
						}

						Handler handler = handlerMap.get(method);
						if (handler == null) {
							Log.d("initSocket", "handler is null");
							continue;
						}
						Log.d("initSocket", "handler:"   method);
						Object obj = json.getJSONObject("Result");
						Log.d("initSocket", "Result:"   obj);
						Message msg = new Message();
						msg.obj = obj;
						handler.sendMessage(msg);

					} catch (IOException e) {

					} catch (JSONException e) {

					}
				}
			}
		};
		thread.start();
	}

	private Map<String, Handler> handlerMap;

	public void putHandler(String methodnName, Handler handler) {
		this.removeHandler(methodnName);
		this.handlerMap.put(methodnName, handler);
	}

	public void removeHandler(String methodnName) {
		if (this.handlerMap.containsKey(methodnName)) {
			this.handlerMap.remove(methodnName);
		}
	}

	public void logon(String userName) {
		Log.d("initSocket", "logon");
		try {
			OutputStreamWriter osw = new OutputStreamWriter(client
					.getOutputStream());

			BufferedWriter writer = new BufferedWriter(osw);

			JSONObject param = new JSONObject();
			param.put("UserName", userName.replace("\n", " "));

			JSONObject json = this.getJSONData("Logon", param);

			writer.write(json.toString());
			writer.flush();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (JSONException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void sendMessage(String message) {
		Log.d("initSocket", "Send");
		try {
			OutputStreamWriter osw = new OutputStreamWriter(client
					.getOutputStream());

			BufferedWriter writer = new BufferedWriter(osw);

			JSONArray array = new JSONArray();
			for (String item : message.split("\n")) {
				array.put(item);
			}

			JSONObject param = new JSONObject();
			param.put("Message", array);

			param.put("UserName", ChartInfo.getInstance().getUserName());

			JSONObject json = this.getJSONData("Send", param);

			writer.write(json.toString());
			writer.flush();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (JSONException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private JSONObject getJSONData(String methodName, JSONObject param) {
		JSONObject json = new JSONObject();
		try {
			json.put("Method", methodName);
			SimpleDateFormat format = new SimpleDateFormat(
					"yyyy-MM-dd HH:mm:ss");
			json.put("DateTime", format.format(new Date()));
			json.put("Param", param);
			return json;
		} catch (JSONException e) {
			return null;
		}
	}
}