Sockets

El archivo principal TelnetSocket.mxml es responsable de crear la interfaz de usuario de toda la aplicación.

Además de la interfaz de usuario, este archivo también define dos métodos, login() y sendCommand() , para conectar el usuario al servidor especificado.

A continuación se muestra el código ActionScript del archivo de la aplicación principal:

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 = ""; 
}

La primera línea de código importa la clase Telnet del paquete com.example.programmingas.socket personalizado. La segunda línea de código declara una instancia de la clase Telnet, telnetClient , que se inicializará posteriormente mediante el método connect() . A continuación, se declara el método connect() e inicializa la variable telnetClient declarada previamente. Este método pasa el nombre del servidor Telnet especificado por el usuario, el puerto del servidor Telnet y una referencia a un componente TextArea de la lista de visualización, que se utiliza para mostrar las respuestas de texto del servidor de socket. Las dos últimas líneas del método connect() establecen la propiedad title de Panel y activan el componente Panel, que permite al usuario enviar datos al servidor remoto. El método final del archivo principal de la aplicación, sendCommand() , se utiliza para enviar los comandos del usuario al servidor remoto como un objeto ByteArray.

La clase Telnet es la responsable de conectar con el servidor Telnet remoto, y de enviar y recibir datos.

La clase Telnet declara las siguientes variables privadas:

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

La primera variable, serverURL , contiene la dirección del servidor, especificada por el usuario, con la que se va a conectar.

La segunda variable, portNumber , es el número de puerto en el que se está ejecutando el servidor Telnet. De forma predeterminada, el servicio Telnet se ejecuta en el puerto 23.

La tercera variable, socket , es una instancia de Socket que intentará conectar con el servidor definido por las variables serverURL y portNumber .

La cuarta variable, ta , es una referencia a una instancia del componente TextArea en el escenario. Este componente se utiliza para mostrar las respuestas del servidor Telnet remoto o cualquier posible mensaje de error.

La última variable, state , es un valor numérico que se utiliza para determinar las opciones que admite el cliente Telnet.

Tal y como se ha visto previamente, se llama a la función constructora de la clase Telnet a través del método connect() en el archivo de la aplicación principal.

El constructor Telnet adopta tres parámetros: server , port y output . Los parámetros server y port especifican el nombre de servidor y el número de puerto donde se ejecuta el servidor Telnet. El parámetro final, output , es una referencia a una instancia del componente TextArea en el escenario, donde los usuarios verán la salida del servidor.

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(); 
    } 
}

Para escribir datos en una conexión de socket, es necesario llamar a cualquiera de los métodos de la clase Socket. Entre estos métodos de escritura se incluyen writeBoolean() , writeByte() , writeBytes() y writeDouble() , entre otros. Posteriormente, vacíe los datos en el búfer de salida con el método flush() . En el servidor Telnet, los datos se escriben en la conexión de socket mediante el método writeBytes() , que utiliza el conjunto de bytes como parámetro y lo envía al búfer de salida. La sintaxis del método writeBytesToSocket() es la siguiente:

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

Este método se llama mediante el método sendCommand() del archivo de la aplicación principal.

Cuando se recibe un mensaje del servidor de socket o se produce un evento, se llama al método personalizado msg() . Este método añade una cadena a TextArea en el escenario y llama a un método personalizado setScroll() , que desplaza el componente TextArea hasta la parte más baja. La sintaxis del método msg() es la siguiente:

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

Si el contenido del componente TextArea no se desplaza automáticamente, el usuario deberá arrastrar manualmente las barras de desplazamiento en el área de texto para ver la última respuesta del servidor.

El método setScroll() contiene una sola línea de código ActionScript que desplaza verticalmente el contenido del componente TextArea para que el usuario pueda ver la última línea del texto devuelto. El siguiente fragmento de código muestra el método setScroll() :

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

Este método establece la propiedad verticalScrollPosition , que es el número de línea de la fila superior de caracteres que se visualiza, con el valor de la propiedad maxVerticalScrollPosition .

El siguiente código muestra un sencillo servidor XMLSocket escrito en Java que acepta conexiones entrantes y muestra los mensajes recibidos en la ventana de símbolo del sistema. De forma predeterminada, se crea un nuevo servidor en el puerto 8080 del equipo local, aunque se puede especificar otro número de puerto cuando se inicia el servidor desde la línea de comandos.

Cree un nuevo documento de texto y añada el siguiente código:

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); 
    } 
}

Guarde el documento en el disco duro como SimpleServer.java y compílelo con la ayuda de un compilador de Java para crear un archivo de clase de Java denominado SimpleServer.class.

Para iniciar el servidor XMLSocket, abra un símbolo del sistema y escriba java SimpleServer . El archivo SimpleServer.class puede almacenarse en cualquier lugar del equipo local o la red; no es necesario que esté en el directorio raíz del servidor web.

Si no puede iniciar el servidor porque los archivos no se encuentran en la ruta de clases de Java, intente iniciar el servidor con java -classpath. SimpleServer .

Para conectarse a XMLSocket desde la aplicación , es necesario crear una nueva instancia de la clase XMLSocket y llamar al método XMLSocket.connect() , pasando un nombre de host y un número de puerto, del siguiente modo:

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

Cuando se reciben datos del servidor, se distribuye el evento data ( flash.events.DataEvent.DATA ):

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

Para enviar datos al servidor XMLSocket, se utiliza el método XMLSocket.send() y se pasa una cadena u objeto XML. Flash Player convierte el parámetro suministrado en un objeto String y envía el contenido al servidor XMLSocket, seguido de un byte cero (0):

xmlsock.send(xmlFormattedData);

El método XMLSocket.send() no devuelve ningún valor que indique si los datos se han transmitido correctamente. Si se produce un error al intentar enviar datos, se emite un error IOError.

Cada mensaje que se envía al servidor de socket XML debe terminar con un carácter de nueva línea ( \n ).

Para obtener más información, consulte XMLSocket .