Sockets

Flash Player 9 of hoger, Adobe AIR 1.0 of hoger

Een socket is een type netwerkverbinding tussen twee computerprocessen. Deze processen worden meestal uitgevoerd op twee verschillende computers die zijn gekoppeld aan hetzelfde IP-netwerk (Internet Protocol). De gekoppelde processen kunnen echter ook worden uitgevoerd op dezelfde computer via het speciale IP-adres “local host”.

Adobe Flash Player biedt ondersteuning voor TCP-sockets (Transport Control Protocol) van de client-kant. Een Flash Player-toepassing kan een verbinding maken met een ander proces dat handelt als een socketserver, maar de toepassing kan geen binnenkomende verbindingsaanvragen accepteren van andere processen. Met andere woorden: een Flash Player-toepassing kan verbinding maken met een TCP-server, maar niet functioneren als TCP-server.

De Flash Player-API bevat ook de XMLSocket-klasse. De XMLSocket-klasse gebruikt een Flash Player-specifiek protocol waarmee u XML-berichten kunt uitwisselen met een server die het protocol begrijpt. De XMLSocket-klasse werd in ActionScript 1 geïntroduceerd en wordt nog steeds ondersteund ten behoeve van compatibiliteit met oudere versies. In het algemeen dient u de klasse Socket te gebruiken voor nieuwe toepassingen, tenzij u een verbinding tot stand brengt met een server die specifiek is ingesteld op communicatie met Flash XMLSockets.

Adobe AIR voegt verschillende extra klassen toe voor netwerkprogrammering op basis van socket. Met de ServerSocket-klasse kunnen AIR-toepassingen fungeren als TCP-socketservers en verbinding maken met socketservers waarvoor SSL- of TLS-beveiliging is vereist. Verder kunnen AIR-toepassingen ook UDP-berichten (Universal Datagram Protocol) ontvangen en verzenden met de DatagramSocket-klasse.

TCP-sockets

Met TCP (het Transmission Control Protocol) kunt u berichten uitwisselen via een ononderbroken netwerkverbinding. TCP garandeert dat alle verzonden berichten in de juiste volgorde aankomen (behalve in geval van grote netwerkproblemen). Voor TCP-verbindingen is een ''client'' en een ''server'' vereist. Flash Player kan clientsockets maken. Bovendien kunt u in Adobe AIR serversockets maken.

De volgende ActionScript API's verschaffen TCP-verbindingen:

  • Socket — hiermee kan een clienttoepassing verbinding maken met een server. De klasse Socket kan niet luisteren naar binnenkomende verbindingen.

  • SecureSocket (AIR) — stelt een clienttoepassing in staat te verbinden met een betrouwbare server en gecodeerde communicatie uit te voeren.

  • ServerSocket (AIR): stelt een toepassing in staat te luisteren naar binnenkomende verbindingen en te fungeren als een server.

  • XMLSocket: hiermee kan een clienttoepassing verbinding maken met een XMLSocket-server.

Binaire clientsockets

Een binaire socketverbinding lijkt op een XML-socket behalve dat de client en server niet beperkt zijn tot het uitwisselen van XML-berichten. In plaats daarvan kan de verbinding gegevens als binaire informatie overbrengen. Hierdoor kunt u verbinding maken met meer soorten services, waaronder e-mailservers (POP3, SMTP en IMAP) en nieuwsservers (NNTP).

Socket, klasse

Met de klasse Socket kunt u socketverbindingen maken en onbewerkte binaire gegevens lezen en schrijven. De klasse Socket is nuttig wanneer u werkt met servers die binaire protocollen gebruiken. Als u binaire socketverbindingen gebruikt, kunt u code schrijven die interactie mogelijk maakt met verschillende internetprotocollen, zoals POP3, SMTP, IMAP en NNTP. Hierdoor kunnen uw toepassingen verbinding maken met e-mail- en nieuwsservers.

Flash Player kan verbinding maken met een server door direct gebruik te maken van het binaire protocol van die server. Sommige servers gebruiken de bytevolgorde big endian en sommige servers gebruiken de bytevolgorde little endian. De meeste servers op internet gebruiken de bytevolgorde big endian omdat de bytevolgorde van een netwerk big endian is. De bytevolgorde little-endian wordt veel gebruikt omdat de Intel® x86-architectuur deze gebruikt. Gebruik de endian-bytevolgorde die overeenkomt met de bytevolgorde van de server die gegevens verzendt of ontvangt. Alle bewerkingen die worden uitgevoerd door de interfaces IDataInput en IDataOutput, en de klassen die die interfaces implementeren (ByteArray, Socket en URLStream), worden standaard gecodeerd in de indeling big-endian, dat wil zeggen, met het meest significante byte eerst. Er is gekozen voor deze standaardbytevolgorde vanwege compatibiliteit met Java en de officiële netwerkbytevolgorde Als u de bytevolgorde wilt wijzigen en wilt opgeven dat big-endian of little-endian moet worden gebruikt, stelt u de eigenschap endian in op Endian.BIG_ENDIAN of Endian.LITTLE_ENDIAN .

