Cargador de archivos Java simple sin dependencias

Publicado: 2023-01-06

Uno de los requisitos fundamentales de las aplicaciones web y los sitios web contemporáneos es la capacidad de cargar archivos, como documentos, fotos y videos. Por ejemplo, los usuarios pueden publicar videos e imágenes en plataformas de redes sociales como Instagram.

Antes, implementar y administrar el procedimiento de carga de archivos era una tarea difícil. Afortunadamente, la carga de archivos se ha simplificado como resultado de los avances en la tecnología en línea. Por ejemplo, un cargador de archivos Java hace que la carga de archivos sea rápida y conveniente.

Sin embargo, a través de la carga de archivos, los ciberdelincuentes pueden introducir malware u otro contenido dañino en su máquina y corromper el servidor. Por lo tanto, los desarrolladores deben asegurarse absolutamente de que la carga de archivos en su sitio web o aplicación web sea segura. Para establecer la carga segura de archivos, le recomendamos que utilice un SDK confiable de carga de archivos Java.

Veremos cómo usar Java para crear un cargador de archivos en este artículo.

¿Cómo implementar un cargador de archivos usando Java?

Un cargador de archivos no es más que un "envío" en el que los usuarios pueden hacer clic para cargar un archivo en una aplicación web o sitio web. Sin embargo, un cargador de archivos significa mucho más para los desarrolladores.

Podemos crear un cargador de archivos simple en el que solo usemos un formulario HTML y un servlet. En nuestro ejemplo, el formulario HTML tendrá dos campos de entrada. Un campo de entrada le permite al usuario cargar su archivo y el segundo campo de entrada le permite al desarrollador decirnos dónde debemos almacenar el archivo.

Estamos demandando el método POST para enviar los datos del formulario, incluido el archivo, al servidor. Además, cuando subimos archivos, usamos encrypt=”multipart/form-data” porque los archivos contienen muchos caracteres no imprimibles.

El servlet administra la solicitud POST y extrae el archivo de la secuencia después de procesar los datos del archivo entrante. El destino especifica la ubicación en el sistema donde se debe guardar el archivo. Cuando presionamos el botón Cargar, los datos se transmiten al servlet, que luego almacena el archivo en la ubicación designada.

Crear un archivo HTML con el campo de entrada

Antes de comenzar, cree un archivo index.html para seguirlo.

El index.html debe tener el siguiente código:

<!DOCTYPEhtml>
 <html lang=”es”>
 <cabeza>
 <title>Cargador de archivos Java</title>
 <meta http-equiv=”Content-Type” content=”text/html; juego de caracteres=UTF-8″>
 </cabeza>
 <cuerpo>
 <form method=”POST” action=”upload” enctype=”multipart/form-data” >
 Archivo:
 <input type=”file” name=”java-file” id=”java-file” /> <br/>
 Destino:
 <input type=”text” value=”/java-folder” name=”destino”/>
 </br>
 <tipo de entrada = "enviar" valor = "Enviar" nombre = "enviar" id = "enviar" />
 </formulario>
 </cuerpo>
 </html>

Así es como debería ser tu página:

Manejo del procesamiento del archivo en el lado del servidor

Para escribir el código del servlet, crearemos un archivo llamado FileUploadServlet.java. Los serlets utilizan anotaciones para definir componentes y metadatos. Entonces, la anotación @WebServlet se usa para definir un componente de servlet en Java.

La anotación de servlet debe decir qué HttpServlet debe ejecutarse para qué URL. Para eso, estamos definiendo los parámetros name y ulrPattern en nuestra anotación @WebServlet. Tenga en cuenta que, cuando enviemos nuestro formulario, lo redireccionaremos a la url /upload donde se ejecutará la clase FileUploadServlet.

La anotación @MultipartConfig informa al servlet que va a recibir datos de varias partes/formularios en tipo MIME.

Escribamos nuestro código completo ahora.

