Proxy Inverso

jueves, 11 de mayo de 2017

Peticiones AJAX (GET, POST, PUT y DELETE) usando jQuery

Hola

En esta entrada vamos a ver cómo invocar métodos GET, POST, PUT y DELETE mediante jQuery.

Utilizaremos el API REST ofertado en la URL https://reqres.in/api

Montaremos una página HTML como la siguiente:


<!DOCTYPE html>

<html lang="es">
<head>

<meta charset="UTF-8">

<meta name="author" content="Eduardo García">

<title>AJAX y jQuery</title>

<meta name="keywords" content="HTML5,CSS,JavaScript,jQuery">
</head>
<body>

<h1>AJAX&JQUERY I. Ejemplos de llamadas GET, POST, PUT y DELETE a un servicio REST.</h1>

<div id="usuarios"></div>

<script type="text/javascript" src="js/jquery-3.2.1.js"></script>

<script type="text/javascript" src="js/ejemplo.js"></script>
</body>
</html>

El contenido de nuestro fichero javascript con jQuery 'ejemplo.js' sería:

/**
* En este ejemplo usaremos un servicio REST gratuíto que está
* disponible en Internet y que ofrece métodos GET, POST, PUT
* y DELETE para operar con 'usuarios'
*/
var urlListaUsuarios = "https://reqres.in/api/users?page=1";
var urlGetUsuario = "https://reqres.in/api/users/";
var urlAltaUsuario = "https://reqres.in/api/users";
var urlBajaUsuario = "https://reqres.in/api/users/";
var urlModificaUsuario = "https://reqres.in/api/users/";

$(document).ready(getListaUsuarios);
//$(document).ready(getUsuario(2));
//$(document).ready(altaUsuario);
//$(document).ready(bajaUsuario(2));
//$(document).ready(modificaUsuario(2));

/**
* Obtenemos por GET la primera página de una lista de usuarios
*/
function getListaUsuarios(){

$.getJSON(urlListaUsuarios)
.done(function(respuesta, textStatus, jqXHR ) {
$("#usuarios").append("<h3>Recuperados los siguientes usuarios:</h3>");
$.each(respuesta.data, function(i,result){
$("#usuarios").append("<div>Id: "+ result.id +
" Nombre: " + result.first_name +
" Apellido: " + result.last_name +
" Foto: <img src="+result.avatar+"></img></div>");
});
})
.fail(function( jqXHR, textStatus, errorThrown ) {
$("#usuarios").append("Error llamando al servicio: " + textStatus);
});
}

/**
* Obtenemos por GET los datos del usuario con el id recibido
*/
function getUsuario(idUsuario){

$.getJSON(urlGetUsuario+idUsuario)
.done(function(result, textStatus, jqXHR ) {
$("#usuarios").append("<h3>Recuperado el siguiente usuario:</h3>");
$("#usuarios").append("<div>Id: "+ result.data.id +
" Nombre: " + result.data.first_name +
" Apellido: " + result.data.last_name +
" Foto: <img src="+result.data.avatar+"></img></div>");
})
.fail(function( jqXHR, textStatus, errorThrown ) {
$("#usuarios").append("Error llamando al servicio: " + textStatus);
});

}

/**
* Damos de alta a un nuevo usuario
*/
function altaUsuario(){

$.ajax({
type: "POST",
dataType: "json",
url: urlAltaUsuario,
data: {"name": "eduardo", "job": "developer"}
})
.done(function(result, textStatus, jqXHR ) {
$("#usuarios").append("<h3>Creado el siguiente usuario:</h3>");
$("#usuarios").append("<div>Id: "+ result.id +
" Nombre: " + result.name +
" Puesto: " + result.job +
" Fecha alta: " + result.createdAt );
})
.fail(function( jqXHR, textStatus, errorThrown ) {
$("#usuarios").append("Error llamando al servicio: " + textStatus);
});

}

