這幾天研究了下Socket互動。
    通過網上的資料做了有關Socket的第一個Demo，雖然不是很成熟，但個人感覺已經相對比較完整了。各型別資料的傳輸接受都有，其中也做了float型別的（因為我感覺做Unity應該用的著）。
    功能方面，為了測試多使用者互動，我在Demo上開啟了4個Socket 4個執行緒接受資料。實現了服務端通知使用者進入 離開功能。
    真機上，需要加上字型檔，要不無法顯示中文。
   
    工程目錄：

 

    下面上程式碼：

客戶端程式碼：

[csharp] view plaincopyprint?

1. using UnityEngine;  
2. using System;  
3. using System.Collections;  
4. using LSocket.Net;  
5. using LSocket.Type;  
6. using LSocket.cmd;  
7. publicclass SocketDemo : MonoBehaviour  
8.    {  
9. public UnitySocket[] socket;  
10. public String[] textAreaString;  
11. public String[] textFieldString;  
12. public GUISkin mySkin;  
13. // Use this for initialization
14. void Start()  
15.        {  
16.            socket = new UnitySocket[4];  
17.            textAreaString = new String[12];  
18. for (int i = 0; i < 12; i++)  
19.            {  
20.                textAreaString[i] = "";  
21.            }  
22.            textFieldString = new String[4];  
23. for(int i=0;i<4;i++){  
24.                textFieldString[i] = 
    "";  
25.            }  
26.        }  
27. // Update is called once per frame
28. void Update()  
29.        {  
30.        }  
31. void OnGUI()  
32.        {  
33.            GUI.skin = mySkin;  
34. for (int i = 0; i < 4; i++)  
35.            {  
36.                String s = textAreaString[i * 3] + "\n" + textAreaString[i * 3 + 1] + "\n" + textAreaString[i * 3 + 2];  
37.                GUI.TextArea(new Rect(i % 2 * Screen.width / 2, i / 2 * (Screen.height / 2) + 50, 100, 60), s);  
38.                textFieldString[i] = GUI.TextField(new Rect(i % 2 * Screen.width / 2+50, i / 2 * (Screen.height / 2), 100, 20), textFieldString[i]);  
39. if (GUI.Button(new Rect(i % 2 * Screen.width / 2, i / 2 * (Screen.height / 2), 40, 20), "連線"))  
40.                {  
41.                    socket[i] = null;  
42.                    socket[i] = new UnitySocket();  
43.                    socket[i].SocketConnection("192.168.0.8", 10000, this, i);  
44.                    socket[i].DoLogin(textFieldString[i]);  
45.                }  
46. elseif (GUI.Button(new Rect(i % 2 * Screen.width / 2, i / 2 *( Screen.height / 2) + 25, 40, 20), "關閉"))  
47.                {  
48. if (socket[i] != null)  
49.                    {  
50.                        socket[i].close();  
51.                        socket[i] = null;  
52.                    }  
53.                }  
54.            }  
55. if (GUI.Button(new Rect(Screen.width - 60, Screen.height - 30, 60, 30), "退出")) {  
56.                Application.Quit();  
57.            }  
58.        }  
59.    }  

 using UnityEngine;
 using System;
 using System.Collections;
 using LSocket.Net;
 using LSocket.Type;
 using LSocket.cmd;

    public class SocketDemo : MonoBehaviour
    {
        public UnitySocket[] socket;
        public String[] textAreaString;
        public String[] textFieldString;
        public GUISkin mySkin;
        // Use this for initialization
        void Start()
        {
            socket = new UnitySocket[4];
            textAreaString = new String[12];
            for (int i = 0; i < 12; i++)
            {
                textAreaString[i] = "";
            }
            textFieldString = new String[4];
            for(int i=0;i<4;i++){
                textFieldString[i] = "";
            }
        }

        // Update is called once per frame
        void Update()
        {

        }

        void OnGUI()
        {
            GUI.skin = mySkin;
            for (int i = 0; i < 4; i++)
            {
                String s = textAreaString[i * 3] + "\n" + textAreaString[i * 3 + 1] + "\n" + textAreaString[i * 3 + 2];
                GUI.TextArea(new Rect(i % 2 * Screen.width / 2, i / 2 * (Screen.height / 2) + 50, 100, 60), s);
                textFieldString[i] = GUI.TextField(new Rect(i % 2 * Screen.width / 2+50, i / 2 * (Screen.height / 2), 100, 20), textFieldString[i]);
                if (GUI.Button(new Rect(i % 2 * Screen.width / 2, i / 2 * (Screen.height / 2), 40, 20), "連線"))
                {
                    socket[i] = null;
                    socket[i] = new UnitySocket();
                    socket[i].SocketConnection("192.168.0.8", 10000, this, i);
                    socket[i].DoLogin(textFieldString[i]);
                }
                else if (GUI.Button(new Rect(i % 2 * Screen.width / 2, i / 2 *( Screen.height / 2) + 25, 40, 20), "關閉"))
                {
                    if (socket[i] != null)
                    {
                        socket[i].close();
                        socket[i] = null;
                    }
                }
            }

            if (GUI.Button(new Rect(Screen.width - 60, Screen.height - 30, 60, 30), "退出")) {
                Application.Quit();
            }

        }
    }