De Socket-klasse neemt alle methoden over die worden gedefinieerd door de IDataInput- en IDataOutput-interfaces (te vinden in het pakket flash.utils). Deze methoden moeten worden gebruikt om te schrijven naar de socket en hieruit te lezen.

Raadpleeg de volgende bronnen voor meer informatie:

Beveiligde clientsockets (AIR)

U kunt de SecureSocket-klasse gebruiken om verbinding te maken met socketservers die gebruik maken van Secure Sockets Layer version 4 (SSLv4) of Transport Layer Security version 1 (TLSv1). Een beveiligde socket biedt drie voordelen: serververificatie, gegevensintegriteit en vertrouwelijkheid van berichten. De runtime verifieert een server aan de hand van het servercertificaat en de relatie van de server met de certificaten van de basis- of tussenliggende certificeringsinstantie in de vertrouwde opslag van de gebruiker. De runtime is afhankelijk van de cryptografiealgoritmen die door de implementaties van het SSL- en TLS-protocol worden gebruikt. Deze algoritmen bieden namelijk gegevensintegriteit en vertrouwelijkheid van berichten.

Als u met het SecureSocket-object verbinding maakt met een server, valideert de runtime het servercertificaat aan de hand van de vertrouwde certificaatopslag. Bij Windows en Mac wordt de vertrouwde opslag geleverd door het besturingssysteem. Bij Linux-computers wordt de vertrouwde opslag geleverd door de runtime.

Als het servercertificaat niet geldig is of niet wordt vertrouwd, verzendt de runtime een ioError -gebeurtenis. U kunt de eigenschap serverCertificateStatus van het SecureSocket-object controleren om te bepalen waarom de validatie is mislukt. Er is geen functionaliteit voor het communiceren met een server zonder een geldig en vertrouwd certificaat.

De klasse CertificateStatus definieert tekenreeksconstanten die de mogelijke validatieresultaten representeren:

  • Vervallen - De vervaldatum van het certificaat is verstreken.

  • Ongeldig - Er zijn een aantal redenen waarom een certificaat ongeldig kan zijn. Zo kan het certificaat gewijzigd of beschadigd zijn of kan het certificaat van het verkeerde type zijn.

  • Ongeldige keten - Een of meer certificaten in de certificaatketen van de server is ongeldig.

  • Niet-overeenkomende principal - De hostnaam van de server en de algemene naam van het certificaat komen niet overeen. Met andere woorden: de server gebruikt het verkeerde certificaat.

  • Ingetrokken - De certificeringsinstantie die het certificaat heeft uitgegeven, heeft het certificaat ingetrokken.

  • Vertrouwd - Het certificaat is geldig en wordt vertrouwd. Een SecureSocket-object kan alleen verbinding maken met een server die een geldig en vertrouwd certificaat gebruikt.

  • Onbekend - Het SecureSocket-object heeft het certificaat nog niet gevalideerd. De eigenschap serverCertificateStatus heeft deze statuswaarde voordat u connect() aanroept en voordat een connect - gebeurtenis of ioError -gebeurtenis wordt verzonden.

  • Niet-vertrouwde handtekeningen - Het certificaat wordt niet geketend aan een vertrouwd basiscertificaat in de vertrouwde opslag van de clientcomputer.

Bij communicatie met een SecureSocket-object moet de server een beveiligd protocol gebruiken en beschikken over een geldig en vertrouwd certificaat. In andere opzichten is het gebruik van een SecureSocket-object hetzelfde als het gebruik van een Socket-object.

Het SecureSocket-object wordt niet op alle platformen ondersteund. Gebruik de eigenschap isSupported van de klasse SecureSocket om te testen of het gebruik van het SecureSocket-object op de huidige clientcomputer door de runtime wordt ondersteund.

Raadpleeg de volgende bronnen voor meer informatie:

Voorbeeld van TCP-socket: een Telnet-client maken

In het Telnet-voorbeeld worden technieken geïllustreerd voor het maken van een verbinding met een externe server en het verzenden van gegevens met de klasse Socket. In dit voorbeeld worden de volgende technieken toegepast:

  • Een aangepaste Telnet-client maken met behulp van de klasse Socket

  • Tekst naar de externe server verzenden met een object ByteArray

  • Ontvangen gegevens van een externe server verwerken

