Flex ByteArray Socket

 

ByteArray

Class public class ByteArray 

继承 ByteArray -->  Object 

Implements IDataInput, IDataOutput 

Subclasses ByteArrayAsset 

 

属性：

bytesAvailable : uint  [] 可从字节数组的当前位置到数组末尾读取的数据的字节数。

defaultObjectEncoding : uint [] 指示用于新 ByteArray 实例的 ByteArray 类的默认对象编码。

length : uint ByteArray 对象的长度（以字节为单位）。

position : uint 将文件指针的当前位置（以字节为单位）移动或返回到 ByteArray 对象中。

 

方法：

ByteArray() 创建一个表示填充的字节数组的 ByteArray 实例，以便使用此类中的方法和属性来优化数据存储和数据流。

writeUTF(value:String):void 将 UTF-8 字符串写入字节流。

writeUTFBytes(value:String):void 将 UTF-8 字符串写入字节流。

writeByte(value:int):void 在字节流中写入一个字节。

writeBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0):void  

将指定字节数组 bytes（起始偏移量为 bytes，从 0 开始的索引）中包含 length 个字节的字节序列写入字节流。

offset:uint (default = 0) — 从 0 开始的索引，表示在数组中开始写入的位置。

 

 

 

 

Socket

Class public class Socket 

继承 Socket  EventDispatcher  Object 

Implements IDataInput, IDataOutput 

类使 代码可以建立套接字连接并读取和写入原始二进制数据。它与 XMLSocket 类似，但没有指定接收或传输的数据格式。

属性:

bytesAvailable : uint [] 输入缓冲区中可读取的数据的字节数。

connected : Boolean [] 指示此 Socket 对象目前是否已连接。

objectEncoding : uint 在写入或读取对象时，控制所使用的 AMF 的版本。

方法：

Socket(host:String = null, port:int = 0) 创建一个 Socket 对象。

close():void 关闭套接字。 Socket 

connect(host:String, port:int):void 将套接字连接到指定的主机和端口。 Socket 

dispatchEvent(event:Event):Boolean 将事件调度到事件流中。 EventDispatcher 

flush():void 对套接字输出缓冲区中积累的所有数据进行刷新。 

readByte():int 从套接字读取一个带符号字节。 Socket 

   readBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0):void 从套接字读取 length 参数所指定的数据的字节数。 

readMultiByte(length:uint, charSet:String):String 使用指定的字符集，从该字节流读取一个多字节字符串。

readUnsignedByte():uint 从套接字读取一个无符号字节。 Socket 

   readUnsignedInt():uint 从套接字读取一个无符号的 32 位整数。 Socket 

   readUnsignedShort():uint 从套接字读取一个无符号的 16 位整数。 

readUTF():String 从套接字读取一个 UTF-8 字符串。 Socket 

   readUTFBytes(length:uint):String 从套接字读取 length 参数所指定的 UTF-8 数据的字节数，并返回一个字符串。 

writeByte(value:int):void 将一个字节写入套接字。 Socket 

   writeBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0):void 从指定的字节数组写入一系列字节。 

writeMultiByte(value:String, charSet:String):void 使用指定的字符集，从该字节流写入一个多字节字符串。 Socket 

   writeObject(object:*):void 以 AMF 序列化格式将一个对象写入套接字。 Socket 

   writeShort(value:int):void 将一个 16 位整数写入套接字。 Socket 

   writeUnsignedInt(value:uint):void 将一个无符号的 32 位整数写入套接字。 Socket 

   writeUTF(value:String):void 将以下数据写入套接字：一个无符号 16 位整数，它指示了指定 UTF-8 字符串的长度（以字节为单位），后面跟随字符串本身。 Socket 

   writeUTFBytes(value:String):void 将一个 UTF-8 字符串写入套接字。

 

 

事件： Event.XX close 在服务器关闭套接字连接时调度。 Socket connect 在建立网络连接后调度。 Socket deactivate Flash Player 或 AIR 应用程序失去操作系统焦点并变为非活动状态时调度。 EventDispatcher ioError 在出现输入/输出错误并导致发送或加载操作失败时调度。 Socket securityError 若对 Socket.connect() 的调用尝试连接到调用方安全沙箱外部的服务器或端口号低于 1024 的端口，则进行调度。 Socket socketData 在套接字接收到数据后调度。

--------------------------------------------------------------------------

Flex 端 代码（跟好的理解Socket）：

 