[csharp] view plaincopyprint?

1. namespace LSocket.Net   
2. { /** 
3.  *  
4.  * @author feng俠,qq:313785443 
5.  * @date 2010-12-23 
6.  * 
7.  */
8. // 描   述：封裝c# socket資料傳輸協議 
9. using UnityEngine;   
10. using System;   
11. using System.Net.Sockets;   
12. using System.Net;   
13. using System.Collections;   
14. using System.Text;  
15. using System.Threading;  
16. using LSocket.Type;   
17. using LSocket.cmd;  
18. class SocketThread  
19.     {  
20.         UnitySocket socket;  
21.         SocketDemo demo;  
22. int idx;  
23. public SocketThread(UnitySocket socket, SocketDemo demo, int idx)  
24.         {  
25. this.socket = socket;  
26. this.demo = demo;  
27. this.idx = idx;  
28.         }  
29. publicvoid run()  
30.         {  
31. while (true)  
32.             {  
33. try
34.                 {  
35.                     String s = socket.ReceiveString();  
36.                     demo.textAreaString[idx * 3] = demo.textAreaString[idx * 3 + 1];  
37.                     demo.textAreaString[idx * 3 + 1] = demo.textAreaString[idx * 3 + 2];  
38.                     demo.textAreaString[idx * 3 + 2] = s;  
39.                     MonoBehaviour.print(s + " " + idx);  
40.                 }  
41. catch (Exception e)  
42.                 {  
43.                     MonoBehaviour.print(e.ToString());  
44.                     socket.t.Abort();  
45.                 }  
46.             }  
47.         }  
48.     }  
49. publicclass UnitySocket   
50.     {   
51. public Socket mSocket = null;  
52. public Thread t=null;  
53. private SocketThread st=null;  
54. public SocketDemo demo=null;  
55. public UnitySocket()   
56.         {   
57.         }   
58. publicvoid SocketConnection(string LocalIP, int LocalPort,SocketDemo demo,int idx)   
59.         {  
60. this.demo=demo;  
61.             mSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);   
62. try
63.             {   
64.                 IPAddress ip = IPAddress.Parse(LocalIP);   
65.                 IPEndPoint ipe = new IPEndPoint(ip, LocalPort);   
66.                 mSocket.Connect(ipe);  
67.                 st =new SocketThread(this, demo, idx);  
68.                 t = new Thread(new ThreadStart(st.run));  
69.                 t.Start();  
70.             }   
71. catch (Exception e)   
72.             {  
73.                 MonoBehaviour.print(e.ToString());  
74.             }   
75.         }  
76. publicvoid close(){  
77.             mSocket.Close(0);  
78.             mSocket=null;  
79.         }  
80. publicvoid DoLogin(String userName){  
81. try
82.             {  
83.                 Send(CommandID.LOGIN);  
84.                 Send(userName);  
85.             }catch(Exception e){  
86.                 MonoBehaviour.print(e.ToString());  
87.             }  
88.         }  
89. publicvoid Send(float data){  
90. byte[] longth = TypeConvert.getBytes(data, true);  
91.             mSocket.Send(longth);  
92.         }  
93. publicfloat ReceiveFloat()  
94.         {  
95. byte[] recvBytes = newbyte[4];  
96.             mSocket.Receive(recvBytes, 4, 0);//從伺服器端接受返回資訊 
97. float data = TypeConvert.getFloat(recvBytes, true);  
98. return data;  
99.         }   
100. publicvoid Send(short data)   
101.         {   
102. byte[] longth=TypeConvert.getBytes(data,true);   
103.             mSocket.Send(longth);  
104.         }   
105. publicvoid Send(long data)   
106.         {   
107. byte[] longth=TypeConvert.getBytes(data,true);   
108.             mSocket.Send(longth);   
109.         }   
110. publicvoid Send(int data)   
111.         {   
112. byte[] longth=TypeConvert.getBytes(data,true);   
113.             mSocket.Send(longth);   
114.         }   
115. publicvoid Send(string data)   
116.         {   
117. byte[] longth=Encoding.UTF8.GetBytes(data);  
118.             Send(longth.Length);  
119.             mSocket.Send(longth);   
120.         }   
121. publicshort ReceiveShort()   
122.         {   
123. byte[] recvBytes = newbyte[2];   
124.              mSocket.Receive(recvBytes,2,0);//從伺服器端接受返回資訊 
125. short data=TypeConvert.getShort(recvBytes,true);   
126. return data;   
127.         }   
128. publicint ReceiveInt()   
129.         {   
130. byte[] recvBytes = newbyte[4];   
131.              mSocket.Receive(recvBytes,4,0);//從伺服器端接受返回資訊 
132. int data=TypeConvert.getInt(recvBytes,true);   
133. return data;   
134.         }   
135. publiclong ReceiveLong()   
136.         {   
137. byte[] recvBytes = newbyte[8];   
138.              mSocket.Receive(recvBytes,8,0);//從伺服器端接受返回資訊 
139. long data=TypeConvert.getLong(recvBytes,true);   
140. return data;   
141.         }   
142. public String ReceiveString()   
143.         {   
144. int length = ReceiveInt();  
145.              MonoBehaviour.print("Stringlen="+length);  
146. byte[] recvBytes = newbyte[length];   
147.              mSocket.Receive(recvBytes,length,0);//從伺服器端接受返回資訊 
148.              String data = Encoding.UTF8.GetString(recvBytes);   
149. return data;   
150.         }   
151.     }  
152. }   

