socket相关

摘抄：blog.csdn.net/huazhihao/archive/2009/06/18/4278699.aspx

从头开始构建一个web即时通讯系统 - 基础 - web即时通讯系统的四种实现

 

页面刷新

页面刷新即通过刷新页面来更新聊天记录，通过页面提交来发送消息。毫无疑问，这种实现是最简单的，也是效率最差的。它意味着每一次收发消息都对应了一次httprequest，而http作为应用层协议，连接代价是相当大的。

ajax

ajax可以理解为xmlhttprequest，本质与页面刷新相同，但是页面上会有很多资源文件，比如图片、css、js、flash，这些文件会随着页面刷新并且没有做浏览器端缓存的时候更新。为了接收或者发送数十字节的消息而更新可能多达数百K字节的字节文件，显然是很愚蠢的。所以使用ajax来通讯，"只"需要为消息的获取或者发送而进行请求。ajax从这一点上是优于页面刷新的。

comet/server push

ajax为每一个消息的发送和接收建立一个新的http连接,并在短暂通讯完毕以后关闭。而server push的本质是http长连接，它的思路是，让服务器和浏览器维持着一个时间跨度很长的http连接，这个http连接可能大部分时候并不需要做什么，只在有消息的时候，向浏览器写入。所以这种方式避免了建立以及关闭http连接时大量的开销，提高了资源利用率。不过server push也有它的问题，在一个web服务器上，http连接数并非没有限制，所以如果把http连接数也看作是系统资源的话，server push确实是对于此资源的极大浪费了。

comet是server push的思路上的一种改进，它在ajax和server push之间使用了一种折中的策略，在高频率的通讯过程中，comet使用http长连接。一旦通讯变得不频繁，comet便释放http连接，并在下一次通讯的时候，是情况而定，看是否需要建立http长连接。

server push在asp.net中可以通过下面的代码片段实现：

        protected void Page_Load(object sender, EventArgs e)

        {

            while (IsSessionEnd as bool)

            {

                lock (token as object)

                {

                    Response.Write(message as string);

                    Response.Flush();

                }

            }

        }

（当然，在实际编码中，as type的写法是不必要的，这里只是为了说明类型）

可以看到，在上面的代码片段中，会话结束前，Response.End()都不会被调用。

socket/tcp

在页面刷新、ajax和server push的思路里，最重要的一个共同点就是基于http。http是web的基础，然而http并不符合即时通讯系统的思想，很大程度上是由于http几个特点：

[

  http是无状态的,

  http是一问一答的,

  http是单播的,

  http是应用层协议，通讯代价很大

]

然而http的下层协议tcp/udp就很适合用来做为即时通讯系统的通讯协议。可是在web标准里，一切都是基于http的。幸运的是，我们可以通过浏览器插件的信路来完成通讯，在java applet、flash和silverlight里，都提供了socket/tcp,并且dom和flash或silverlight是可以互操作的。这就意味着，dom也可以间接的使用socket来与服务器通讯。

评论

10 楼 leopard0825 2010-04-27  

http://blog.csdn.net/hacktt/archive/2010/04/02/5443909.aspx

9 楼 leopard0825 2010-04-27  

AS3与JAVA socket通讯的 安全沙箱问题

