FLEX IO 之XMLSocket

一门好的语言需要良好的支持IO操作, Java有了Socket才有了JDBC, Servlet, Tomcat and etc.

先看下FLEX的XMLSocket.

 

XMLSocket提供的接口比较简单, 文档还有简单的例子, 跟Java区别写法比较大的就是它异步的回调.

 

FLASH客户端代码:

1. 一门好的语言需要良好的支持IO操作, Java有了Socket才有了JDBC, Servlet, Tomcat and etc.
3. 先看下FLEX的XMLSocket.
7. XMLSocket提供的接口比较简单, 文档还有简单的例子, 跟Java区别写法比较大的就是它异步的回调.
11. <?xml version="1.0" encoding="utf-8"?>
12. <mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" width="800" height="600" creationComplete="initApp()">
14. <mx:Script><![CDATA[
15.     import mx.controls.Alert;
17. private var sock:XMLSocket = null;
19. //Initial the GUI 
20. private function initApp():void {
21. }
23. //Click logon 
24. private function connectServer(event:MouseEvent):void {
25.     if (this.sock != null)
26.         return;
27.     this.sock = new XMLSocket();
28.     //Refer to XMLSocket document, follow the sample here 
29.     this.configureListeners(this.sock);
30.     this.sock.connect("localhost", 8080);
31.     this.sendButton.enabled = true;
32. }
33.         public function send(data:Object):void {
34.             this.sock.send(data);
35.         }
37.         private function configureListeners(dispatcher:IEventDispatcher):void {
38.             dispatcher.addEventListener(Event.CLOSE, closeHandler);
39.             dispatcher.addEventListener(Event.CONNECT, connectHandler);
40.             dispatcher.addEventListener(DataEvent.DATA, dataHandler);
41.             dispatcher.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
42.             dispatcher.addEventListener(ProgressEvent.PROGRESS, progressHandler);
43.             dispatcher.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
44.         }
46.         private function closeHandler(event:Event):void {
47.             trace("closeHandler: " + event);
48.             this.appendLine("CLose event socket");
49.         }
51.         private function connectHandler(event:Event):void {
52.             trace("connectHandler: " + event);
53.             this.appendLine("Send: connect to server sucessfully." + event.target.toLocaleString());
54.             
55.         }
56.         private function appendLine(mesg:String):void {
57.             //The /0 will be added automatically like C 
58.             this.messageArea.text += (mesg);
59.         }
61.         private function dataHandler(event:DataEvent):void {
62.             trace("dataHandler: " + event);
63.             this.appendLine("Server Response:" + event.data);
64.             //this.messageArea.text += ("Server Response:" + event.target.toLocaleString() + "/r/n"); 
65.         }
67.         private function ioErrorHandler(event:IOErrorEvent):void {
68.             trace("ioErrorHandler: " + event);
69.             this.appendLine("Oops, ioError");
70.         }
72.         private function progressHandler(event:ProgressEvent):void {
73.             trace("progressHandler loaded:" + event.bytesLoaded + " total: " + event.bytesTotal);
74.         }
76.         private function securityErrorHandler(event:SecurityErrorEvent):void {
77.             trace("securityErrorHandler: " + event);
78.             this.appendLine("Oops, encounter security error:" + event.text);
79.         }
80.         
81.         private function sendMessage(event:MouseEvent):void {
82.             var message:String = this.messageField.text;
83.             //message = "<message>" + message + "</message>/r/n"; 
84.             message = message + "/r/n";  
85.             if (message != null && message.length > 0) {
86.                 this.send(message);
87.                 //this.messageArea.text += ("Send:" + message + "/r/n"); 
88.                 this.appendLine("Send:" + message );
89.             }
90.         }
94. ]]>
95. </mx:Script>
96.             
97.     <mx:TextArea x="10" y="10" width="780" height="386" id="messageArea"/>
98.     <mx:TextInput x="10" y="416" width="536" height="31" id="messageField"/>
99.     <mx:Button x="577" y="416" label="Send" height="31" width="69" id="sendButton" enabled="false" click="sendMessage(event)"/>
100.     <mx:Button x="669" y="416" label="Logon" height="31" id="logonButton" click="connectServer(event)"/>
101.     
102. </mx:Application>

JAVA服务器:

 

