Enviar Archivos Sockets

[Unxky]

Hola !

Estoy haciendo un programa con Sockets en Java para el Envio de Archivos de un Cliente al Servidor. Y mi problema es como puedo Leer el archivo para detectar si es una imagen o un archivo. Por ejemplo el Cliente me envia una imagen y sus extensiones son : jpg, png, gif.

La solución completa para el hilo: aquí.

Y si es un archivo :

zip, pdf, rar etc.

El cliente solo me envia el archivo solo el archivo nada de parametros. El servidor solo es el que se encarga de almacenarlo y guardarlo en la Base de datos.

Lo que ya hize es recibir el archivo pero no he encontrado como leer el tipo de dato. Pongo una parte del codigo:

Socket client=null;
    File Ruta=null;
   

   while (true) {
                                  
                 if (server==null)
                     return;
               
                  try {
                        client=server.accept();                       
                            
                        System.out.println("Conexion recibida de "+ client.getInetAddress());
                        System.out.println("Llegó un cliente!");
                     }//Fin del Try
                        
                  catch(java.io.IOException e) {
                        System.err.println("No se pudo establecer conexión " + e.getMessage());
                     }//Fin del catch 

try {         
                   System.out.println("Se esta enviando la imagen...");
                               
                                           
               Ruta = new File("C:/LlegaFichero/");                              
                NombreDelArchivo="Nueva.jpg";     
                                                                                            
                                 java.io.InputStream in = client.getInputStream();
                         
                                                                                                                                                                          
                          
                          

                         
             //CREAMOS LA INSTANCIA PARA ESCRIBIR EL ARCHIVO EN DISCO
                       
                       
  java.io.FileOutputStream out = new java.io.FileOutputStream(new java.io.File(Ruta+"/"+NombreDelArchivo));

                          byte[] buf=new byte[52428800]; //50 MB
                          
                         int len;

                           while ((len = in.read(buf)) > 0) {
                                    out.write(buf, 0, len);
                               }//Fin del while ************************
                            
                            in.close();//Cliente
                            out.close();//Salida
                                                                              
                        System.out.println("Se envio exitosamente la Imagen...");
                        }//************ Fin del Try 
                     
                     catch(java.io.IOException e) {
                           System.out.println("Error: " + e);
                        }// Fin del Catch ***********************
     
     }//Fin del While True 

Como observan en NombreDelArchivo ya se lo estoy dando por default.

Y no encuentro la manera de antes de guardarlo leerlo antes y ver que tipo de archivo es.

Espero una respuesta...y saludos por leer completo el Post.

Saludos.!

[ggosparo]

Hola Unxky, la solucion mas rapida es realizar un split de la variable "NombreDelArchivo" y tomar la ultima posicion y verificar que extension tiene.
Por ejemplo:

  String NombreDelArchivo = "esto.es.una.prueba.txt";
  String tmp[] = NombreDelArchivo.split(".");
  // nos da como resultado
  // tmp[0] = "esto";
  // tmp[1] = "es";
  // tmp[2] = "una";
  // tmp[3] = "prueba";
  // tmp[4] = "txt"; 

El unico inconveniente es que el split de java no se puede realizar por puntos, asi que te paso unas lineas de codigo que utilizo yo.

/**
 * Metodo que realiza un split por cualquier tipo de caracteres.
 *
 * @param linea      Contiene la cadena de String que deseo separar.
 * @param caracteres Contiene los caracteres de separacion (pueden ser mas de uno)
 *
 * @return Retorna una lista.
 */
public List splitList (String linea, String caracteres) {
  // realiza un split total de la linea
  String cadena[] = linea.split ("");
  // genero una lista para retornar el resultado
  List resul = new ArrayList ();
  int nc = 0;
  String temp = "";
  boolean igual;
  // iteror los caracteres de la linea
  for (int i = 0; i < cadena.length; i++) {
    String aCadena = cadena[i];
    igual = true;
    // itero los caracteres por los cuales deseo hacer el split
    for (int j = 0; j < caracteres.length () && igual; j++) {
      if (!cadena[i + j].equals (String.valueOf (caracteres.charAt (j)))) {
     igual = false;
        }
    }
    // almaceno los resultados.
    if (igual) {
    resul.add (nc, temp);
    temp = "";
    nc += 1;
    i = i + getCaracter ().length () - 1;
    } else {
    temp += aCadena;
    }
 }
resul.add (nc, temp);
// retorna la lista
return resul;
} 

Espero que te ayude con tu problema.

Saludos...

[Unxky]

Hola ggosparo !

Gracias por tu respuesta y creeme que tambien me va servir. Pero la cuestion es que cuando el cliente me envia el archivo todavia no tengo el nombre y no encuentro la manera de como leerlo. Para asi ya poder usar tu funcion.