AS3与JAVA socket通讯的 安全沙箱问题 终于解决了 ，你看网上那些都不行，这一次 试试行不行，要不就死FLASH PLAYer的问题
下面是AS3 FLash的代码
此代码也是复制别人的 但是他们的不行 ，我稍微改进 了。。。。 本来SOCKET就这么写
package {
import flash.display.Sprite;
import flash.events.DataEvent;
import flash.events.*;
import flash.net.XMLSocket;
import flash.system.Security;
import flash.system.System;
public class EdenSockets extends Sprite{
private var socket:XMLSocket;
  public function EdenSockets()
  {
   System.useCodePage = true;
   socket = new XMLSocket();
   socket.addEventListener( Event.CONNECT, onConnect );
   socket.addEventListener( IOErrorEvent.IO_ERROR , failConnect );
   socket.addEventListener( DataEvent.DATA, onDatas );

   sendBtn.addEventListener(MouseEvent.MOUSE_DOWN,sendEvent);
   socket.connect("192.168.10.18", 5000);
  }

  public function onConnect(myStatus:Event):void
  {
   msgText.text = msgText.text + "连接成功\n";
   //立即发送成功 信息到服务器
   socket.send("<policy-file-xxquest/>\n");
  }
  public function failConnect(myStatus:IOErrorEvent):void
  {
   msgText.text = msgText.text + "连接失败\n";
  }
  public function onDatas(event:DataEvent):void
  {
   if(event.data != null)
   {
    msgText.text = msgText.text + event.data + "\n";
   }
  }

  public function sendEvent(event:MouseEvent):void
  {
   socket.send(speakText.text + "\n");
   speakText.text = "";
  }
}

}
（注意要在FLASH中 加2个Text 叫msgText和speakText 还有加一个BUTTON 叫SendBtn）
view plaincopy to clipboardprint?
import java.io.*;  
import java.net.*;  
public class AMFServer {  
public void start()throws Exception{  
  String xml; 
   
xml="<?xml version=\"1.0\"?>" +  
"<!DOCTYPE cross-domain-policy SYSTEM \"http://www.adobe.com/xml/dtds/cross-domain-policy.dtd\">" +  
"<cross-domain-policy>" +  
"<allow-access-from domain=\"*\" to-ports=\"*\" />" +  
  "</cross-domain-policy>"; 
 
 
 
 
 
 
  ServerSocket serverSocket=new ServerSocket(5000);  
  System.out.println("等待用户连接````````");  
  while(true){  
   try{  
    Socket socket=serverSocket.accept();  
    System.out.println("连接成功```````");  
    BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));  
    PrintWriter pw=new PrintWriter(socket.getOutputStream());  
     
    char[] by=new char[22];  
    br.read(by,0,22);  
    String head=new String(by);  
    System.out.println("消息头是:"+head+";");  
    if(head.equals("<policy-file-request/>")){  
     pw.write(xml+"\0");  
     pw.flush();  
    }else{  
     ServerThread thread=new ServerThread(socket);  
     thread.start();  
    }  
     
   }catch(Exception e){  
    System.out.println("服务器发生异常");  
   }  
  }  
}  
public static void main(String[] args) {  
  try{  
   new AMFServer().start();  
  }catch(Exception e){  
   System.out.println("Socket发生异常:"+e);  
  }  
}  
}  

线程的

view plaincopy to clipboardprint?
import java.net.Socket;  
import java.io.BufferedReader;  
import java.io.PrintWriter;  
import java.io.InputStreamReader;  
public class ServerThread extends Thread{  
private Socket socket;  
private BufferedReader input;  
private PrintWriter output;  
public ServerThread(Socket socket){  
  this.socket=socket;  
}  
 
public void run(){  
  System.out.println("---------------启动一个线程-----------------");  
  try{  
   input=new BufferedReader(new InputStreamReader(socket.getInputStream()));  
   output=new PrintWriter(socket.getOutputStream());  
   while(true){  
    String msg=input.readLine();  
    if(msg==null){  
     break;  
    }  
    System.out.println("收到客户端的数据:"+msg);  
    output.print("服务器返回:"+msg+"\0");  
    output.flush();  
   }  
   System.out.println("子线程结束了");  
  }catch(Exception e){  
   System.out.println("子线程发生异常");  
   try{  
    input.close();  
    output.close();  
   }catch(Exception ex){  
    System.out.println("关闭资源发生异常");  
   }  
   System.out.println("子线程结束了");  
  }  
}  
}  

8 楼 leopard0825 2010-04-27  

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.Net.Sockets;
using System.IO;
using System.Net;

