我看不下去鸟。。。。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的反转读取。

        /// <summary>
        /// 读取大端序的int
        /// </summary>
        /// <param name="value"></param>
        public int ReadInt(byte[] intbytes)
        {
            Array.Reverse(intbytes);
            return BitConverter.ToInt32(intbytes, 0);
        }

        /// <summary>
        /// 写入大端序的int
        /// </summary>
        /// <param name="value"></param>
        public byte[] WriterInt(int value)
        {
            byte[] bs = BitConverter.GetBytes(value);
            Array.Reverse(bs);
            return bs;
        }

 

粘包问题解决。

C#代码

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

/**
 * 
 * @author 失足程序员
 * @Blog http://www.cnblogs.com/ty408/
 * @mail 492794628@qq.com
 * @phone 13882122019
 * 
 */
namespace Sz.Network.SocketPool
{
    public class MarshalEndian : IMarshalEndian
    {

        public enum JavaOrNet
        {
            Java,
            Net,
        }

        public MarshalEndian()
        {

        }

        public static JavaOrNet JN = JavaOrNet.Net;

        /// <summary>
        /// 读取大端序的int
        /// </summary>
        /// <param name="value"></param>
        public int ReadInt(byte[] intbytes)
        {
            Array.Reverse(intbytes);
            return BitConverter.ToInt32(intbytes, 0);
        }

        /// <summary>
        /// 写入大端序的int
        /// </summary>
        /// <param name="value"></param>
        public byte[] WriterInt(int value)
        {
            byte[] bs = BitConverter.GetBytes(value);
            Array.Reverse(bs);
            return bs;
        }

        //用于存储剩余未解析的字节数
        private List<byte> _LBuff = new List<byte>(2);

        //字节数常量一个消息id4个字节
        const long ConstLenght = 4L;

        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool flag1)
        {
            if (flag1)
            {
                IDisposable disposable = this._LBuff as IDisposable;
                if (disposable != null) { disposable.Dispose(); }
            }
        }

        public byte[] Encoder(SocketMessage msg)
        {
            MemoryStream ms = new MemoryStream();
            BinaryWriter bw = new BinaryWriter(ms, UTF8Encoding.Default);
            byte[] msgBuffer = msg.MsgBuffer;

            if (msgBuffer != null)
            {
                switch (JN)
                {
                    case JavaOrNet.Java:
                        bw.Write(WriterInt(msgBuffer.Length + 4));
                        bw.Write(WriterInt(msg.MsgID));
                        break;
                    case JavaOrNet.Net:
                        bw.Write((Int32)(msgBuffer.Length + 4));
                        bw.Write(msg.MsgID);
                        break;
                }

                bw.Write(msgBuffer);
            }
            else
            {
                switch (JN)
                {
                    case JavaOrNet.Java:
                        bw.Write(WriterInt(0));
                        break;
                    case JavaOrNet.Net:
                        bw.Write((Int32)0);
                        break;
                }
            }
            bw.Close();
            ms.Close();
            bw.Dispose();
            ms.Dispose();
            return ms.ToArray();
        }

        public List<SocketMessage> Decoder(byte[] buff, int len)
        {
            //拷贝本次的有效字节
            byte[] _b = new byte[len];
            Array.Copy(buff, 0, _b, 0, _b.Length);
            buff = _b;
            if (this._LBuff.Count > 0)
            {
                //拷贝之前遗留的字节
                this._LBuff.AddRange(_b);
                buff = this._LBuff.ToArray();
                this._LBuff.Clear();
                this._LBuff = new List<byte>(2);
            }
            List<SocketMessage> list = new List<SocketMessage>();
            MemoryStream ms = new MemoryStream(buff);
            BinaryReader buffers = new BinaryReader(ms, UTF8Encoding.Default);
            try
            {
                byte[] _buff;
            Label_0073:
                //判断本次解析的字节是否满足常量字节数 
                if ((buffers.BaseStream.Length - buffers.BaseStream.Position) < ConstLenght)
                {
                    _buff = buffers.ReadBytes((int)(buffers.BaseStream.Length - buffers.BaseStream.Position));
                    this._LBuff.AddRange(_buff);
                }
                else
                {
                    long offset = 0;
                    switch (JN)
                    {
                        case JavaOrNet.Java:
                            offset = ReadInt(buffers.ReadBytes(4));
                            break;
                        case JavaOrNet.Net:
                            offset = buffers.ReadInt32();
                            break;
                    }

                    //剩余字节数大于本次需要读取的字节数
                    if (offset <= (buffers.BaseStream.Length - buffers.BaseStream.Position))
                    {
                        int msgID = 0;
                        switch (JN)
                        {
                            case JavaOrNet.Java:
                                msgID = ReadInt(buffers.ReadBytes(4));
                                break;
                            case JavaOrNet.Net:
                                msgID = buffers.ReadInt32();
                                break;
                        }
                        _buff = buffers.ReadBytes((int)(offset - 4));
                        list.Add(new SocketMessage(msgID, _buff));
                        goto Label_0073;
                    }
                    else
                    {
                        //剩余字节数刚好小于本次读取的字节数 存起来，等待接受剩余字节数一起解析
                        buffers.BaseStream.Seek(ConstLenght, SeekOrigin.Current);
                        _buff = buffers.ReadBytes((int)(buffers.BaseStream.Length - buffers.BaseStream.Position));
                        this._LBuff.AddRange(_buff);
                    }
                }
            }
            catch { }
            finally
            {
                buffers.Close();
                if (buffers != null) { buffers.Dispose(); }
                ms.Close();
                if (ms != null) { ms.Dispose(); }
            }
            return list;
        }
    }
}