1. /*
2.  * testflex.CellPhoneLocator.java       2008-12-23
3.  */
4. package testflex;
6. import java.io.BufferedReader;
7. import java.io.IOException;
8. import java.io.InputStream;
9. import java.io.InputStreamReader;
10. import java.io.PrintWriter;
11. import java.io.UnsupportedEncodingException;
12. import java.net.InetAddress;
13. import java.net.ServerSocket;
14. import java.net.Socket;
15. import java.util.Date;
16. import java.util.HashMap;
17. import java.util.Map;
18. import java.util.StringTokenizer;
20. /**
21.  * The demo provided to test the flash XMLSocket
22.  * @author zealvampire
23.  * @version 1.0  2008-12-23
24.  */
25. public class CellPhoneLocator {
26.     
27.     /** The listening port of server. */
28.     private int serverPort = 8080;
29.     private int backlog = 50;
30.     private InetAddress bindAddress = null;
31.     private Map<String,String> questions = new HashMap<String,String>(5);
32.     private boolean toStopServer = false;
33.     
34.     //Open 843 to handle the policy request.
35.     private PolicyService policyService = null;
37.     /** The server socket */
38.     private ServerSocket serverSocket = null;
39.     
40.     
41.     
42.     public CellPhoneLocator() {
43.         questions.put("130", "130's from chinaunicom");
44.         questions.put("131", "131's from chinaunicom");
45.         questions.put("133", "133's from Chinatelecom");
46.         questions.put("135", "135's from China Mobile");
47.         questions.put("138", "138's from China Mobile");
48.     }
49.     
50.     private String locateNumber(String phoneNum)  {
51.         String location = this.questions.get(phoneNum);
52.         return location==null ? (phoneNum + "'s Unknown") : location;
53.     }
54.     
55.     
56.     private class FlexStringReader extends InputStreamReader {
57.         
58.         private StringBuffer buf = new StringBuffer();
60.         public FlexStringReader(InputStream in) {
61.             super(in);
62.         }
63.         public FlexStringReader(InputStream in, String charsetName) throws UnsupportedEncodingException {
64.             super(in, charsetName);
65.         }
66.         //Make sure it works.
67.         public String readLine() throws IOException {
68.             int oneChar = 0;
69.             buf.setLength(0);
70.             while ((oneChar = this.read()) != -1) {
71.                 if (oneChar == '/0')
72.                     break;
73.                 buf.append((char) oneChar);
74.             }
75.             return buf.toString();
76.         }
77.         
78.     }
79.     
80.     private class RequestHanlder implements Runnable {
81.         private Socket sock = null;
82.         public RequestHanlder(Socket pSock) {
83.             this.sock = pSock;
84.         }
85.         private String command = "";
86.         private String parameter = "";
87.         public void run() {
88.             FlexStringReader reader = null;
89.             PrintWriter pw = null;
90.             String line = null;
91.             try {
92.                 System.out.println("Client:" + this.sock);
93.                 InputStream in = this.sock.getInputStream();
94.                 reader = new FlexStringReader(in, "UTF-8");
95.                 pw = new PrintWriter(this.sock.getOutputStream());
96.                 String policyRequest = reader.readLine();//new String(headers);
97.                 //FLash client will open two ports, one to retrieve the policy.
98.                 //Another to normal communicate to server. 
99.                 if (policyRequest.startsWith("<policy-file-request/>")) {
100.                     pw.write("<?xml version=/"1.0/"?><cross-domain-policy><site-control permitted-cross-domain-policies=/"all/"/><allow-access-from domain=/"*/" to-ports=/"*/" /></cross-domain-policy>/0");
101.                     pw.flush();
102.                     System.out.println("Policy's sent by current listening port:" + serverPort);
103.                     Thread.sleep(10000);
104.                     throw new IOException("A dirty return, never follow it dude.");
105.                 }
106.                 else {
107.                     pw.write("Hi " + this.sock + ",at your service, send me the cell phone please./0");
108.                 }
109.                 pw.flush();
111.                 while ((line = reader.readLine()).length() > 0) {
112.                     this.parseRequest(line);
113.                     if ("where".equalsIgnoreCase(command)) {
114.                         pw.write(locateNumber(this.parameter)+ '/0');
115.                         pw.flush();
116.                     }
117.                     else if ("quit".equalsIgnoreCase(command) || "exit".equalsIgnoreCase(command)) {
118.                         break;
119.                     }
120.                     else {
121.                         pw.write("Oops, unknown command./0");
122.                         pw.flush();
123.                     }
124.                 }
125.             }
126.             catch (IOException e) {
127.                 e.printStackTrace();
128.             } catch (InterruptedException e) {
129.                 e.printStackTrace();
130.             }
131.             finally {
132.                 //FIXME, try to close the I/O stream
133.                 try {
134.                     sock.close();
135.                 } catch (IOException e) {
136.                     e.printStackTrace();
137.                 }
138.             }
139.             
140.         }
141.         private void parseRequest(String line) {
142.             command = "";
143.             parameter = "";
144.             StringTokenizer tokens = new StringTokenizer(line, " /t/n/r/f/0", false);
145.             int count = tokens.countTokens();
146.             if (count  > 0) {
147.                 this.command = tokens.nextToken();
148.                 if (count > 1)
149.                     this.parameter = tokens.nextToken();
150.             }
151.             System.out.println("Command=" + this.command + "/tParameter=" + this.parameter);
152.         }
153.         
154.     }
155.     
156.     /**
157.      * Start the server first.
158.      * @throws IOException
159.      */
160.     public void startServer() throws IOException {
161.         this.serverSocket = new ServerSocket(serverPort, backlog, bindAddress);
162.         System.out.println(new Date() + ": Starting server.");
163.         
164.         //The policy swith
165.         this.policyService = new PolicyService();
166.         this.policyService.start();
167.     }
168.     
169.     private class PolicyService extends Thread {
170.         private ServerSocket policySock = null;
171.         public void run() {
172.             try {
173.                 this.policySock = new ServerSocket(843);
174.                 System.out.println(new Date() + ":The policy server is running on 843......");
175.                 Socket sock = null;
176.                 String request = null;
177.                 FlexStringReader br = null;
178.                 PrintWriter pw = null;
179.                 //FIXME, create another thread to handle the request.
180.                 while ((sock = this.policySock.accept()) != null) {
181.                     br = new FlexStringReader(sock.getInputStream());
182.                     pw = new PrintWriter(sock.getOutputStream());
183.                     System.out.println("Policy server:client socket=" + sock);
184.                     request = br.readLine();
185.                     System.out.println("Policy service: request=" + request);
186.                     if (request.startsWith("<policy-file-request/>")) {
187.                         pw.write("<?xml version=/"1.0/"?><cross-domain-policy><site-control permitted-cross-domain-policies=/"all/"/><allow-access-from domain=/"*/" to-ports=/"*/" /></cross-domain-policy>/0");
188.                         pw.flush();
189.                         System.out.println("Policy service:Policy file's sent......");
190.                         //Wait until the xml's pushed to client.
191.                         Thread.sleep(10000);
192.                     }
193.                     //FIXME, not a good way the release resources. 
194.                     System.out.println("Policy service: close the client socket.");
195.                     br.close();
196.                     pw.close();
197.                     sock.close();
198.                 }
199.             } catch (IOException e) {
200.                 e.printStackTrace();
201.             } catch (InterruptedException e) {
202.                 e.printStackTrace();
203.             }  finally {
204.                 //FIXME, refactor it ..
205.                 if (this.policySock != null) {
206.                     try {
207.                         this.policySock.close();
208.                     } catch (IOException e) {
209.                         e.printStackTrace();
210.                     }
211.                 }
212.             }
213.         }
214.     }
215.     
216.     /**
217.      * Service's running
218.      * @throws IOException
219.      */
220.     public void service() throws IOException {
221.         Socket clientSock = null;
222.         Thread handler = null;
223.         while (!this.toStopServer && (clientSock = this.serverSocket.accept()) != null) {
224.             //FIXME, only a demo, try to control the threads using producer/consumer,threadpool in your project.
225.             handler = new Thread(new RequestHanlder(clientSock));
226.             handler.start();
227.         }
228.         this.releaseResource();
229.         
230.     }
231.     public void releaseResource() {
232.         if (this.serverSocket != null)
233.             try {
234.                 this.serverSocket.close();
235.                 this.serverSocket = null;
236.             } catch (IOException e) {
237.                 // TODO Auto-generated catch block
238.                 e.printStackTrace();
239.             }
240.     }
241.     
242.     
243.     
244.     
246.     /**
247.      * @param args
248.      */
249.     public static void main(String[] args) {
250.         CellPhoneLocator server = new CellPhoneLocator();
251.         try {
252.             server.startServer();
253.             server.service();
254.         } catch (IOException e) {
255.             e.printStackTrace();
256.             server.releaseResource();
257.         }
258.         
260.     }
264.     /**
265.      * @return the serverPort
266.      */
267.     public int getServerPort() {
268.         return serverPort;
269.     }
273.     /**
274.      * @param serverPort the serverPort to set
275.      */
276.     public void setServerPort(int serverPort) {
277.         this.serverPort = serverPort;
278.     }
280. }