/**
* Damos de baja al usuario con el id recibido
*/
function bajaUsuario(idUsuario){

$.ajax({
type: "DELETE",
dataType: "json",
url: urlBajaUsuario+idUsuario
})
.done(function(result, textStatus, jqXHR ) {
$("#usuarios").append("<h3>Borrado correctamente el usuario: "+idUsuario+"</h3>");
})
.fail(function( jqXHR, textStatus, errorThrown ) {
$("#usuarios").append("Error llamando al servicio: " + textStatus);
});

}

/**
* Modificamos los datos del usuario recibido por parametro
*/
function modificaUsuario(idUsuario){

$.ajax({
type: "PUT",
dataType: "json",
url: urlModificaUsuario+idUsuario,
data: {"name": "EduardoX", "job": "DeveloperX"}
})
.done(function(result, textStatus, jqXHR ) {
$("#usuarios").append("<h3>Modifiacdo correctamente el usuario: "+idUsuario+"</h3>");
$("#usuarios").append("<div>Nombre: " + result.name +
" Puesto: " + result.job +
" Fecha modificacion: " + result.updatedAt );
})
.fail(function( jqXHR, textStatus, errorThrown ) {
$("#usuarios").append("Error llamando al servicio: " + textStatus);
});

}

viernes, 17 de febrero de 2017

Descargar vídeos de Youtube con Ubuntu desde la terminal

Hola

Tras probar sin éxito varias extensiones de Firefox y Chrome que permitiesen descargar vídeos desde YouTube he googleado un poco encontrando una herramienta de línea de comando muy buena y fácil de manejar llamada 'youtube-dl'.

Para instalarla teclearemos:

$ sudo apt-get install youtube-dl

Su utilización es muy simple, basta con movernos a la carpeta donde deseemos que se almacene el vídeo, por ejemplo el escritorio:

$ cd $HOME/Escritorio

Luego lanzamos la herramienta mediante el comando:

$ youtube-dl URL_VIDEO_YOUTUBE

Por ejemplo:

$ youtube-dl https://www.youtube.com/watch?v=PlLHc60egiQ

Con lo que se descargará el vídeo deseado

Un saludo

Eliminar Malware Extensions de Google Chrome en Ubuntu

Hola

Tras instalar una cierta extensión (video-download-helper) de Google Chrome, que se anunciaba como extensión para la descarga de videos de Youtube, me he dado cuenta de que dicha extensión no solo no descargaba vídeos sino que además levantaba ventanas de publicidad y cerraba Chrome cada vez que intentaba acceder a la configuración de extensiones para desinstalarla.

En fin, no se cómo Google ofrece este tipo de extensiones en su área de descargas (https://chrome.google.com/webstore/detail/video-download-helper/mngdadkapbemiekajhhalpakdpleogfn?hl=es), muchos usuarios pueden llegar a desinstalar el navegador definitivamente, porque las extensiones no desaparecen al reinstalar Chrome.

Para desinstalar la extensión a mano debemos acceder a la carpeta:

$HOME/.config/google-chrome/Default/Extensions

Donde encontraremos varios directorios con nombres como:

mlomiejdfkolichcflejclcbmpeaniij
nmmhkkegccagdldgiimedpiccmgmieda
pkedcjkdefgpdelpbcmbmeomcjbeemfm

He optado por borrar todos los directorios, dado que no he tenido ganas de entretenerme en averiguar cual era el directorio asociado a la extensión malware en cuestión:

$ rm -R *

Tras lo cual he reiniciado Chrome y he podido acceder a la zona de configuración de extensiones con normalidad, limpiando los 'residuos' de las extensiones anteriormente existentes y reinstalando mis extensiones favoritas.

Un saludo

miércoles, 18 de enero de 2017

Miniservidor con Node.js y oracledb

Hola

En esta entrada vamos a montar un miniservidor html con Node.js que conecte a cierta tabla de Oracle mediante oracledb. Los pasos para instalar todo son:

1) Instalamos node.js y su gestor de paquetes npm

sudo apt-get install nodejs
sudo apt-get install npm

2) Verificamos que está bien instalado con:

nodejs --version                   --> v4.2.6
npm --version                      --> 3.5.2

3) Instalamos algunas de las librerías javascript que vamos a necesitar en nuestro servidor 'miserver.js':

   npm install http
   npm install httpdispatcher