namespace LSocket.Net 
{ /**
 * 
 * @author feng俠,qq:313785443
 * @date 2010-12-23
 *
 */

    // 描   述：封裝c# socket資料傳輸協議 
  	using UnityEngine; 
	using System; 
	using System.Net.Sockets; 
	using System.Net; 
	using System.Collections; 
	using System.Text;
    using System.Threading;
	using LSocket.Type; 
	using LSocket.cmd;


    class SocketThread
    {

        UnitySocket socket;
        SocketDemo demo;
        int idx;

        public SocketThread(UnitySocket socket, SocketDemo demo, int idx)
        {
            this.socket = socket;
            this.demo = demo;
            this.idx = idx;
        }

        public void run()
        {
            while (true)
            {
                try
                {
                    String s = socket.ReceiveString();
                    demo.textAreaString[idx * 3] = demo.textAreaString[idx * 3 + 1];
                    demo.textAreaString[idx * 3 + 1] = demo.textAreaString[idx * 3 + 2];
                    demo.textAreaString[idx * 3 + 2] = s;
                    MonoBehaviour.print(s + " " + idx);
                }
                catch (Exception e)
                {
                    MonoBehaviour.print(e.ToString());
                    socket.t.Abort();
                }
            }
        }

    }

    public class UnitySocket 
    { 
        public Socket mSocket = null;
        public Thread t=null;
        private SocketThread st=null;
        public SocketDemo demo=null;

        public UnitySocket() 
        { 
             
        } 
		public void SocketConnection(string LocalIP, int LocalPort,SocketDemo demo,int idx) 
		{
            this.demo=demo;
			mSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
            try 
            { 
				 
                IPAddress ip = IPAddress.Parse(LocalIP); 
                IPEndPoint ipe = new IPEndPoint(ip, LocalPort); 
				mSocket.Connect(ipe);
                st =new SocketThread(this, demo, idx);
                t = new Thread(new ThreadStart(st.run));
                t.Start();
            } 
            catch (Exception e) 
            {
                MonoBehaviour.print(e.ToString());
            } 
		}
        
        public void close(){
            mSocket.Close(0);
            mSocket=null;
        }

        public void DoLogin(String userName){
            try
            {
                Send(CommandID.LOGIN);
                Send(userName);
            }catch(Exception e){
                MonoBehaviour.print(e.ToString());
            }
        }


        public void Send(float data){
            byte[] longth = TypeConvert.getBytes(data, true);
            mSocket.Send(longth);
        }

        public float ReceiveFloat()
        {
            byte[] recvBytes = new byte[4];
            mSocket.Receive(recvBytes, 4, 0);//從伺服器端接受返回資訊 
            float data = TypeConvert.getFloat(recvBytes, true);
            return data;
        } 

