AS3.0客户端协议框架搭建

刚刚开通了微博，希望大家来捧场，技术不咋地，写点东西希望对大家有帮助，觉得好赞一个哦，觉得不好，也赞一个吧，看我写得很辛苦呢，呜呜。

话归正题，就给大家讲讲怎么样搭建客户端协议框架，下面给代码

1.通讯协议底层事件派发类（充分利用了非显示对象的派发的事件只有他自己能在目标阶段能够侦听到这一特性，后面继续讲到）

package netConnect
{
 import flash.events.EventDispatcher;

 public class MyTranservation extends EventDispatcher
 {
  private static var _instance:MyTranservation;
  
  public function MyTranservation(foecer:inforcerSingle)
  {
   if(_instance)
   {
    throw ArgumentError("这是一个单例，请使用静态Instance()获取唯一的实例！");
   }
  }
  
  static public function Instance():MyTranservation
  {
   if(!_instance)
   {
    _instance = new MyTranservation(new inforcerSingle());
   }
   return _instance;
  }
 }
}

class inforcerSingle{}

2.自定义底层通讯协议事件类

package myEvent
{
 import flash.events.Event;
 import flash.utils.ByteArray;

 /**通讯类事件类型*/
 public class TranservationEvent extends Event
 {
  //这些常量应该专门写一个TranservationConst类，放在里面，这里是简单演示
  /**链接成功*/
  static public const SOCKETCONNECT:String = "socketConnected";
  /**登陆成功*/
  static public const LOGINSUCCESS:String = "loginSuccess";
  /**登陆失败*/
  static public const LOGINFAILE:String = "loginFaile";
  
  /**主线任务a*/
  static public const MAINTASK:String = "mainTask";
  
  /**师门任务*/
  static public const DOORTASK:String = "doorTask";
  
  /**主线任务更新*/
  static public const UPDATEMAINTASK:String = "updateMainTask";
  
  private var _data:ByteArray;
  
  
  public function TranservationEvent(type:String,data:ByteArray=null,bubbles=false,cancelable=false)
  {
   super(type,bubbles,cancelable);
   _data = data;
  }
  
  public function get Data():ByteArray
  {
   return _data;
  }
  
  override public function clone():Event
  {
   return new TranservationEvent(type,_data,bubbles,cancelable);
  }
 }
}

3.唯一的Socket类实例类

package netConnect
{
 import flash.net.Socket;
 
 public class mySocket extends Socket
 {
  /**一开始就要在理写好服务器主机和端口号*/
  public function mySocket(forcer:singleForcer,host:String=null, port:int=0)
  {
   if(forcer)
   {
    throw ArgumentError("这是一个单例...");
   }
   super(host, port);
  }
  
  static public var _instance:mySocket;
  
  static public function get Instance():mySocket
  {
   if(!_instance)
   {
    _instance = new mySocket(new singleForcer());
   }
   return _instance;
  }
 }
}

class singleForcer{};

