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
.
![](images/tip_help.png)
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.
![](images/tip_help.png)
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.
![](images/tip_help.png)
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:
-
Maak een ServerSocket-object en zorg dat dit gebonden is aan een lokale poort.
-
Voeg gebeurtenislisteners voor de gebeurtenis
connect
toe.
-
Roep de methode
listen()
aan.
-
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:
-
Maak een DatagramSocket-object.
-
Voeg een gebeurtenislistener voor de gebeurtenis
data
toe.
-
Gebruik de methode
bind()
om de socket aan een lokaal IP-adres en een lokale IP-poort te binden.
-
Verzend berichten door de methode
send()
aan te roepen en geef hierbij het IP-adres en de IP-poort van de lokale computer door.
-
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.
|
|
|
|
|