		public void Send(short data) 
		{ 
			byte[] longth=TypeConvert.getBytes(data,true); 
			mSocket.Send(longth);
		} 
		 
		public void Send(long data) 
		{ 
			byte[] longth=TypeConvert.getBytes(data,true); 
			mSocket.Send(longth); 
		} 
		 
		public void Send(int data) 
		{ 
			byte[] longth=TypeConvert.getBytes(data,true); 
			mSocket.Send(longth); 
			 
		} 
		 
		public void Send(string data) 
		{ 
			byte[] longth=Encoding.UTF8.GetBytes(data);
            Send(longth.Length);
			mSocket.Send(longth); 
			 
		} 
		 
		public short ReceiveShort() 
		{ 
			 byte[] recvBytes = new byte[2]; 
             mSocket.Receive(recvBytes,2,0);//從伺服器端接受返回資訊 
			 short data=TypeConvert.getShort(recvBytes,true); 
			 return data; 
		} 
		 
		public int ReceiveInt() 
		{ 
			 byte[] recvBytes = new byte[4]; 
             mSocket.Receive(recvBytes,4,0);//從伺服器端接受返回資訊 
			 int data=TypeConvert.getInt(recvBytes,true); 
			 return data; 
		} 
		 
		public long ReceiveLong() 
		{ 
			 byte[] recvBytes = new byte[8]; 
             mSocket.Receive(recvBytes,8,0);//從伺服器端接受返回資訊 
			 long data=TypeConvert.getLong(recvBytes,true); 
			 return data; 
		} 
		 
		public String ReceiveString() 
		{ 
             int length = ReceiveInt();
             MonoBehaviour.print("Stringlen="+length);
			 byte[] recvBytes = new byte[length]; 
             mSocket.Receive(recvBytes,length,0);//從伺服器端接受返回資訊 
             String data = Encoding.UTF8.GetString(recvBytes); 
			 return data; 
		} 
		 
		 
	}
} 

[csharp] view plaincopyprint?