@WebServlet(nombre = “FileUploadServlet” , urlPatterns = { “/upload” })
 @MultipartConfig
 clase pública FileUploadServlet extiende HttpServlet {

 Registrador estático final privado LOGGER =
 Logger.getLogger(FileUploadServlet.class.getCanonicalName());

 solicitud de proceso vacía protegida (solicitud HttpServletRequest,
 respuesta HttpServletResponse)
 lanza ServletException, IOException {
 respuesta.setContentType( “text/html;charset=UTF-8” );

 final String dest= request.getParameter( “destino” );
 parte final parte = solicitud.getPart( “archivo” );
 final String nombreDeArchivo = getFileName(parte);

 OutputStream fuera = nulo ;
 InputStream cont = nulo ;
 final PrintWriter printWriter = respuesta.getWriter();

 prueba {
 out = new FileOutputStream( new File(dest + File.separator
 + nombreDeArchivo));
 cont = part.getInputStream();

 lector int = 0 ;
 byte final[] bytes = byte nuevo [ 1024 ];

 while ((lector = cont.read(bytes)) != -1 ) {
 out.write(bytes, 0 , lector);
 }
 printWriter.println( “Archivo “ + nombreDeArchivo + ” creado en “ + destino);
 LOGGER.log(Level.INFO, “Archivo{0} subido a {1}” ,
 nuevo Objeto[]{nombreDeArchivo, destino});
 } captura (FileNotFoundException fne) {
 printWriter.println( "No mencionó un nombre de archivo o es"
 + “intentando subir un archivo a un inexistente”
 + “ubicación”. );
 printWriter.println( “<br/> ERROR: “ + fne.getMessage());

 LOGGER.log(Level.SEVERE, “Error al cargar el archivo. Error: {0}” ,
 nuevo Objeto[]{fne.getMessage()});
 } finalmente {
 si (fuera! = nulo ) {
 fuera.cerrar();
 }
 si (continuación! = nulo ) {
 cont.cerrar();
 }
 if (printWriter != null ) {
 imprimirEscritor.close();
 }
 }
 }

 cadena privada getFileName (parte de la parte final) {
 final String partHeader = part.getHeader( “disposición-contenido” );
 LOGGER.log(Level.INFO, “Part Header = {0}” , partHeader);
 for (String content: part.getHeader( “disposición-contenido” ).split( “;” )) {
 if (contenido.trim().startsWith( “nombre de archivo” )) {
 devolver contenido.subcadena(
 content.indexOf( '=' ) + 1 ).trim().replace( “\”” , “” );
 }
 }
 devolver nulo ;
 }
 }

El método processRequest invoca el método getFileName para obtener el nombre del archivo de la parte del archivo después de recuperar el destino y la parte del archivo de la solicitud. A continuación, el método crea un FileOutputStream y transfiere el archivo a la ubicación deseada. La parte de manejo de errores del método detecta y aborda algunas de las causas más frecuentes de errores de archivos no encontrados.

Implementar el código

Ahora tenemos que construir y ejecutar nuestro programa. Para eso, puede usar cualquiera de sus IDE preferidos, como NetBeans, Eclipse, Intellij Idea, etc. Una vez que haya hecho eso, vaya a la parte

https://cdn.pixabay.com/photo/2016/11/30/20/58/programming-1873854__340.png

Si está utilizando NetBeans, abra Netbeans IDE y navegue hasta el directorio de trabajo. Consulte la documentación oficial de Java si tiene problemas. Haga clic con el botón derecho en su carpeta en la pestaña Proyectos y seleccione Implementar. A continuación, podemos acceder al navegador y escribir la siguiente URL:

http://localhost:8080/{nombre de carpeta}/

La página HTML creada anteriormente se abrirá después de ingresar la URL y presionar la tecla Intro. Para subir un archivo a la ubicación deseada, podemos buscar en el sistema y elegir el archivo. Escribimos la ruta a la carpeta en la que queremos almacenar el Archivo en el área de destino. El directorio debe tener permisos de escritura y ya existir en el sistema. Cuando hacemos clic en el botón de carga con el campo de destino vacío, se genera una excepción.

El servlet recibe una solicitud POST cuando hacemos clic en el botón de carga y copia el archivo seleccionado en la carpeta especificada.