namespace ChatServer
{
    public partial class Form1 : Form
    {
        Socket clientsocket;
        public Form1()
        {
            InitializeComponent();
            Form.CheckForIllegalCrossThreadCalls = false;
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Thread mythread = new Thread(new ThreadStart(StartListening));
            mythread.Start();
        }
        private void StartListening()//主线程
        {
            int listenport = 843;
            IPAddress ipAddress = Dns.Resolve("localhost").AddressList[0];
            TcpListener listener = new TcpListener(ipAddress, listenport);
            listener.Start();
            this.msgtxt.Text = "";
            this.msgtxt.Text = "开始桢听连接";

            while (true)
            {
                Socket s = listener.AcceptSocket();
                if (s.Connected)
                {
                    try
                    {
                        clientsocket = s;
                             Thread clientservice;//客服端线程
                            clientservice = new Thread(new ThreadStart(ServiceClient));
                            clientservice.Start();
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.ToString());
                    }
                }
            }
        }
        private void GetChatterList()
        {

        }
        private void SendToClient(Client cl, string s)
        {

        }
        private void ServiceClient()
        {

            msgtxt.Text += "进来了客端线程了";
            NetworkStream networkStream = new NetworkStream(clientsocket);//网络仿问基础数据流

            StreamWriter streamWriter = new StreamWriter(networkStream);//写入
            StreamReader streamReader = new StreamReader(networkStream);//读取
            string line = streamReader.ReadLine();//读取流，用于收集数据




            if (line.IndexOf("<policy-file-request/>") != -1)
            {
                msgtxt.Text += "发送策略文件";
                　
　

                 String xml = "<cross-domain-policy>";
                        xml += "<allow-access-from domain=\"*\" to-ports=\"843\"/>";
                        xml += "</cross-domain-policy>";
                        //String xml = " <cross-domain-policy> <allow-access-from domain=\"*\" to-ports=\"*\" /></cross-domain-policy>\0";
                        mytxtbox.Text = xml;
                        streamWriter.WriteLine(xml);//写入流，返回给FLASH
                        streamWriter.Flush();//发给FLASH
                        msgtxt.Text += "worte:" + line;//输出
                        //clientsocket.Close();

            }
            else
            {
                line = line.ToUpper() + "1";//改大写并加1
                streamWriter.WriteLine("worte:"+line);//写入流，返回给FLASH
                msgtxt.Text += "worte:" + line;//输出
                streamWriter.Flush();//发给FLASH
            }
                //clientsocket.Close();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            msgtxt.Text = "";
        }//具体操作

    }
}




test.as



package {
       import flash.display.Sprite;
       import flash.events.*;
       import flash.net.Socket;

       public class test extends Sprite {
              private var socket:Socket;
              public function test() {
                     //初始化
                     var socket = new Socket();
                     socket.addEventListener(Event.CONNECT,onConnect);
                     socket.addEventListener("socketData",comedata);
                     socket.connect("localhost",843);
              }
              private function onConnect(event:Event):void {
                     //连接状态
                     txt.text="连接成功";

                     event.target.writeUTFBytes("aaaa\n");
                     event.target.writeUTFBytes("<policy-file-xxquest/>\n");
                     event.target.writeByte(22);
                     event.target.flush();

              }
              private function comedata(event:Event):void {

                     txt.text+=event.target.readUTFBytes(event.target.bytesAvailable);
              }
       }
}

7 楼 leopard0825 2010-04-27  

相信大家在进行AS3的SOCKET开发时都会遇到安全沙箱问题。ADODE也可以说是用心良苦,当我写AS3的SOCKET的代码时可以说跟C#，java的SOCKET操作没什么两样，代码很快就完成了。服务端采用C#开发，本地测试时，完全正常。

　　但是当部署到网页上时，问题出来了

[SecurityErrorEvent　type="securityError"　bubbles=false　cancelable=false　eventPhase=2　text="Error　#2048"]

　　看提示就知道是安全沙箱问题。

　　网上查了一些资料，说的也是很清楚，当Flash的SOCKET进行连接时会到843端口进行请求策略文件，于是我就在C#中添加了一段对843端口的监听，VS.NET 2008也很快捕捉到了830端口有SOCKET连接，接着返回策略文件。接着访问SOCKET的连接端口。

　　似乎开发起来很顺利

　　接着道服务端进行部署。把FLASH网页文件放到域名http://youname.com/chat/下，然后开启服务端的各个端口进行监听，本地打开进行测试，问题接着就来了，本地死活都是连接不上去。饭后错误任然是

[SecurityErrorEvent　type="securityError"　bubbles=false　cancelable=false　eventPhase=2　text="Error　#2048"]

