PDF de programación - Ejemplos programación socket - Java

EJEMPLOS PROGRAMACIÓN SOCKET - JAVA


1.- Calcular el Cuadrado –TCP


En esta aplicación el cliente se conecta al servidor, para ello debe introducir la
dirección IP del servidor y los parámetros sobre los cuales el servidor debe hacer las
operaciones. Una vez conectado con el servidor este toma los parámetros y calcula su
cuadrado y lo imprime por pantalla. Posteriormente envía los resultados al cliente, el
cual también los imprime por pantalla.


En esta aplicación la conexión se realiza mediante conexión TCP, lo que permite
al cliente y al servidor disponer de un stream que facilita una comunicación libre de
errores.


El comportamiento para usar este tipo de socket es diferente en el cliente y el
servidor. Cada uno de ellos utilizará unos métodos distintos. El esquema básico pasa por
suponer que el servidor adoptará un papel pasivo y procederá a esperar conexiones de
los posibles clientes. Mientras que los clientes serán los encargados de solicitar
conexiones a los servidores de forma activa.

Código de ClienteTCP.java


En primer lugar se determina la dirección IP del host a partir de un string

representando su dirección IP.


Creamos el socket, extraemos los flujos de entrada y salida, los escribimos y

leemos el resultado final devuelto por el servidor, y lo imprimimos en pantalla.


Finalmente cerramos los flujos y el socket.


//ClienteTCP.java

import java.io.*;
import java.net.*;

class ClienteTCP
{



public static void main(String args[])
{



// Leemos el primer parámetro, donde debe ir la dirección
// IP del servidor
InetAddress direcc = null;
try
{

}
catch(UnknownHostException uhe)
{


}
// Puerto que hemos usado para el servidor
int puerto = 1234;

System.err.println("Host no encontrado : " + uhe);
System.exit(-1);

direcc = InetAddress.getByName(args[0]);





}

// Para cada uno de los argumentos...
for (int n=1;n<args.length;n++)
{



}



Socket sckt = null;

DataInputStream dis = null;

DataOutputStream dos = null;

try

{

// Convertimos el texto en número


int numero = Integer.parseInt(args[n]);


// Creamos el Socket


sckt = new Socket(direcc,puerto);


// Extraemos los streams de entrada y salida


dis = new

DataInputStream(sckt.getInputStream());
dos = new


DataOutputStream(sckt.getOutputStream());

// Lo escribimos


dos.writeInt(numero);

// Leemos el resultado final


long resultado = dis.readLong();



// Indicamos en pantalla


System.out.println( "Solicitud = " + numero +

"\tResultado = " +resultado );
// y cerramos los streams y el socket



dis.close();


dos.close();


}
catch(Exception e)


{


excepción : " +e);
}

try


{



}
catch(IOException ioe)


{


" + ioe);

}


}

Código de ServidorTCP.java

Primero se obtiene la dirección IP del servidor, abrimos un socket del servidor TCP en
el puerto 1234, esperamos a que alguien se conecte a nuestro socket, una vez conectado
el cliente extraemos los flujos de entrada y salida a través del puerto remoto y
realizamos la operación del cuadrado y enviaremos el resultado al cliente. Luego se
escribe ese resultado en la pantalla de servidor y se cierran los flujos.