Zie www.adobe.com/go/learn_programmingAS3samples_flash_nl als u de toepassingsbestanden voor dit voorbeeld wilt downloaden. U vindt de bestanden voor de Telnet-toepassing in de map Samples/Telnet. De toepassing bestaat uit de volgende bestanden:

Bestand

Beschrijving

TelnetSocket.fla

of

TelnetSocket.mxml

Het hoofdtoepassingsbestand dat bestaat uit de gebruikersinterface voor Flex (MXML) of Flash (FLA).

TelnetSocket.as

Klasse Document die de logica voor de gebruikersinterface bevat (alleen Flash).

com/example/programmingas3/Telnet/Telnet.as

Hiermee wordt de Telnet-clientfunctionaliteit voor de toepassing geboden, zoals verbinding maken met een externe server en gegevens verzenden, ontvangen en weergeven.

Overzicht van Telnet-sockettoepassing

Het hoofdbestand TelnetSocket.mxml maakt de gebruikersinterface (UI) voor de hele toepassing.

Naast de UI definieert dit bestand ook twee methoden, login() en sendCommand() , die de gebruiker verbinden met de opgegeven server.

De volgende code toont het ActionScript in het hoofdtoepassingsbestand:

import com.example.programmingas3.socket.Telnet; 
 
private var telnetClient:Telnet; 
private function connect():void 
{ 
    telnetClient = new Telnet(serverName.text, int(portNumber.text), output); 
    console.title = "Connecting to " + serverName.text + ":" + portNumber.text; 
    console.enabled = true; 
} 
private function sendCommand():void 
{ 
    var ba:ByteArray = new ByteArray(); 
    ba.writeMultiByte(command.text + "\n", "UTF-8"); 
    telnetClient.writeBytesToSocket(ba); 
    command.text = ""; 
}

De eerste coderegel importeert de klasse Telnet uit het aangepaste pakket com.example.programmingas.socket. De tweede coderegel declareert een instantie van de klasse Telnet, telnetClient , die later wordt geïnitialiseerd door de methode connect() . Vervolgens wordt de methode connect() gedeclareerd die de eerder gedeclareerde variabele telnetClient initialiseert. Deze methode geeft de door de gebruiker opgegeven naam voor de Telnet-server door, samen met de poort voor de Telnet-server en een verwijzing naar een TextArea-component in het weergaveoverzicht, die wordt gebruikt om de tekstreacties van de socketserver weer te geven. Met de laatste twee regels van de methode connect() wordt de eigenschap title ingesteld voor Panel, waarna de component Panel wordt ingesteld. Hiermee kan de gebruiker gegevens naar de externe server verzenden. De laatste methode in het hoofdtoepassingsbestand, sendCommand() , wordt gebruikt om de opdrachten van de gebruiker als een object ByteArray naar de externe server te verzenden.

Overzicht van de klasse Telnet

De klasse Telnet is verantwoordelijk voor de verbinding met de externe Telnet-server en het verzenden/ontvangen van gegevens.

De klasse Telnet declareert de volgende variabelen van het type private:

private var serverURL:String; 
private var portNumber:int; 
private var socket:Socket; 
private var ta:TextArea; 
private var state:int = 0;

De eerste variabele, serverURL , bevat het door de gebruiker opgegeven adres van de server waarmee verbinding moet worden gemaakt.

De tweede variabele, portNumber , is het poortnummer waarop de Telnet-server wordt uitgevoerd. De Telnet-service wordt standaard uitgevoerd op poort 23.

De derde variabele, socket , is een Socket-instantie die probeert verbinding te maken met de server die wordt aangegeven door de variabelen serverURL en portNumber .

De vierde variabele, ta , is een verwijzing naar een instantie van een TextArea-component in het werkgebied. Deze component wordt gebruikt om reacties van de externe Telnet-server of eventuele foutberichten weer te geven.

De laatste variabele, state , is een numerieke waarde die wordt gebruikt om te bepalen welke opties uw Telnet-client ondersteunt.

Zoals u eerder zag, wordt de constructorfunctie van de klasse Telnet aangeroepen door de methode connect() in het hoofdtoepassingsbestand.

De Telnet-constructor werkt met drie parameters: server , port en output . De parameters server en port geven de servernaam en het poortnummer op waarop de Telnet-server wordt uitgevoerd. De laatste parameter, output , is een verwijzing naar een instantie van een TextArea-component in het werkgebied waarin de uitvoer van de server voor de gebruikers wordt weergegeven.