　　把抓包工具打开，进行抓包分析。

　　结果在显示对服务器的端口843进行连接时都是正常的，本地发送<policy-file-request/>\0，服务端返回策略文件内容

<cross-domain-policy>　
<allow-access-from　domain="*"　to-ports="8888"　/>　
</cross-domain-policy>　

显示正常，但是过了许久，还是返回ERR 2048错误,郁闷

　　无意中，打开了机房里的另外一台服务器，结果返回的数据竟然一切正常。见了鬼了

　　此时可以确定程序和布署都是正常的，只是跟网络环境有莫大的关系

　　于是我在网上进行了狂搜 "as3 socket 843 端口 3秒"等关键词，呵呵。

　　呵呵，看样子，大家都没有碰到这种情况，难道，还是我的程序有问题

　　接着我是到各大相关论坛进行发贴求教，回复的也是不少，我也是谢了一大堆,可惜没有什么新意，都是网上流传那几招

　　时隔一天，我已经有点放弃了，无意中在FLASH8看到了一篇文章,http://space.flash8.net/bbs/viewthread.php?tid=370600&highlight=socket

　　似乎有所收获，由于目前的FLASH版本基本都己经升到了flash 10，对策略文件的部署也是相当的严格，不通过843端口，另外可以通过 详情见：http://www.mobans.cn/flash/1089.html

　　Security.loadPolicyFile("xmlsocket://mysite.com:port")，进行部署,两外等待策略文件的时间也是足够的放宽

　　接着进行修改代码，进行测试，出了碰到了点小的插曲，在测试的过程中，连接的端口改了，但是策略文件里的端口没有修改，导致结果还是没有连接上，但是我在测试的同时却进行了抓包，还好没有错过这次机会。抓包软件上已经发现本地对目标端口进行了请求。

　　呵呵，这下子好办了。接着一翻风顺，只是对843端口进行等待的时间，连接慢了3秒

　　看样子网上的文章虽多，但是有大量的文章没有区别

　　Security.loadPolicyFile("xmlsocket://mysite.com:port")和

　　Security.loadPolicyFile("xmlsocket://mysite.com:port")

为了说明问题,我用上面的方法进行设置

Security.loadPolicyFile("xmlsocket://202.101.172.*:844")

　　采用上面的策略文件

<cross-domain-policy>　
<allow-access-from　domain="*"　to-ports="8888"　/>　
</cross-domain-policy>　

　　监听的端口是8888

　　通过抓包，可以很清楚的发现连接过程



　　图片看不清楚？请点击这里查看原图（大图）。

　　主要代码如下：

　　AS3部分

public　class　Main　extends　Sprite　
{
　　　　private　var　socket:Socket　=　new　Socket();
　　　　public　function　Main():void　
　　　　{　　　　
　　　　　　　　Security.allowDomain("*");
　　　　　　　　Security.loadPolicyFile("xmlsocket://202.91.*.*:844");
　　　　　　　　this.socket.addEventListener(Event.CONNECT,　function(e:Event):void　{
　　　　　　　　　　　　　　　　this.SendChat("socket　data");
　　　　　　　　　　　　});
　　　　　　　　this.socket.addEventListener(ProgressEvent.SOCKET_DATA,　function(e:ProgressEvent):void　{
　　　　　　　　　　　　trace("有数据");
　　　　　　　　　　　　});
　　　　　　　　this.socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR,　function(e:SecurityErrorEvent):void　{
　　　　　　　　　　　　trace(e.text);
　　　　　　　　　　　　});
　　　　　　　　this.socket.connect("202.91.*.*",　8888);
　　　　}
　　　　
　　　　private　function　SendChat(s:String):void
　　　　{
　　　　　　　　if　(s.length　==　0)　{
　　　　　　　　　　　　return;
　　　　　　　　}
　　　　　　　　var　buffer:ByteArray　=　new　ByteArray();
　　　　　　　　buffer.writeMultiByte(s,　"GBK");
　　　　　　　　trace(buffer.length);
　　　　　　　　this.socket.writeUnsignedInt(buffer.length);
　　　　　　　　this.socket.writeBytes(buffer,　0,　buffer.length);
　　　　　　　　this.socket.flush();
　　　　}
}