Yo por default le asigno un nombre para poder guardarlo para asi usarlo. Pero lo que quiero hacer es recibir el archivo del cliente que me lo envio y detectar que tipo de archivo es y es lo que no he podido hacer. Este es el codigo que tengo:

try {         
       System.out.println("Se esta recibiendo un Archivo...");
        
Ruta = new File("C:/LlegaFichero/"); 

//Aqui es donde debo de asiganar el Nombre del Archivo para poder detectar de que tipo es para despues guardarlo en el Servidor

NombreDelArchivo=Null; 

//************************************************** *

 java.io.InputStream in = client.getInputStream();
                         
  //CREAMOS LA INSTANCIA PARA ESCRIBIR EL ARCHIVO EN DISCO
                       
java.io.FileOutputStream out = new java.io.FileOutputStream(new java.io.File(Ruta+"/"+NombreDelArchivo));

 byte[] buf=new byte[52428800]; //50 MB
 int len;

   while ((len = in.read(buf)) > 0) {
        out.write(buf, 0, len);
      }//Fin del while ************************
   in.close();//Cliente
 out.close();//Salida
  System.out.println("Se Recibio Exitosamente el Archivo...");
}//************ Fin del Try 

Espero una respuesta y de nuevo gracias

 ggosparo 

...por tomarte tu tiempo en leer el mensaje...

Saludos.

[ggosparo]

Hola Unxky, no termino de entender el codigo, pero creo que la solucion puede ser alguna de las siguientes opciones.

-Si el cliente solo se conecta solo para subir un archivo, a la hora de presionar el boton de envio vos podes conocer el nombre del archivo ya que lo tiene que seleccionar de algun lado. Esta solucion tiene como contra que debes leer 2 veces el socket ya que en la primera obtenes el nombre del archivo y luego el archivo propiamente dicho.

-Otra solucion mas optima para esto es hacer un objeto serializable, en el cual vos recibirias todos los datos del cliente.
Aca te paso un ejemplo de como hacer esto.
http://www.chuidiang.com/java/sockets/socket.php

Espero que te sirva, y para poder ayudarte un poco mas necesitaria conocer al mas del codigo del cliente, ya que creo que la solucion pasa por ahi y no por el servidor.

Saludos...

[Unxky]

Holaaaa Mira aqui te pongo el Archivo del Servidor ...

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

//**************************************

public class Servidor implements Runnable {

ServerSocket server;
static String NombreDelArchivo = new String();
static String mens=new String(""); 

public Servidor() {

try {

      server=new ServerSocket(16000);
      System.out.println("Servidor corriendo...");
    }//Fin del Try

     catch(Exception e) {
           System.out.println("Error al correr el servidor\n"+e);
           System.exit(1);       
       }//fin del Catch
       
}//*** Fin del Servfidor

//*********************************************

public void run() {

Socket client=null;
      File Ruta=null;
   
 while (true) {
                                  
  if (server==null)
     return;
    try {
           client=server.accept();                       
                            
       System.out.println("Conexion recibida de "+ client.getInetAddress());
       System.out.println("Llegó un cliente!");
    }//Fin del Try
 catch(java.io.IOException e) {
      System.err.println("No se pudo establecer conexión " + e.getMessage());
    }//Fin del catch
                  //***********************************************
    try {         
           System.out.println("Se esta Recibiendo un Archivo...");
           Ruta = new File("C:/LlegaFichero/");
                             
//********  Aqui es donde debo de darle el Nombre a la Variable //********  NombreDelArchivo en por default yo le doy uno pero debe ser //********   el nombre que me esta llegando del cliente
        
NombreDelArchivo="Nueva.jpg";     

//****************************************************                                                                                            
              java.io.InputStream in = client.getInputStream();

java.io.FileOutputStream out = new java.io.FileOutputStream(new java.io.File(Ruta+"/"+NombreDelArchivo));

                          byte[] buf=new byte[52428800]; //50 MB
                          
                         int len;

                           while ((len = in.read(buf)) > 0) {
                                    out.write(buf, 0, len);
                               }//Fin del while ************************
                            
                            in.close();//Cliente
                            out.close();//Salida
                                                                              
                        System.out.println("Se envio exitosamente la Imagen...");
                        }//************ Fin del Try 
                     
                     catch(java.io.IOException e) {
                           System.out.println("Error: " + e);
                        }// Fin del Catch ***********************
     
     }//Fin del While True
     
}//**************************
//******* R U N *************

   public static void main(String a[]) {

          Servidor servidor = new Servidor();
          // Ponemos a correr nuestro hilo servidor
          new Thread(servidor).start();
    }//*********************************
    //*************

}//******************** implements Runnable
//******************************************** 

Y esta es la parte del Cliente ....