public function Telnet(server:String, port:int, output:TextArea) 
{ 
    serverURL = server; 
    portNumber = port; 
    ta = output; 
    socket = new Socket(); 
    socket.addEventListener(Event.CONNECT, connectHandler); 
    socket.addEventListener(Event.CLOSE, closeHandler); 
    socket.addEventListener(ErrorEvent.ERROR, errorHandler); 
    socket.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); 
    socket.addEventListener(ProgressEvent.SOCKET_DATA, dataHandler); 
    Security.loadPolicyFile("http://" + serverURL + "/crossdomain.xml"); 
    try 
    { 
        msg("Trying to connect to " + serverURL + ":" + portNumber + "\n"); 
        socket.connect(serverURL, portNumber); 
    } 
    catch (error:Error) 
    { 
        msg(error.message + "\n"); 
        socket.close(); 
    } 
}
Gegevens schrijven naar een socket

Als u gegevens naar een socketverbinding wilt schrijven, kunt een van de schrijfmethoden in de klasse Socket aanroepen. Deze schrijfmethoden zijn onder meer writeBoolean() , writeByte() , writeBytes() en writeDouble() . Gebruik vervolgens de methode flush() om de gegevens in de uitvoerbuffer te verwijderen. In de Telnet-server worden gegevens naar de socketverbinding geschreven met de methode writeBytes() , die de bytearray als parameter neemt en naar de uitvoerbuffer verzendt. De methode writeBytesToSocket() ziet er als volgt uit:

public function writeBytesToSocket(ba:ByteArray):void 
{ 
    socket.writeBytes(ba); 
    socket.flush(); 
}

Deze methode wordt aangeroepen door de methode sendCommand() van het hoofdtoepassingsbestand.

Berichten van de socketserver weergeven

Wanneer een bericht wordt ontvangen van de socketserver of wanneer er een gebeurtenis plaatsvindt, wordt de aangepaste methode msg() aangeroepen. Deze methode voegt een tekenreeks toe aan de component TextArea in het werkgebied en roept de aangepaste methode setScroll() aan, die ervoor zorgt dat de component TextArea naar het einde schuift. De methode msg() ziet er als volgt uit:

private function msg(value:String):void 
{ 
    ta.text += value; 
    setScroll(); 
}

Als u de inhoud van de component TextArea niet automatisch verschuift, zouden gebruikers handmatig de schuifbalken van het tekstgebied moeten verschuiven om het laatste antwoord van de server te zien.

Schuiven in een TextArea-component

De methode setScroll() bevat één regel ActionScript die de inhoud van de component TextArea verticaal verschuift, zodat de gebruiker de laatste regel van de geretourneerde tekst ziet. Het volgende fragment toont de methode setScroll() :

public function setScroll():void 
{ 
    ta.verticalScrollPosition = ta.maxVerticalScrollPosition; 
}

Deze methode stelt de eigenschap verticalScrollPosition , het regelnummer van de bovenste rij tekens die momenteel wordt weergegeven, in op de waarde van de eigenschap maxVerticalScrollPosition .

XML-sockets

Met een XML-socket kunt u een verbinding tot stand brengen met een externe server, waarbij deze verbinding geopend blijft totdat u deze expliciet sluit. U kunt reeksgegevens, zoals XML-gegevens, uitwisselen tussen de server en de client. Een voordeel van het gebruik van een XML-socketserver is dat de client gegevens niet expliciet hoeft aan te vragen. De server kan gegevens verzenden zonder op een aanvraag te moeten wachten en kan gegevens verzenden naar elke aangesloten client.

In Flash Player en in Adobe AIR-inhoud buiten de toepassingssandbox vereisen XML-socketverbindingen een socketbeleidbestand op de doelserver. Zie Controlemiddelen voor websites (beleidsbestanden) en Verbinding maken met sockets voor meer informatie.

De klasse XMLSocket kan niet automatisch een tunnel maken via firewalls omdat XMLSocket, in tegenstelling tot RTMP (Real-Time Messaging Protocol), niet beschikt over HTTP-tunnelmogelijkheden. Als u HTTP-tunnelmogelijkheden nodig hebt, kunt u overwegen Flash Remoting of Flash Media Server (met RTMP-ondersteuning) te gebruiken.

