Programación Cliente Servidor De Bajo Nivel Socket m4c2h

INSTITUTO TECNOLOGICO NACIONAL DE MÉXICO, CAMPUS ORIZABA

Programación Cliente-Servidor de Bajo Nivel: sockets y canales MATERIA Programación en ambiente cliente/servidor

PRESENTA

Altamirano Cruz Luis Enrique

DOCENTE Pelaez Camarena Silvestre Gustavo

CARRERA INGENERIA INFORMATICA

10° SEMESTRE

TEMAS A PRESENTAR: 2.1 concepto de socket 2.2 dominios y tipos de socket 2.3. creación/ implementación y supresión de sockets. apertura de sockets 2.4. desarrollo del lado del servidor con sockets 2.5. desarrollo del lado del cliente con sockets

2.1. Concepto de socket. Un socket (enchufe), es un método para la comunicación entre un programa del cliente y un programa del servidor en una red, se define, por tanto, como el punto final en una conexión. Este mecanismo surge a principios de los 80 con el sistema Unix de Berkeley, para proporcionar un medio de comunicación entre procesos y presentan la misma funcionalidad que tiene la comunicación por correo o por teléfono (de un buzón se extraen mensajes completos, mientras que el teléfono permite el envío de flujos de información que no tienen una estructura claramente definida), es decir permiten que un proceso hable (emita o reciba información) con otro incluso estando estos en distintas máquinas. Esta característica de interconectividad hace que el concepto de socket sea de gran utilidad. Un socket queda definido por un par de direcciones IP local y remota, un protocolo de transporte y un par de números de puerto local y remoto. Para que dos programas puedan comunicarse entre sí es necesario que se cumplan ciertos requisitos:  

Que un programa sea capaz de localizar al otro. Que ambos programas sean capaces de intercambiarse cualquier secuencia de octetos, es decir, datos relevantes a su finalidad.

Para ello son necesarios los tres recursos que originan el concepto de socket:  



Un protocolo de comunicaciones, que permite el intercambio de octetos. Un par de direcciones del Protocolo de Red (Dirección IP, si se utiliza el Protocolo T/IP), que identifica la computadora de origen y la remota. Un par de números de puerto, que identifica a un programa dentro de cada computadora.

Los sockets permiten implementar una arquitectura cliente-servidor o peer to peer. La comunicación debe ser iniciada por uno de los programas que se denomina programa cliente. El segundo programa espera a que otro inicie la comunicación, por este motivo se denomina programa servidor. Un socket es un proceso o hilo existente en la máquina cliente y en la máquina servidora, que sirve en última instancia para que el programa servidor y el

cliente lean y escriban la información. Esta información será la transmitida por las diferentes capas de red. Cuando un cliente conecta con el servidor se crea un nuevo socket, de esta forma, el servidor puede seguir esperando conexiones en el socket principal y comunicarse con el cliente conectado, de igual manera se establece un socket en el cliente en un puerto local. Una aplicación servidor normalmente escucha por un puerto específico esperando una petición de conexión de un cliente, una vez que se recibe, el cliente y el servidor se conectan de forma que les sea posible comunicarse entre ambos. Durante este proceso, el cliente es asignado a un número de puerto, mediante el cual envía peticiones al servidor y recibe de este las respuestas correspondientes. Similarmente, el servidor obtiene un nuevo número de puerto local que le servirá para poder continuar escuchando cada petición de conexión del puerto original. De igual forma une un socket a este puerto local. URL s y URLConnection s proporcionan un mecanismo relativamente alto nivel para acceder a recursos en Internet. A veces, sus programas requieren comunicación de red de nivel inferior, por ejemplo, cuando desea escribir una aplicación cliente-servidor. En las aplicaciones cliente-servidor, el servidor proporciona algún servicio, como el procesamiento de consultas de bases de datos o el envío de precios de acciones actuales. El cliente utiliza el servicio proporcionado por el servidor, ya sea mostrando los resultados de la consulta de la base de datos al o haciendo recomendaciones de compra de acciones a un inversionista. La comunicación que se produce entre el cliente y el servidor debe ser confiable. Es decir, no se puede eliminar ningún dato y debe llegar al lado del cliente en el mismo orden en que el servidor lo envió. T proporciona un canal de comunicación punto a punto confiable que las aplicaciones cliente-servidor en Internet utilizan para comunicarse entre sí. Para comunicarse a través de T, un programa cliente y un programa servidor establecen una conexión entre sí. Cada programa enlaza un socket a su extremo de la conexión. Para comunicarse, el cliente y el servidor leen y escriben en el socket vinculado a la conexión.

Un socket es un punto final de un enlace de comunicación de dos vías entre dos programas que se ejecutan en la red. Las clases de socket se utilizan para representar la conexión entre un programa cliente y un programa servidor. El paquete java.net proporciona dos clases, Socket y ServerSocket, que implementan el lado del cliente de la conexión y el lado del servidor de la conexión, respectivamente. Normalmente, un servidor se ejecuta en una computadora específica y tiene un socket que está vinculado a un número de puerto específico. El servidor solo espera, escuchando el socket de un cliente para realizar una solicitud de conexión. En el lado del cliente: el cliente conoce el nombre de host de la máquina en la que se ejecuta el servidor y el número de puerto en el que el servidor está escuchando. Para realizar una solicitud de conexión, el cliente intenta reunirse con el servidor en la máquina y el puerto del servidor. El cliente también debe identificarse con el servidor, por lo que se enlaza con un número de puerto local que utilizará durante esta conexión. Esta es generalmente asignada por el sistema.

Si todo va bien, el servidor acepta la conexión. Una vez aceptado, el servidor obtiene un nuevo socket vinculado al mismo puerto local y también tiene su punto final remoto configurado en la dirección y el puerto del cliente. Necesita un nuevo zócalo para que pueda seguir escuchando el zócalo original en busca de solicitudes de conexión mientras atiende las necesidades del cliente conectado.

