我看不下去鳥。。。。Java和C#的socket通信真的簡單嗎？，

我看不下去鳥。。。。Java和C#的socket通信真的簡單嗎？，

這幾天在博客園上看到好幾個寫Java和C#的socket通信的帖子。但是都為指出其中關鍵點。

C# socket通信組件有很多，在vs 使用nuget搜索socket組件有很多類似的。本人使用的是自己開發的一套組件。

Java socket通信的組件也有很多，常用的大多數都是用的mina或者netty。游戲行業使用也是居多。

關於socket的底層寫法，實在太多，我就不在BB。

這裡我想說，C#和C++或者叫VC++把是使用小端序作為字節序。而java使用的是大端序作為字節序。

也就是說比如一個int占用四個字節，java的字節序和c#的字節序是相反的，java的int四個字節第一個字節在數組的最後一個。C#是第一個。

也就是說如果java端正常發送一個int的字節序給C#，需要翻轉一次端緒。反之也是一樣的。一句話來概括的話就是高位在前還是低位在前的問題。

C#輸出數字 int 4 的字節序。為了保證c#下面絕對是是int所以加入了強制int轉化。默認的話可能是byte

java的默認輸出，這裡使用的是netty的默認框架。進行的int4的字節序輸出

高位和低位表示法完全不同。

java下面如果傳輸字符串，那麼必須要先把字符串轉化成byte數組，然後獲取數組長度，在字節序裡面壓入int表示的數組長度，然後在然如byte數組。不管你的字符串多長。

而C#也是相同做法。但是唯一不同的是數組的長度表示法不同。微軟經過了字節壓縮的。用字節的前7位表示長度。第8位表示下一個字節是否也是表示長度的字節，值需要與128位於。

從而減少字節的消耗。

現在一般如果我們在java和C#中無論是哪一個語言作為服務器。架設socket通信基准。其中另外一方都要妥協字節序反轉問題。

大多數情況下我們也許通信的要求不高，或許把一些類或者參數通過json格式化以後傳輸給對方。但是在這一條消息的傳輸中，一般會有兩個int需要字節序。最少也要一個字節序。

一個字節序int表示消息長度。另外一個字節序表示消息協議。

如果消息協議都放到json裡面沒有問題。但是消息長度是必不可少的。因為你需要知道在網絡環境中，消息壓棧，然後等待系統發出是有可能兩條消息一同發送的。也或者消息發送後由於網絡阻塞，前後相差好幾秒的消息同一時間達到。

這就是所謂的粘包。

我這裡就不表演了。

還有另外一種通信方式，就是通過protobuf進行字節序的序列化，和反序列，官方支持java，第三方支持C#。這個組件可以減少字節流。達到省流量，減少網絡資源消耗的問題。

例如一個long的類型值是1常規發送需要8個字節，64位。發送。如果改用protobuf的話只需要1字節8位就能發送。

同樣的問題，無論你使用哪一種序列化方式，都需要消息長度和消息協議號。

C#下面對int的反轉讀取。

 1         /// <summary>
 2         /// 讀取大端序的int
 3         /// </summary>
 4         /// <param name="value"></param>
 5         public int ReadInt(byte[] intbytes)
 6         {
 7             Array.Reverse(intbytes);
 8             return BitConverter.ToInt32(intbytes, 0);
 9         }
10 
11         /// <summary>
12         /// 寫入大端序的int
13         /// </summary>
14         /// <param name="value"></param>
15         public byte[] WriterInt(int value)
16         {
17             byte[] bs = BitConverter.GetBytes(value);
18             Array.Reverse(bs);
19             return bs;
20         }

粘包問題解決。