1. namespace LSocket.Type  
2. {  
3. using UnityEngine;  
4. using System.Collections;  
5. publicclass TypeConvert  
6.     {  
7. public TypeConvert()  
8.         {  
9.         }  
10. publicstaticbyte[] getBytes(float s,bool asc){  
11. int buf = (int)(s * 100);  
12. return getBytes(buf,asc);  
13.         }  
14. publicstaticfloat getFloat(byte[] buf,bool asc){  
15. int i=getInt(buf,asc);  
16. float s=(float)i;  
17. return s/100;  
18.         }  
19. publicstaticbyte[] getBytes(short s, bool asc)  
20.         {  
21. byte[] buf = newbyte[2];  
22. if (asc)  
23.             {  
24. for (int i = buf.Length - 1; i >= 0; i--)  
25.                 {  
26.                     buf[i] = (byte)(s & 0x00ff);  
27.                     s >>= 8;  
28.                 }  
29.             }  
30. else
31.             {  
32. for (int i = 0; i < buf.Length; i++)  
33.                 {  
34.                     buf[i] = (byte)(s & 0x00ff);  
35.                     s >>= 8;  
36.                 }  
37.             }  
38. return buf;  
39.         }  
40. publicstaticbyte[] getBytes(int s, bool asc)  
41.         {  
42. byte[] buf = newbyte[4];  
43. if (asc)  
44. for (int i = buf.Length - 1; i >= 0; i--)  
45.                 {  
46.                     buf[i] = (byte)(s & 0x000000ff);  
47.                     s >>= 8;  
48.                 }  
49. else
50. for (int i = 0; i < buf.Length; i++)  
51.                 {  
52.                     buf[i] = (byte)(s & 0x000000ff);  
53.                     s >>= 8;  
54.                 }  
55. return buf;  
56.         }  
57. publicstaticbyte[] getBytes(long s, bool asc)  
58.         {  
59. byte[] buf = newbyte[8];  
60. if (asc)  
61. for (int i = buf.Length - 1; i >= 0; i--)  
62.                 {  
63.                     buf[i] = (byte)(s & 0x00000000000000ff);  
64.                     s >>= 8;  
65.                 }  
66. else
67. for (int i = 0; i < buf.Length; i++)  
68.                 {  
69.                     buf[i] = (byte)(s & 0x00000000000000ff);  
70.                     s >>= 8;  
71.                 }  
72. return buf;  
73.         }  
74. publicstaticshort getShort(byte[] buf, bool asc)  
75.         {  
76. if (buf == null)  
77.             {  
78. //throw new IllegalArgumentException("byte array is null!");
79.             }  
80. if (buf.Length > 2)  
81.             {  
82. //throw new IllegalArgumentException("byte array size > 2 !");
83.             }  
84. short r = 0;  
85. if (!asc)  
86. for (int i = buf.Length - 1; i >= 0; i--)  
87.                 {  
88.                     r <<= 8;  
89.                     r |= (short)(buf[i] & 0x00ff);  
90.                 }  
91. else
92. for (int i = 0; i < buf.Length; i++)  
93.                 {  
94.                     r <<= 8;  
95.                     r |= (short)(buf[i] & 0x00ff);  
96.                 }  
97. return r;  
98.         }  
99. publicstaticint getInt(byte[] buf, bool asc)  
100.         {  
101. if (buf == null)  
102.             {  
103. // throw new IllegalArgumentException("byte array is null!");
104.             }  
105. if (buf.Length > 4)  
106.             {  
107. //throw new IllegalArgumentException("byte array size > 4 !");
108.             }  
109. int r = 0;  
110. if (!asc)  
111. for (int i = buf.Length - 1; i >= 0; i--)  
112.                 {  
113.                     r <<= 8;  
114.                     r |= (buf[i] & 0x000000ff);  
115.                 }  
116. else
117. for (int i = 0; i < buf.Length; i++)  
118.                 {  
119.                     r <<= 8;  
120.                     r |= (buf[i] & 0x000000ff);  
121.                 }  
122. return r;  
123.         }  
124. publicstaticlong getLong(byte[] buf, bool asc)  
125.         {  
126. if (buf == null)  
127.             {  
128. //throw new IllegalArgumentException("byte array is null!");
129.             }  
130. if (buf.Length > 8)  
131.             {  
132. //throw new IllegalArgumentException("byte array size > 8 !");
133.             }  
134. long r = 0;  
135. if (!asc)  
136. for (int i = buf.Length - 1; i >= 0; i--)  
137.                 {  
138.                     r <<= 8;  
139.                     r |= (buf[i] & 0x00000000000000ff);  
140.                 }  
141. else
142. for (int i = 0; i < buf.Length; i++)  
143.                 {  
144.                     r <<= 8;  
145.                     r |= (buf[i] & 0x00000000000000ff);  
146.                 }  
147. return r;  
148.         }  
149.     }  
150. }  

namespace LSocket.Type
{
    using UnityEngine;
    using System.Collections;

    public class TypeConvert
    {

        public TypeConvert()
        {
        }

        public  static byte[] getBytes(float s,bool asc){
            int buf = (int)(s * 100);
            return getBytes(buf,asc);
        }
    
         public static float getFloat(byte[] buf,bool asc){
            int i=getInt(buf,asc);
            float s=(float)i;
            return s/100;
        }

        public static byte[] getBytes(short s, bool asc)
        {
            byte[] buf = new byte[2];
            if (asc)
            {
                for (int i = buf.Length - 1; i >= 0; i--)
                {
                    buf[i] = (byte)(s & 0x00ff);
                    s >>= 8;
                }
            }
            else
            {
                for (int i = 0; i < buf.Length; i++)
                {

                    buf[i] = (byte)(s & 0x00ff);
                    s >>= 8;
                }
            }
            return buf;
        }
        public static byte[] getBytes(int s, bool asc)
        {
            byte[] buf = new byte[4];
            if (asc)
                for (int i = buf.Length - 1; i >= 0; i--)
                {
                    buf[i] = (byte)(s & 0x000000ff);
                    s >>= 8;
                }
            else
                for (int i = 0; i < buf.Length; i++)
                {
                    buf[i] = (byte)(s & 0x000000ff);
                    s >>= 8;
                }
            return buf;
        }