java netty

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package sz.network.socketpool.nettypool;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;

/**
 * 解码器
 */
class NettyDecoder extends ByteToMessageDecoder {

    private static final Logger logger = Logger.getLogger(NettyDecoder.class);

    private byte ZreoByteCount = 0;
    private ByteBuf bytes;
    private final ByteOrder endianOrder = ByteOrder.LITTLE_ENDIAN;
    private long secondTime = 0;
    private int reveCount = 0;

    public NettyDecoder() {

    }

    ByteBuf bytesAction(ByteBuf inputBuf) {
        ByteBuf bufferLen = Unpooled.buffer();
        if (bytes != null) {
            bufferLen.writeBytes(bytes);
            bytes = null;
        }
        bufferLen.writeBytes(inputBuf);
        return bufferLen;
    }

    /**
     * 留存无法读取的byte等待下一次接受的数据包
     *
     * @param bs 数据包
     * @param startI 起始位置
     * @param lenI 结束位置
     */
    void bytesAction(ByteBuf intputBuf, int startI, int lenI) {
        if (lenI - startI > 0) {
            bytes = Unpooled.buffer();
            bytes.writeBytes(intputBuf, startI, lenI);
        }
    }

    @Override
    protected void decode(ChannelHandlerContext chc, ByteBuf inputBuf, List<Object> outputMessage) {
        if (System.currentTimeMillis() - secondTime < 1000L) {
            reveCount++;
        } else {
            secondTime = System.currentTimeMillis();
            reveCount = 0;
        }

        if (reveCount > 50) {
            logger.error("发送消息过于频繁");
            chc.disconnect();
            return;
        }

        if (inputBuf.readableBytes() > 0) {
            ZreoByteCount = 0;
            //重新组装字节数组
            ByteBuf buffercontent = bytesAction(inputBuf);
            List<NettyMessageBean> megsList = new ArrayList<>(0);
            for (;;) {
                //读取 消息长度（short）和消息ID（int） 需要 8 个字节
                if (buffercontent.readableBytes() >= 8) {
                    ///读取消息长度
                    int len = buffercontent.readInt();
                    if (buffercontent.readableBytes() >= len) {
                        int messageid = buffercontent.readInt();///读取消息ID
                        ByteBuf buf = buffercontent.readBytes(len - 4);//读取可用字节数;
                        megsList.add(new NettyMessageBean(chc, messageid, buf.array()));
                        //第二次重组
                        if (buffercontent.readableBytes() > 0) {
                            bytesAction(buffercontent, buffercontent.readerIndex(), buffercontent.readableBytes());
                            buffercontent = Unpooled.buffer();
                            buffercontent.writeBytes(bytes);
                            continue;
                        } else {
                            break;
                        }
                    }
                    ///重新设置读取进度
                    buffercontent.setIndex(buffercontent.readableBytes() - 2, inputBuf.readableBytes());
                }
                ///缓存预留的字节
                bytesAction(buffercontent, buffercontent.readerIndex(), buffercontent.readableBytes());
                break;
            }
            outputMessage.addAll(megsList);
        } else {
            ZreoByteCount++;
            if (ZreoByteCount >= 3) {
                //todo 空包处理 考虑连续三次空包，断开链接
                logger.error("decode 空包处理 连续三次空包");
                chc.close();
            }
        }
    }
}

这是我封装的部分代码，因为现目前公司的开发组织架构为，java是服务器端。U3D 使用C#是客户端开发。所以考虑性能问题，是C#妥协进行字节序反转操作~！

就不在添加调试和测试代码和结果因为觉得没多少意义~！

到此结束~！