Voor inhoud in Flash Player of in een AIR-toepassing buiten de beveiligingssandbox van de toepassing gelden bepaalde beperkingen. Deze beperkingen zijn van toepassing op de manier waarop en de plaats waar de inhoud een XMLSocket-object kan gebruiken om verbinding te maken met de server:

  • Voor inhoud buiten de toepassingsbeveiligingssandbox kan met de methode XMLSocket.connect() alleen verbinding worden gemaakt met TCP-poortnummers die hoger zijn dan of gelijk zijn aan 1024. Een gevolg van deze beperking is dat ook de serverdaemons die met het XMLSocket -object communiceren, moeten worden toegewezen aan poortnummers die hoger zijn dan of gelijk zijn aan 1024. Poortnummers die lager zijn dan 1024, worden vaak gebruikt door systeemservices, zoals FTP (21), Telnet (23), SMTP (25), HTTP (80) en POP3 (110), zodat XMLSocket-objecten uit veiligheidsoverwegingen van deze poorten worden buitengesloten. Het beperken van poortnummers verkleint de kans dat deze bronnen ongewenst worden geopend en misbruikt.

  • Voor inhoud buiten de toepassingsbeveiligingssandbox kan met de methode XMLSocket.connect() alleen verbinding worden gemaakt met computers in hetzelfde domein als de inhoud. (Deze beperking is identiek aan de beveiligingsregels voor URLLoader.load() .) Als u verbinding wilt maken met een serverdaemon die wordt uitgevoerd in een ander domein dan het domein waarin de inhoud zich bevindt, kunt u op de server een domeinoverschrijdend beveiligingsbeleidsbestand maken dat toegang toestaat vanaf specifieke domeinen. Zie Beveiliging in AIR voor meer informatie over domeinoverschrijdende beleidsbestanden.

Opmerking: Het kan lastig zijn een server zodanig in te stellen dat deze met het XMLSocket-object kan communiceren. Als uw toepassing geen realtime interactiviteit vereist, gebruikt u de klasse URLLoader in plaats van de klasse XMLSocket.

U kunt de methoden XMLSocket.connect() en XMLSocket.send() van de klasse XMLSocket gebruiken om XML via een socketverbinding van en naar een server te verzenden. Met de methode XMLSocket.connect() wordt een socketverbinding met een webserverpoort tot stand gebracht. Met de methode XMLSocket.send() wordt een XML-object doorgegeven aan de server die is opgegeven in de socketverbinding.

Als u de methode XMLSocket.connect() oproept, opent de toepassing een TCP/IP-verbinding met de server. Deze verbinding wordt opengehouden totdat een van de volgende gebeurtenissen plaatsvindt:

  • De methode XMLSocket.close() van de klasse XMLSocket wordt opgeroepen.

  • Er bestaan geen verwijzingen meer naar het XMLSocket-object.

  • Flash Player wordt afgesloten.

  • De verbinding wordt verbroken (de modemverbinding wordt bijvoorbeeld verbroken).

Verbinding maken met een server met behulp van de XMLSocket-klasse

Als u een socketverbinding wilt maken, moet u een servertoepassing maken die wacht op de aanvraag voor de socketverbinding en een antwoord verzendt naar de Flash Player- of AIR-toepassing. Dit soort servertoepassingen kan worden geschreven in AIR of in een andere programmeertaal zoals Java, Python of Perl. Als u de klasse XMLSocket wilt gebruiken, moet de servercomputer een daemon uitvoeren waarmee het eenvoudige protocol kan worden herkend dat door de klasse XMLSocket wordt gebruikt:

  • XML-berichten worden via een full-duplex TCP/IP-streamsocketverbinding verzonden.

  • Elk XML-bericht is een volledig XML-document dat met een nulbyte (0) wordt afgesloten.

  • Er kan een onbeperkt aantal XML-berichten worden verzonden en ontvangen via één XMLSocket-verbinding.

Java-XML-socketservers maken en er verbinding mee maken

De volgende code bevat een voorbeeld van een eenvoudige XMLSocket-server, geschreven in Java, die inkomende verbindingen accepteert en de ontvangen berichten weergeeft in het opdrachtpromptvenster. Standaard wordt een nieuwe server gemaakt op poort 8080 van de lokale computer, maar u kunt desgewenst een ander poortnummer opgeven wanneer u de server vanaf de opdrachtregel start.

Maak een nieuwe tekstdocument en voeg de volgende code toe:

import java.io.*; 
import java.net.*; 
 
class SimpleServer 
{ 
    private static SimpleServer server; 
    ServerSocket socket; 
    Socket incoming; 
    BufferedReader readerIn; 
    PrintStream printOut; 
 
    public static void main(String[] args) 
    { 
        int port = 8080; 
 
        try 
        { 
            port = Integer.parseInt(args[0]); 
        } 
        catch (ArrayIndexOutOfBoundsException e) 
        { 
            // Catch exception and keep going. 
        } 
 
        server = new SimpleServer(port); 
    } 
 