En el lado del cliente, si se acepta la conexión, se crea un socket con éxito y el cliente puede usar el socket para comunicarse con el servidor. El cliente y el servidor ahora pueden comunicarse escribiendo o leyendo desde sus sockets. Un socket es un punto final de un enlace de comunicación de dos vías entre dos programas que se ejecutan en la red. Un socket está vinculado a un número de puerto para que la capa T pueda identificar la aplicación que los datos están destinados a enviar.

Un punto final es una combinación de una dirección IP y un número de puerto. Cada conexión T puede identificarse de forma única por sus dos puntos finales. De esa manera puede tener múltiples conexiones entre su host y el servidor. Los java.net paquete en la plataforma Java proporciona una clase, Socket , que implementa un lado de una conexión bidireccional entre su programa Java y otro programa en la red. los Enchufe La clase se encuentra sobre una implementación dependiente de la plataforma, ocultando los detalles de cualquier sistema en particular de su programa Java. Usando el java.net.Socket En lugar de confiar en el código nativo, sus programas Java pueden comunicarse a través de la red de manera independiente de la plataforma. Adicionalmente, java.net incluye el ServerSocket clase, que implementa un socket que los servidores pueden usar para escuchar y aceptar conexiones a clientes. Esta lección le muestra cómo usar el Enchufe y ServerSocket clases. Los sockets no son más que puntos o mecanismos de comunicación entre procesos que permiten que un proceso hable (emita o reciba información) con otro proceso incluso estando estos procesos en distintas máquinas. Esta característica de interconectividad entre máquinas hace que el concepto de socket nos sirva de gran utilidad. Esta interfaz de comunicaciones es una de las distribuciones de Berkeley al sistema UNIX, implementándose las

utilidades de interconectividad de este Sistema Operativo (r, telnet, ftp, ... ) usando sockets. Un socket es al sistema de comunicación entre ordenadores lo que un buzón o un teléfono es al sistema de comunicación entre personas: un punto de comunicación entre dos agentes ( procesos o personas respectivamente ) por el cual se puede emitir o recibir información. La forma de referenciar un socket por los procesos implicados es mediante undescriptor del mismo tipo que el utilizado para referenciar ficheros. Debido a esta característica, se podrá realizar redirecciones de los archivos de E/S estándar (descriptores 0,1 y 2) a los sockets y así combinar entre ellos aplicaciones de la red. Todo nuevo proceso creado heredará, por tanto, los descriptores de sockets de su padre. La comunicación entre procesos a través de sockets se basa en la filosofía CLIENTE-SERVIDOR: un proceso en esta comunicación actuará de proceso servidor creando un socket cuyo nombre conocerá el proceso cliente, el cual podrá "hablar" con el proceso servidor a través de la conexión con dicho socket nombrado. El proceso crea un socket sin nombre cuyo valor de vuelta es un descriptor sobre el que se leerá o escribirá, permitiéndose una comunicación bidireccional, característica propia de los sockets y que los diferencia de los pipes, o canales de comunicación unidireccional entre procesos de una misma máquina. El mecanismo de comunicación vía sockets tiene los siguientes pasos: 1º) El proceso servidor crea un socket con nombre y espera la conexión. 2º) El proceso cliente crea un socket sin nombre. 3º) El proceso cliente realiza una petición de conexión al socket servidor. 4º) El cliente realiza la conexión a través de su socket mientras el proceso servidor mantiene el socket servidor original con nombre.

Es muy común en este tipo de comunicación lanzar un proceso hijo, una vez realizada la conexión, que se ocupe del intercambio de información con el proceso cliente mientras el proceso padre servidor sigue aceptando

conexiones. Para eliminar esta característica se cerrará el descriptor del socket servidor con nombre en cuanto realice una conexión con un proceso socket cliente. -Todo socket viene definido por dos características fundamentales: - El tipo del socket, que indica la naturaleza del mismo, el tipo de comunicación que puede generarse entre los sockets. - El dominio del socket especifica el conjunto de sockets que pueden establecer una comunicación con el mismo.

La programación en red siempre ha sido dificultosa, el programador debía de conocer la mayoría de los detalles de la red, incluyendo el hardware utilizado, los distintos niveles en que se divide la capa de red, las librerías necesarias para programar en cada capa, etc. Pero, la idea simplemente consiste en obtener información desde otra maquina, aportada por otra aplicación software. Por lo tanto, de cierto modo se puede reducir al mero hecho de leer y escribir archivos, con ciertas salvedades. El sistema de Entrada/Salida de Unix sigue el paradigma que normalmente se designa como Abrir-Leer-Escribir-Cerrar. Antes de que un proceso de pueda realizar operaciones de entrada/salida, debe hacer una llamada a Abrir (open) para indicar, y obtener los permisos del fichero o dispositivo que se desea utilizar. Una vez que el fichero o dispositivo se encuentra abierto, el proceso de realiza una o varias llamadas a Leer (read) y Escribir (write), para la lectura y escritura de los datos. El proceso de lectura toma los datos desde el objeto y los transfiere al proceso de , mientras que el de escritura los transfiere desde el proceso de al objeto. Una vez concluido el intercambio de información, el proceso de llamará a Cerrar (close) para informar al sistema operativo que ha finalizado la utilización del fichero o dispositivo.