麻烦的只是权限, 因为flash player只相信一个原则, SWF从哪里来, 它就相信哪个域; 也就是说SWF本地运行还有从网络下载到浏览器它的采访权限是完全不一样的, SANDBOX沙漏这个限制就好像java applet一样. 我们需要设置好policy.

 

1. 在本地Flash player运行, I mean 直接点击生成的SWF

不需要设置, XMLSocket可以直接发送接受服务器的信息.  不过我这里用的都是localhost, 不知道使用外部IP会如何..不确定.

 

2. SWF放在web 服务器下, 使用浏览器采访

(1)默认先连XMLSocket目标服务器的843端口, 发送<policy-file-request/>/0 类似这样的信息.

我们返回"<?xml version=/"1.0/"?><cross-domain-policy><site-control permitted-cross-domain-policies=/"all/"/><allow-access-from domain=/"*/" to-ports=/"*/" /></cross-domain-policy>/0"

 

(2) 如1失败, 则查看AS中是否

Security.loadPolicyFile( "xmlsocket://host:port" )  有则尝试加载crossdomain.xml

(3)2失败则只能链XMLSocket的目标端口了. 还失败就不可能建立连接了.

 

3.需要注意的是XMLSocket未必一定要发送XML, 你也可以直接发送String, 但是flex里面的string发送过去是以/0结束的.

后台需要额外处理一下/0; 返回到flash的字符串也必须使用/0才能在在客户端接收到. 冇办法, 每个语言都有自己的规则.

        private function dataHandler(event:DataEvent):void {
            trace("dataHandler: " + event);
            this.appendLine("Server Response:" + event.data);
            //this.messageArea.text += ("Server Response:" + event.target.toLocaleString() + "/r/n");
        }

 

 

 

之后会继续测试一下Flex 的binary socket和其他IO