    private SimpleServer(int port) 
    { 
        System.out.println(">> Starting SimpleServer"); 
        try 
        { 
            socket = new ServerSocket(port); 
            incoming = socket.accept(); 
            readerIn = new BufferedReader(new InputStreamReader(incoming.getInputStream())); 
            printOut = new PrintStream(incoming.getOutputStream()); 
            printOut.println("Enter EXIT to exit.\r"); 
            out("Enter EXIT to exit.\r"); 
            boolean done = false; 
            while (!done) 
            { 
                String str = readerIn.readLine(); 
                if (str == null) 
                { 
                    done = true; 
                } 
                else 
                { 
                    out("Echo: " + str + "\r"); 
                    if(str.trim().equals("EXIT")) 
                    { 
                        done = true; 
                    } 
                } 
                incoming.close(); 
            } 
        } 
        catch (Exception e) 
        { 
            System.out.println(e); 
        } 
    } 
 
    private void out(String str) 
    { 
        printOut.println(str); 
        System.out.println(str); 
    } 
}

Sla het document op de vaste schijf op als SimpleServer.java en compileer dit met een Java-compiler. Hierbij wordt een Java-klassebestand met de naam SimpleServer.class gemaakt.

U kunt de XMLSocket-server starten door een opdrachtprompt te openen en java SimpleServer te typen. Het bestand SimpleServer.class kan overal op de lokale computer of in het netwerk worden opgeslagen; het hoeft niet in de hoofdmap van de webserver te worden geplaatst.

Als u de server niet kunt starten omdat de bestanden zich niet in het Java-klassepad bevinden, kunt u de server proberen te starten met java -classpath. SimpleServer .

Als u verbinding wilt maken met de XMLSocket vanuit uw toepassing, moet u een nieuwe instantie van de XMLSocket-klasse maken en de methode XMLSocket.connect() aanroepen, waarbij u een hostnaam en poortnummer doorgeeft, zoals in de volgende code:

var xmlsock:XMLSocket = new XMLSocket(); 
xmlsock.connect("127.0.0.1", 8080);

Wanneer u gegevens van de server ontvangt, wordt de gebeurtenis data ( flash.events.DataEvent.DATA ) verzonden:

xmlsock.addEventListener(DataEvent.DATA, onData); 
private function onData(event:DataEvent):void 
{ 
    trace("[" + event.type + "] " + event.data); 
}

Als u gegevens wilt verzenden naar de XMLSocket-server, gebruikt u de methode XMLSocket.send() en geeft u een XML-object of tekenreeks door. Flash Player zet de opgegeven parameter om in een object String en verzendt de inhoud naar de XMLSocket-server, gevolgd door een nulbyte (0):

xmlsock.send(xmlFormattedData);

De methode XMLSocket.send() retourneert geen waarde die aangeeft of de gegevens zijn verzonden. Als er een fout optreedt terwijl wordt geprobeerd gegevens te verzenden, wordt een IOError-fout gegenereerd.

Elk bericht dat u naar de XML-socketserver verzendt, moet eindigen op een nieuwe-regelteken ( \n ).

Zie XMLSocket voor meer informatie.

Serversockets

Gebruik de klasse ServerSocket om toe te staan dat andere processen met gebruik van een TCP-socket (Transport Control Protocol) verbinding maken met uw toepassing. Het proces dat een verbinding maakt, kan worden uitgevoerd op een lokale computer of op een computer met een netwerkverbinding. Als een ServerSocket-object een verbindingsaanvraag ontvangt, verzendt dit object een connect -gebeurtenis. Het ServerSocketConnectEvent-object dat bij deze gebeurtenis wordt verzonden, bevat een Socket-object. U kunt dit Socket-object gebruiken voor verdere communicatie met het andere proces.

Luisteren of er socketverbindingen binnenkomen:

  1. Maak een ServerSocket-object en zorg dat dit gebonden is aan een lokale poort.

  2. Voeg gebeurtenislisteners voor de gebeurtenis connect toe.

  3. Roep de methode listen() aan.

  4. Reageer op de gebeurtenis connect . Deze gebeurtenis levert voor elke binnenkomende gebeurtenis een Socket-object.

Het ServerSocket-object blijft luisteren of er nieuwe verbindingen worden gemaakt totdat u de methode close() aanroept.

In het volgende codevoorbeeld wordt getoond hoe u een socketservertoepassing kunt maken. In dit voorbeeld wordt er geluisterd of er verbindingen binnenkomen op poort 8087. Als een verbinding wordt ontvangen, wordt er een bericht verzonden (de tekenreeks "Connected") naar de clientsocket. Hierna verzendt de server een herhaling van de ontvangen berichten terug naar de client.