En Unix, un proceso tiene un conjunto de descriptores de entrada/salida desde donde leer y por donde escribir. Estos descriptores pueden estar referidos a ficheros, dispositivos, o canales de comunicaciones sockets. El ciclo de vida de un descriptor, aplicado a un canal de comunicación (por ejemplo, un socket), está determinado por tres fases: - Creación, apertura del socket - Lectura y Escritura, recepción y envío de datos por el socket - Destrucción, cierre del socket La interface IPC en Unix-BSD está implementada sobre los protocolos de red T y UDP. Los destinatarios de los mensajes se especifican como direcciones de socket; cada dirección de socket es un identificador de comunicación que consiste en una dirección Internet y un número de puerto. Las operaciones IPC se basan en pares de sockets. Se intercambian información transmitiendo datos a través de mensajes que circulan entre un socket en un proceso y otro socket en otro proceso. Cuando los mensajes son enviados, se encolan en el socket hasta que el protocolo de red los haya transmitido. Cuando llegan, los mensajes son encolados en el socket de recepción hasta que el proceso que tiene que recibirlos haga las llamadas necesarias para recoger esos datos. El lenguaje Java fue desarrollado por la empresa Sun MicroSystems hacia el año 1990, mediante la creación de un grupo de trabajo en cuya cabeza estaba James Gosling. Este grupo de trabajo fue ideado para desarrollar un sistema de control de electrodomésticos y de PDAs o asistentes personales (pequeños ordenadores) y que además tuviese la posibilidad de interconexión a redes de ordenadores. Todo ello implicaba la creación de un hardware polivalente, un sistema operativo eficiente (SunOS) y un lenguaje de desarrollo (Oak). El proyecto concluyó dos años más tarde con un completo fracaso que condujo a la disolución del grupo. Pero el desarrollo del proyecto relativo al lenguaje oak siguió adelante gracias entre otras cosas a la distribución libre del lenguaje por Internet mediante la incipiente, por aquellos años, World Wide Web. De esta forma el lenguaje alcanzó cierto auge y un gran número de programadores se encargaron de su depuración así como de perfilar la forma y usos del mismo.

El nombre de Java, surgió durante una de las sesiones de brain storming que se celebraban por el equipo de desarrollo del lenguaje. Hubo que cambiar el nombre debido a que ya existía otro lenguaje con el nombre de oak.

Sun MicroSystems lanzó las primeras versiones de Java a principios de 1995, y se han ido sucediendo las nuevas versiones durante estos últimos años, fomentando su uso y extendiendo las especificaciones y su funcionalidad.

Una de las características más importantes de Java es su capacidad y, a la vez, facilidad para realizar aplicaciones que funcionen en red. La mayoría de los detalles de implementación a bajo nivel están ocultos y son tratados de forma transparente por la JVM (Java Virtual Machine). Los programas son independientes de la arquitectura y se ejecutan indistintamente en una gran variedad de equipos con diferentes tipos de microprocesadores y sistemas operativos.

2.2. Dominios y Tipos de sockets. Tipos de sockets. Define las propiedades de las comunicaciones en las que se ve envuelto un socket, esto es, el tipo de comunicación que se puede dar entre cliente y servidor. Estas pueden ser: - Fiabilidad de transmisión. - Mantenimiento del orden de los datos. - No duplicación de los datos. - El "Modo Conectado" en la comunicación. - Envío de mensajes urgentes. Los tipos disponibles son los siguientes: * Tipo SOCK_DGRAM: sockets para comunicaciones en modo no conectado, con envío de datagramas de tamaño limitado (tipo telegrama). En dominios Internet como la que nos ocupa el protocolo del nivel de

transporte sobre el que se basa es el UDP. * Tipo SOCK_STREAM: para comunicaciones fiables en modo conectado, de dos vías y con tamaño variable de los mensajes de datos. Por debajo, en dominios Internet, subyace el protocolo T. * Tipo SOCK_RAW: como el IP (nivel de red)

permite el a protocolos de más bajo nivel

* Tipo SOCK_SEQPACKET: tiene las características del SOCK_STREAM pero además el tamaño de los mensajes es fijo.

Cada tipo de socket va a definir una serie de propiedades en función de las comunicaciones en las cuales está implicado: a) La fiabilidad de la transmisión. Ningún dato transmitido se pierde. b) La conservación del orden de los datos. Los datos llegan en el orden en el que han sido emitidos. c) La no duplicación de datos. Sólo llega a destino un ejemplar de cada dato emitido. d) La comunicación en modo conectado. Se establece una conexión entre dos puntos antes del principio de la comunicación (es decir, se establece un circuito virtual). A partir de entonces, una emisión desde un extremo está implícitamente destinada al otro extremo conectado. e) La conservación de los límites de los mensajes. Los límites de los mensajes emitidos se pueden encontrar en el destino. f) El envío de mensajes (urgentes). Corresponde a la posibilidad de enviar datos fuera del flujo normal, y por consecuencia accesibles inmediatamente (datos fuera de flujo). Cabe reseñar que un cauce de comunicación normal tiene las cuatro primeras propiedades, pero no las dos últimas. En cuanto a los tipos de sockets disponibles, se pueden considerar:

* SOCK_STREAM: Los sockets de este tipo permiten comunicaciones fiables en modo conectado (propiedades a, b, c y d) y eventualmente autorizan, según el protocolo aplicado los mensajes fuera de flujo (propiedad f). El protocolo subyacente en el dominio Internet es T. Se establece un circuito virtual realizando una búsqueda de enlaces libres que unan los dos ordenadores a conectar (parecido a lo que hace la red telefónica conmutada para establecer una conexión entre dos teléfonos). Una vez establecida la conexión, se puede proceder al envío secuencial de los datos, ya que la conexión es permanente. Son streams de bytes full-dúplex (similar a pipes). Un socket stream debe estar en estado conectado antes de que se envíe o reciba en él. * SOCK_DGRAM: Corresponde a los sockets destinados a la comunicación en modo no conectado para el envío de datagramas de tamaño limitado. Las comunicaciones correspondientes tienen la propiedad e. En el dominio Internet, el protocolo subyacente es el UDP. Los datagramas no trabajan con conexiones permanentes. La transmisión por los datagramas es a nivel de paquetes, donde cada paquete puede seguir una ruta distinta, no garantizándose una recepción secuencial de la información. * SOCK_RAW: Permite el a los protocolos de más bajo nivel (por ejemplo, el protocolo IP en el dominio Internet). Su uso está reservado al super. * SOCK_SEQPACKET: Corresponde a las comunicaciones que poseen las propiedades a, b, c, d y e. Estas comunicaciones se encuentran en el dominio XNS. Los dos tipos de sockets más utilizados son los dos primeros.

