 |
|
Envio de archivos con sockets
Introduccion.
Los sockets son puntos finales de enlaces de comunicaciones entre procesos. Los procesos los tratan como descriptores de ficheros, de forma que se pueden intercambiar datos con otros procesos transmitiendo y recibiendo a través de sockets.
El tipo de sockets
describe la forma en la que se transfiere información a través
de ese socket.
Manos a la Obra.
Para realizar el envio de un archivo se debe de resolver el problema utilizando una arquitectura cliente-servidor.
En este caso la función del servidor es la de realizar la recepción del archivo y la función del cliente es la de enviar el archivo.
Así que primero realizaremos el cliente, las funciones que realizará el cliente son las siguientes:
- Envio del nombre del archivo
- Envio del tamaño del archivo
- Envio del archivo por flujo de bytes
Codigo fuente para el envio del archivo:
import java.net.*; import java.io.*;
class EnviarArchivo
{
private String nombreArchivo = "";
public EnviarArchivo( String nombreArchivo )
{
this.nombreArchivo = nombreArchivo;
}
public void enviarArchivo( )
{
try
{
// Creamos la direccion IP de la maquina que recibira el archivo
InetAddress direccion = InetAddress.getByName( "192.168.1.12" );
// Creamos el Socket con la direccion y elpuerto de comunicacion
Socket socket = new Socket( direccion, 4400 );
socket.setSoTimeout( 2000 );
socket.setKeepAlive( true );
// Creamos el archivo que vamos a enviar
File archivo = new File( nombreArchivo );
// Obtenemos el tamaño del archivo
int tamañoArchivo = ( int )archivo.length();
// Creamos el flujo de salida, este tipo de flujo nos permite
// hacer la escritura de diferentes tipos de datos tales como
// Strings, boolean, caracteres y la familia de enteros, etc.
DataOutputStream dos = new DataOutputStream( socket.getOutputStream() );
System.out.println( "Enviando Archivo: "+archivo.getName() );
// Enviamos el nombre del archivo
dos.writeUTF( archivo.getName() );
// Enviamos el tamaño del archivo
dos.writeInt( tamañoArchivo );
// Creamos flujo de entrada para realizar la lectura del archivo en bytes
FileInputStream fis = new FileInputStream( nombreArchivo );
BufferedInputStream bis = new BufferedInputStream( fis );
// Creamos el flujo de salida para enviar los datos del archivo en bytes
BufferedOutputStream bos = new BufferedOutputStream( socket.getOutputStream() );
// Creamos un array de tipo byte con el tamaño del archivo
byte[] buffer = new byte[ tamañoArchivo ];
// Leemos el archivo y lo introducimos en el array de bytes
bis.read( buffer );
// Realizamos el envio de los bytes que conforman el archivo
for( int i = 0; i < buffer.length; i++ )
{
bos.write( buffer[ i ] );
}
System.out.println( "Archivo Enviado: "+archivo.getName() );
// Cerramos socket y flujos
bis.close();
bos.close();
socket.close();
}
catch( Exception e )
{
System.out.println( e.toString() );
}
}
// Lanzamos nuestro cliente para realizar el envio del archivo calc.exe
// ubicado en C:\Windows\calc.exe
public static void main( String args[] )
{
EnviarArchivo ea = new EnviarArchivo( "C:\\WINDOWS\\calc.exe" );
ea.enviarArchivo();
}
}
Lo siguiente que hay que construir es el servidor que realizara la recepción del archivo
Las funciones que realiza son:
- Recepción del nombre del archivo
- Recepción del tamaño del archivo
- Recepción
de bytes para construir archivo
import java.net.*; import java.io.*; import java.util.*; class RecibirArchivo { private ServerSocket servidor = null; public RecibirArchivo( ) throws IOException { // Creamos socket servidor escuchando en el mismo puerto donde se comunica el cliente // en este caso el puerto es el 4400 servidor = new ServerSocket( 4400 ); System.out.println( "Esperando recepcion de archivos..." ); } public void iniciarServidor() { while( true ) { try { // Creamos el socket que atendera el servidor Socket cliente = servidor.accept(); // Creamos flujo de entrada para leer los datos que envia el cliente DataInputStream dis = new DataInputStream( cliente.getInputStream() ); // Obtenemos el nombre del archivo String nombreArchivo = dis.readUTF().toString(); // Obtenemos el tamaño del archivo int tam = dis.readInt(); System.out.println( "Recibiendo archivo "+nombreArchivo ); // Creamos flujo de salida, este flujo nos sirve para // indicar donde guardaremos el archivo FileOutputStream fos = new FileOutputStream( "C:\\"+nombreArchivo ); BufferedOutputStream out = new BufferedOutputStream( fos ); BufferedInputStream in = new BufferedInputStream( cliente.getInputStream() ); // Creamos el array de bytes para leer los datos del archivo byte[] buffer = new byte[ tam ]; // Obtenemos el archivo mediante la lectura de bytes enviados for( int i = 0; i < buffer.length; i++ ) { buffer[ i ] = ( byte )in.read( ); } // Escribimos el archivo out.write( buffer ); // Cerramos flujos out.flush(); in.close(); out.close(); cliente.close(); System.out.println( "Archivo Recibido "+nombreArchivo ); } catch( Exception e ) { System.out.println( "Recibir: "+e.toString() ); } } } // Lanzamos el servidor para la recepción de archivos public static void main( String args[] ) throws IOException { new RecibirArchivo().iniciarServidor(); } }
Aqui solo lo muestro para que funcione en modo consola, ahora que si lo quieren grafico pueden hacer un arbol con la representación del sistema de archivos, a continuación les presento como me quedo a mi.
Y asi realizamos el envio y recepción de archivos utilizando sockets, el programa se probo con archivos que van desde los 2 bytes hasta archivos de 100 MB, cualquier duda o aclaración enviar un correo.
Espero y les sirva este pequeño pero practico ejemplo.
Saludos...
P.D. El codigo de la parte grafica lo pueden solicitar a mi correo...
e-mail: mgrappin arroba gmail punto com