package 
{ 
    import flash.display.Sprite; 
    import flash.events.Event; 
    import flash.events.IOErrorEvent; 
    import flash.events.ProgressEvent; 
    import flash.events.ServerSocketConnectEvent; 
    import flash.net.ServerSocket; 
    import flash.net.Socket; 
     
    public class ServerSocketExample extends Sprite 
    { 
        private var serverSocket:ServerSocket; 
        private var clientSockets:Array = new Array(); 
 
        public function ServerSocketExample() 
        { 
            try 
            { 
                // Create the server socket 
                serverSocket = new ServerSocket(); 
                 
                // Add the event listener 
                serverSocket.addEventListener( Event.CONNECT, connectHandler ); 
                serverSocket.addEventListener( Event.CLOSE, onClose ); 
                 
                // Bind to local port 8087 
                serverSocket.bind( 8087, "127.0.0.1" ); 
                 
                // Listen for connections 
                serverSocket.listen(); 
                trace( "Listening on " + serverSocket.localPort ); 
 
            } 
            catch(e:SecurityError) 
            { 
                trace(e); 
            } 
        } 
 
        public function connectHandler(event:ServerSocketConnectEvent):void 
        { 
            //The socket is provided by the event object 
            var socket:Socket = event.socket as Socket; 
            clientSockets.push( socket ); 
             
            socket.addEventListener( ProgressEvent.SOCKET_DATA, socketDataHandler); 
            socket.addEventListener( Event.CLOSE, onClientClose ); 
            socket.addEventListener( IOErrorEvent.IO_ERROR, onIOError ); 
             
            //Send a connect message 
            socket.writeUTFBytes("Connected."); 
            socket.flush(); 
             
            trace( "Sending connect message" ); 
        } 
         
        public function socketDataHandler(event:ProgressEvent):void 
        { 
            var socket:Socket = event.target as Socket 
                 
            //Read the message from the socket 
            var message:String = socket.readUTFBytes( socket.bytesAvailable ); 
            trace( "Received: " + message); 
 
            // Echo the received message back to the sender 
            message = "Echo -- " + message; 
            socket.writeUTFBytes( message ); 
            socket.flush(); 
            trace( "Sending: " + message ); 
        } 
         
        private function onClientClose( event:Event ):void 
        { 
            trace( "Connection to client closed." ); 
            //Should also remove from clientSockets array... 
        } 
 
        private function onIOError( errorEvent:IOErrorEvent ):void 
        { 
            trace( "IOError: " + errorEvent.text ); 
        } 
 
        private function onClose( event:Event ):void 
        { 
            trace( "Server socket closed by OS." ); 
        } 
}}

Raadpleeg de volgende bronnen voor meer informatie:

UDP-sockets (AIR)

Met het Universal Datagram Protocol (UDP) kunt u berichten uitwisselen via een staatloze netwerkverbinding. UDP biedt geen garantie dat berichten op volgorde worden afgeleverd of dat berichten überhaupt worden afgeleverd. Bij het gebruik van UDP hoeft de netwerkcode van het besturingssysteem doorgaans minder aandacht te besteden aan het marshallen, bijhouden en bevestigen van berichten. UDP-berichten arriveren daarom meestal met minder vertraging op hun bestemming dan TCP-berichten.

UDP-socketcommunicatie is handig als u realtime-informatie moet verzenden, bijvoorbeeld positie-updates tijdens een game of geluidspakketen bij een audiochattoepassing. Bij dergelijke toepassingen is een bepaalde mate van gegevensverlies acceptabel en is een kleine vertraging bij het verzenden belangrijker dan een gegarandeerde aflevering. Voor bijna alle andere doeleinden zijn TCP-sockets een betere keuze.

Uw AIR-toepassing kan UDP-berichten verzenden en ontvangen met de klassen DatagramSocket en DatagramSocketDataEvent. Een UDP-bericht verzenden of ontvangen:

  1. Maak een DatagramSocket-object.

  2. Voeg een gebeurtenislistener voor de gebeurtenis data toe.

  3. Gebruik de methode bind() om de socket aan een lokaal IP-adres en een lokale IP-poort te binden.

  4. Verzend berichten door de methode send() aan te roepen en geef hierbij het IP-adres en de IP-poort van de lokale computer door.

  5. Ontvang berichten door te reageren op de gebeurtenis data . Het DatagramSocketDataEvent-object dat voor deze gebeurtenis wordt verzonden, bevat een ByteArray-object met de berichtgegevens.

In het volgende codevoorbeeld wordt getoond hoe een toepassing UDP-berichten kan verzenden en ontvangen. In het voorbeeld wordt één bericht met de tekenreeks "Hello" naar de doelcomputer verstuurd. Ook wordt de inhoud van ontvangen berichten getraceerd.