Podemos visitar la carpeta designada y verificar si el archivo cargado (por ejemplo, TextFile.txt) está allí después de hacer clic en el botón de carga.

Hasta ahora, creamos un cargador de archivos Java simple usando HTML y Java. Sin embargo, a medida que el "simple" se convierte en un cargador complejo con muchas funciones, puede ser difícil hacer un seguimiento de las funciones importantes de las que no lo son. Sin mencionar que existen varios problemas de seguridad cuando consideramos construir un cargador desde cero. Por lo tanto, la siguiente sección lo guiará a través de cómo puede cargar archivos con el SDK seguro de Filestack.

Cómo subir archivos fácilmente con Filestack SDK

Para seguir, necesitará una clave API de Filestack .

Para comenzar, instale el SDK de Filestack con el siguiente comando:

implementación 'com.filestack:filestack-java:0.9.0'

Para implementar las funciones de carga usando Filestack, use el siguiente código en su archivo Java:

// Creando el cliente
 Configuración de configuración = nueva configuración ( "API_KEY" );
 Cliente cliente = nuevo Cliente (configuración);

 // Configuración de opciones y metadatos relacionados con la carga
 Opción StorageOptions = new StorageOptions.Builder()
 .mimeType( "texto/simple" )
 .nombre de archivo( "archivo.txt" )
 .construir();

 // Realizar una carga sincrónica
 Archivos de FileLink = client.upload ( "/filepath" , false );

 // Realizar una carga asíncrona
 Flowable<Progress<FileLink>> upload = client.uploadAsync( “filepath” , false );
 upload.doOnNext( new Consumer<Progress<FileLink>>() {
 @Anular
 public void accept(Progress<FileLink> progreso) arroja Excepción {
 System.out.printf( “%f%% Su archivo se cargó\n” , progreso.getPercent());
 if (progreso.getData() != null ) {
 Archivos FileLink = progreso.getData();
 }
 }
 });

Para asegurarse de que funciona, se pueden ejecutar las siguientes pruebas:

./prueba de archivos

En caso de que esté buscando implementar su aplicación, Bintray es el objetivo de las implementaciones. Para implementar, necesita una cuenta de usuario que se haya registrado con la organización Filestack. Observe también las pautas básicas de lanzamiento de Filestack. Se necesitan las variables de entorno "BINTRAY USER" y "BINTRAY API KEY". Correr:

exportar BINTRAY_USER= ”
 exportar BINTRAY_API_KEY= ”
 ./archivos bintraySubir

Conclusión

También puede optar por una herramienta de terceros si le resulta difícil mantener y crear su propio sistema de carga de archivos Java. Debido a problemas de seguridad y privacidad de los datos, las personas pueden evitar utilizar sistemas de terceros, por ejemplo, al cargar archivos que contienen registros médicos.

Además, les preocupa tener poco control sobre quién tiene acceso a la infraestructura de almacenamiento de archivos. Sin embargo, puede garantizar la seguridad de los datos de formularios y documentos utilizando una solución confiable de carga de archivos.

Preguntas frecuentes (FAQ)

¿Puedes mover archivos usando una API?

Sí. La transferencia de archivos mediante una API se puede realizar mediante herramientas basadas en API disponibles en el mercado. Esto se puede combinar con programas que se ejecutan en varias plataformas, como también programas en línea.

¿Puedo enviar un archivo grande a la API REST?

Puede ser difícil cargar archivos grandes, especialmente cuando existen otros factores como un ancho de banda y conexiones de red deficientes. Puede resultar en numerosas fallas de carga.

¿Cómo lee Java un archivo cargado?

Usando flujos de entrada, un programa Java lee colecciones de bytes o caracteres. La lectura de archivos es una operación secuencial que comienza con la construcción del objeto de archivo, lo pasa al archivo de entrada, lee los datos de la secuencia, los procesa y luego cierra la secuencia y el objeto de archivo.

¿Qué es una herramienta de carga de archivos?

Es una API o complemento que se puede conectar a su aplicación web y permite a los usuarios cargar fotos, videos y archivos de texto, así como también permitir algunas modificaciones básicas, efectos de filtro, etc.