import java.net.Socket;
import java.io.InputStreamReader;

public class Cliente {
    
private String ip = "127.0.0.1";
private int puerto = 16000;
private String nomArchivo = "C:/TomaFichero/1.jpg";

public Cliente(){
    
Socket socket = null;

java.io.FileInputStream in = null;
java.io.FileOutputStream pt = null;

try  {
       socket = new Socket(ip,puerto);
           pt = (java.io.FileOutputStream)socket.getOutputStream() ;//
           in = new java.io.FileInputStream(new java.io.File(nomArchivo));

    }//Fin del Try *************** 
      catch(Exception e) {
              System.out.println("No se pudo crear la conexión\n"+e);
     }//Fin del Catch *********
     
try {
       socket.sendUrgentData(100);
       byte[] buf = new byte[1024];
       int len;
          
          while ((len = in.read(buf)) > 0 ){
                   pt.write(buf, 0, len);
           }//Fin del while
        
        pt.close();
        in.close();
        socket.close();
      
      }///********** fin del Try 
      
     catch(Exception e) {
       
            System.out.println("Error al enviar mensaje\n"+e);
       
       }//***Fin del Catch
  }//Fin del Cliente

//***********************************************************  
public static void main(String a[]) {
     new Cliente();
   }///Fin del void Main
}//************************ Fin del Clase Cliente 

Como veras el Cliente su Objetivo solo es enviar el Archivo. Solo eso el servidor se encarga de recibirlo y guardarlo. Pero antes debe de verificar que tipo de archivo es para asi guardarlo.

Saludos y de nuevo gracias por la molestia de contestar...

[ggosparo]

Hola Unxky, ahora te entendi y te paso la clase servidor y cliente, tene en cuenta que para esto si o si vas a tener que pasar el nombre del archivo y el path
El codigo del cliente.

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;

public class Cliente {
    private String ip = "127.0.0.1";
    private int puerto = 16000;
//    private String nomArchivo = "C:/Resultados.txt";

    public Cliente (String nomArchivo) {
        Socket socket = null;
        FileInputStream in = null;
        FileOutputStream pt = null;
        // creo esta variable para poder mandar objetos basicos de java (como ser un String)
        ObjectOutputStream ous = null;
        try {
            socket = new Socket (ip, puerto);
            pt = (FileOutputStream) socket.getOutputStream ();//
            in = new FileInputStream (new File (nomArchivo));
            // le seteo el outputStream del socket
            ous = new ObjectOutputStream (socket.getOutputStream ());
        }//Fin del Try ***************
        catch (Exception e) {
            e.printStackTrace ();
            System.out.println ("No se pudo crear la conexión\n" + e);
        }//Fin del Catch *********
        try {
            socket.sendUrgentData (100);
            // envio el nombre del archivo. Le concateno al final 'ext' para verificar que se esta pasando el archivo(sino le agrego esto el
            //  nombre de origen y destino son el mismo), vos lo tenes que sacar
            ous.writeUTF (nomArchivo + "ext");
            // envio los datos de forma urgente.
            ous.flush ();
            // ahora se continua con el envio del archivo.
            byte[] buf = new byte[1024];
            int len;
            while ((len = in.read (buf)) > 0) {
                pt.write (buf, 0, len);
            }//Fin del while
            pt.close ();
            in.close ();
            socket.close ();
        }///********** fin del Try
        catch (Exception e) {
            e.printStackTrace ();
            System.out.println ("Error al enviar mensaje\n" + e);

        }//***Fin del Catch
    }//Fin del Cliente

    //***********************************************************
    public static void main (String args[]) {
        // suponemos que el nombre del archivo te lo pasa como un parametro a la hora de ejecutar el programa java
        // para ejecutar escribimos: java <paquetesDondeEstaLaClase>.nomreClase <pathDeLaImagen>
        // por ejemplo: <paquetesDondeEstaLaClase> =  test.programa
        //              <pathDeLaImagen> = C:/Archivo.jpg 
        // si lo hacemos asi en args[0] = <pathDeLaImagen>
        new Cliente (args[0]);
    }///Fin del void Main
}//************************ Fin del Clase Cliente 

Codigo del servidor

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;
//**************************************

public class Servidor implements Runnable {
    ServerSocket server;
    static String NombreDelArchivo = new String ();
    static String mens = new String ("");

    public Servidor () {
        try {
            server = new ServerSocket (16000);
            System.out.println ("Servidor corriendo...");
        }//Fin del Try
        catch (Exception e) {
            System.out.println ("Error al correr el servidor\n" + e);
            System.exit (1);
        }//fin del Catch

    }//*** Fin del Servfidor
//*********************************************