C#代碼

  1 using System;
  2 using System.Collections.Generic;
  3 using System.IO;
  4 using System.Linq;
  5 using System.Text;
  6 using System.Threading.Tasks;
  7 
  8 /**
  9  * 
 10  * @author 失足程序員
 11  * @Blog http://www.cnblogs.com/ty408/
 12  * @mail [email protected]
 13  * @phone 13882122019
 14  * 
 15  */
 16 namespace Sz.Network.SocketPool
 17 {
 18     public class MarshalEndian : IMarshalEndian
 19     {
 20 
 21         public enum JavaOrNet
 22         {
 23             Java,
 24             Net,
 25         }
 26 
 27         public MarshalEndian()
 28         {
 29 
 30         }
 31 
 32         public static JavaOrNet JN = JavaOrNet.Net;
 33 
 34         /// <summary>
 35         /// 讀取大端序的int
 36         /// </summary>
 37         /// <param name="value"></param>
 38         public int ReadInt(byte[] intbytes)
 39         {
 40             Array.Reverse(intbytes);
 41             return BitConverter.ToInt32(intbytes, 0);
 42         }
 43 
 44         /// <summary>
 45         /// 寫入大端序的int
 46         /// </summary>
 47         /// <param name="value"></param>
 48         public byte[] WriterInt(int value)
 49         {
 50             byte[] bs = BitConverter.GetBytes(value);
 51             Array.Reverse(bs);
 52             return bs;
 53         }
 54 
 55         //用於存儲剩余未解析的字節數
 56         private List<byte> _LBuff = new List<byte>(2);
 57 
 58         //字節數常量一個消息id4個字節
 59         const long ConstLenght = 4L;
 60 
 61         public void Dispose()
 62         {
 63             this.Dispose(true);
 64             GC.SuppressFinalize(this);
 65         }
 66 
 67         protected virtual void Dispose(bool flag1)
 68         {
 69             if (flag1)
 70             {
 71                 IDisposable disposable = this._LBuff as IDisposable;
 72                 if (disposable != null) { disposable.Dispose(); }
 73             }
 74         }
 75 
 76         public byte[] Encoder(SocketMessage msg)
 77         {
 78             MemoryStream ms = new MemoryStream();
 79             BinaryWriter bw = new BinaryWriter(ms, UTF8Encoding.Default);
 80             byte[] msgBuffer = msg.MsgBuffer;
 81 
 82             if (msgBuffer != null)
 83             {
 84                 switch (JN)
 85                 {
 86                     case JavaOrNet.Java:
 87                         bw.Write(WriterInt(msgBuffer.Length + 4));
 88                         bw.Write(WriterInt(msg.MsgID));
 89                         break;
 90                     case JavaOrNet.Net:
 91                         bw.Write((Int32)(msgBuffer.Length + 4));
 92                         bw.Write(msg.MsgID);
 93                         break;
 94                 }
 95 
 96                 bw.Write(msgBuffer);
 97             }
 98             else
 99             {
100                 switch (JN)
101                 {
102                     case JavaOrNet.Java:
103                         bw.Write(WriterInt(0));
104                         break;
105                     case JavaOrNet.Net:
106                         bw.Write((Int32)0);
107                         break;
108                 }
109             }
110             bw.Close();
111             ms.Close();
112             bw.Dispose();
113             ms.Dispose();
114             return ms.ToArray();
115         }
116 
117         public List<SocketMessage> Decoder(byte[] buff, int len)
118         {
119             //拷貝本次的有效字節
120             byte[] _b = new byte[len];
121             Array.Copy(buff, 0, _b, 0, _b.Length);
122             buff = _b;
123             if (this._LBuff.Count > 0)
124             {
125                 //拷貝之前遺留的字節
126                 this._LBuff.AddRange(_b);
127                 buff = this._LBuff.ToArray();
128                 this._LBuff.Clear();
129                 this._LBuff = new List<byte>(2);
130             }
131             List<SocketMessage> list = new List<SocketMessage>();
132             MemoryStream ms = new MemoryStream(buff);
133             BinaryReader buffers = new BinaryReader(ms, UTF8Encoding.Default);
134             try
135             {
136                 byte[] _buff;
137             Label_0073:
138                 //判斷本次解析的字節是否滿足常量字節數 
139                 if ((buffers.BaseStream.Length - buffers.BaseStream.Position) < ConstLenght)
140                 {
141                     _buff = buffers.ReadBytes((int)(buffers.BaseStream.Length - buffers.BaseStream.Position));
142                     this._LBuff.AddRange(_buff);
143                 }
144                 else
145                 {
146                     long offset = 0;
147                     switch (JN)
148                     {
149                         case JavaOrNet.Java:
150                             offset = ReadInt(buffers.ReadBytes(4));
151                             break;
152                         case JavaOrNet.Net:
153                             offset = buffers.ReadInt32();
154                             break;
155                     }
156 
157                     //剩余字節數大於本次需要讀取的字節數
158                     if (offset <= (buffers.BaseStream.Length - buffers.BaseStream.Position))
159                     {
160                         int msgID = 0;
161                         switch (JN)
162                         {
163                             case JavaOrNet.Java:
164                                 msgID = ReadInt(buffers.ReadBytes(4));
165                                 break;
166                             case JavaOrNet.Net:
167                                 msgID = buffers.ReadInt32();
168                                 break;
169                         }
170                         _buff = buffers.ReadBytes((int)(offset - 4));
171                         list.Add(new SocketMessage(msgID, _buff));
172                         goto Label_0073;
173                     }
174                     else
175                     {
176                         //剩余字節數剛好小於本次讀取的字節數 存起來，等待接受剩余字節數一起解析
177                         buffers.BaseStream.Seek(ConstLenght, SeekOrigin.Current);
178                         _buff = buffers.ReadBytes((int)(buffers.BaseStream.Length - buffers.BaseStream.Position));
179                         this._LBuff.AddRange(_buff);
180                     }
181                 }
182             }
183             catch { }
184             finally
185             {
186                 buffers.Close();
187                 if (buffers != null) { buffers.Dispose(); }
188                 ms.Close();
189                 if (ms != null) { ms.Dispose(); }
190             }
191             return list;
192         }
193     }
194 }