<?xml version="1.0" encoding="utf-8"?>

<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" width="353" height="336"

creationComplete="initApp();" >

<mx:Script>

<![CDATA[

private var socket:Socket = new Socket();

private var intClient:int; //定义客户端数字出拳

private var intServer:int; //定义服务端数字出拳

private var intSY:int; //定义输赢判断

private var strClient:String; //客户端文字出拳

private var strServer:String; //服务端的文字出拳

internal function initApp():void{

socket.connect("127.0.0.1",8888);

socket.addEventListener(Event.CONNECT,funConnect);

                socket.addEventListener(Event.CLOSE,funClose);

                socket.addEventListener(ProgressEvent.SOCKET_DATA,funSocket);

}

internal function funConnect(e:Event):void{

myText.text+="连接已建立 \n";

}

internal function funClose(e:Event):void{

myText.text+="连接已关闭 \n";

}

private function sendMessage(msg:String):void{

var message:ByteArray = new ByteArray();

message.writeUTF(msg); //发送出拳数字

socket.writeBytes(message);

socket.flush();

intClient=int(msg);

switch(intClient){ //将数字转换成文字用于发布到屏幕上

case 0:

                            strClient="剪刀";

                            break;

                    case 1:

                            strClient="锤";

                            break;

                    case 2:

                            strClient="包袱";

                            break;

}

myText.text+="你出："+strClient+";  ";

                myInput.text="";

}

internal function funSocket(e:ProgressEvent):void{ //接到服务器信息

var msg:String="";

while(socket.bytesAvailable)

{

msg=socket.readUTF();

intServer=int(msg);

intSY=intClient-intServer; //通过数值判断输赢

switch(intServer) //将数字转换成文字用于发布到屏幕上

                    {

                        case 0:

                                strServer="剪刀";

                                break;

                        case 1:

                                strServer="锤";

                                break;

                        case 2:

                                strServer="包袱";

                                break;

                    }

                    myText.text+="服务器出："+strServer+";  ";

                    //判断输赢的算法

                    if(intSY>0&&intSY<2)

                    {

                            myText.text+=" 结果:你赢了 \n";

                    }else if(intClient==intServer)

                    {

                            myText.text+=" 结果:平手 \n";

                    }else if(intSY<0&&intSY>-2)

                    {

                            myText.text+=" 结果:你输了 \n";

                    }else if(intSY>=2)

                    {

                            myText.text+=" 结果:你输了 \n";

                    }else if(intSY<=-2)

                    {

                            myText.text+=" 结果:你赢了 \n";

                    }

                    // myText滚动到最下面

                    myText.verticalScrollPosition = myText.maxVerticalScrollPosition;

}

}

]]>

</mx:Script>

<mx:TextArea x="10" y="32" width="331" height="263" id="myText"/>

    <mx:TextInput x="10" y="303" width="245" id="myInput"/>

    <mx:Button x="273" y="304" label="发送" id="myBtn" click="sendMessage(myInput.text)"/>

    <mx:Label x="10" y="10" text="规则：0代表剪刀；1代表锤；2代表包袱" width="331" fontWeight="bold"/>

</mx:Application>

Java 端代码：

package f1.f1_005.socket;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.Random;

import java.util.Vector;

/**

知识点：套接字管理器（Vector）会将于客户机连接的套接字添加到其列表中，在客户机断开连接后，在将相应的套接自从列表中删除，从中可以看出，客户机连接数与列表中添加套接字数目是一致的。

Vector sManager=new Vector();

sManager.add(socket);  // 向列表添加套接字

sManager.remove(socket);　　 //从列表移除套接字

sManager.size();　　//获取客户机连接数

*/

