JT/T 809服务(样例)

Code下载

 

709PDF

一个ServiceGB809包含Master和Slaver，实现绝大部分业务数据包逻辑(比如：Except Login())。

Master为MasterLink；

Slaver为SlaverChannel；

　　SlaverChannel由多个SlaverLink构成（由LinksCollection来管理数量以及策略）

由于通讯包相同，构建TcpOperator类，作为两种Link的通用成员；

 

整体过程使用Reader和Writer的流操作模式；

自行通过线程管理异步读取；

通讯包各个内部成员类（如Head、Version等）实现到buffer的writer操作过程，因此Writer不再单独实现，非基础类型往往继承至BufferedEntityBase；

TcpOperator内部通过PackageReader类成员实现读取，以及通过通讯包Buffer实现写入；

 

需要通过Open和Close调用的类继承至ServiceBase；

业务及配置使用惯例。

 

代码仅曾运行测试过登录，包解析尚未完成。

（不必质疑为什么不用快速连接方式，此根据809一些常态化参数以及非大规模连接并发，此码为业余熟悉809所写，不涉及公司任何商业信息）

未对接收进行任何处理，已通过sokit测试验证。

 

此代码主要展示说明一下809的设计以及一些童鞋凌乱的buffer应该怎么做得简洁。

但涉及缓冲到结构的，可依照：

public abstract class BufferedEntityBase:IBuffer, IBuffered
    {
        protected BufferedEntityBase(params object[] properties)
        {
            InitializeProperties(properties);
            ToBuffer();
        }
        protected BufferedEntityBase(byte[] buffer)
        {
            Buffer = buffer;
            InitializePropertiesFromBuffer();
        }

        protected abstract void InitializeProperties(params object[] properties);
        protected abstract void OnInitializePropertiesFromReadBuffer(BinaryReader reader);
        protected virtual void InitializePropertiesFromBuffer()
        {
            using (var stream = new MemoryStream(Buffer))
            {
                var reader = new BinaryReader(stream);
                OnInitializePropertiesFromReadBuffer(reader); 
                stream.Close();
            }
        }

        protected abstract void OnWriteToBuffer(BinaryWriter writer);
        public virtual byte[] ToBuffer()
        {
            using (var stream = new MemoryStream())
            {
                var writer = new BinaryWriter(stream);
                OnWriteToBuffer(writer);
                var reader = new BinaryReader(stream);
                stream.Seek(0, SeekOrigin.Begin);
                Buffer = reader.ReadBytes((int)stream.Length);//stream.GetBuffer();
                stream.Close();
            }
            return Buffer;
        }
        public byte[] Buffer { get; protected set; }
    }

for example(809头)：

    public class Header : BufferedEntityBase
    {
        public static uint CounterOnSendGenerater { get; private set; }
        public static uint CounterOnRecieveGenerater { get; private set; }
        public const int HeaderFixedByteLength = 22;
        public uint Length { get;private set; }
        public uint Number { get; private set; }
        public PackageCatelog Catelog { get; private set; }
        public uint SessionId { get; private set; }
        public Version Version { get; private set; }
        public EncryptOpitions EncryptOpition { get; private set; }
        public uint KeyForCommonEncript { get; private set; }
        public Header(byte[] buffer) : base(buffer) { CounterOnRecieveGenerater++;}
        public Header(uint length, uint number, PackageCatelog catelog)
            :base(length,number, catelog,Config.Value.ServiceGB809Info.MasterLinkInfo.SessionId,Config.Version,Config.Value.ServiceGB809Info.MasterLinkInfo.EncryptFlag, Config.Value.ServiceGB809Info.MasterLinkInfo.EncryptKey)
        { CounterOnSendGenerater++;}
        public Header(uint length, PackageCatelog catelog): this(length, CounterOnSendGenerater, catelog){}
        protected override void InitializeProperties(params object[] properties)
        {
            Length = (uint)properties[0] + Package.NotDataLength;
            Number = (uint)properties[1]; 
            Catelog = (PackageCatelog)properties[2];
            SessionId = (uint)properties[3];
            Version = properties[4] as Version;
            EncryptOpition = (EncryptOpitions)properties[5];
            KeyForCommonEncript = (uint)properties[6];
        }
        protected override void OnInitializePropertiesFromReadBuffer(BinaryReader reader)
        {
            Length = reader.ReadUInt32Big();
            Number = reader.ReadUInt32Big();
            Catelog = (PackageCatelog)reader.ReadUInt16Big();
            SessionId = reader.ReadUInt32Big();
            Version = new Version(reader.ReadByte(),reader.ReadByte(),reader.ReadByte());
            EncryptOpition = (EncryptOpitions)reader.ReadByte();
            KeyForCommonEncript = reader.ReadUInt32Big();
        }
        protected override void OnWriteToBuffer(BinaryWriter writer)
        {
            writer.WriterBig(Length);
            writer.WriterBig(Number);
            writer.WriterBig((ushort)Catelog);
            writer.WriterBig(SessionId);
            writer.WriterBig(Version.Buffer);
            writer.WriterBig((byte)EncryptOpition);
            writer.WriterBig(KeyForCommonEncript);
        }
    }

 2016-01

更新添加了部分子包内容——也由此在BodyBase分化了BodyEmbedChildBase。

 

谩骂语：

有一些可取之处，更多的是复杂的文档和设计~~，只需规定一些特定流程（这个文档已有），其他业务太繁琐——只需提供类说明（可保留保投保为和头），包体统一使用现成的Protobuff即可（如果你愿意，接入者业务类都不用写了不是），也不闲写到累；更是累接入者！