java netty

  1 /*
  2  * To change this license header, choose License Headers in Project Properties.
  3  * To change this template file, choose Tools | Templates
  4  * and open the template in the editor.
  5  */
  6 package sz.network.socketpool.nettypool;
  7 
  8 import io.netty.buffer.ByteBuf;
  9 import io.netty.buffer.Unpooled;
 10 import io.netty.channel.ChannelHandlerContext;
 11 import io.netty.handler.codec.ByteToMessageDecoder;
 12 import java.nio.ByteOrder;
 13 import java.util.ArrayList;
 14 import java.util.List;
 15 import org.apache.log4j.Logger;
 16 
 17 /**
 18  * 解碼器
 19  */
 20 class NettyDecoder extends ByteToMessageDecoder {
 21 
 22     private static final Logger logger = Logger.getLogger(NettyDecoder.class);
 23 
 24     private byte ZreoByteCount = 0;
 25     private ByteBuf bytes;
 26     private final ByteOrder endianOrder = ByteOrder.LITTLE_ENDIAN;
 27     private long secondTime = 0;
 28     private int reveCount = 0;
 29 
 30     public NettyDecoder() {
 31 
 32     }
 33 
 34     ByteBuf bytesAction(ByteBuf inputBuf) {
 35         ByteBuf bufferLen = Unpooled.buffer();
 36         if (bytes != null) {
 37             bufferLen.writeBytes(bytes);
 38             bytes = null;
 39         }
 40         bufferLen.writeBytes(inputBuf);
 41         return bufferLen;
 42     }
 43 
 44     /**
 45      * 留存無法讀取的byte等待下一次接受的數據包
 46      *
 47      * @param bs 數據包
 48      * @param startI 起始位置
 49      * @param lenI 結束位置
 50      */
 51     void bytesAction(ByteBuf intputBuf, int startI, int lenI) {
 52         if (lenI - startI > 0) {
 53             bytes = Unpooled.buffer();
 54             bytes.writeBytes(intputBuf, startI, lenI);
 55         }
 56     }
 57 
 58     @Override
 59     protected void decode(ChannelHandlerContext chc, ByteBuf inputBuf, List<Object> outputMessage) {
 60         if (System.currentTimeMillis() - secondTime < 1000L) {
 61             reveCount++;
 62         } else {
 63             secondTime = System.currentTimeMillis();
 64             reveCount = 0;
 65         }
 66 
 67         if (reveCount > 50) {
 68             logger.error("發送消息過於頻繁");
 69             chc.disconnect();
 70             return;
 71         }
 72 
 73         if (inputBuf.readableBytes() > 0) {
 74             ZreoByteCount = 0;
 75             //重新組裝字節數組
 76             ByteBuf buffercontent = bytesAction(inputBuf);
 77             List<NettyMessageBean> megsList = new ArrayList<>(0);
 78             for (;;) {
 79                 //讀取 消息長度（short）和消息ID（int） 需要 8 個字節
 80                 if (buffercontent.readableBytes() >= 8) {
 81                     ///讀取消息長度
 82                     int len = buffercontent.readInt();
 83                     if (buffercontent.readableBytes() >= len) {
 84                         int messageid = buffercontent.readInt();///讀取消息ID
 85                         ByteBuf buf = buffercontent.readBytes(len - 4);//讀取可用字節數;
 86                         megsList.add(new NettyMessageBean(chc, messageid, buf.array()));
 87                         //第二次重組
 88                         if (buffercontent.readableBytes() > 0) {
 89                             bytesAction(buffercontent, buffercontent.readerIndex(), buffercontent.readableBytes());
 90                             buffercontent = Unpooled.buffer();
 91                             buffercontent.writeBytes(bytes);
 92                             continue;
 93                         } else {
 94                             break;
 95                         }
 96                     }
 97                     ///重新設置讀取進度
 98                     buffercontent.setIndex(buffercontent.readableBytes() - 2, inputBuf.readableBytes());
 99                 }
100                 ///緩存預留的字節
101                 bytesAction(buffercontent, buffercontent.readerIndex(), buffercontent.readableBytes());
102                 break;
103             }
104             outputMessage.addAll(megsList);
105         } else {
106             ZreoByteCount++;
107             if (ZreoByteCount >= 3) {
108                 //todo 空包處理 考慮連續三次空包，斷開鏈接
109                 logger.error("decode 空包處理 連續三次空包");
110                 chc.close();
111             }
112         }
113     }
114 }

這是我封裝的部分代碼，因為現目前公司的開發組織架構為，java是服務器端。U3D 使用C#是客戶端開發。所以考慮性能問題，是C#妥協進行字節序反轉操作~！

就不在添加調試和測試代碼和結果因為覺得沒多少意義~！

到此結束~！