    public void run () {
        Socket client = null;
        File Ruta;
        // genero la variable para leer objetos serializables de java
        ObjectInputStream ois;
        while (true) {
            if (server == null)
                return;
            try {
                client = server.accept ();
                System.out.println ("Conexion recibida de " + client.getInetAddress ());
                System.out.println ("Llegó un cliente!");
            }//Fin del Try
            catch (java.io.IOException e) {
                e.printStackTrace ();
                System.err.println ("No se pudo establecer conexión " + e.getMessage ());
            }//Fin del catch
            //***********************************************
            try {
                System.out.println ("Se esta Recibiendo un Archivo...");
//                Ruta = new File ("C:");
//  Aqui es donde debo de darle el Nombre a la Variable
// NombreDelArchivo en por default yo le doy uno pero debe ser
// el nombre que me esta llegando del cliente
//                NombreDelArchivo = "Resultado.txt";
//
                assert client != null;
                InputStream in = client.getInputStream ();
                // le asigno el inputStrem
                ois = new ObjectInputStream (client.getInputStream ());
                // leo el path del arhivo junto al nombre (ahora debes usar la funcion split que te pase con anterioridad)
                NombreDelArchivo = ois.readUTF ();
                System.out.println ("path del archivo: " + NombreDelArchivo);
                // comienzo con la lectura del archivo
                FileOutputStream out = new FileOutputStream (new File (NombreDelArchivo));
//                FileOutputStream out = new FileOutputStream (new File (Ruta + "/" + NombreDelArchivo));
                byte[] buf = new byte[52428800]; //50 MB
                int len;
                while ((len = in.read (buf)) > 0) {
                    out.write (buf, 0, len);
                }//Fin del while ************************
                in.close ();//Cliente
                out.close ();//Salida
                System.out.println ("Se envio exitosamente la Imagen...");
            }//************ Fin del Try
            catch (java.io.IOException e) {
                e.printStackTrace ();
                System.out.println ("Error: " + e);
            }// Fin del Catch ***********************

        }//Fin del While True

    }//**************************
//******* R U N *************

    public static void main (String a[]) {
        Servidor servidor = new Servidor ();
        // Ponemos a correr nuestro hilo servidor
        new Thread (servidor).start ();
    }//*********************************
    //*************

}//******************** implements Runnable
//******************************************** 

Fijate los cambios que le hice y cualquier cosa consultame.

Saludos...

[Unxky]

Holaaaaaa ggosparo !


Gracias por tu respuesta muy rapida y tomarte la Molestia de Leer el Post.

Pues Mira, esta forma que escribiste ya la tenia donde yo le enviaba los parametros del cliente al Servidor...en este caso el Nombre.

Pero lo que yo busco es que solo me llege el archivo y en el servidor porder detectar el nombre, asi como el tipo d archivo que me esta enviando.

Espero una respuesta y saludos.

Gracias.

[ggosparo]

Hola Unxky, la verdad que lo que vos queres hacer es mucho mas complicado de lo que vos pensas.

Aca hay que dejar algo en claro, el 'cliente' lee bytes de un archivo y los envia a travez de un socket (solo
el cliente conoce el nombre del archivo), el 'servidor' solo lee bytes que se estan escribiendo en el socket.
Lo que intento decir es que el servidor nunca va a conocer el nombre del archivo y mucho menos el path
ya que solo recibe bytes. Esto se ve mucho mejor cuando tienes 2 PC's una como cliente y otra como servidor.

Lo que vos podes hacer es que el usuario cliente siempre guarde los archivos en un mismo directorio (vos lo pones
por defecto Ej. 'c:/envioArchivoServidor'), luego el cliente java lee ese directorio y envia al servidor
la lista con todos los archivos que se encuentran en el.
El servidor tiene una lista de los archivos que transmite cada cliente, y por lo tanto puede realizar una
comparacion entre los archivos que transmitio con anterioridad y los actuales (con esto podes saber cual
es el nuevo archivo que se desea enviar).
En caso de que la carpeta 'c:/envioArchivoServidor' siempre contenga un solo archivo, no va a haber problemas.

La desventaja de esto es que el 'servidor' va a tener que tener una lista de los archivos enviados, la
cual debera tener la ip del cliente, el nombre del archivo y una marca de tiempo para que se puedan
reenviar archivos.

Espero haber sido claro, cualquier cosa volve a consultar.

Saludos...

[Unxky]

Gracias....

Tienes razon ya estueve viendo y forsozamente debe se enviarse del cliente mas informacion acerca del Archivo. Por la tanto lo tendre que hacer de esa Manera...

Gracias...y estamos en contacto...

Saludos.!

[ziniestro]

Hola Unxky, si estas conforme con las respuestas de un usuario puedes apretar el boton que dice "gracias" al final de cada post.

Muchas gracias por participar de la comunidad.