System.err.println("Se ha producido la

if (sckt!=null) sckt.close();

System.err.println("Error al cerrar el socket :

System.out.println("LocalHost = " +

System.err.println("No puedo saber la dirección IP

ss = new ServerSocket(1234);

//ServidorTCP.java

import java.io.*;
import java.net.*;

class ServidorTCP
{
public static void main(String args[])

{



InetAddress.getLocalHost().toString());



local : " + uhe);



servidor : " + ioe);



Socket



DataOutputStream(sckt.getOutputStream());



// Primero indicamos la dirección IP local
try
{

}
catch (UnknownHostException uhe)
{

}
// Abrimos un "Socket de Servidor" TCP en el puerto 1234.
ServerSocket ss = null;
try
{

}
catch (IOException ioe)
{


}
int entrada;
long salida;
// Bucle infinito
while(true)
{



System.err.println("Error al abrir el socket de
System.exit(-1);

try
{



// Esperamos a que alguien se conecte a nuestro
Socket sckt = ss.accept();
// Extraemos los Streams de entrada y de salida
DataInputStream dis = new
DataInputStream(sckt.getInputStream());
DataOutputStream dos = new
// Podemos extraer información del socket
// Nº de puerto remoto
int puerto = sckt.getPort();
// Dirección de Internet remota
InetAddress direcc = sckt.getInetAddress();
// Leemos datos de la peticion
entrada = dis.readInt();
// Calculamos resultado
salida = (long)entrada*(long)entrada;
// Escribimos el resultado
dos.writeLong(salida);
// Cerramos los streams
dis.close();
dos.close();

sckt.close();
// Registramos en salida estandard
System.out.println( "Cliente = " + direcc + ":"
+ "\tEntrada = " + entrada + "\tSalida = " +

System.err.println("Se ha producido la



}



}



+ puerto


salida );
}

catch(Exception e)

{



excepción : " +e);

}


}



2.- Calcular el Cuadrado –UDP


En esta aplicación el cliente envía un paquete al servidor, para ello debe
introducir la dirección IP del servidor y los parámetros sobre los cuales el servidor debe
hacer las operaciones. Una vez enviado el paquete al servidor este toma los parámetros
y calcula su cuadrado y lo imprime por pantalla. Posteriormente el servidor envía un
paquete con los resultados al cliente con la dirección IP y el puerto del cliente obtenidos
anteriormente, el cual también los imprime por pantalla.


En este caso se trata de un mecanismo más simple, puesto que el servicio sin
conexión tan sólo nos ofrece un mero envío de datos. Puesto que no existe aquí la
conexión no hay proceso previo alguno antes de enviar información. Para poder
comunicar con otro proceso lo único que hay que hacer es crear el socket y utilizar sus
métodos para el envío y recepción de información.


Código de clienteUDP.java


En primer lugar se determina la dirección IP del host a partir de un string

representando su dirección IP.


Se construye un socket para datagramas y lo “conecta” al primer puerto

disponible.


Creamos un paquete con los datos y lo enviamos al servidor, preparemos un
buffer para recibir los datos enviados por el servidor, creamos el contenedor del paquete
y lo recibimos, creamos un stream de lectura a partir del buffer, leemos el resultado
final y lo imprimimos en pantalla.



direcc = InetAddress.getByName(args[0]);

System.err.println("Host no encontrado : " + uhe);
System.exit(-1);

ds = new DatagramSocket();

//clienteUDP.java

import java.net.*;
import java.io.*;

class clienteUDP
{
public static void main(String args[])

{



se);



ByteArrayOutputStream();


DataOutputStream(baos);



DatagramPacket(baos.toByteArray(),4,direcc,puerto);



bytes



// Leemos el primer parámetro, donde debe ir la dirección
// IP del servidor
InetAddress direcc = null;
try
{

}
catch(UnknownHostException uhe)
{


}
// Puerto que hemos usado para el servidor
int puerto = 1234;
// Creamos el Socket
DatagramSocket ds = null;
try
{

}
catch(SocketException se)
{


}
// Para cada uno de los argumentos...
for (int n=1;n<args.length;n++)
{



System.err.println("Error al abrir el socket : " +
System.exit(-1);

try
{



//creamos un buffer para escribir
ByteArrayOutputStream baos = new
DataOutputStream dos = new
// Convertimos el texto en número
int numero = Integer.parseInt(args[n]);
// Lo escribimos
dos.writeInt(numero);
// y cerramos el buffer
dos.close();
// Creamos paquete
DatagramPacket dp = new
// y lo mandamos
ds.send(dp);
// Preparamos buffer para recibir número de 8
byte bufferEntrada[] = new byte[8];
// Creamos el contenedor del paquete
dp = new DatagramPacket(bufferEntrada,8);

// y lo recibimos
ds.receive(dp);
// Creamos un stream de lectura a partir del
ByteArrayInputStream bais = new
DataInputStream dis = new
// Leemos el resultado final
long resultado = dis.readLong();
// Indicamos en pantalla
System.out.println( "Solicitud = " + numero +

System.err.println("Se ha producido un error :



}



}
catch (Exception e)
{

}



buffer


ByteArrayInputStream(bufferEntrada);


DataInputStream(bais);



"\tResultado = " +resultado );



" + e);



}
}

Código de servidorUDP.java



Primero se obtiene la dirección IP del servidor, abrimos un socket UDP en el
puerto 1234, a través de este socket enviaremos los datagramas, crearemos un
contenedor de datagrama, cuyo buffer será un array, esperamos a recibir un paquete,
extraemos la información del paquete recibido por parte de algún cliente, obtenemos el
puerto y la dirección IP del cliente desde donde se envió el paquete, obtenemos el
resultado y generamos un paquete con dicho res