Sockets TCP y UDP en J ava

Ms. Ing. J airo E. Mrquez D.

Objetivo:
Utilizar sockets TCP y UDP para el intercambio de mensajes mediante el uso de
sockets en Java.
Debido a la lentitud de las lneas de comunicaciones (sobre todo en internet), el
intercambio de mensajes es recomendable que sea mnimo de tal forma que
se obtenga el mximo rendimiento de nuestro programa, no debemos depender
demasiado de dichas comunicaciones.
Introduccin
Los sockets fueron popularizados por Berckley Software Distribution, de la
universidad norteamericana de Berkley. En esencia son formas en las que se
puede interconectar dos (o ms) programas mediante el uso de internet. En java
se utilizan para poder crear conexiones utilizando una IP/hostname y un puerto
para establecer la conexin. Para aprender podemos utilizarla para conectar 2
programas por medio de Internet.
Sokets
Los sockets constan de dos programas, un cliente y servidor. El programa
servidor comienza a escuchar en un puerto determinado (nosotros lo
especificamos), y posteriormente el programa que hace de cliente debe conocer
la IP o nombre de dominio/hostname del servidor y el puerto que est escuchando,
al saber esto simplemente solicita establecer una conexin con el servidor. Es
aqu cuando el servidor acepta esa conexin y se puede decir que estos
programas estn conectados, de este modo pueden intercambiar informacin.
Con base en lo anterior, se puede inferir que los sockets permiten la comunicacin
entre procesos de diferentes mquinas de una red. Es decir, un socket es un
punto de comunicacin por el cual un proceso puede emitir o recibir informacin.
Los sockets han de ser capaces de utilizar el protocolo de streams TCP (Transfer
Contro Protocol) y el de datagramas UDP (User Datagram Protocol).
Utilizan una serie de primitivas para establecer el punto de comunicacin, para
conectarse a una mquina remota en un determinado puerto que est
disponible, para escuchar en l, para leer o escribir y publicar informacin en l, y
finalmente para desconectarse.
Con todas primitivas se puede crear un sistema de dilogo muy completo.
Tomado de http://zarza.usal.es/~fgarcia/doc/tuto2/V_2.htm
Nota:
Ambos programas (servidor y cliente) no necesitan estar programados en Java, se
puede programar en otros lenguajes, incluso programar un servidor en java y
utilizar un cliente ya existente que pueda conectarse a un puerto especificado.
El cliente debe de conocer tanto el puerto a utilizar como la IP o dominio del
servidor, mientras el servidor solo debe conocer el puerto de conexin.
Ejemplos
Java proporciona la clase InetAddress para administrar las direcciones IP y los
dominios, algunos mtodos que se puede encontrar son los siguientes:
byte[] getAddress(); devuelve la direccin IP de un objeto InetAddress.
InetAddress getByName(String host); devuelve un objeto InetAddress.
static InetAddressgetByAddress(byte[] direccion) ; introducimos una
direccin IP y nos devuelve un objeto con esa direccin.
static InetAddressgetByAddress(String host, byte[] addr) ; igual que el
anterior pero tambin guarda el host.
InetAdress getLocalHost() ; devuelve un objeto con la direccin IP local del
equipo
A continuacin se tiene un ejemplo de todos estos mtodos:
1
package InetAddress;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class DireccionesIP {
public static void main(String[] args) {
byte[] direccionLocal = {127, 0, 0, 1}; //Direccin IP del Localhost
InetAddress equipo;
try {
// Mtodos estticos de InetAddress para obtener el objeto equipo
equipo = InetAddress.getLocalHost(); // Creamos el objeto equipo de la clase
InetAddress
System.out.println("Mi equipo es: "+equipo);
1
Fuente de consulta. http://www.redeszone.net/2012/10/15/curso-java-volumen-xi-todo-sobre-sockets-
tcp-y-udp-en-java/
System.out.println("Su direccin IP es: "+equipo.getHostAddress());
System.out.println("Su nombre es: "+equipo.getHostName());
System.out.println("Y su nombre cannico: "+equipo.getCanonicalHostName());
System.out.println();
// Se obtiene el equipo a partir del nombre
equipo = InetAddress.getByName("www.google.com");
System.out.println("el equipo www.google.com es: "+equipo);
System.out.println("Su direccin IP es: "+equipo.getHostAddress());
System.out.println("Su nombre es: "+equipo.getHostName());
System.out.println("Y su nombre cannico: "+equipo.getCanonicalHostName());
System.out.println();
// Obtenemos el equipo a partir de su direccin IP
equipo = InetAddress.getByAddress(direccionLocal);
System.out.println("Mi equipo es: "+equipo);
System.out.println("Su direccin IP es: "+equipo.getHostAddress());
System.out.println();
// Obtenemos todas las direcciones IP de un equipo
InetAddress[] identidades;
equipo = InetAddress.getLocalHost();
identidades = InetAddress.getAllByName(equipo.getHostName());
for (int i=0; i<identidades.length; i++) System.out.println("Id"+i+": "+identidades[i]);
System.out.println();
} catch (UnknownHostException e) {
System.out.println("Error de conexin");
System.out.println(e.toString());
}
}
}
La salida del programa anterior es:
Equipo es: -/10.10.2.11
Su direccin IP es: 10.10.2.11
Su nombre es: -
Y su nombre cannico: -
el equipo www.google.com es: www.google.com/173.194.34.240
Su direccin IP es: 173.194.34.240
Su nombre es: www.google.com
Y su nombre cannico: mad01s09-in-f16.1e100.net
Mi equipo es: /127.0.0.1
Su direccin IP es: 127.0.0.1
Id0: -/10.10.2.11
Id1: -/192.168.213.1
Id2: -/192.168.182.1
Id3: -/**%10
Id4: -/**%17
Id5: -/**%18
Ahora se va a desarrollar un cliente-servidor TCP para el intercambio de
mensajes.
Servidor TCP
package Sockets;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class Servidor {
public static void main(String args[]) {
ServerSocket servidor;
Socket conexion;
DataOutputStream salida;
DataInputStream entrada;
int num = 0;
try
{
servidor = new ServerSocket(5000); // Creamos un ServerSocket en el puerto
especificado
System.out.println("Servidor Arrancado correctamente");
while (true) {
conexion = servidor.accept(); // Esperamos una conexin
num++;
System.out.println("Conexin nmero" + num + " desde: " +
conexion.getInetAddress().getHostName());
entrada = new DataInputStream(conexion.getInputStream()); // Abrimos los
canales de entrada y salida
salida = new DataOutputStream(conexion.getOutputStream());
String mensaje = entrada.readUTF(); //Leemos el mensaje del cliente
System.out.println("Conexin n." + num + " mensaje: " + mensaje);
salida.writeUTF("Sois los mejores " + mensaje); // Le respondemos
conexion.close(); // Y cerramos la conexin
}
} catch (IOException e) {
}
}
}
Cliente TCP
package Sockets;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
public class Cliente {
public static void main(String args[]) {
Socket cliente;
DataInputStream entrada;
DataOutputStream salida;
String mensaje, respuesta;
try {
cliente = new Socket(InetAddress.getLocalHost(), 5000); // se crea el socket para
conectarnos al puerto 5000 del servidor
entrada = new DataInputStream(cliente.getInputStream()); //Creamos los canales
de entrada/salida
salida = new DataOutputStream(cliente.getOutputStream());
mensaje = "RedesZone";
salida.writeUTF(mensaje); // Enviamos un mensaje al servidor
respuesta = entrada.readUTF(); // Leemos la respuesta
System.out.println("Mi mensaje: " + mensaje);
System.out.println("Respuesta del Servidor: " + respuesta);
cliente.close(); // Cerramos la conexion
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
}
Ahora se va ver cmo realizar un programa cliente-servidor con UDP. El programa
cliente genera un nmero aleatorio cada 100ms y lo convierte en una cadena dada
y lo enva por el socket UDP para imprimir la cadena que ha enviado (no el
nmero de envo) y comprobaremos si se ha recibido en orden.
Servidor UDP:
package ProgramaJavaCompleto;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ServidorUDP {
public static void main(String[] args) throws SocketException {
DatagramSocket socket = new DatagramSocket(5001); //Creamos el socket UDP
System.out.println("Servidor iniciado correctamente");
int i = 0;
while (true) {
try {
byte[] buf = new byte[128];
DatagramPacket paquete = new DatagramPacket(buf, buf.length); //Formamos el
datagrama para empezar a recibir datos
socket.receive(paquete); //Orden para recibir paquetes
String cadena = new String(paquete.getData());
i++;
System.out.println("Recibido de cliente: " + cadena);
String trozo [] = cadena.split(":");
String trozoBueno [] = trozo[0].split("<");
int comprobar = Integer.parseInt(trozoBueno[1]);
if (i == comprobar) {
System.out.println("Correcto");
} else {
System.out.println("Ha habido un error");
}
} catch (IOException ex) {
Logger.getLogger(ClienteUDP.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
Cliente UDP:
package ProgramaJavaCompleto;
import java.io.IOException;
import java.net.*;
public class ClienteUDP {
public static void main(String[] args) throws SocketException,
UnknownHostException, IOException, InterruptedException {
DatagramSocket socket = new DatagramSocket(); //Creamos el socket UDP.
int i = 0;
while (true) {
i++;
Thread.sleep(100);
if (i < 10) {
int aleatorio = (int) (Math.random() * 1000);
String cadena = "<00" + i + ":" + aleatorio + ">";
DatagramPacket paquete = new DatagramPacket(cadena.getBytes(),
cadena.length(), InetAddress.getLocalHost(), 5001); //Creamos el datagrama y lo
enviamos con los datos sealados (argumentos)
socket.send(paquete);
} else if (i >= 10 && i < 100) {
int aleatorio = (int) (Math.random() * 1000);
String cadena = "<0" + i + ":" + aleatorio + ">";
DatagramPacket paquete = new DatagramPacket(cadena.getBytes(),
cadena.length(), InetAddress.getLocalHost(), 5001);
socket.send(paquete);
} else if (i >= 100) {
int aleatorio = (int) (Math.random() * 1000);
String cadena = "<" + i + ":" + aleatorio + ">";
DatagramPacket paquete = new DatagramPacket(cadena.getBytes(),
cadena.length(), InetAddress.getLocalHost(), 5001);
socket.send(paquete);
}
}
}
}
Prctica Cliente y Servidor UDP en Java
El funcionamiento es el siguiente:
- En el cliente se pondr una palabra, el servidor la leer y la transformar en
maysculas, a continuacin el servidor se la manda al cliente junto con la IP y el
puerto usado por el cliente.
- Se puede elegir los puertos a usar con el comando p, si no ponemos puerto, se
pondr por defecto el 2510.
Se tratan excepciones y control de errores, si se activan el cliente antes de abrir el
servidor no saldr como en TCP ya que UDP es no conectivo y no fiable, no
orientado a conexin.
El cdigo puede mejorarse, pero en esencia establece el proceso cliente / servidor
FTPo un cliente de email.
Modo de ejecucin (GNU/Linux) del SERVIDOR:
Compilar:
javac UDPServidor.java
Ejecutar:
java UDPServidor

java TCPServidor p <puerto>

import java.io.*;
import java.net.*;
class UDPServidor
{
public static void main(String args[]) throws Exception
{
System.out.println("El servidor va a ponerse a la escucha, un momento mientras
se leen los parametros");
int port = 2510;
if (args.length == 0 || args==null) {
System.out.println("El puerto no se ha especificado, se usara el puerto por
defecto: 2510");
} else if (args[0].equals("p")) {
port = Integer.parseInt(args[1]);
System.out.println("Vamos a usar el puerto:"+port);
}
else {
System.out.println("Debes especificar la opcion p");
}
DatagramSocket socketServidor = null;
try {
socketServidor = new DatagramSocket(port);
} catch (IOException e)
{
System.out.println("Error al crear el objeto socket servidor");
System.exit ( 0 );
}
byte [] recibirDatos = new byte[1024];
byte [] enviarDatos = new byte[1024];
byte [] enviarDatos2 = new byte[1024];
while(true)
{
DatagramPacket recibirPaquete = new DatagramPacket(recibirDatos,
recibirDatos.length);
try { socketServidor.receive(recibirPaquete);
} catch (IOException e)
{
System.out.println("Error al recibir");
System.exit ( 0 );
}
String frase = new String(recibirPaquete.getData());
InetAddress DireccionIP = recibirPaquete.getAddress();
int puerto = recibirPaquete.getPort();
String fraseMayusculas = frase.toUpperCase();
enviarDatos = fraseMayusculas.getBytes();
DatagramPacket enviarPaquete = new DatagramPacket(enviarDatos,
enviarDatos.length, DireccionIP, puerto);
try { socketServidor.send(enviarPaquete);
} catch (IOException e)
{
System.out.println("Error al recibir");
System.exit ( 0 );
}
}
}
}
Ahora con el cliente:
Compilar:
javac UDPCliente.java
Ejecutar:
java UDPCliente.java d <DIRECCION IP> m <MENSAJE> p <PUERTO
(OPCIONAL)>
import java.io.*;
import java.net.*;
class UDPCliente
{
public static void main(String args[]) throws Exception
{
System.out.println("El cliente se pone en marcha, un momento mientras se leen
los parametros");
int port = 2510;
String dire = null;
String frase = null;
if (args.length == 0 || args == null) {
System.out.println("La direccin IP es obligatoria, el programa terminara");
System.exit(0);
} else if (args.length < 4) {
// ERROR SIEMPRE: EL NUMERO DE ARGUMENTOS OBLIGATORIOS ES 4
System.out.println("El nmero de argumentos es errneo, mnimo direccin y
palabra: d direccin m palabra");
System.exit(0);
}
else if (args.length > 4) {
if (args[4].equals("p")) {
if (args.length < 6) {
System.out.println("No se ha especificado puerto con opcion p; el programa
terminara");
System.exit(0);
} else {
port = Integer.parseInt(args[5]);
}
System.out.println("Vamos a usar el puerto:" + port);
}
}
if (args[0].equals("d")) {
dire = (args[1]);
System.out.println("Vamos a usar la direccion IP:" + dire);
} else { // si no colocan d, que es obligatorio, fallara
System.out.println("El parametro debe ser d, el programa terminara");
System.exit(0);
}
if (args[2].equals("m")) {
frase = args[3];
} else {// si no colocan m, que es obligatorio, fallara
System.out.println("El parametro debe ser m, el programa terminara");
System.exit(0);
}
BufferedReader entradaDesdeUsuario = new BufferedReader(new
InputStreamReader(System.in));
DatagramSocket socketCliente = null;
try {
socketCliente = new DatagramSocket();
} catch (IOException e)
{
System.out.println("Error al crear el objeto socket cliente");
System.exit ( 0 );
}
InetAddress DireccionIP = null;
try {
DireccionIP = InetAddress.getByName(dire);
} catch (IOException e)
{
System.out.println("Error al recuperar la IP del proceso");
System.exit ( 0 );
}
byte [] enviarDatos = new byte[1024];
byte [] recibirDatos = new byte[1024];
enviarDatos = frase.getBytes();
DatagramPacket enviarPaquete = new DatagramPacket(enviarDatos,
enviarDatos.length, DireccionIP, port);
socketCliente.send(enviarPaquete);
DatagramPacket recibirPaquete = new DatagramPacket(recibirDatos,
recibirDatos.length);
socketCliente.receive(recibirPaquete);
String fraseModificada = new String(recibirPaquete.getData());
InetAddress direccion = (recibirPaquete.getAddress());
int puertoUsado = (recibirPaquete.getPort());
System.out.println("DEL SERVIDOR: " + fraseModificada);
System.out.println("La direccion IP es:"+ direccion);
System.out.println("El puerto es:"+ puertoUsado);
socketCliente.close();
}
}
Otro cdigo muy parecido a los anteriores, escucha por el puerto 5000, cuando un
cliente se conecta este enva un mensaje de confirmacin al cliente, luego el
cliente al enviar su primer mensaje, el servidor enva un segundo mensaje y se
cierra la conexin. Tambin el de un cliente, se puede observar cmo se pide la
conexin al servidor, el cliente nicamente enva un mensaje de texto pero no
recibe informacin.
2
Cdigo fuente del servidor
import java.net.*;
import java.io.*;
public class Conex {
final int PUERTO=5000;
ServerSocket sc;
Socket so;
DataOutputStream salida;
String mensajeRecibido;
//SERVIDOR
2
Tomado de http://codigoprogramacion.com/cursos/java/103-sockets-en-java-con-cliente-y-
servidor.html#.UlHkCNKmHLk
public void initServer()
{
BufferedReader entrada;
try
{
sc = new ServerSocket(PUERTO );/* crea socket servidor que escuchara en
puerto 5000*/
so=new Socket();
System.out.println("Esperando una conexin:");
so = sc.accept();
//Inicia el socket, ahora est esperando una conexin por parte del cliente
System.out.println("Un cliente se ha conectado.");
//Canales de entrada y salida de datos
entrada = new BufferedReader(new InputStreamReader(so.getInputStream()));
salida = new DataOutputStream(so.getOutputStream());
System.out.println("Confirmando conexion al cliente....");
salida.writeUTF("Conexin exitosa...n envia un mensaje <img
src="http://codigoprogramacion.com/wp-includes/images/smilies/icon_biggrin.gif"
alt=":D" class="wp-smiley"> ");
//Recepcion de mensaje
mensajeRecibido = entrada.readLine();
System.out.println(mensajeRecibido);
salida.writeUTF("Se recibio tu mensaje.n Terminando conexin...");
salida.writeUTF("Gracias por conectarte, adios!");
System.out.println("Cerrando conexin...");
sc.close();//Aqui se cierra la conexin con el cliente
}catch(Exception e )
{
System.out.println("Error: "+e.getMessage());
}
}
}
Cdigo fuente cliente simple
import java.net.*;
import java.io.*;
public class Conex {
final String HOST = "localhost";
final int PUERTO=5000;
Socket sc;
DataOutputStream mensaje;
DataInputStream entrada;
//Cliente
public void initClient() /*ejecuta este metodo para correr el cliente */
{
try
{
sc = new Socket( HOST , PUERTO ); /*conectar a un servidor en localhost con
puerto 5000*/
//creamos el flujo de datos por el que se enviara un mensaje
mensaje = new DataOutputStream(sc.getOutputStream());
//enviamos el mensaje
mensaje.writeUTF("hola que tal!!");
//cerramos la conexin
sc.close();
}catch(Exception e )
{
System.out.println("Error: "+e.getMessage());
}
}
}
Otra opcin a probar es la siguiente:
Servidor TCP. Cdigo JAVA
La aplicacin servidor TCP depende de una clase de comunicaciones
proporcionada por Java: ServerSocket. Esta clase realiza la mayor parte
del trabajo de crear un servidor. El servidor implementado escucha por
el puerto de comunicaciones 8001, y acepta rdenes del tipo HELP,
DATE, QUIT y NAME.
import java.util.*;
import java.io.*;
import java.net.*;
public class ServerTest {
final static int SERVER_PORT = 8001; // puerto de escucha de nuestro
servidor
public static void main (String args[]) {
Server server;
String clientRequest;
BufferedReader reader;
PrintWriter writer;
// se crea el servidor y los canales de entrada y salida
server = new Server (SERVER_PORT);
reader = new BufferedReader (new InputStreamReader (server.in));
writer = new PrintWriter (new OutputStreamWriter (server.out), true);
// En cuanto se establece una conexin por parte del cliente, se enva
un saludo
writer.println ("Bienvenido al Servidor: " + new Date() + "/n");
while (true) {
try {
// se lee el canal de entrada la peticin del cliente
clientRequest = reader.readLine();
// sale por pantalla la peticin del cliente
System.out.println ("Recibido :" + clientRequest);
// El protocolo de nuestro servidor solo acepta ordenes : HELP,
QUIT,NAME,DATE
if (clientRequest.startsWith ("HELP")) {
writer.println ("rdenes: HELP QUIT NAME DATE");
} else {
if (clientRequest.startsWith ("QUIT")) {
System.exit(0);
}
else {
if (clientRequest.startsWith("NAME"))
{InetAddress host;
host=InetAddress.getLocalHost();
writer.println("Nombre del host :"+ host.getHostName());}
else
if (clientRequest.startsWith("DATE"))
(writer.println("Fecha del sistema :"+ new Date()));
else {
writer.println ("ERROR: Comando :'" + clientRequest +"' no reconocido,
use HELP");
}
}
}
} catch (IOException e) {
System.out.println ("Excepcin en el servidor " + e);
System.exit(0);
}
}
}
}
//-------------------------------------------------------------------
// Esta clase es la que implementa el socket del servidor (ServerSocket)
class Server {
private ServerSocket server;
private Socket socket;
public InputStream in;
public OutputStream out;
public Server (int port) {
try {
server = new ServerSocket (port);
System.out.println ("Servidor Java Activo! \n");
System.out.println(""+server+"\n");
// Espera suspendido hasta que un cliente establece una conexin
socket = server.accept();
in = socket.getInputStream();
out = socket.getOutputStream();
} catch (IOException e) {
System.out.println ("Excepcin en el constructor server: " + e);
}
}
}
NOTA: Para poder ejecutar el servidor, siga las siguientes instrucciones:
Guardar el programa con el nombre:ServerTest.java.
Instale el jdk 1.3 o superior de Sun.
Compile el fichero mediante la utilidad javac, para ello escriba la siguiente
orden en la lnea de comandos : javac ServerTest.java
Por ltimo, lance la ejecucin del servidor mediante la orden: java
ServerTest
Puede comprobar el funcionamiento del servidor mediante el uso de un programa
cliente, o bien, mediante el uso de telnet. Para ello, ejecute telnet con la direccin
IP donde este ejecutndose el servidor, si est en el mismo ordenador, la IP es
127.0.0.1 y el puerto de comunicaciones es el 8001.
Cliente TCP. Cdigo JAVA
El lado cliente de una aplicacin TCP/IP descansa en la clase Socket. De
nuevo, mucho del trabajo necesario para establecer la conexin lo ha
realizado la clase Socket.
import java.io.*;
import java.net.*;
public class ClientTest {
public static void pausa(){
try {
Thread.sleep(3000);
} catch (Exception ignored) {}
}
public static void main (String args[]) {
String welcome, response;
Client client;
BufferedReader reader;
PrintWriter writer;
client = new Client (args[0], 8001); //la clase Client Implementa el
socket cliente al que se le pasa el argumento 0 que contendr la
direccin o nombre del servidor
try {
//creamos los canales de entrada/salida para comunicarnos con el
servidor
reader = new BufferedReader (new InputStreamReader (client.in));
writer = new PrintWriter (new OutputStreamWriter (client.out), true);
//leemos la bienvenida que nos da el servidor
welcome = reader.readLine();
pausa();
System.out.println ("Mensaje procedente del servidor: '"+ welcome
+"'");
//para ver el funcionamiento, enviamos los comandos
System.out.println ("Enviando comando NAME");
writer.println("NAME");
response = reader.readLine();
System.out.println ("Respuesta del servidor: '"+ response +"'");
//pausa
pausa();
System.out.println ("Enviando comando HELP");
writer.println ("HELP");
response = reader.readLine();
System.out.println ("Respuesta del servidor: '"+ response +"'");
pausa();
System.out.println ("Enviando comando DATE");
writer.println("DATE");
response = reader.readLine();
System.out.println ("Respuesta del servidor: '"+ response +"'");
pausa();
//el siguiente comando no es entendido por el protocolo implementado
por el servidor//como vemos en la respuesta que nos devuelve
System.out.println ("Enviando comando xl");
writer.println("xl");
response = reader.readLine();
System.out.println ("Respuesta del servidor: '"+ response +"'");
pausa();
System.out.println ("Enviando comando QUIT");
writer.println("QUIT");
} catch (IOException e) {
System.out.println ("IOException en client.in.readln()");
System.out.println(e);
}
try {
Thread.sleep(2000);
} catch (Exception ignored) {}
}
}
//-------------------------------------------------------------------
class Client {
// establece los canales de entrada y de salida a disposicion de las
clases de usuario
public InputStream in;
public OutputStream out;
// El socket cliente
private Socket client;
public Client (String host, int port) {
try {
client = new Socket (host, port);
System.out.println ("Datos del socket: " + client);
in = client.getInputStream();
out= client.getOutputStream();
} catch (IOException e) {
System.out.println("IOExc : " + e);
}
}
}
NOTA. Dilogo entre el cliente y el servidor.
En la ejecucin del cliente, deber pasarle como parmetro el nombre o direccin
del servidor. Ejemplo: Java Clientest localhost
En este ejemplo, el cliente establecer la comunicacin en el puerto 8001 y en el
ordenador local, ya que como parmetro se le ha pasado localhost.
Servidor UDP. Cdigo JAVA
La aplicacin servidor UDP depende de una clase de comunicaciones
proporcionada por Java: DatagramSocket Esta clase realiza la mayor
parte del trabajo de crear el socket. El servidor implementado escucha
por el puerto de comunicaciones 8050, cuando le llega un datagrama
procedente de algn cliente, imprime la direccin del cliente, y el puerto
por la salida estndar del sistema, y luego enva un datagrama que
contiene la fecha del sistema.
import java.net.*;
import java.io.*;
import java.util.*;
public class ServerTime{
public static void main(String[] args) throws IOException {
//el puerto de escucha del servidor ser el 8050
int PUERTO=8050;
byte msg[]=new byte[1024];
//se crea el socket UDP del servidor en el puerto asociado
DatagramSocket s = new DatagramSocket(PUERTO);
System.out.println("Servidor Activo");
//implementacin del protocolo del servidor en un bucle infinito
while (true) {
DatagramPacket recibido = new DatagramPacket(new byte
[1024],1024);
//llega un datagrama
s.receive(recibido);
System.out.println("Ha llegado una peticion \n");
System.out.println("Procedente de :" + recibido.getAddress());
System.out.println("En el puerto :" + recibido.getPort());
System.out.println("Sirviendo la peticin");
//se prepara el mensaje a enviar con la fecha del sistema
String message=new String("HORA DEL SERVIDOR " + new Date());
msg=message.getBytes();
//se crea el datagrama que contendr al mensaje
DatagramPacket
paquete=new DatagramPacket(msg,msg.length,recibido.getAddress(),
recibido.getPort());
//se le envia al cliente
s.send(paquete);
}
} }
NOTA: Para ejecutar el servidor, siga las siguientes instrucciones:
Guarde el programa con el nombre: ServerTime.java
Instale el jdk 1.3 o superior de Sun.
Compile el fichero mediante la utilidad javac, para ello escriba la siguiente
orden en la lnea de comandos : javac ServerTime.java
Lance la ejecucin del servidor mediante la orden: java ServerTime
Puede comprobar el funcionamiento del servidor mediante el uso del programa
client
Cliente UDP. Cdigo JAVA
El lado cliente de una aplicacin UDP descansa en la clase
DatagramSocket. De nuevo, mucho del trabajo necesario para
establecer la conexin lo ha realizado la clase DatagramSocket junto a
la clase DatagramPacket.
import java.net.*;
public class GetDate {
final static int PORT_DAYTIME = 8050;
// Puerto asignado para la comunicacin con el servidor
public static void main (String args[]) throws Exception {
DatagramSocket dgSocket;
DatagramPacket datagram;
InetAddress destination;
byte msg[] = new byte[1024];
// Se establece en socket bajo UDP
dgSocket = new DatagramSocket();
//se recoge el destino del servidor, que se le pasa como parmetro
destination = InetAddress.getByName (args[0]);
//se crea un DATAGRAMA, con el mensaje, la longitud, la direccin y el
puerto
datagram = new DatagramPacket (msg, msg.length, destination,
PORT_DAYTIME);
//se enva el datagrama
dgSocket.send(datagram);
datagram = new DatagramPacket (msg, msg.length);
//se espera que llegue respuesta desde el servidor
dgSocket.receive(datagram);
//ha llegado un datagrama, para ver los datos se utiliza getDAta()
String received = new String (datagram.getData());
System.out.println ("DATOS DEL DATAGRAMA: " + received );
//se cierra el socket UDP
dgSocket.close();
}
} // final de la clase cliente
El siguiente cdigo muestra un ejemplo de comunicacin bajo UDP, el cliente
conecta con el servidor en el puerto 8050, este servidor devolver la hora del
sistema en un datagrama.
En la ejecucin del cliente, deber pasarle como parmetro el nombre o direccin
del servidor. Ejemplo:
Java GetDate localhost
En este ejemplo, el cliente establecer la comunicacin en el puerto 8050 y
en el ordenador local, ya que como parmetro se le ha pasado localhost.