package 
{ 
import flash.display.Sprite; 
import flash.events.DatagramSocketDataEvent; 
import flash.events.Event; 
import flash.net.DatagramSocket; 
import flash.utils.ByteArray; 
 
public class DatagramSocketExample extends Sprite 
{ 
    private var datagramSocket:DatagramSocket; 
     
    //The IP and port for this computer 
    private var localIP:String = "192.168.0.1"; 
    private var localPort:int = 55555; 
     
    //The IP and port for the target computer 
    private var targetIP:String = "192.168.0.2"; 
    private var targetPort:int = 55555; 
     
    public function DatagramSocketExample() 
    { 
        //Create the socket 
        datagramSocket = new DatagramSocket(); 
        datagramSocket.addEventListener( DatagramSocketDataEvent.DATA, dataReceived ); 
         
        //Bind the socket to the local network interface and port 
        datagramSocket.bind( localPort, localIP ); 
         
        //Listen for incoming datagrams 
        datagramSocket.receive(); 
         
        //Create a message in a ByteArray 
        var data:ByteArray = new ByteArray(); 
        data.writeUTFBytes("Hello."); 
         
        //Send the datagram message 
        datagramSocket.send( data, 0, 0, targetIP, targetPort); 
    } 
     
    private function dataReceived( event:DatagramSocketDataEvent ):void 
    { 
        //Read the data from the datagram 
        trace("Received from " + event.srcAddress + ":" + event.srcPort + "> " + 
            event.data.readUTFBytes( event.data.bytesAvailable ) ); 
    } 
}}

Houd bij het gebruik van UDP-sockets rekening met de volgende overwegingen:

  • Eén gegevenspakket kan niet groter zijn dan de kleinste maximale verzendeenheid van de netwerkinterface of van de netwerknodes tussen de zender en de ontvanger. Alle gegevens in het ByteArray-object dat aan de methode send() wordt doorgegeven, worden als één enkel pakket verzonden. (Bij TCP worden grote berichten verdeeld in afzonderlijke pakketten.)

  • Er vindt geen handshake plaats tussen de zender en de ontvanger. Berichten worden zonder waarschuwing verwijderd als de ontvanger niet bestaat of als er zich bij de ontvanger geen actieve listener op de opgegeven poort bevindt.

  • Als u de methode connect() gebruikt, worden door andere bronnen verzonden berichten genegeerd. Een UDP-verbinding biedt alleen passende pakketfiltering. Dit hoeft niet te betekenen dat er zich een geldige listener op het adres en de poort van de ontvanger bevindt.

  • Een netwerk kan overbelast raken door UDP-verkeer. Als dit gebeurt, is het wellicht nodig dat netwerkbeheerders maatregelen implementeren om de servicekwaliteit te bewaken. (TCP beschikt over een ingebouwd controlemechanisme voor netwerkverkeer, zodat de gevolgen van een overbelast netwerk beperkt blijven.)

Raadpleeg de volgende bronnen voor meer informatie:

IPv6-adressen

Flash Player 9.0.115.0 en hoger ondersteunen IPv6 (Internet Protocol versie 6). IPv6 is een versie van Internet Protocol die 128-bits adressen ondersteunt (een verbetering ten opzichte van het eerdere IPv4-protocol dat alleen 32-bits adressen ondersteunt). Mogelijk moet u IPv6 activeren op uw netwerkinterfaces. Raadpleeg de Help van het besturingssysteem dat als host van de gegevens fungeert voor meer informatie.

Als IPv6 wordt ondersteund door het hostsysteem, kunt u numerieke literale IPv6-adressen opgeven in URL's tussen haakjes ([]), bijvoorbeeld:

[2001:db8:ccc3:ffff:0:444d:555e:666f]

Flash Player retourneert literale IPv6-waarden die aan de volgende regels voldoen:

  • Flash Player retourneert de lange vorm van de tekenreeks voor IPv6-adressen.

  • De IP-waarde heeft geen afkortingen met twee dubbele punten.

  • Hexadecimale cijfers zijn alleen in kleine letters.

  • IPv6-adressen staan tussen vierkante haken ([]).

  • Elk adresviertal wordt weergegeven als 0 tot 4 hexadecimale cijfers; voorloopnullen worden weggelaten.

  • Een adresviertal van alleen nullen wordt weergegeven als één enkele nul (geen twee dubbele punten), behalve als deze voorkomt in de volgende lijst met uitzonderingen.

De IPv6-waarden die Flash Player retourneert, hebben de volgende uitzonderingen:

  • Een niet-opgegeven IPv6-adres (alleen nullen) wordt weergegeven als [::].

  • Het IPv6-adres van de loopback of localhost wordt weergegeven als [::1].

  • Aan IPv4 toegewezen adressen (geconverteerd naar IPv6) worden weergegeven als [::ffff:a.b.c.d], waarbij a.b.c.d een gewone decimale IPv4-waarde met punten is.

  • IPv4-compatibele adressen worden weergegeven als [::a.b.c.d], waarbij a.b.c.d een gewone decimale IPv4-waarde met punten is.