软件工程 2016.7.3 日报

软件工程 2016.7.3日报

---

 

　　在周五我初步搭建了吐槽墙的结构，实现了部分的功能。经过与组长的讨论，我们最终决定使用TCP通信的方式实现功能。因为对于这种比较明显的C/S结构，UDP方式的通信会使得整体处理信息的过程延迟比较大，不符合功能需求。

　　经过讨论分析，Server和Client通信的信息主要有以下几类：

　　　　1、Client向Server发送Client房间列表，Server端check本地是否含有所有房间，若不含的话，需要创建新文件存储响应聊天信息。

　　　　2、Client向Server请求特定房间的聊天记录。

　　　　3、Client向Server发送特定房间的吐槽消息。

　　　　4、Server向Client发送特定房间的聊天记录。

　　　　5、Server向Client发送Client端向Server端发送的消息是否更新成功的信息。

　　由此我定义了一下状态字，存于所有消息的第一位，用于标记消息后续部分的作用：

    private const byte CHECK_ROOM_LIST = 0;
    private const byte REQUEST_ROOM_MSG = 1;
    private const byte SEND_MSG = 2;
    private const byte DISCONNECT = 3;
    private const byte IS_RECEIVE_MSG = 4;
    private const byte IS_NOT_RECEIVE_MSG = 5;
    private const byte INVALID_MESSAGE = 6;

　　对于上述消息通信，Client端向Server端发送的消息包含两部分内容，一为房间id，二为吐槽消息，所以需要定义一个结构体保存两部分的内容，而后使用JSON解析工具进行包装、解析等。结构体定义如下：

    public struct MsgHandler
    {
        public string roomId;
        public string msg;

        public MsgHandler(string r, string m)
        {
            roomId = r; msg = m;
        }
    }

　　除此之外，实现了服务端的逻辑框架，以及部分的功能，已实现的代码如下：

　　　　开启服务器

        public void StartServer()
        {
            // Create a socket, use IPv4, stream connection and TCP
            socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            // create a endpoing which binds the ip and port 
            IPAddress ipAddress = IPAddress.Parse(ipAddr);
            IPEndPoint endPoint = new IPEndPoint(ipAddress, port);

            try
            {
                // bind the watching socket to the endpoint
                socketWatch.Bind(endPoint);

                // set the length of waiting queue
                socketWatch.Listen(20);

                // Create a watching thread
                threadWatch = new Thread(WatchConnection);
                // Set the background property
                threadWatch.IsBackground = true;
                // Start the thread
                threadWatch.Start();

                Console.WriteLine();
                Console.WriteLine("                          ---Server Start---");
                Console.WriteLine();

                return;
            }
            catch (SocketException se)
            {
                Console.WriteLine("[SocketERROR]" + se.Message);
                return;
            }
            catch (Exception e)
            {
                Console.WriteLine("[ERROR]" + e.Message);
                return;
            }
        }

　　　　监听客户请求

        private void WatchConnection()
        {
            // keep watching 
            while (true)
            {
                Socket socketConnection = null;
                try
                {
                    // watch the request, if has, create a socket for it
                    socketConnection = socketWatch.Accept();
                    string socketKey = socketConnection.RemoteEndPoint.ToString();
                    
                    // save every socket with the key in the form of IP : port
                    dictSocket.Add(socketKey, socketConnection);

                    Console.WriteLine("User IP : {0} has connected...", socketKey);

                    // Create a thread to watch the data sent from client for every socket
                    // Create the communicate thread
                    Thread threadCommunicate = new Thread(ReceiveMsg);
                    threadCommunicate.IsBackground = true;
                    threadCommunicate.Start(socketConnection);

                    dictThread.Add(socketKey, threadCommunicate);

                }
                catch (SocketException se)
                {
                    Console.WriteLine("[ERROR]" + se.Message);
                    return;
                }
                catch (Exception e)
                {
                    Console.WriteLine("[ERROR]" + e.Message);
                    return;
                }
            }
        }

　　　　监听用户信息

        private void ReceiveMsg(object socketClientPara)
        {
            Socket socketClient = socketClientPara as Socket;
            string socketKey = socketClient.RemoteEndPoint.ToString();

            while (true)
            {
                // define a buffer for received message
                byte[] msgReceiver = new byte[1024 * 1024 * 2];

                // length of received message
                int length = -1;

                try
                {
                    length = socketClient.Receive(msgReceiver);
                }
                catch (SocketException se)
                {
                    Console.WriteLine("[ERROR]" + socketKey + " receive error. Message: " + se.Message);

                    dictSocket[socketKey].Close();
                    Thread tmp = dictThread[socketKey];

                    // Remove the error object
                    dictSocket.Remove(socketKey);
                    dictThread.Remove(socketKey);
                    tmp.Abort();

                    return;
                }
                catch (Exception e)
                {
                    Console.WriteLine("[ERROR]" + e.Message);
                    return;
                }

                string msg = Encoding.UTF8.GetString(msgReceiver, 1, length - 1);

                if (msgReceiver[0] == CHECK_ROOM_LIST)
                    CheckRoomList(msg);
                else if (msgReceiver[0] == REQUEST_ROOM_MSG)
                    GetRoomMsg(socketKey, msg);
                else if (msgReceiver[0] == SEND_MSG)
                    AddMsgToFile(socketKey, msg);
                else if (msgReceiver[0] == DISCONNECT)
                    RemoveOfflineUser(socketKey);
                else
                    InvalidMsg(socketKey);
            }
        }

　　　　发送消息

        private void SendMessage(string clientIP, byte flag, string msg)
        {
            try
            {
                byte[] arrMsg = Encoding.UTF8.GetBytes(msg);
                byte[] sendArrMsg = new byte[arrMsg.Length + 1];

                // set the msg type
                sendArrMsg[0] = flag;
                Buffer.BlockCopy(arrMsg, 0, sendArrMsg, 1, arrMsg.Length);

                dictSocket[clientIP].Send(sendArrMsg);
            }
            catch (SocketException se)
            {
                Console.WriteLine("[SocketERROR] send message error : {0}", se.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("[ERROR] send message error : {0}", e.Message);
            }
        }