Flex通訊-與Java實現Socket通訊實例

Flex通訊-與Java實現Socket通訊實例  轉自：http://blessht.iteye.com/blog/1136888

博客分類：

• Flex

• 環境準備

【服務器端】

JDK1.6，「java.net」包對網絡編程提供了很是全面的支持，包括Socket

開發環境：Eclipse

【客戶端】

Flex4，」flash.net」包也提供了Socket的支持

開發環境：FlashBuilder4

 

• 實例效果

我是用Java啓動一個ServerSocket做爲服務器，Flex建立一個頁面，當點擊頁面上的按鈕時向Java服務器發送消息。

 

Flex客戶端輸入「阿里巴巴」再點擊按鈕：

 Java控制檯：

 

 

• 注意事項

Flex項目分爲兩種：一種是普通的本地項目，也就是不依賴其它服務器；另外一種是遠程服務器項目，這須要依賴其它語言的服務器容器。若是是普通的本地項目，Socket通訊是很是容易的，可是若是是遠程項目，Socket通訊須要考慮Flex安全沙箱問題，後面會詳細介紹。

 

 

• Java Socket服務器

編寫Socket Server代碼的步驟一般是：

①建立ServerSocket，定義服務端口號

②使用ServerSocket.accept()監聽socket請求，若是有請求會建立一個Socket對象

③經過socket.getInputStream()獲取客戶端的請求數據

④經過socket.getOutputStream()向客戶端返回數據

⑤經過socket.close()結束本次會話

按照上面的步驟，若是有多個客戶端向服務器發送請求的話，服務器只會處理第一個請求，其它請求會排隊等待，只有第一個請求執行socket.close的時候下一個客戶端請求才會運行。爲了實現多客戶端併發請求，在第②步後面須要創建多線程。

 

廢話很少說，直接代碼說明。

 

首先建立一個 SocketUtil類，用於建立ServerSocket和獲取Socket

public class SocketUtil {

