AS3 Socket使用ByteArray进行自定义数据处理

Socket数据获取

        /**
         * 当客户端给服务端传递信息处理，这里将自动处理内容分割
         * @param e
         */     
        protected function onSocketData(e:ProgressEvent):void
        {
            if(socket.bytesAvailable == 0)
                return;
            //将数据储存在缓存区
            var byte:ByteArray = new ByteArray();
            socket.readBytes(byte,0,e.bytesTotal);
            pushCache(byte);
            parsingCache();
        }

当Socket给我们传输数据的时候，我们可以侦听ProgressEvent事件进行加载读取。Socket的传输原理就跟下载文件一样，你在下载服务端那边的数据，只是数据是自定义的，但数据是按循序而来的。

将数据添加到缓存

        /**
         * 写入缓存区 
         * @param byte
         */     
        public function pushCache(byte:ByteArray):void
        {
            if(_cache == null)
            {
                _cache = byte;
            }
            else
            {
                _cache.position = _cache.length;
                _cache.writeBytes(byte);
                byte.clear();
            }
        }

下载数据，意味着并不是每次下载的数据都是完整的，可能会有错位，数据不完整的情况。所以需要将下载到的数据，装到一个ByteArray里作为缓存，方便下一次获取使用。

自定义发送内容格式

        /**
         * 发送信息到服务端，或者客户端 
         * @param data
         */     
        public function send(data:Object):void
        {
            //新建一个二进制内容
            var byte:ByteArray = new ByteArray();
            //写入Object
            byte.writeObject(data);
            //压缩二进制内容
            byte.compress();
            //传输内容长度
            socket.writeShort(byte.length);
            //传输内容
            socket.writeBytes(byte);
            //确定内容写入
            socket.flush();
        }

这里有一个自定义方法send，里面的data就是我要发送的内容，但不管是什么内容，都将它装载到一个ByteArray数组里。重要的是，ByteArray自带有compress的压缩功能，这意味着传输的宽带需求进行了压缩。这里的传输顺序是：内容长度(Short):内容(ByteArray)。

解析接收到的内容

        /**
         * 解析分发数据包
         */     
        public function parsingCache():void
        {
            //判断缓存是否存在
            if(!_cache)
                return;
            //初始化缓存的读取位置
            var par:int = 0;
            _cache.position = par;
            //如果缓存的字节大于2，因为Short占位2个字符
            while(_cache.bytesAvailable > 2){
                //解析时，读取内容长度，这里会取出2个字符
                var len:uint = _cache.readShort();
                //判断缓存的可用长度是否足够读取内容
                if(_cache.bytesAvailable < len)
                {
                    //当缓存不足读取时，中断读取
                    break;
                }
                else
                {
                    //当缓存足够可读取时，将当前的缓存位置增加两个字符，跳过Short内容。
                    _cache.position = par + 2;
                    //读取其内容
                    var data:ByteArray = new ByteArray();
                    _cache.readBytes(data,0,len);
                    //返回数据
                    backData(data);
                    //缓存位置刷新至下一个
                    par += 2 + len;
                    _cache.position = par;
                }
            }
            //判断缓存的位置是否做了刷新，如果有刷新，意味着读取过内容
            if(par != 0)
            {
                //判断缓存的可用长度
                if(_cache.bytesAvailable > 0)
                {
                    //存在可用的长度时，截取par后面未使用的新数据，以便下一次使用
                    var newbyte:ByteArray = new ByteArray();
                    _cache.position = par;
                    _cache.readBytes(newbyte,0,_cache.bytesAvailable);
                    _cache.clear();
                    _cache = newbyte;
                }
                else
                {
                    //如果数据本身不存在可用数据，那么可以进行释放
                    _cache.clear();
                    _cache = null;
                }
            }
        }

        //数据返回，进行解析
        private function backData(data:ByteArray):void
        {
            try{
                //还原读取点
                data.position = 0;
                //解压数据
                data.uncompress();
                //读取之前定义好的Object内容
                var ob:Object = data.readObject();
                if(ob)
                {
                    //自定义操作
                    if(dataFunc != null)
                        dataFunc(ob);
                }
            }
            catch(e:Error)
            {
                trace("解析出现异常");
            }
        }

这里做了ByteArray的解析处理，根据其内容长度，读取内容。Short占两个字符，因此跳过固定为2值。有一个固定的规则，二进制的内容都是自由定义的。