c#端口监听

　1　public　class　AllowDomain
　2　　　　　{
　3　　　　　　　　　private　TcpListener　Server;
　4　　　　　　　　　private　AsyncCallback　callback;
　5　　　　　　　　　private　bool　islisten　=　false;
　6　
　7　　　　　　　　　public　AllowDomain()
　8　　　　　　　　　{
　9　　　　　　　　　　　　　this.Server　=　new　TcpListener(844);
10　　　　　　　　　　　　　this.Server.Start();
11　　　　　　　　　　　　　this.callback　=　new　AsyncCallback(this.OnConnectionEvent);
12　　　　　　　　　　　　　this.islisten　=　true;
13　　　　　　　　　　　　　this.Server.BeginAcceptSocket(this.callback,　null);
14　　　　　　　　　}
15　
16　　　　　　　　　public　void　Close()
17　　　　　　　　　{
18　　　　　　　　　　　　　this.islisten　=　false;
19　　　　　　　　　　　　　this.Server.Stop();
20　　　　　　　　　}
21　
22　　　　　　　　　private　void　OnConnectionEvent(IAsyncResult　syn)
23　　　　　　　　　{
24　　　　　　　　　　　　　if　(this.islisten)
25　　　　　　　　　　　　　{
26　　　　　　　　　　　　　　　　　SocketError　error;
27　　　　　　　　　　　　　　　　　Socket　conn　=　this.Server.EndAcceptSocket(syn);
28　　　　　　　　　　　　　　　　　//conn.Send(PolicyFile.Policys);
29　　　　　　　　　　　　　　　　　
30　　　　　　　　　　　　　　　　　byte[]　buffer　=　new　byte[1024];
31　　　　　　　　　　　　　　　　　int　len　=　conn.Receive(buffer,　0,　1024,　SocketFlags.None,　out　error);
32　　　　　　　　　　　　　　　　　if　(error　==　SocketError.Success)
33　　　　　　　　　　　　　　　　　{
34　　　　　　　　　　　　　　　　　　　　　string　s　=　Encoding.Default.GetString(buffer,　0,　len);
35　　　　　　　　　　　　　　　　　　　　　if　(s　==　"<policy-file-request/>\0")
36　　　　　　　　　　　　　　　　　　　　　{
37　　　　　　　　　　　　　　　　　　　　　　　　　buffer　=　Encoding.Default.GetBytes("<cross-domain-policy><allow-access-from　domain=\"*\"　to-ports=\"8888\"/></cross-domain-policy>\0");
38　　　　　　　　　　　　　　　　　　　　　　　　　conn.Send(buffer);
39　　　　　　　　　　　　　　　　　　　　　}
40　　　　　　　　　　　　　　　　　}
41　　　　　　　　　　　　　　　　　conn.Close();　　　　　　　　　　　　
42　　　　　　　　　　　　　　　　　if　(this.islisten)
43　　　　　　　　　　　　　　　　　　　　　this.Server.BeginAcceptSocket(this.OnConnectionEvent,　null);
44　　　　　　　　　　　　　}
45　　　　　　　　　}
46　　　　　}

6 楼 leopard0825 2010-04-27  

http://bbs.blueidea.com/thread-2967863-1-6.html

5 楼 leopard0825 2010-04-27  

ActionScript3.0 Socket编程同Socket服务器进行握手,并确定收到了什么样的数据和如何处理这些数...


解决方法:
    创建不同的常量来声明协议的状态.使用这些常量将指定的处理函数映射到相应的状态.在一个socketData事件控制器中,通过状态映射调用这些函数的.