    /**
     * 建立ServerSocket
     * @param port
     * @return
     */
    public static ServerSocket getServerSocket(int port){
        ServerSocket server = null;
        try {
            server = new ServerSocket(port);
            System.out.println("------ServerSocket建立成功，Port:"+port);
            return server;
        } catch (IOException e) {
            if(server!=null && !server.isClosed()){
                try {
                    server.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            throw new RuntimeException("建立ServerSocket時發生異常，Port:"+port,e);
        }
    }

    /**
     * 獲取Socket
     * @param server
     * @return
     */
    public static Socket getSocket(ServerSocket server){
        Socket socket = null;
        try {
            socket = server.accept();
            System.out.println("------Socket鏈接成功，IP:"+socket.getInetAddress());
            return socket;
        } catch (IOException e) {
            if(socket!=null && !socket.isClosed()){
                try {
                    socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            throw new RuntimeException("建立Socket時發送異常",e);
        }
    }

}

 

而後建立一個帶多線程的類，用於服務器與客戶端的IO通訊

public class SocketThread implements Runnable {
    private Socket socket;
    private String encoding;

    public SocketThread(Socket socket,String encoding) {
        this.socket = socket;
        this.encoding = encoding;
    }

    /**
     * 與客戶端交互代碼
     */
    @Override
    public void run() {
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(socket
                    .getInputStream(), encoding));
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
                    socket.getOutputStream(), encoding));

            String getMsg;
            while ((getMsg = br.readLine()) != null && !"exit".equalsIgnoreCase(getMsg)) {
                // 客戶端未提出"exit"命令，則循環交流
                System.out.println("From client message:" + getMsg);
                bw.append("你好[" + socket.getInetAddress() + "],服務器收到你的信息："
                        + getMsg + "\r\n");
                bw.flush();
            }

            //客戶端提出"exit"請求，關閉當前socket...
            br.close();
            bw.close();
            socket.close();
            System.out.println("當前Socket鏈接結束......");
        } catch (Exception e) {
            if(!socket.isClosed()){
                try {
                    socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            throw new RuntimeException("Socket線程類發送異常...",e);
        }
    }
}

 

最後在Main函數中啓動Socket服務便可：

public static void main(String[] args) {
        new SocketServer().startSocket();
    }

 

• Flex客戶端代碼

Flex端建立Socket有兩種方式：

第一種經過connect方法鏈接Socket服務器：

var socket:Socket = new Socket();
socket.connect("localhost",10086);

 第二種經過建立Socket實例時在構造函數中傳入服務器ip和端口號鏈接：

socket = new Socket("localhost",10086);

 Flex經過ByteArray傳送IO數據，這裏有一點稍微注意一下在寫入的內容後面會加" \r\n"回車換行符，由於java端是經過BufferedReader.readLine的形式獲取一行數據，若是不換行服務器端IO就一直處於阻塞狀態：

//ByteArray存放數據
var message:ByteArray = new ByteArray();
//使用UTF形式防止中文亂碼
message.writeUTFBytes(txt_socket.text+"\r\n");
//數據寫入緩衝區
socket.writeBytes(message);

 Flex有多種事件用於監聽Socket的狀態：

Event.CONNECT：Socket與服務器成功鏈接時觸發的事件
Event.CLOSE：Socket與服務器斷開鏈接時觸發的事件
IOErrorEvent.IO_ERROR：Socket通訊時發生IO錯誤時觸發的事件
ProgressEvent.SOCKET_DATA：服務器返回數據時觸發的事件

 

新建一個Flex普通項目，入口文件定義爲index.mxml，在mxml文件中新建一個textinput文本框用於獲取用戶輸入的內容，button按鈕用戶發送內容到java socket服務器，一個label用戶顯示向前socket狀態，另外一個label用於顯示從服務器返回的信息。 index.mxml代碼以下：

<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
               xmlns:s="library://ns.adobe.com/flex/spark"
               xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600">

    <fx:Script>
        <![CDATA[


            private var socket:Socket = null;
            protected function button1_clickHandler(event:MouseEvent):void
            {
                if(socket==null || !socket.connected){
                    //鏈接服務器(ip,port)
                    socket = new Socket("localhost",10086);

                    //成功鏈接狀態事件
                    socket.addEventListener(Event.CONNECT,function connFun(e:Event):void{
                        l_status.text = "Connect to server success...";
                    });
                    //鏈接中斷事件
                    socket.addEventListener(Event.CLOSE,function closeFun(e:Event):void{
                        l_status.text = "Connect to server closed...";
                    });
                    //鏈接異常事件
                    socket.addEventListener(IOErrorEvent.IO_ERROR,function closeFun(e:IOErrorEvent):void{
                        l_status.text = "Connect exception ..."+e.toString();
                    });
                    //服務器信息事件
                    socket.addEventListener(ProgressEvent.SOCKET_DATA,function dataFun(e:ProgressEvent):void{
                        var getMsg:ByteArray = new ByteArray;
                        socket.readBytes(getMsg);
                        l_result.text = getMsg.toString();
                    });
                }

                //ByteArray存放數據
                var message:ByteArray = new ByteArray();
                //使用UTF形式防止中文亂碼
                message.writeUTFBytes(txt_socket.text+"\r\n");
                //數據寫入緩衝區
                socket.writeBytes(message);
                //將緩衝區數據發送出去
                socket.flush();
                //清空文本框內容
                txt_socket.text = "";
            }
        ]]>
    </fx:Script>

    <fx:Declarations>
        <!-- 將非可視元素（例如服務、值對象）放在此處 -->
    </fx:Declarations>
    <s:Button x="156" y="56" label="按鈕" click="button1_clickHandler(event)"/>
    <s:TextInput x="20" y="56" id="txt_socket"/>
    <s:Label x="20" y="104" id="l_status"/>
    <s:Label x="234" y="65" id="l_result"/>
</s:Application>

 

代碼編寫完成後運行index.mxml文件，最後執行效果就如前面【實例效果】所示。

 

 

• 安全沙箱

下面這段是從網上抄的：

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

在 Adobe Flash Player 升級到 9.0.124 後，因爲安全策略更改，原來 Socket 或 XmlSocket 的應用裏的 http 方式加載安全策略的手段不能繼續使用。更改以下：
1, 首先檢測目標服務器的 843 端口是否提供安全策略 
2, 若是 1 沒有檢測到策略，則檢測 actionscript 是否使用了 Security.loadPolicyFile(xmlsocket://)手段提供安全策略，若是還沒檢測到，則使用第 3 步檢測
3, 檢測目標服務器目標端口是否提供安全策略。

在說具體處理方式前，我先描述一下 Flash Player 的驗證過程。在 Flex 程序發出 Socket 或 XmlSocket( 如下統稱爲 Socket) 請求前， FlashPlayer 會先判斷是否爲本地調用，若是不是。即用一個 Socket 去連接到你的服務端，三次握手成功後一方面發出字符串「 <policy-file-request/>\0 「另外一方面監聽返回的安全策略。安全策略接收成功後， FlashPlayer 就斷開驗證的 Socket ，而後再運行程序自己的 Socket 。在整個 SWF 運行期間，不管你請求多少次，只要域相同， FlashPlayer 就只驗證一次。這裏有兩個重點: 
第一個是驗證的 Socket 和程序的 Socket 是兩個 Socket 。因此你在本地測試時，服務端監聽到 N 個 Socket 請求，但佈置到服務端後，服務端會監聽到 N+1 個請求。
第二是驗證的 Socket 發送「 <policy-file-request/>\0 「請求和接收你的策略文件是沒有前後關係的，因此你不必接收完「 <policy-file-request/>\0 「後才發策略文件。個人作法是隻要監聽到請求，就把策略字符串發過去。

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

 

那麼簡單的說，若是Flex項目依賴其它語言的服務器的話（好比依賴J2EE服務器），在flex的socket客戶端向JavaSocket服務器發送請求以前，Flex會優先發送一個安全驗證消息，若是java服務器不返回驗證消息則當前socket通訊失敗。

解決辦法有不少種，我在網上也看了不少，可是不少寫得有問題。

根據我多方調查，我的以爲這種方案比較靠譜：

在Java服務器端建立一個端口號爲843的ServerSocket監聽Flex安全沙箱驗證消息，若是接收到<policy-file-request/>文件信息，則向客戶端返回XMl驗證內容：「<?xml version=\"1.0\"?><cross-domain-policy><site-control permitted-cross-domain-policies=\"all\"/><allow-access-from domain=\"*\" to-ports=\"*\"/></cross-domain-policy>\0」

具體代碼以下：

/**
 * 處理與Flex認證的線程類
 * @author Administrator
 */
public class PolicyThread implements Runnable {
    private final String policy_xml = "<policy-file-request/>";
    private final String cross_xml = "<?xml version=\"1.0\"?><cross-domain-policy><site-control permitted-cross-domain-policies=\"all\"/><allow-access-from domain=\"*\" to-ports=\"*\"/></cross-domain-policy>\0";
    private Socket socket;

    public PolicyThread(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            //接收併發送Flex安全驗證請求
            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 s = new String(by);
            if(s.equals(policy_xml)){
                System.out.println("接收policy-file-request認證");
                pw.print(cross_xml);
                pw.flush();
                br.close();
                pw.close();
                socket.close();
                System.out.println("完成policy-file-request認證");
            }
        } catch (IOException e) {
            if(!socket.isClosed()){
                try {
                    socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            throw new RuntimeException("執行policy認證時發生異常",e);
        }
    }

}

public class PolicyServer implements Runnable{

    private final int policy_port = 843;
    private boolean status = true;

    private ServerSocket server = null;
    @Override
    public void run() {
        //建立安全驗證服務器
        server = SocketUtil.getServerSocket(policy_port);

        while(status){
            Socket socket = SocketUtil.getSocket(server);
            new Thread(new PolicyThread(socket)).start();
        }
    }


    /**
     * 啓動服務器
     */
    public void startPolicy(){
        new Thread(this).start();
    }

    /**
     * 關閉服務器
     */
    public void stopPolicy(){
        status = false;
        if(server!=null && !server.isClosed()){
            try {
                server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 

Flex客戶端向Java發送第一次Socket請求（例子裏的端口號是10086）時，ServerSocket843端口會收到安全沙箱驗證，隨後server將正確的驗證消息返回給Flex客戶端，Flex認證成功後真正的10086端口Socket連結就已經搭建了，隨後雙方就能夠暢通無阻通訊了（一次會話只進行一次沙箱驗證）。

 

 

• Servlet啓動ServerSocket

我一般比較喜歡建立一個servlet，在web.xml中配置容器啓動時運行servlet的init方法，這樣端口號爲10086和843的serverSocket就會啓動：

public class InitServers extends HttpServlet {
    private static final long serialVersionUID = 1L;

    /**
     * @see HttpServlet#HttpServlet()
     */
    public InitServers() {
        super();
    }

    /**
     * @see Servlet#init(ServletConfig)
     */
    public void init(ServletConfig config) throws ServletException {
        new PolicyServer().startPolicy();
        new SocketServer().startSocket();
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
    }

}

 web.xml

 

<servlet>
        <display-name>InitServers</display-name>
        <servlet-name>InitServers</servlet-name>
        <servlet-class>socket.InitServers</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

 

以上一個完整的Flex+Java的Socket通訊就完成了。