El dominio de un socket. Indica el formato de las direcciones que podrán tomar los sockets y los protocolos que soportarán dichos sockets.

La estructura genérica es struct sockaddr { u__short sa__family; char sa__data[14]; };

/* familia */ /* dirección */

Pueden ser: * Dominio AF_UNIX ( Address Family UNIX ): El cliente y el servidor deben estar en la misma máquina. Debe incluirse el fichero cabecera /usr/include/sys/un.h. La estructura de una dirección en este dominio es: struct sockaddr__un { short sun__family; /* en este caso AF_UNIX */ char sun__data[108]; /* dirección */ }; * Dominio AF_INET ( Address Family INET ): El cliente y el servidor pueden estar en cualquier máquina de la red Internet. Deben incluirse los ficheros cabecera /usr/include/netinet/in.h, /usr/include/arpa/inet.h, /usr/include/netdb.h. La estructura de una dirección en este dominio es: struct in__addr { u__long s__addr; }; struct sockaddr__in { short sin_family; /* en este caso AF_INET */ u__short sin_port; /* numero del puerto */ struct in__addr sin__addr; /* direcc Internet */ char sin_zero[8]; /* campo de 8 ceros */ }; Estos dominios van a ser los utilizados en xshine. Pero existen otros como: * Dominio AF_NS:

Servidor y cliente deben estar en una red XEROX. * Dominio AF_CCITT: Para protocolos CCITT, protocolos X25, ...

Una familia, o dominio de la conexión, agrupa todos aquellos sockets que comparten características comunes. Especifica el formato de las direcciones que se podrán dar al socket y los diferentes protocolos soportados por las comunicaciones vía los sockets de este dominio. Cada protocolo, a la hora de referirse a un nodo de la red, implementa un mecanismo de direccionamiento. La dirección distingue de forma inequívoca a cada nodo u ordenador, y es utilizada para encaminar los datos desde el nodo origen hasta el nodo destino. Hay muchas llamadas al sistema que necesitan un puntero a una estructura de dirección de socket para trabajar. La siguiente estructura genérica, se utiliza para describir las diferente primitivas. struct sockaddr { u_short sa_family; /* familia de sockets; se emplean constantes de la forma AF_xxx */ char sa_data[14]; /* 14 bytes que contienen la dirección; su significado depende de la familia de sockets que se emplee */ }; Pero en el caso de que estemos tratando con una aplicación particular, esta estructura se deberá reemplazar por la estructura correspondiente del dominio de comunicaciones utilizado, ya que por desgracia, no todas las familias de direcciones se ajustan a la estructura genérica descrita. No obstante, esta estructura genérica encaja en la estructura definida para la familia AF_INET, perteneciente al dominio Internet, lo que hace que el software de T/IP trabaje correctamente aunque el programador use la estructura genérica anterior, puesto que ambas tienen el mismo número de bytes. A continuación, pasamos a describir esta estructura del dominio Internet.