4) Descargamos el 'Oracle Instant Client' de Oracle (http://www.oracle.com/technetwork/database/features/instant-client/index-097480.html) siguiendo las instrucciones de (https://github.com/oracle/node-oracledb). Necesitaremos los packages 'basic' y 'SDK' si la BBDD está en remoto (es lo habitual). Por lo que hemos bajado las versiones de RedHat/linux:

   oracle-instantclient11.2-basic-11.2.0.4.0-1.x86_64.rpm
   oracle-instantclient11.2-devel-11.2.0.4.0-1.x86_64.rpm

5) Para Ubuntu no hay instalador, así que transformamos el instalador rpm (RedHat) con:

   sudo alien -i oracle-instantclient11.2-basic-11.2.0.4.0-1.x86_64.rpm
   sudo alien -i oracle-instantclient11.2-devel-11.2.0.4.0-1.x86_64.rpm

Nota Ubuntu. Tambien hemos necesitado instalar la libreria libaio, no se para qué hace falta

   sudo apt-get install libaio1

6) Seguidamente instalamos la librería javascript oracledb con:

   npm install oracledb

Nota Ubuntu. Para poder lanzar sin problemas la instalacion de oracledb (saltaba un error en 'node-gyp rebuild' descrito en (https://github.com/npm/npm/issues/11335)) he tenido que crear un softlink 'node' dado que se petaba por tener instalado nodejs (el package de ubuntu) en vez del paquete node 'oficial'. Para crear el softlink lanzamos:

   sudo ln -s /usr/bin/nodejs /usr/local/bin/node

8) Creamos nuestro servidor web por el puerto 8888 en javascrip, para ello creamos un fichero llamado 'miserver.js' con el siguiente codigo:

//Importamos las librerias necesarias
var http = require('http');
var HttpDispatcher = require('httpdispatcher');
var oracledb = require('oracledb');

//Inicializamos el enrutador
var enrutador = new HttpDispatcher();

//Definimos la función que manejara las peticiones
function handleRequest(request, response){
        console.log("Peticion:");
        console.log(request.url);
        enrutador.dispatch(request, response);
}

//Creamos el servidor y lo ponemos a escuchar en el puerto 8888
var server = http.createServer(handleRequest);
server.listen(8888, function(){
    console.log("Arrancado y escuchando en el puerto 8888");
});

//Creamos la función que devuelve la pagina /
enrutador.onGet("/", function(req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write("<?xml version='1.0' encoding='UTF-8'?>");
res.write("<!DOCTYPE html>");
res.write("<html lang='es' xmlns='http://www.w3.org/1999/xhtml'>");
res.write("<head>");
res.write(" <meta http-equiv='Content-type' content='text/html; charset=UTF-8'/>");
res.write(" <meta name='language' content='es'/>");
res.write("</head>");
res.write("<body>");
res.write("<h3> Primer miniportal con Node.js</h3>");
res.write(" <ul>");
res.write("   <li><a href='/listaprovincias'>Lista de provincias</a></li>");
res.write(" </ul>");
res.write("</body>");
res.end();
});

//Creamos la función que devuelve la pagina /listaprovincias
enrutador.onGet("/listaprovincias", function(req, res) {

oracledb.getConnection(
    {
      user          : "user",
      password      : "pwd",
      connectString : "127.0.0.1:1535/prueba"
    },
    function(err, connection) {
        if (err) {
           console.error(err);
           return;
        }
        connection.execute("SELECT CPRO, DPRO FROM PROVINCIAS ORDER BY DPRO",
        function(err, result) {
          if (err) {
             console.error(err.message);
             connection.close();
             return;
          }
          console.log("Encontradas "+result.rows.length+" provincias");

    res.writeHead(200, {'Content-Type': 'text/html'});
    res.write("<?xml version='1.0' encoding='UTF-8'?>");
    res.write("<!DOCTYPE html>");
    res.write("<html lang='es' xmlns='http://www.w3.org/1999/xhtml'>");
    res.write("<head>");
    res.write(" <meta http-equiv='Content-type' content='text/html; charset=UTF-8'/>");
    res.write(" <meta name='language' content='es'/>");
    res.write("</head>");
    res.write("<body>");
    res.write("<h3> Listado de provincias </h3>");
          res.write("<table>");
          res.write("<tr>");
          res.write("<th>CPRO</th>");
          res.write("<th>DPRO</th>");
          res.write("</tr>");
          for (reg in result.rows){
             res.write("<tr>");
             res.write("<th>"+result.rows[reg][0]+"</th>");
             res.write("<th>"+result.rows[reg][1]+"</th>");
             res.write("</tr>");
             console.log(result.rows[reg][0] + "---" + result.rows[reg][1]);
          }
          res.write("</table>");
    res.write("<a href='/'>Volver</a>");
    res.write("</body>");
          res.end();
        });
    });
});

9) Levantamos el servidor con:

node miserver.js

10) Desde el navegador lanzamos la siguiente URL: http://localhost:8888/

Eso es todo

martes, 13 de diciembre de 2016

Primeros pasos con SQLite

Para pequeñas pruebas o arquetipos solemos utilizar una BBDD SQLite, en esta entrada dejo un pequeño trozo de código con algunas de las operaciones mas comunes:

Conectar y desconectar de la BBDD
Crear y borrar tablas
Insertar, actualizar y borrar registros
Lanzar diferentes consultas
Commit y rollback de transacciones
Uso de PreparedStatement

En el pom.xml de nuestro proyecto deberemos incluir la dependencia:

<dependency>
    <groupId>org.xerial</groupId>
    <artifactId>sqlite-jdbc</artifactId>
    <version>3.15.1</version>
</dependency>

El código sería:

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestSQLite {

 private static final String URL = "jdbc:sqlite:test.db";
 
 public static void main(String[] args) throws SQLException {
  
  final Connection conexion = DriverManager.getConnection(URL);
  final DatabaseMetaData metadatos = conexion.getMetaData();
  System.out.println("------------------------------------------------------------");
  System.out.println("Conectados al motor de BBDD: " + metadatos.getDriverName());
  System.out.println("DriverVersion: " + metadatos.getDriverVersion());
  System.out.println("DatabaseProductVersion: " + metadatos.getDatabaseProductVersion());
  System.out.println("JDBCMajorVersion: " + metadatos.getJDBCMajorVersion());
  
        String sql = "DROP TABLE IF EXISTS CLIENTE;";
        Statement stmt = conexion.createStatement();
        stmt.execute(sql);
  System.out.println("------------------------------------------------------------");
  System.out.println("Borrada la tabla CLIENTE");
  
        sql = "CREATE TABLE IF NOT EXISTS CLIENTE (ID integer PRIMARY KEY, NOMBRE text NOT NULL, DIRECCION text NOT NULL, PRIORIDAD integer NOT NULL);";
        stmt = conexion.createStatement();
        stmt.execute(sql);
  System.out.println("------------------------------------------------------------");
  System.out.println("Creada la tabla CLIENTE");
  
  conexion.setAutoCommit(false);
        sql = "INSERT INTO CLIENTE(NOMBRE,DIRECCION,PRIORIDAD) VALUES(?,?,?);";
        PreparedStatement pstmt = conexion.prepareStatement(sql);
        pstmt.setString(1, "cliente1");
        pstmt.setString(2, "direccion1");
        pstmt.setString(3, "1");
        pstmt.executeUpdate();
        pstmt.setString(1, "cliente2");
        pstmt.setString(2, "direccion2");
        pstmt.setString(3, "1");
        pstmt.executeUpdate();
        pstmt.setString(1, "cliente3");
        pstmt.setString(2, "direccion3");
        pstmt.setString(3, "2");
        pstmt.executeUpdate();
        conexion.commit();
  System.out.println("------------------------------------------------------------");
  System.out.println("Insertados 3 registros en tabla CLIENTE");
  
  sql = "SELECT count(*) as NUMREG FROM CLIENTE";
  ResultSet rs = stmt.executeQuery(sql);
  System.out.println("------------------------------------------------------------");
  System.out.println("Encontrados " + rs.getInt("NUMREG") + " registros en tabla CLIENTE");
  
  sql = "SELECT count(*) as NUMREG FROM CLIENTE WHERE NOMBRE ='cliente1'";
  rs = stmt.executeQuery(sql);
  System.out.println("------------------------------------------------------------");
  System.out.println("Encontrados " + rs.getInt("NUMREG") + " registros en tabla CLIENTE con NOMBRE ='cliente1'");
  
  sql = "SELECT count(*) as NUMREG FROM CLIENTE WHERE NOMBRE LIKE 'cliente%'";
  rs = stmt.executeQuery(sql);
  System.out.println("------------------------------------------------------------");
  System.out.println("Encontrados " + rs.getInt("NUMREG") + " registros en tabla CLIENTE con NOMBRE like 'cliente%'");
  
  sql = "SELECT * FROM CLIENTE WHERE PRIORIDAD=1";
  rs = stmt.executeQuery(sql);
  System.out.println("------------------------------------------------------------");
  System.out.println("Encontrados los siguientes registros en tabla CLIENTE con PRIORIDAD=1");
  System.out.println("ID NOMBRE DIRECCION PRIORIDAD");
  while (rs.next()) {
   System.out.println(rs.getInt("ID") + " " + rs.getString("NOMBRE") + " " + rs.getString("DIRECCION") + " " + rs.getInt("PRIORIDAD"));
  }
  
  sql = "UPDATE CLIENTE SET PRIORIDAD=2 WHERE PRIORIDAD=1";
  int numRecAct = stmt.executeUpdate(sql);
  conexion.commit();
  System.out.println("------------------------------------------------------------");
  System.out.println("Actualizados "+numRecAct+" registros de PRIORIDAD=1 a PRIORIDAD=2");
  System.out.println("ID NOMBRE DIRECCION PRIORIDAD");
  
  sql = "SELECT * FROM CLIENTE";
  rs = stmt.executeQuery(sql);
  System.out.println("------------------------------------------------------------");
  System.out.println("Encontrados los siguientes registros en tabla CLIENTE");
  System.out.println("ID NOMBRE DIRECCION PRIORIDAD");
  while (rs.next()) {
   System.out.println(rs.getInt("ID") + " " + rs.getString("NOMBRE") + " " + rs.getString("DIRECCION") + " " + rs.getInt("PRIORIDAD"));
  }
  
  sql = "DELETE FROM CLIENTE WHERE NOMBRE='cliente1'";
  numRecAct = stmt.executeUpdate(sql);
  System.out.println("------------------------------------------------------------");
  System.out.println("Borrados los registros con NOMBRE='cliente1'");
  
  sql = "SELECT * FROM CLIENTE";
  rs = stmt.executeQuery(sql);
  System.out.println("------------------------------------------------------------");
  System.out.println("Encontrados los siguientes registros en tabla CLIENTE");
  System.out.println("ID NOMBRE DIRECCION PRIORIDAD");
  while (rs.next()) {
   System.out.println(rs.getInt("ID") + " " + rs.getString("NOMBRE") + " " + rs.getString("DIRECCION") + " " + rs.getInt("PRIORIDAD"));
  }
  
  sql = "DELETE FROM CLIENTE";
  numRecAct = stmt.executeUpdate(sql);
  conexion.rollback();
  System.out.println("------------------------------------------------------------");
  System.out.println("Intento cancelado de borrado completo de la tabla CLIENTE");
  
  sql = "SELECT * FROM CLIENTE";
  rs = stmt.executeQuery(sql);
  System.out.println("------------------------------------------------------------");
  System.out.println("Encontrados los siguientes registros en tabla CLIENTE");
  System.out.println("ID NOMBRE DIRECCION PRIORIDAD");
  while (rs.next()) {
   System.out.println(rs.getInt("ID") + " " + rs.getString("NOMBRE") + " " + rs.getString("DIRECCION") + " " + rs.getInt("PRIORIDAD"));
  }
  
  conexion.close();
 }
}