public class Server4 {

private ServerSocket server;

//Vector 类提供了实现可增长数组的功能，随着更多元素加入其中，数组变的更大。

Vector sManager = new Vector(); //管理套接字的Vector

Random rnd = new Random(); //创建随机数的发生器

public Server4(){}

void startServer() //运行服务器

{

try {

server = new ServerSocket(8888);

System.out.println("服务器套接字已创建成功！");

while (true)

{

Socket socket = server.accept();

System.out.println("已经与客户机连接");

new KBBCom_Thread(socket).start();

sManager.add(socket);

System.out.println("当前客户机连结数："+sManager.size());

}

} catch (IOException e) {

e.printStackTrace();

}

}

public static void main(String[] args) {

Server4 server=new Server4();

        server.startServer();

}

class KBBCom_Thread extends Thread  //与客户机进行通信的线程累

{

Socket socket; //套接字引用变量

private DataInputStream reader; //套接字输入流

private DataOutputStream writer;

KBBCom_Thread(Socket socket){ //构造函数

this.socket = socket;

}

public void run(){

try {

//获取套接字的输入输出流

reader = new DataInputStream(socket.getInputStream());

writer = new DataOutputStream(socket.getOutputStream());

String msg;

//如果收到客户端发来的数据

while((msg=reader.readUTF())!= null){

//向客户机传送0-2之间的整型随机数

writer.writeUTF(rnd.nextInt(3)+"\n");

writer.flush();

System.out.println("来自客户机："+msg);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

sManager.remove(socket); //删除套接字

//关闭输入输出流及套接字

if(reader!=null)reader.close();

if(writer!=null)writer.close();

if(socket!=null)socket.close();

reader=null;

writer=null;

socket=null;

//向屏幕输出相关信息

System.out.println("客户机离开");

                    System.out.println("当前客户机的连接数："+sManager.size());

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

}

--------------------------------------------------------------------------

以上看不懂，可以一步一步来，去理解

参考文章：http://bbs.9ria.com/viewthread.php?tid=3256&page=1&extra=page%3D1

--------------------------------------------------------------------------

ByteArray实例代码：

var byteArr:ByteArray = new ByteArray();

byteArr.writeBoolean(false);

trace(byteArr.length); // 1

trace(byteArr[0]); // 0

/*

ByteArray 类提供用于优化读取、写入以及处理二进制数据的方法和属性。

ByteArray字节数组中存储的是字节流。

所以，在你存入的内容，都是转化成字节的格式存储的。

boolean类型，占，一个字节，8位

double 类型，占，占八哥字节，8*8=64位。

不够位数的补0，例如，3.1415926，把其转化成二进制的形式然后在其数组中存储，然后按8位为一个字节

*/

byteArr.writeDouble(Math.PI);  // trace(Math.PI); //3.141592653589793

trace(byteArr.length); // 9

trace(byteArr[0]); // 0     

trace(byteArr[1]); // 64

trace(byteArr[2]); // 9

trace(byteArr[3]); // 33

trace(byteArr[4]); // 251

trace(byteArr[5]); // 84

trace(byteArr[6]); // 68

trace(byteArr[7]); // 45

trace(byteArr[8]); // 24

byteArr.position = 0;

try { trace(byteArr.readBoolean() == false); // true } catch(e:EOFError) { trace(e); // EOFError: Error #2030: End of file was encountered. } try { trace(byteArr.readDouble()); // 3.141592653589793 } catch(e:EOFError) { trace(e); // EOFError: Error #2030: End of file was encountered. }

Soclet 实例代码：

package {

    import flash.display.Sprite;

    public class SocketExample extends Sprite

    {

        public function SocketExample() {

        var socket:CustomSocket = new CustomSocket("localhost", 80);

    }

    }

    }

import flash.errors.*; import flash.events.*;

import flash.net.Socket;

class CustomSocket extends Socket

{

    private var response:String;

    public function CustomSocket(host:String = null, port:uint = 0)

    {

        super(host, port);

        configureListeners();

    }

    private function configureListeners():void

    {

        addEventListener(Event.CLOSE, closeHandler);

        addEventListener(Event.CONNECT, connectHandler);

        addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);                    addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);            addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);

    }

    private function writeln(str:String):void {

        str += "\n"; try {

            writeUTFBytes(str);

        } catch(e:IOError)

        {

            trace(e);

        }

    }

    private function sendRequest():void {

        trace("sendRequest"); response = ""; writeln("GET /"); flush();

    }

    private function readResponse():void

    {

        var str:String = readUTFBytes(bytesAvailable); response += str;

    }

    private function closeHandler(event:Event):void

    {

        trace("closeHandler: " + event); trace(response.toString());

    }

    private function connectHandler(event:Event):void

    {

        trace("connectHandler: " + event); sendRequest();

    }

    private function ioErrorHandler(event:IOErrorEvent):void

        { trace("ioErrorHandler: " + event);

    }

    private function securityErrorHandler(event:SecurityErrorEvent):void

        { trace("securityErrorHandler: " + event);

    }

    private function socketDataHandler(event:ProgressEvent):void

        { trace("socketDataHandler: " + event); readResponse();

    }

}