        public static byte[] getBytes(long s, bool asc)
        {
            byte[] buf = new byte[8];
            if (asc)
                for (int i = buf.Length - 1; i >= 0; i--)
                {
                    buf[i] = (byte)(s & 0x00000000000000ff);
                    s >>= 8;
                }
            else
                for (int i = 0; i < buf.Length; i++)
                {
                    buf[i] = (byte)(s & 0x00000000000000ff);
                    s >>= 8;
                }
            return buf;
        }
        public static short getShort(byte[] buf, bool asc)
        {
            if (buf == null)
            {
                //throw new IllegalArgumentException("byte array is null!");
            }
            if (buf.Length > 2)
            {
                //throw new IllegalArgumentException("byte array size > 2 !");
            }
            short r = 0;
            if (!asc)
                for (int i = buf.Length - 1; i >= 0; i--)
                {
                    r <<= 8;
                    r |= (short)(buf[i] & 0x00ff);
                }
            else
                for (int i = 0; i < buf.Length; i++)
                {
                    r <<= 8;
                    r |= (short)(buf[i] & 0x00ff);
                }
            return r;
        }
        public static int getInt(byte[] buf, bool asc)
        {
            if (buf == null)
            {
                // throw new IllegalArgumentException("byte array is null!");
            }
            if (buf.Length > 4)
            {
                //throw new IllegalArgumentException("byte array size > 4 !");
            }
            int r = 0;
            if (!asc)
                for (int i = buf.Length - 1; i >= 0; i--)
                {
                    r <<= 8;
                    r |= (buf[i] & 0x000000ff);
                }
            else
                for (int i = 0; i < buf.Length; i++)
                {
                    r <<= 8;
                    r |= (buf[i] & 0x000000ff);
                }
            return r;
        }
        public static long getLong(byte[] buf, bool asc)
        {
            if (buf == null)
            {
                //throw new IllegalArgumentException("byte array is null!");
            }
            if (buf.Length > 8)
            {
                //throw new IllegalArgumentException("byte array size > 8 !");
            }
            long r = 0;
            if (!asc)
                for (int i = buf.Length - 1; i >= 0; i--)
                {
                    r <<= 8;
                    r |= (buf[i] & 0x00000000000000ff);
                }
            else
                for (int i = 0; i < buf.Length; i++)
                {
                    r <<= 8;
                    r |= (buf[i] & 0x00000000000000ff);
                }
            return r;
        }
    }
}

[csharp] view plaincopyprint?

1. namespace LSocket.cmd  
2. {  
3. publicclass CommandID  
4.     {  
5. /** 登陸訊息命令 **/
6. publicstaticint LOGIN = 1001;  
7.     }  
8. }  

namespace LSocket.cmd
{
    public class CommandID
    {
        /** 登陸訊息命令 **/
        public static int LOGIN = 1001;
     
    }
}

伺服器端程式碼 Java:

[java] view plaincopyprint?

1. package com.unity.socket;  
2. import java.net.ServerSocket;  
3. import java.net.Socket;  
4. import java.util.HashMap;  
5. publicclass SocketServer {  
6. private HashMap<String,User> userMap;  
7. public  SocketServer(){  
8.          userMap=new HashMap<String, User>();  
9.     }  
10. publicstaticvoid main(String[] args){  
11. new SocketServer().startServer();  
12.     }  
13. publicvoid startServer()  
14.     {  
15. try
16.         {  
17.             ServerSocket serverSocket = new ServerSocket(10000);  
18.             System.out.println("伺服器開啟");  
19. while (true){  
20.                 Socket socket = serverSocket.accept();  
21.                 System.out.println("有使用者登陸進來了");  
22. new UserThread(socket,userMap).start();  
23.             }  
24.         }catch (Exception e){  
25.              System.out.println("伺服器出現異常！" + e);  
26.         }  
27.     }  
28. }  

package com.unity.socket;


import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;


public class SocketServer {
    private HashMap<String,User> userMap;

    public  SocketServer(){
         userMap=new HashMap<String, User>();
    }

    public static void main(String[] args){
        new SocketServer().startServer();
    }

    public void startServer()
	{
		try
		{
			ServerSocket serverSocket = new ServerSocket(10000);
			System.out.println("伺服器開啟");
            while (true){
                Socket socket = serverSocket.accept();
                System.out.println("有使用者登陸進來了");
                new UserThread(socket,userMap).start();
            }

        }catch (Exception e){
             System.out.println("伺服器出現異常！" + e);
        }
    }
}

[java] view plaincopyprint?

1. package com.unity.socket;  
2. import java.net.Socket;  
3. publicclass User {  
4. private String name;  
5. private Socket socket;  
6. public String getName() {  
7. return name;  
8.     }  
9. publicvoid setName(String name) {  
10. this.name = name;  
11.     }  
12. public Socket getSocket() {  
13. return socket;  
14.     }  
15. publicvoid setSocket(Socket socket) {  
16. this.socket = socket;  
17.     }  
18. }  

package com.unity.socket;

import java.net.Socket;

public class User {
    private String name;
    private Socket socket;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Socket getSocket() {
        return socket;
    }