package netConnect
{
 import flash.events.Event;
 import flash.events.ProgressEvent;
 import flash.net.Socket;
 import flash.sensors.Accelerometer;
 import flash.utils.ByteArray;
 
 import myEvent.TranservationEvent;

 public class myConnect
 {
  public static function connect(host:String,port:int)
  
  public function myConnect(host:String,port:int)
  {
   
   mySocket.Instance.addEventListener(Event.CONNECT,clpOnConnect);
   mySocket.Instance.addEventListener(ProgressEvent.SOCKET_DATA,clDoing);
  }
  
  /**当然我们也可以弄多个备用端口，执行的时候检测是否连接成功，不成功就见解第二个端口，设置一个_params变量，在构造函数中传入*/
  public function connect(host:String,port:int)
  {
   mySocket.Instance.connect(host,port);
  }
  
  private function clpOnConnect(e:Event):void
  {
   //链接成功
   MyTranservation.Instance().dispatchEvent( new TranservationEvent（TranservationEvent.SOCKETCONNECT));
  }
  
  private function clDoing(e:ProgressEvent):void
  {
   switch(mySocket.Instance.readUnsignedShort())
   {
    case 1001:
     MyTranservation.Instance().dispatchEvent( new TranservationEvent（TranservationEvent.LOGINSUCCESS));//登陆成功
    case 1002:MyTranservation.Instance().dispatchEvent( new TranservationEvent（TranservationEvent.LOGINFAILE));//登陆失败
    case 1003:
     var data:ByteArray = new ByteArray();
     data.writeInt(mySocket.Instance.readInt());
     data.writeUTF(mySocket.Instance.readUTF());
     
     MyTranservation.Instance().dispatchEvent( new TranservationEvent(TranservationEvent.MAINTASK,data));//首次获取玩家的主线任务信息
    case 1004:
     var data:ByteArray = new ByteArray();
     data.writeInt(mySocket.Instance.readInt());
     data.writeUTF(mySocket.Instance.readUTF());
     MyTranservation.Instance().dispatchEvent( new TranservationEvent（TranservationEvent.UPDATEMAINTASK,data));//主线任务信息更新 
   }
   //使用协议去派发特定的事件，这样广播就可以了
   
  }
 }
}

这样底层基本上写好了哦，大家仔细体会哦

下面讲模块通讯类，我们以简单的任务通讯cache类向大家讲解吧

自定义cache通讯事件类

package myEvent
{
 import flash.events.Event;
 
 public class CacheEvent extends Event
 {
  static public const MAINTASK:String = "cacheMianTask";
  static public const UPDATEMAINTASK:String = "cacheUpdateMainTask";
  
  private var _data:*;
  
  public function CacheEvent(type:String,data, bubbles:Boolean=false, cancelable:Boolean=false)
  {
   super(type, bubbles, cancelable);
   _data = data;
  }
  
  public function get Data():*
  {
   return _data;
  }
  
  override public function clone():Event
  {
   return new CacheEvent(type,_data,bubbles,cancelable);
  }
 }
}

下面是TaskCache类

package cache
{
 import flash.events.EventDispatcher;
 import flash.events.IEventDispatcher;
 
 import myEvent.CacheEvent;
 import myEvent.TranservationEvent;
 
 import netConnect.MyTranservation;
 
 public class TaskCache extends EventDispatcher
 {
  public function TaskCache(forcer:singleForcer)
  {
   if(forcer)
   {
    throw ArgumentError("这是一个单例...");
   }
   super();
   MyTranservation.Instance().addEventListener(TranservationEvent.MAINTASK,mainTask);
   MyTranservation.Instance().addEventListener(TranservationEvent.UPDATEMAINTASK,updateMainTask);
  }
  
  static public var _instance:TaskCache;
  
  static public function get Instance():TaskCache
  {
   if(!_instance)
   {
    _instance = new TaskCache(new singleForcer());
   }
   return _instance;
  }
  
  private function mainTask(e:TranservationEvent):void
  {
   var data:Array = new Array();
   data.push(e.Data.readInt());
   data.push(e.Data.readUnsignedShort());
   dispatchEvent(new CacheEvent(CacheEvent.MAINTASK,data));
  }
  
  private function updateMainTask(e:TranservationEvent):void
  {
   var data:Array = new Array();
   data.push(e.Data.readInt());
   data.push(e.Data.readUnsignedShort());
   dispatchEvent(new CacheEvent(CacheEvent.UPDATEMAINTASK,data));
  }
 }
}

class singleForcer{};

下面讲解具体使用的地方

事实上就是用的地方使用TaskCache.Instance().addEventListener(***,***);这样处理就好，那么怎么发送数据呢 

事实上很简单实用mySocket.Instance.write***;
   mySocket.Instance.write***;
   mySocket.Instance.write***;
   mySocket.Instance.flush();就好啦，大家看过之后别忘记赞一个哦，我会很开心的，哦哦。

转载于:https://www.cnblogs.com/wenjiehou/archive/2013/05/20/3088782.html