Un saludo

Comparativa librerías JSON: Gson y Jackson

Para manipular datos en formato JSON existen dos librerías: Jackson y Gson. La primera es muy conocida por ser el 'motor' usado por el framework Jersey de Web Services RESTfull, la segunda no lo es tanto.

El presente ejemplo tiene como finalidad comparar el rendimiento de ambas. Tras unas primeras pruebas con POJOS java de diversos tamaños me da la sensación de que Jackson es un poquitín mas rápida.

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;

public class TestMotoresJSON {

 private static final int NUMCLIENTES = 5;
 private static final int NUMFACTURAS = 100000;
 
 private static final Gson motorGSON = new GsonBuilder().create();
 private static final ObjectMapper motorJACKSON = new ObjectMapper();
 
 public static void main(String[] args) throws IOException {

  //Montamos un pojo Java con la lista de clientes y facturas
  final List lstClientes = montaListaClientes();

  //Serializo GSon
  long tmp = System.currentTimeMillis();
  String lstClientesJSON = serializoGSon(lstClientes);
  System.out.println("Tiempo serialización GSon:"+(System.currentTimeMillis()-tmp));

  //Deserializo GSon
  tmp = System.currentTimeMillis();
  deserializoGSon(lstClientesJSON);
  System.out.println("Tiempo deserialización GSon:"+(System.currentTimeMillis()-tmp));
  
  //Serializo Prueba
  tmp = System.currentTimeMillis();
  lstClientesJSON = serializoJackson(lstClientes);
  System.out.println("Tiempo serialización Jackson:"+(System.currentTimeMillis()-tmp));
  
  //Deserializo Prueba
  tmp = System.currentTimeMillis();
  deserializoJackson(lstClientesJSON);
  System.out.println("Tiempo deserialización Jackson:"+(System.currentTimeMillis()-tmp));
 }
 