讨论:
    建立Socket连接通常要处理握手这个环节.尤其是在服务器初始化需要向客户端发送数据.然后客户端通过一种特殊的方式相应这些数据,接着服务器因此再次响应.整个处理过程直到握手完成并且建立起一个"正常的"连接为止.

   处理服务器的不同响应是非难的,主要的原因是socketData事件控制器不能保存上下文的顺序.也就是说,服务器的响应不会告诉你"为什么"响应,也不告诉你这些响应数据被那个处理程序来处理.要想知道如何处理这些从服务器返回的响应不能从响应的本身来获得,尤其在响应变化的时候.或许一个响应返回了两个字节码,另一个返回了一个整数值还跟了一个双精度浮点数.这样看来让响应本身处理自己是一大难题.

   我们通过创建一个状态量来标注不同的上下文,服务器通过这些上下文将数据发送到客户端.与这些状态量都有一个相关联的函数来处理该数据,这样你就可以很轻松的按照当前的协议状态去调用正确的处理函数.

   当你要与一个Socket服务器建立连接需要考虑如下几个步骤:
1.当与服务器连接的时候,服务器立刻返回一个标志服务器可以支持的最高协议版本号的整数值.
2.客户端在响应的时候会返回一个实际使用协议的版本号.
3.服务器返回一个8byte的鉴定码.
4.然后客户端将这鉴定码返回到服务器.
5.如果客户端的响应不是服务器端所期望的,或者,就在这个时候该协议变成了一个常规操作模式,于是握手结束.

   实际上在第四步可以在鉴定码中包含更多的安全响应.你可以通过发送各种加密方法的密匙来代替逐个发送的鉴定码.这通常使用在客户端向用户索要密码的时候,然后密码成为了加密过的8byte鉴定码.该加密过的鉴定码接着返回到服务器.如果响应的鉴定码匙服务器所期望的,客户端就知道该密码是正确的,然后同意建立连接.

   实现握手框架,你首先要为处理从服务器返回的不同类型的数据分别创建常量.首先,你要从步骤1确定版本号.然后从步骤3收取鉴定码.最后就是步骤5的常规操作模式.我们可以声明

如下常量:

public const DETERMINE_VERSION:int = 0;
public const RECEIVE_CHALLENGE:int = 1;
public const NORMAL:int = 2;

   常量的值并不重要,重要的是这些值要是不同的值,两两之间不能有相同的整数值.

   下一个步骤我们就要为不同的数据创建不同处理函数了.创建的这三个函数分别被命名为readVersion( ), readChallenge( ) 和 readNormalProtocol( ). 创建完这三个函数后,我们就必须将这三个函数分别映射到前面不同状态常量,从而分别处理在该状态中收到的数据.代码如下:

stateMap = new Object( );
stateMap[ DETERMINE_VERSION ] = readVersion;
stateMap[ RECEIVE_CHALLENGE ] = readChallenge;
stateMap[ NORMAL            ] = readNormalProtocol;

   最后一步是编写socketData事件处理控制器,只有通过这样的方式,建立在当前协议状态之上的正确的处理函数才可以被调用.首先需要创建一个currentState的int变量.然后使用stateMap去查询与currentState相关联的函数,这样处理函数就可以被正确调用了.

var processFunc:Function = stateMap[ currentState ];
processFunc( ); // Invoke the appropriate processing function

   下面是一点与薄记相关的处理程序.在你的代码中更新currentState从而确保当前协议的状态.

   前面我们所探讨的握手步骤的完整的代码如下:
package {
import flash.display.Sprite;
import flash.events.ProgressEvent;
import flash.net.Socket;
import flash.utils.ByteArray;

public class SocketExample extends Sprite {

    // The state constants to describe the protocol
    public const DETERMINE_VERSION:int = 0;
    public const RECEIVE_CHALLENGE:int = 1;
    public const NORMAL:int = 2;
   
    // Maps a state to a processing function
    private var stateMap:Object;
   
    // Keeps track of the current protocol state
    private var currentState:int;
   
    private var socket:Socket;

    public function SocketExample( ) {
      // Initialzes the states map
      stateMap = new Object( );
      stateMap[ DETERMINE_VERSION ] = readVersion;
      stateMap[ RECEIVE_CHALLENGE ] = readChallenge;
      stateMap[ NORMAL            ] = readNormalProtocol;
     
      // Initialze the current state
      currentState = DETERMINE_VERSION;

      // Create and connect the socket
      socket = new Socket( );
      socket.addEventListener( ProgressEvent.SOCKET_DATA, onSocketData );
      socket.connect( "localhost", 2900 );
    }
   
    private function onSocketData( event:ProgressEvent ):void {
      // Look up the processing function based on the current state
      var processFunc:Function = stateMap[ currentState ];
      processFunc( );
    }
   
    private function readVersion( ):void {
      // Step 1 - read the version from the server
      var version:int = socket.readInt( );
     
      // Once the version is read, the next state is receiving
      // the challenge from the server
      currentState = RECEIVE_CHALLENGE;
     
      // Step 2 - write the version back to the server
      socket.writeInt( version );
      socket.flush( );
    }
   
    private function readChallenge( ):void {
      // Step 3 - read the 8 byte challenge into a byte array
      var bytes:ByteArray = new ByteArray( );
      socket.readBytes( bytes, 0, 8 );
     
      // After the challenge is received, the next state is
      // the normal protocol operation
      currentState = NORMAL;
     
      // Step 4 - write the bytes back to the server
      socket.writeBytes( bytes );
      socket.flush( );
    }
   
    private function readNormalProtocol( ):void {
      // Step 5 - process the normal socket messages here now that
      // that handshaking process is complete
    }
}
}

4 楼 leopard0825 2010-04-27  

关于ActionScript Socket通讯

我们在使用ActionScript3.0进行Socket编程的时候需要关注下面的问题,
1.与Socket服务器建立连接.
2.向Socket服务器发送数据.
3.从Socket服务器读数据.
4.同Socket服务器进行握手,并确定收到了什么样的数据和如何处理这些数据.
5.与Socket服务器断开,或者当服务器想与你断开的时候发消息给你.
6.处理使用Sockets时候引发的错误.


1.与Socket服务器建立连接.
解决方法:
我们通过调用Socket.connect( )或者XMLSocket.connect( )方法并监听网络连接的事件消息.
请牢记,当与一个主机建立一个Socket连接时,Flash Player要遵守如下安全沙箱规则.
1.Flash的.swf文件和主机必须严格的在同一个域名,只有这样才可以成功建立连接.
2.一个从网上发布的.swf文件是不可以访问本地服务器的.
3.本地未通过认证的.swf文件是不可以访问任何网络资源的.
4.你想跨域访问或者连接低于1024的端口,必须使用一个跨域策略文件.


2.向Socket服务器发送数据.
解决方法:
对于Socket对象来说,通过是用write方法(writeByte(),writeUTFBytes( )等方法.)先向缓存区写入数据,然后使用flush()方法发送数据.对于XMLSocket对象,使用send()方法.


3.从Socket服务器读数据
解决方法:
对于Socket实例,先收到socketData事件,然后调用如下两个方法的一个,比如,readByte()或者readInt(),在事件控制器中确定不会去读过去的bytesAvailable.
对于XMLSocket实例,先收到data事件,然后解析从事件控制器内部装载的XML数据.


4.同Socket服务器进行握手,并确定收到了什么样的数据和如何处理这些数据.
解决方法:
创建不同的常量来声明协议的状态.使用这些常量将指定的处理函数映射到相应的状态.在一个socketData事件控制器中,通过状态映射调用这些函数的.


5.与Socket服务器断开,或者当服务器想与你断开的时候发消息给你.
解决方法:
通过调用Socket.close( )或者XMLSocket.close( )方法显性的断开与服务器的连接.同时可以通过监听close事件获得服务器主动断开的消息.


6.处理使用Sockets时候引发的错误.
解决方法:
使用try/catch处理I/O和EOF(end of file)错误.

Socket和XMLSocket类对错误的处理很类似.不如,当调用connect()方法的时候,在下面任何一个条件成立的情况下Socket和XMLSocket对象会抛出一个类型为SecurityError的错误.
* 该.swf未通过本地安全认证.
* 端口号大于655535.

3 楼 leopard0825 2010-04-27  

http://uh.9ria.com/space-10432-do-blog-id-2294.html

2 楼 leopard0825 2010-04-27  

http://blog.csdn.net/huazhihao/archive/2009/06/18/4279938.aspx

1 楼 leopard0825 2010-04-27  

http://blog.csdn.net/huazhihao/archive/2009/06/18/4279544.aspx