    public void setSocket(Socket socket) {
        this.socket = socket;
    }

}

[java] view plaincopyprint?

1. package com.unity.socket;  
2. import java.io.*;  
3. import java.net.Socket;  
4. import java.util.Iterator;  
5. import java.io.ByteArrayOutputStream;  
6. import java.io.DataOutputStream;  
7. import java.util.HashMap;  
8. publicclass UserThread extends Thread{  
9. /** 錯誤訊息命令 **/
10. publicstaticfinalint             ERROR = 0;  
11. /** 登陸訊息命令 **/
12. publicstaticfinalint             LOGIN = 1001;  
13. private Socket socket;  
14. private HashMap<String,User> userMap;  
15. private User user;  
16. private ByteArrayOutputStream byteOutput;  
17. private DataOutputStream output;  
18. private DataInputStream input;  
19. public UserThread(Socket socket,HashMap<String,User> userMap){  
20. this.socket=socket;  
21. this.userMap=userMap;  
22.     }  
23. //重新初始化2個新的output
24. privatevoid initOutput()  
25.     {  
26.         byteOutput = new ByteArrayOutputStream();  
27.         output = new DataOutputStream(byteOutput);  
28.     }  
29. publicvoid sendAllUser(byte[] bytes) throws Exception  
30.     {  
31. for(Iterator<User> it = userMap.values().iterator(); it.hasNext();)  
32.         {  
33.             sendMessage(it.next().getSocket(),bytes);  
34.         }  
35.     }  
36. publicvoid sendMessage(Socket socket,byte[] bytes) throws Exception  
37.     {  
38.         DataOutputStream dataOutput = new DataOutputStream(socket.getOutputStream());  
39.         dataOutput.write(bytes);  
40.         dataOutput.flush();  
41.     }  
42. publicshort readShort()throws IOException{  
43. byte[] buf=newbyte[2];  
44.           input.read(buf);  
45. return ConvertType.getShort(buf,true);  
46.     }  
47. publicint readInt()throws IOException{  
48. byte[] buf=newbyte[4];  
49.           input.read(buf);  
50. return ConvertType.getInt(buf, true);  
51.     }  
52. publiclong readLong()throws IOException{  
53. byte[] buf=newbyte[8];  
54.           input.read(buf);  
55. return ConvertType.getLong(buf, true);  
56.     }  
57. publicfloat readFloat()throws IOException{  
58. byte[] buf=newbyte[4];  
59.           input.read(buf);  
60. return ConvertType.getFloat(buf, true);  
61.     }  
62. public String readString()throws IOException{  
63. int length=readInt();  
64. byte[] buf=newbyte[length];  
65.           input.read(buf);  
66. return

    相關推薦

    Unity Socket 互動程式設計

    這幾天研究了下Socket互動。     通過網上的資料做了有關Socket的第一個Demo，雖然不是很成熟，但個人感覺已經相對比較完整了。各型別資料的傳輸接受都有，其中也做了float型別的（因為我感覺做Unity應該用的著）。     功能方面，為了測試多使用者互

    Unity Socket網路程式設計(TCP) 簡單例子-1

    開發工具：Visual Studio、Unity 開發語言：C# 【伺服器端】 在VS建立一個C#空專案 程式碼如下： using System; using Syste

    Unity Socket網路程式設計(TCP)

    開發工具：Visual Studio、Unity 開發語言：C# 【伺服器端】 在VS建立一個C#空專案 程式碼如下： using System; using System.Collections.G

    java：socket 網路程式設計

    socket的通俗解釋： 套接字=主機+埠號。兩個東西配在一起，叫做“配套”。 另外“套”也有對應的意思，它可以把網路上的兩個應用對應起來，所以用“套”。 它是用來與另一個應用連線的，所以用“接”。 又因為它是一小段資料，很小一小段，所以叫“字”。 “套接字",就是一小段用來將網路個兩個應用

    [Socket網路程式設計]一個封鎖操作被對 WSACancelBlockingCall 的呼叫中斷。

    原文地址：http://www.cnblogs.com/xiwang/archive/2012/10/25/2740114.html記錄在此，方便查閱。 C#中在使用UDPClient迴圈監聽埠，在斷開UPDClient的時候，使用try...catch捕獲了異常，System.NET.Socket

    Python_day6:socket網路程式設計

    一、socket 　　socket即套接字，用於描述IP地址和埠，是一個通訊鏈的控制代碼，應用程式通常通過"套接字"向網路發出請求或者應答網路請求。 　　最簡單的socket，一次 1 import socket 2 server = socket.socket() #獲得例項

    python------Socket網路程式設計（二）粘包問題

    一.socket網路程式設計  粘包：服務端兩次傳送指令在一起，它會把兩次傳送內容合在一起傳送，稱為粘包，從而出現錯誤。 解決方法：（比較low的方法） 有些需要實時更新的，用sleep有延遲，不能這樣解決問題。 解決方法之高階方法： 客戶端： 二.傳送檔案 ftp s

    門禁系統socket通訊程式設計

    最近遇到一個socke udp協議通訊的需求，而且是16進位制資料接收。這樣在傳輸引數的時候老是提示引數錯誤，因為計算機是不能直接傳輸16進位制的，會自行轉換，所有以下程式碼非常完美的解決我的問題，同時也讓我認識到並不是所有socket都是需要一個客戶端和服務端程式碼 <?php  &nbs

    Socket網路程式設計進階與實戰資源分享

    Socket網路程式設計進階與實戰資源分享 Socket網路程式設計進階與實戰資源分享 獲取資源新增qq+2100776785 獲取資源新增qq+2100776785 第1章 課程介紹 本章將從軟體測試的起源與發展、測試行業的現狀及職業生涯規劃等整體做介紹。 第2章 軟體測試工程師必

    python 協程及socket網路程式設計

    協程 什麼是協程 協程，英文Coroutines，是一種比執行緒更加輕量級的存在。正如一個程序可以擁有多個執行緒一樣，一個執行緒也可以擁有多個協程。 最重要的是，協程不是被作業系統核心所管理，而完全是由程式所控制（也就是在使用者態執行）。 這樣帶來的好處就是效能得到了很大的提升，不會

    Python Socket網路程式設計（一）初識Socket和Socket初步使用

    目錄 前言 網路程式設計 實質 IP地址和埠 資料傳輸協議 協議 Socket

    Python Socket網路程式設計（二）區域網內和區域網與廣域網的持續通訊

    目錄 前言 IP地址 簡介 公有IP 私有IP 區域網之間網路通訊 前提 功能描述

    銀行業務系統（c/s架構、socket網路程式設計、多執行緒）

    1、功能要求 包括兩類使用者：管理人員和普通使用者（本文只寫了普通使用者程式） 普通使用者功能：登入登出、存取款、轉賬、查詢餘額 2、技術要求 要求用到多程序多執行緒 要求同時允許多個使用者操作（因為沒有註冊賬號功能，且只初始化了兩個賬號資訊，所以同時只能允許兩個賬號線上）

    Socket網路程式設計（一）

    此文使用的協議是 TCP       首先要寫入以下程式碼，不然很多函式都用不了 #include <WinSock2.h> #pragma comment(lib, "ws2_32.lib")   ●伺服器端    

    Unity+Lua互動篇

    首先在我們偉大的GetHub上下載XLua框架。 今天就只發點基礎哈，畢竟第一次弄這個。。 本章主要說一些 Lua 的引用以及 C# 呼叫 Lua。 C#： //執行字串 //其中 Dostring 函式返回值即為程式碼塊裡 return 語句的返回值

    unity Socket TCP連線案例（一）

    非常清晰的demo 服務端 using System; using System.Collections; using System.Collections.Generic; using System.Net; using System.Net.Sockets; using Syste

    unity Socket TCP連接案例（一）

    mon star connect color 服務器 void ipaddress field .get 非常清晰的demo 服務端 using System; using System.Collections; using System.Collectio

    python運維-Socket網路程式設計

    課程地址：https://www.imooc.com/learn/1031 一、 課程介紹 二、Socket通訊入門 1.服務端程式 相關引數有預設 同一時間只有1個被處理，可以掛起的

    簡單的java socket TCP程式設計 每隔幾秒伺服器向客戶端傳時間

    客戶端 package javaSocket; import java.io.*; import java.net.*; import org.junit.Test; import jinghai.base.time.LocalDateTime; import jinghai.base.uti

    socket伺服器程式設計的多程序，多執行緒實現

    socket伺服器程式設計： 顧名思義就是使用socket套接字來編寫伺服器程式的過程。不熟悉socket程式設計的小夥伴可以看我之前的文章，但是當時所實現的功能伺服器同時只能和一個客戶端進行互動，效率太低，利用多程序或者多執行緒方式來實現伺服器可以做到同時和多個客戶端進行互動。提高伺服器的效能