 private static String serializoGSon(final List lstClientes){
   
  return motorGSON.toJson(lstClientes);
 }
 
 private static void deserializoGSon(final String lstClientesJSON){
  
  motorGSON.fromJson(lstClientesJSON, new TypeToken>(){}.getType());
 }
 
 private static String serializoJackson(final List lstClientes) throws IOException {

  return motorJACKSON.writeValueAsString(lstClientes);
 }
 
 private static void deserializoJackson(final String lstClientesJSON) throws IOException {
  
  motorJACKSON.readValue(lstClientesJSON, motorJACKSON.getTypeFactory().constructCollectionType(ArrayList.class, Cliente.class));
 }
 
 private static List montaListaClientes(){
  
  final List lst = new ArrayList();
  Cliente cliente = null;
  Factura fac = null;
  for (int c=0;c());
   for (int f=0;f

Necesitaremos las clases de apoyo:

import java.util.List;

public class Cliente {

 private String CIF;
 private String nombre;
 private String direccion;
 private String email;
 private String telefono;
 private String fax;
 private List facturas;
 
 public String getCIF() {
  return CIF;
 }
 public void setCIF(String cIF) {
  CIF = cIF;
 }
 public String getNombre() {
  return nombre;
 }
 public void setNombre(String nombre) {
  this.nombre = nombre;
 }
 public String getDireccion() {
  return direccion;
 }
 public void setDireccion(String direccion) {
  this.direccion = direccion;
 }
 public String getEmail() {
  return email;
 }
 public void setEmail(String email) {
  this.email = email;
 }
 public String getTelefono() {
  return telefono;
 }
 public void setTelefono(String telefono) {
  this.telefono = telefono;
 }
 public String getFax() {
  return fax;
 }
 public void setFax(String fax) {
  this.fax = fax;
 }
 public List getFacturas() {
  return facturas;
 }
 public void setFacturas(List facturas) {
  this.facturas = facturas;
 }
}

public class Factura {

 private String id;
 private String fecha;
 private long bruto;
 private long neto;
 private long iva;
 
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getFecha() {
  return fecha;
 }
 public void setFecha(String fecha) {
  this.fecha = fecha;
 }
 public long getBruto() {
  return bruto;
 }
 public void setBruto(long bruto) {
  this.bruto = bruto;
 }
 public long getNeto() {
  return neto;
 }
 public void setNeto(long neto) {
  this.neto = neto;
 }
 public long getIva() {
  return iva;
 }
 public void setIva(long iva) {
  this.iva = iva;
 }
}

Necesitaremos importar en el pom.xml las dependencias:

     <dependencies>
          <dependency>
               <groupId>com.fasterxml.jackson.core</groupId>
               <artifactId>jackson-databind</artifactId>
               <version>2.8.5</version>
          </dependency>
          <dependency>
               <groupId>com.google.code.gson</groupId>
               <artifactId>gson</artifactId>
               <version>2.6.2</version>
          </dependency>
     </dependencies>

miércoles, 7 de diciembre de 2016

Añadir un fichero nuevo a un fichero zip previamente existente

Hola

Se nos presentó la necesidad de añadir contenido a ciertos ficheros ZIP preexistentes, para abordar el problema podíamos usar la librería Commons Compress de Apache (https://commons.apache.org/proper/commons-compress/) o directamente las clases del paquete 'java.util.zip' del JDK.

El problema es que ambas librerías no añaden contenido a un zip preexistente, sino que sobrescriben el contenido del ZIP original por el nuevo contenido. Debe ser por alguna cuestión 'conceptual' relativa al formato ZIP.

Por tanto la forma de abordar el problema es generar un nuevo fichero zip temopral, volcar en dicho fichero el contenido del fichero zip original, añadir al fichero zip temporal el nuevo fichero, borrar el fichero zip original y renombrar el fichero temporal con el nombre del original.

Ya puestos a documentar el tema, dejo el código con la clase generada:

package org.casa.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

public class TestZip {

 private static final int BUFFER_SIZE = 1024;

 /**
  * Crea un fichero zip a partir del fichero recibido con el nombre
  * de dicho fichero y extensión zip, el zip se genera en la carpeta
  * que contiene el fichero recibido.
  * 
  * @param fichero
  * @throws IOException
  */
 public static void comprimeFichero(final File fichero) throws IOException {

  //Generamos un fichero zip con nombre del fichero recibido y extensión zip
  final String nombreFichZip = fichero.getName().substring(0, fichero.getName().lastIndexOf("."))+".zip";

  //Creamos el nuevo fichero zip en la ubicación del fichero recibido
  final File zf = new File(fichero.getParentFile()+File.separator+nombreFichZip);
  final FileOutputStream fos = new FileOutputStream(zf);
  final ZipOutputStream zos = new ZipOutputStream(fos);

  //Comprimimos el fichero recibido en el nuevo zip
  final ZipEntry ze = new ZipEntry(fichero.getName());
  zos.putNextEntry(ze);
  final FileInputStream fisEntry = new FileInputStream(fichero);
  copyToZip(fisEntry, zos);

  //Cerramos los manejadores
  fisEntry.close();
  zos.flush();
  zos.closeEntry();
  zos.close();
  fos.close();
 }

 /**
  * Crea un fichero zip con todos los ficheros contenidos en la carpeta
  * recibida, el zip tendrá el nombre del directorio con extensión zip y 
  * se ubicará en el directorio padre del directorio recibido.
  * 
  * @param directorio
  * @throws IOException 
  */
 public static void comprimeDirectorio(final File carpeta) throws IOException {

  //Generamos un fichero zip con nombre de la carpeta recibida y extensión zip
  final String nombreFichZip = carpeta.getName()+".zip";

  //Creamos el nuevo fichero zip en la carpeta padre de la carpeta recibida
  final File zf = new File(carpeta.getParentFile()+File.separator+nombreFichZip);
  final FileOutputStream fos = new FileOutputStream(zf);
  final ZipOutputStream zos = new ZipOutputStream(fos);

  //Comprimimos cada fichero de la carpeta en el nuevo zip
  ZipEntry ze = null;
  FileInputStream fisEntry = null;
  for (final File fich : carpeta.listFiles()) {
   ze = new ZipEntry(fich.getName());
   zos.putNextEntry(ze);
   fisEntry = new FileInputStream(fich);
   copyToZip(fisEntry, zos);
   fisEntry.close();
  }

  //Cerramos los manejadores
  zos.flush();
  zos.closeEntry();
  zos.close();
  fos.close();
 }

 /**
  * Añade un nuevo fichero comprimido al fichero zip recibido por parámetro.
  * 
  * Creamos un zip temporal intermedio donde copiamos el contenido del zip
  * recibido y en este zip temporal añadimos el fichero recibido. Finalmente
  * reemplazamos el fichero zip original con el fichero zip generado.
  * 
  * @param zipFile
  * @param fichero
  * @throws IOException
  */
 public static void addFicheroZip(final File zipFile, final File fichero) throws IOException {

  //Guardamos el nombre y el path del fichero zip recibido
  final String nombreFicheroZip = zipFile.getName();
  final String pathFicheroZip = zipFile.getParent();
  
  //Creamos un nuevo fichero zip temporal en la ubicación del zip recibido
  final File ftemp = File.createTempFile(nombreFicheroZip,null,zipFile.getParentFile());
  final FileOutputStream fostemp = new FileOutputStream(ftemp);
  final ZipOutputStream zostemp = new ZipOutputStream(fostemp);
  
  //Abrimos el fichero zip recibido por parametro
  final FileInputStream fis = new FileInputStream(zipFile);
  final ZipInputStream zis = new ZipInputStream(fis);
  
  //Sacammos el contenido del zip recibido por parametro y lo volcamos al zip temporal
  ZipEntry ze = zis.getNextEntry();
  while (ze!= null) {
   ze.getName();
   zostemp.putNextEntry(ze);
   copyToZip(zis, zostemp);
   ze = zis.getNextEntry();
  }
  
  //Añadimos el fichero nuevo al fichero zip temporal
  final ZipEntry zenuevo = new ZipEntry(fichero.getName());
  zostemp.putNextEntry(zenuevo);
  final FileInputStream fisNuevo = new FileInputStream(fichero);
  copyToZip(fisNuevo, zostemp);

  //Cerramos los manejadores
  fisNuevo.close();
  zis.close();
  fis.close();
  zostemp.flush();
  zostemp.closeEntry();
  zostemp.close();
  fostemp.close();

  //Borramos el fichero zip recibido
  zipFile.delete();
  
  //Renombramos el fichero temporal nuevo
  ftemp.renameTo(new File(pathFicheroZip+File.separator+nombreFicheroZip));
 }

 /**
  * Extrae el contenido del zip recibido por parámetro en la carpeta
  * que contiene el fichero zip recibido.
  * 
  * 
  * @param zipFile
  * @throws IOException
  */
 public static void descomprimeZip(final File zipFile) throws IOException {
  
  //Abrimos el fichero zip recibido por parametro
  final FileInputStream fis = new FileInputStream(zipFile);
  final ZipInputStream zis = new ZipInputStream(fis);

  //Extraemos cada fichero del zip en la carpeta del ZIP recibido
  File fe = null;
  FileOutputStream fose = null;
  ZipEntry ze = zis.getNextEntry();
  while (ze!= null) {
   //Procesamos cada fichero del zip
   fe = new File(zipFile.getParentFile().getCanonicalPath()+File.separator+ze.getName());
   fose = new FileOutputStream(fe);
   copyFromZip(zis, fose);
   fose.flush();
   fose.close();
   //Saltamos al siguiente fichero del zip
   ze = zis.getNextEntry();
  }
  
  //Cerramos los manejadores
  zis.close();
  fis.close();  
 }

 private static void copyToZip(final InputStream is, final ZipOutputStream zos) throws IOException {

  byte[] buffer = new byte[BUFFER_SIZE];
  int length;
  while ((length = is.read(buffer)) >= 0) {
   zos.write(buffer, 0, length);
  }
 }
 
 private static void copyFromZip(final ZipInputStream zis, final OutputStream os) throws IOException {

  byte[] buffer = new byte[BUFFER_SIZE];
  int length;
  while ((length = zis.read(buffer)) >= 0) {
   os.write(buffer, 0, length);
  }
 }
}