struct sockaddr_in { short sin_family; /* la familia de la dirección AF_INET*/ u_short sin_port; /* 16 bits con el número del puerto */ u_long sin_addr; /* 32 bits con la dirección Internet (identificación de la red y del host)*/ char sin _zero[8]; /* 8 bytes no usados */ Se puede observar que en la dirección Internet el campo sin_family es equivalente al campo sa_family de la dirección genérica y que los campos sin_port, sin_addr y sin_zero cumplen la misma función que el campo sa_addr. También podemos ver el dominio UNIX (AF_UNIX), donde los sockets son locales al sistema en el cual han sido definidos. Permiten la comunicación interna de procesos, y su designación se realiza por medio de una referencia UNIX. struct sockaddr_un { short sun_family; /* dominio UNIX: AF_UNIX */ char sun_data[108]; /* path */ }; Estas direcciones se corresponden en realidad con paths de ficheros, y su longitud (110 bytes) es superior a los 16 bytes que de forma estándar tienen las direcciones del resto de familias. Esto es posible debido a que esta familia se usa para comunicar procesos ejecutados bajo control de la misma máquina, no teniendo así que acceder a la red. Otros dominios son: AF_NS /* protocolos XEROX NS */ AF_CCITT /* protocolos CCITT, protocolos X.25, etc. */

AF_SNA /* IBM SNA */ AF_DECnet /* DECnet */

2.3. Creación/ implementación y supresión de sockets. Apertura de Sockets Si estamos programando un CLIENTE, el socket se abre de la forma: Socket miCliente; miCliente = new Socket( "maquina", numeroPuerto ); Donde maquina es el nombre de la máquina en donde estamos intentando abrir laconexión y numeroPuerto es el puerto (un número) del servidor que está corriendo sobre el cualnos queremos conectar. Cuando se selecciona un número de puerto, se debe tener en cuenta que los puertos en el rango 0-1023 están reservados para s con muchos privilegios (supers o root). Estos puertos son los que utilizan los servicios estándar del sistema como email, ftp o http. Para las aplicaciones que se desarrollen, asegurarse de seleccionar un puerto por encima del 1023. En el ejemplo anterior no se usan excepciones; sin embargo, es una gran idea la captura de excepciones cuando se está trabajando con sockets. El mismo ejemplo quedaría como: Socket miCliente; try { miCliente = new Socket( "maquina",numeroPuerto ); } catch( IOException e ){ System.out.println( e ); }

Si estamos programando un SERVIDOR, la forma de apertura del socket es la quemuestra el siguiente ejemplo: Socket miServicio; try { miServicio = new ServerSocket( numeroPuerto ); } catch( IOException e ) { System.out.println( e ); } A la hora de la implementación de un servidor también necesitamos crear un objetosocket desde el ServerSocket para que esté atento a las conexiones que le puedan realizar clientes potenciales y poder aceptar esas conexiones: Socket socketServicio = null; try { socketServicio = miServicio.accept(); } catch( IOException e ) { System.out.println( e ); }

Creación de Streams de Entrada En la parte CLIENTE de la aplicación, se puede utilizar la clase DataInputStream para crear un stream de entrada que esté listo a recibir todas las respuestas que el servidor le envíe. DataInputStream entrada; try { entrada = new DataInputStream( miCliente.getInputStream() ); } catch( IOException e ) { System.out.println( e );

} La clase DataInputStream permite la lectura de líneas de texto y tipos de datos primitivos de Java de un modo altamente portable; dispone de métodos para leer todos esos tipos como: read(), readChar(), readInt(), readDouble() y readLine(). Deberemos utilizar la función que creamos necesaria dependiendo del tipo de dato que esperemos recibir del servidor. En el lado del SERVIDOR, también usaremos DataInputStream, pero en este caso para recibir las entradas que se produzcan de los clientes que se hayan conectado: DataInputStream entrada; try { entrada = new DataInputStream( socketServicio.getInputStream() ); } catch( IOException e ) { System.out.println( e ); }

Creación de Streams de Salida En el lado del CLIENTE, podemos crear un stream de salida para enviar información alsocket del servidor utilizando las clases PrintStream o DataOutputStream: PrintStream salida; try { salida = new PrintStream( miCliente.getOutputStream() ); } catch( IOException e ) { System.out.println( e ); }

La clase PrintStream tiene métodos para la representación textual de todos los datosprimitivos de Java. Sus métodos write y println() tienen una especial importancia en este aspecto.No obstante, para el envío de información al servidor también podemos utilizarDataOutputStream:

DataOutputStream salida; try { salida = new DataOutputStream( miCliente.getOutputStream() ); } catch( IOException e ) { System.out.println( e ); } La clase DataOutputStream permite escribir cualquiera de los tipos primitivos de Java, muchos de sus métodos escriben un tipo de dato primitivo en el stream de salida. De todos esos métodos, el más útil quizás sea writeBytes(). En el lado del SERVIDOR, podemos utilizar la clase PrintStream para enviar información al cliente: PrintStream salida; try { salida = new PrintStream( socketServicio.getOutputStream() );

Cierre de Sockets Siempre deberemos cerrar los canales de entrada y salida que se hayan abierto durante la ejecución de la aplicación. En la parte del cliente: try { salida.close(); entrada.close(); miCliente.close();

} catch( IOException e ) { System.out.println( e ); } Y en la parte del servidor: try { salida.close(); entrada.close(); socketServicio.close(); miServicio.close(); } catch( IOException e ) { System.out.println( e ); } Es importante destacar que el orden de cierre es relevante. Es decir, se deben cerrar primero los streams relacionados con un socket antes que el propio socket, ya que de esta forma evitamos posibles errores de escrituras o lecturas sobre descriptores ya cerrados.

Clases útiles en comunicaciones Socket Es el objeto básico en toda comunicación a través de Internet, bajo el protocolo T. Esta clase proporciona métodos para la entrada/salida a través de streams que hacen la lectura y escritura a través de sockets muy sencilla.

ServerSocket Es un objeto utilizado en las aplicaciones servidor para escuchar las peticiones que realicen los clientes conectados a ese servidor. Este objeto no realiza el servicio, sino que crea un objeto Socket en función del cliente para realizar toda la comunicación a través de él.

DatagramSocket La clase de sockets datagrama puede ser utilizada para implementar datagramas no fiables (sockets UDP), no ordenados. Aunque la comunicación por estos sockets es muy rápida porque no hay que perder tiempo estableciendo la conexión entre cliente y servidor.

DatagramPacket Clase que representa un paquete datagrama conteniendo información de paquete, longitud de paquete, direcciones Internet y números de puerto.

MulticastSocket Clase utilizada para crear una versión multicast de la clase socket datagrama. Múltiples clientes/servidores pueden transmitir a un grupo multicast (un grupo de direcciones IP compartiendo el mismo número de puerto).

NetworkServer Una clase creada para implementar métodos y variables utilizadas en la creación de un servidorT/IP.

NetworkClient Una clase creada para implementar métodos y variables utilizadas en la creación de un clienteT/IP.

SocketImpl Es un Interface que nos permite crearnos nuestro propio modelo de comunicación. Tendremos que implementar sus métodos cuando la usemos. Si vamos a desarrollar una aplicación con requerimientos especiales de comunicaciones, como pueden ser la implementación de un corta fuegos (T

es un protocolo no seguro), o acceder a equipos especiales (como un lector de código de barras o un GPS diferencial), necesitaremos nuestra propia clase Socket.

2.4. Desarrollo del lado del servidor con sockets. Escribiendo el lado del servidor de un socket Esta sección le muestra cómo escribir un servidor y el cliente que lo acompaña. El servidor en el par cliente / servidor sirve para hacer chistes de Knock Knock. Las bromas de Knock Knock son preferidas por los niños y suelen ser vehículos para malos juegos de palabras. Van así: Servidor : "Knock knock!" Cliente : "¿Quién está ahí?" Servidor : "Dexter". Cliente : "Dexter who?" Servidor : "Dexter salas con ramas de acebo". Cliente : "Groan". El ejemplo consta de dos programas Java que se ejecutan de forma independiente: el programa cliente y el programa servidor. El programa cliente es implementado por una sola clase , KnockKnockClient , y es muy similar a la EchoClient Ejemplo de la sección anterior. El programa del servidor es implementado por dos clases: KnockKnockServer y KnockKnockProtocol , KnockKnockServer contiene el principal Método para el programa del servidor y realiza el trabajo de escuchar el puerto, establecer conexiones y leer y escribir en el socket. KnockKnockProtocol Sirve los chistes. Realiza un seguimiento de la broma actual, el estado actual (mandó a golpear, envió una pista, etc.) y devuelve las distintas partes de texto de la broma según el estado actual. Este objeto implementa el protocolo, el lenguaje que el cliente y el servidor han acordado usar para comunicarse. La siguiente sección examina en detalle cada clase, tanto en el cliente como en el servidor, y luego le muestra cómo ejecutarlas.

El servidor de Knock Knock Esta sección describe el código que implementa el programa del servidor Knock Knock. Aquí está la fuente completa para el KnockKnockServer clase.

El programa servidor comienza creando una nueva ServerSocket objeto para escuchar en un puerto específico (consulte la declaración en negrita en el siguiente segmento de código). Al escribir un servidor, elija un puerto que aún no esté dedicado a algún otro servicio. KnockKnockServer escucha en el puerto 4444 ya 4 pasa a ser mi número favorito y el puerto 4444 no está siendo utilizado para cualquier otra cosa en mi entorno: tratar { serverSocket = nuevo ServerSocket (4444); } captura (IOException e) { System.out.println ("No se pudo escuchar en el puerto: 4444"); System.exit (-1); } ServerSocket es un java.net Clase que proporciona una implementación independiente del sistema del lado del servidor de una conexión de socket cliente / servidor. El constructor para ServerSocket emite una excepción si no puede escuchar en el puerto especificado (por ejemplo, el puerto ya se está utilizando). En este caso, la KnockKnockServer no tiene más remedio que salir. Si el servidor se enlaza exitosamente a su puerto, entonces el ServerSocket el objeto se creó correctamente y el servidor continúa con el siguiente paso: aceptar una conexión de un cliente (se muestra en negrita): Socket clientSocket = null; tratar { clientSocket = serverSocket.accept (); } captura (IOException e) { System.out.println ("Error de aceptación: 4444"); System.exit (-1); } los aceptar El método espera hasta que un cliente se inicie y solicite una conexión en el host y el puerto de este servidor (en este ejemplo, el servidor se está ejecutando en la máquina hipotética Taranis en el puerto 4444). Cuando se solicita una conexión y se establece con éxito, el método de aceptación devuelve un nuevo Enchufe objeto que está vinculado al mismo puerto local y tiene su dirección remota y su puerto remoto establecidos en el del cliente. El servidor puede comunicarse con el cliente a través de este nuevo Enchufe y siga escuchando las solicitudes de conexión del cliente en

el original ServerSocket Esta versión particular del programa no escucha más solicitudes de conexión de clientes. Sin embargo, una versión modificada del programa se proporciona en Apoyo a múltiples clientes . Una vez que el servidor establece con éxito una conexión con un cliente, se comunica con el cliente utilizando este código: PrintWriter out = new PrintWriter (clientSocket.getOutputStream (), true); BufferedReader in = nuevo BufferedReader (nuevo InputStreamReader (clientSocket.getInputStream ())); String inputLine, outputLine; // iniciar la conversación con el cliente KnockKnockProtocol kkp = nuevo KnockKnockProtocol (); outputLine = kkp.processInput (null); out.println (outputLine); while ((inputLine = in.readLine ())! = null) { outputLine = kkp.processInput (inputLine); out.println (outputLine); if (outputLine.equals ("Bye.")) descanso; } Esta código : 1. Obtiene el flujo de entrada y salida del socket y abre lectores y escritores en ellos. 2. Inicia la comunicación con el cliente escribiendo en el socket (se muestra en negrita). 3. Se comunica con el cliente leyendo y escribiendo en el socket (el mientras lazo). El paso 1 ya es familiar. El paso 2 se muestra en negrita y vale unos pocos comentarios. Las declaraciones en negrita en el segmento de código anterior inician la conversación con el cliente. El código crea un KnockKnockProtocol objeto: el objeto que realiza un seguimiento de la broma actual, el estado actual dentro de la broma, etc. Después de la KnockKnockProtocol Se crea, el código llama. KnockKnockProtocol 's proceso de entrada Método para obtener el primer mensaje que el servidor envía al cliente. Para este ejemplo, lo primero

que dice el servidor es "Knock! Knock!" A continuación, el servidor escribe la información al PrintWriter conectado al socket del cliente, enviando así el mensaje al cliente. El paso 3 se codifica en el mientras lazo. Mientras el cliente y el servidor aún tengan algo que decirse, el servidor lee y escribe en el socket, enviando mensajes entre el cliente y el servidor. El servidor inició la conversación con un "Knock! Knock!" así que luego el servidor debe esperar a que el cliente diga "¿Quién está ahí?" Como resultado, el bucle while se repite en una lectura desde el flujo de entrada. El método readLine espera hasta que el cliente responda escribiendo algo en su flujo de salida (el flujo de entrada del servidor). Cuando el cliente responde, el servidor pasa la respuesta del cliente a la KnockKnockProtocol objeto y pregunta al KnockKnockProtocol objeto para una respuesta adecuada. El servidor envía inmediatamente la respuesta al cliente a través del flujo de salida conectado al zócalo, utilizando una llamada para imprimir. Si la respuesta del servidor se genera desde el KnockKnockServer El objeto es "Bye". esto indica que el cliente no quiere más chistes y el bucle se cierra. los KnockKnockServer clase es un servidor de buen comportamiento, por lo que las últimas líneas de esta sección de KnockKnockServer limpie cerrando todos los flujos de entrada y salida, el socket del cliente y el socket del servidor: fuera.close (); cercar(); clientSocket.close (); serverSocket.close ();

El Protocolo de Knock Knock Los KnockKnockProtocol La clase implementa el protocolo que el cliente y el servidor utilizan para comunicarse. Esta clase realiza un seguimiento de dónde se encuentran el cliente y el servidor en su conversación y presenta la respuesta del servidor a las declaraciones del cliente. los KnockKnockServer object contiene el texto de todos los chistes y se asegura de que el cliente dé la respuesta adecuada a las declaraciones del servidor. No sería bueno que el cliente dijera "Dexter who?" cuando el servidor dice "Knock! Knock!" Todos los pares cliente / servidor deben tener algún protocolo mediante el cual se hablan entre sí; de lo contrario, los datos que pasan de un lado a otro no tendrían sentido. El protocolo que utilizan sus propios clientes y servidores

depende completamente de la comunicación requerida por ellos para realizar la tarea.

El cliente de Knock Knock Los KnockKnockClient clase implementa el programa cliente que habla a la KnockKnockServer . KnockKnockClient se basa en el EchoClient Programa en la sección anterior, Leyendo desde y escribiendo a un socket y debe ser algo familiar para usted. Pero repasaremos el programa de todos modos y veremos lo que sucede en el cliente en el contexto de lo que sucede en el servidor. Cuando inicie el programa cliente, el servidor ya debería estar ejecutándose y escuchando el puerto, esperando que un cliente solicite una conexión. Entonces, lo primero que hace el programa cliente es abrir un socket que está conectado al servidor que se ejecuta en el nombre de host y el puerto especificado: kkSocket = new Socket ("taranis", 4444); out = new PrintWriter (kkSocket.getOutputStream (), true); in = new BufferedReader (new InputStreamReader (kkSocket.getInputStream ())); Al crear su zócalo, KnockKnockClient usa el nombre de host taranis , el nombre de una máquina hipotética en nuestra red. Cuando escribe y ejecuta este programa, cambie el nombre de host al nombre de una máquina en su red. Esta es la máquina en la que ejecutará el KnockKnockServer . los KnockKnockClient El programa también especifica el número de puerto 4444 al crear su socket. Esto es un número de puerto remoto, el número de un puerto en la máquina del servidor, y es el puerto al cual KnockKnockServer esta escuchando. El socket del cliente está vinculado a cualquier disponible puerto local - un puerto en la máquina cliente. Recuerda que el servidor también obtiene un nuevo socket. Ese zócalo está vinculado al número de puerto local 4444 en su máquina. El zócalo del servidor y el zócalo del cliente están conectados. Luego viene el bucle while que implementa la comunicación entre el cliente y el servidor. El servidor habla primero, por lo que el cliente debe escuchar primero. El cliente hace esto leyendo el flujo de entrada adjunto al socket. Si el servidor habla, dice "Adiós". y el cliente sale del bucle. De lo contrario, el cliente muestra el texto en la salida estándar y luego lee la respuesta del , que escribe en la entrada estándar. Después de que el escribe

un retorno de carro, el cliente envía el texto al servidor a través de la secuencia de salida adjunta al socket. while ((fromServer = in.readLine ())! = null) { System.out.println ("Servidor:" + servidor); if (fromServer.equals ("Bye.")) descanso; from = stdIn.readLine (); if (from! = null) { System.out.println ("Cliente:" + de ); out.println (from); } } La comunicación finaliza cuando el servidor pregunta si el cliente desea escuchar otra broma, el cliente dice que no y el servidor dice "Adiós". En aras de un buen mantenimiento, el cliente cierra sus flujos de entrada y salida y el socket: fuera.close (); cercar(); stdIn.close (); kkSocket.close ();

Ejecutando los programas Debe iniciar el programa del servidor primero. Para hacer esto, ejecute el programa del servidor usando el intérprete de Java, como lo haría con cualquier otra aplicación Java. Recuerde ejecutar el servidor en la máquina que el programa cliente especifica cuando crea el socket. A continuación, ejecute el programa cliente. Tenga en cuenta que puede ejecutar el cliente en cualquier máquina de su red; no tiene que ejecutarse en la misma máquina que el servidor. Si es demasiado rápido, puede iniciar el cliente antes de que el servidor tenga la oportunidad de inicializarse y comenzar a escuchar en el puerto. Si esto sucede, verá un seguimiento de la pila del cliente. Si esto sucede, simplemente reinicie el cliente. Si olvida cambiar el nombre de host en el código fuente para el KnockKnockClient programa, verá el siguiente mensaje de error:

No sé sobre el anfitrión: taranis Para arreglar esto, modifique el KnockKnockClient programa y proporciona un nombre de host válido para tu red. Recompila el programa cliente y vuelve a intentarlo. Si intenta iniciar un segundo cliente mientras el primer cliente está conectado al servidor, el segundo cliente simplemente se bloquea. La siguiente sección, Apoyo a múltiples clientes , habla sobre el soporte de múltiples clientes. Cuando obtenga con éxito una conexión entre el cliente y el servidor, verá el siguiente texto que se muestra en su pantalla: Servidor: Knock! ¡Golpe! Ahora, debes responder con: ¿Quién está ahí? El cliente se hace eco de lo que escribe y envía el texto al servidor. El servidor responde con la primera línea de uno de los muchos chistes de Knock Knock en su repertorio. Ahora su pantalla debe contener esto (el texto que escribió está en negrita): Servidor: Knock! ¡Golpe! ¿Quién está ahí? Cliente: ¿Quién está ahí? Servidor: Nabo Ahora, respondes con: Nabo quién? " Nuevamente, el cliente hace eco de lo que escribe y envía el texto al servidor. El servidor responde con la línea de perforación. Ahora tu pantalla debe contener esto: Servidor: Knock! ¡Golpe! ¿Quién está ahí? Cliente: ¿Quién está ahí? Servidor: Nabo Nabo quien? Cliente: Turnip who? Servidor: ¡Apaga el calor, hace frío aquí! ¿Quieres otro? (s / n) Si quieres escuchar otro chiste, escribe y ; si no, escribe n . Si escribes y , el servidor comienza de nuevo con "Knock! Knock!" Si escribes n , el servidor dice "Bye". causando así que el cliente y el servidor salgan.

Si en algún momento comete un error de escritura, la KnockKnockServer el objeto lo atrapa y el servidor responde con un mensaje similar a este: Servidor: se supone que debes decir "¿Quién está ahí?" El servidor vuelve a iniciar la broma de nuevo: Servidor: inténtalo de nuevo. ¡Golpe! ¡Golpe! Tenga en cuenta que el KnockKnockProtocol el objeto es particular sobre la ortografía y la puntuación, pero no sobre el uso de mayúsculas.

2.5. Desarrollo del lado del cliente con sockets Leyendo y escribiendo desde un socket Veamos un ejemplo simple que ilustra cómo un programa puede establecer una conexión a un programa de servidor usando el Enchufe clase y luego, cómo el cliente puede enviar y recibir datos del servidor a través del socket. El programa de ejemplo implementa un cliente, EchoClient , que se conecta al servidor Echo. El servidor Echo simplemente recibe datos de su cliente y los devuelve. El servidor Echo es un servicio bien conocido con el que los clientes pueden encontrarse en el puerto 7. EchoClient crea un socket para obtener una conexión con el servidor Echo. Lee la entrada del en la secuencia de entrada estándar y luego envía ese texto al servidor Echo escribiendo el texto en el socket. El servidor repite la entrada de nuevo a través del socket al cliente. El programa cliente lee y muestra los datos que se le devuelven desde el servidor: import java.io. *; import java.net. *; clase pública EchoClient { public static void main (String [] args) lanza IOException { Socket echoSocket = nulo; PrintWriter out = null; BufferedReader in = null; tratar { echoSocket = new Socket ("taranis", 7); out = new PrintWriter (echoSocket.getOutputStream (), true);

in = new BufferedReader (new InputStreamReader ( echoSocket.getInputStream ())); } catch (UnknownHostException e) { System.err.println ("No sé sobre host: taranis."); System.exit (1); } captura (IOException e) { System.err.println ("No se pudo obtener E / S para" + "la conexión a: taranis."); System.exit (1); } BufferedReader stdIn = new BufferedReader ( nuevo InputStreamReader (System.in)); String Input; while ((Input = stdIn.readLine ())! = null) { out.println (Input); System.out.println ("echo:" + in.readLine ()); } fuera.close (); cercar(); stdIn.close (); echoSocket.close (); } } Tenga en cuenta que EchoClient escribe y lee desde su socket, enviando datos al servidor Echo y recibiendo datos del mismo. Veamos el programa e investiguemos las partes interesantes. Las tres afirmaciones en el tratar bloque de la principal El método es crítico. Estas líneas establecen la conexión de socket entre el cliente y el servidor y abren una PrintWriter y un BufferedReader en el zócalo: echoSocket = new Socket ("taranis", 7); out = new PrintWriter (echoSocket.getOutputStream (), true); in = new BufferedReader (new InputStreamReader (echoSocket.getInputStream ())); La primera declaración en esta secuencia crea una nueva Enchufe objeto y lo nombra echoSocket . los Enchufe El constructor utilizado aquí requiere el nombre de la máquina y el número de puerto al que desea conectarse. El

programa de ejemplo usa el nombre de host taranis. Este es el nombre de una máquina hipotética en nuestra red local. Cuando escribe y ejecuta este programa en su máquina, cambie el nombre del host al nombre de una máquina en su red. Asegúrese de que el nombre que utiliza sea el nombre IP completo de la máquina a la que desea conectarse. El segundo argumento es el número de puerto. El número de puerto 7 es el puerto en el que escucha el servidor Echo. La segunda declaración obtiene el flujo de salida del socket y abre un PrintWriter en eso. De manera similar, la tercera instrucción obtiene el flujo de entrada del socket y abre un BufferedReader en eso. El ejemplo utiliza lectores y escritores para que pueda escribir caracteres Unicode en el socket. Para enviar datos a través del socket al servidor, EchoClient simplemente tiene que escribir al PrintWriter . Para obtener la respuesta del servidor, EchoClient lee desde el BufferedReader . El resto del programa lo consigue. Si aún no está familiarizado con las clases de E / S de la plataforma Java, puede leer I / O básico . La siguiente parte interesante del programa es la mientras lazo. El bucle lee una línea a la vez desde el flujo de entrada estándar y lo envía inmediatamente al servidor escribiéndolo en el PrintWriter conectado al zócalo: String Input; while ((Input = stdIn.readLine ())! = null) { out.println (Input); System.out.println ("echo:" + in.readLine ()); } La última afirmación en el mientras bucle lee una línea de información de la BufferedReader conectado al zócalo. los readLine El método espera hasta que el servidor devuelve la información a EchoClient . Cuando readline devoluciones, EchoClient Imprime la información a la salida estándar. los mientras el bucle continúa hasta que el escribe un carácter de final de entrada. Es decir, EchoClient lee la entrada del , la envía al servidor Echo, obtiene una respuesta del servidor y la muestra hasta que llega al final de la entrada. los mientras entonces el bucle termina y el programa continúa, ejecutando las siguientes cuatro líneas de código: fuera.close (); cercar(); stdIn.close ();

echoSocket.close (); Estas líneas de código entran en la categoría de limpieza. Un programa de buen comportamiento siempre se limpia después de sí mismo, y este programa tiene un buen comportamiento. Estas declaraciones cierran los lectores y escritores conectados al socket y al flujo de entrada estándar, y cierran la conexión del socket al servidor. El orden aquí es importante. Debe cerrar todas las secuencias conectadas a un socket antes de cerrar el socket. Este programa cliente es sencillo y simple porque el servidor Echo implementa un protocolo simple. El cliente envía texto al servidor, y el servidor lo repite. Cuando sus programas cliente están hablando con un servidor más complicado como un servidor HTTP, su programa cliente también será más complicado. Sin embargo, los conceptos básicos son muy similares a los de este programa: 1. Abra un zócalo. 2. Abra un flujo de entrada y un flujo de salida al socket. 3. Lea y escriba en el flujo de acuerdo con el protocolo del servidor. 4. Cierra los arroyos. 5. Cierre el zócalo. Solo el paso 3 difiere de cliente a cliente, dependiendo del servidor. Los otros pasos siguen siendo en gran medida los mismos.