sábado, 4 de mayo de 2013

Escritura de archivos XML con JAXB

En un post anterior presenté el proceso que hay que seguir para leer archivos XML usando JAXB. En dicho post generé las clases necesarias y las usé de ejemplo.

Para cerrar el círculo adecuadamente, usando el mismo ejemplo, presento ahora una clase que permite escribir un archivo XML en disco.


import java.io.File;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;

import org.example.personas.Persona;
import org.example.personas.Personas;


public class SaveXMLwithJAXB {

 public static void main(String[] args) {

  JAXBContext ctx;
  
  Personas p = new Personas();
  Persona pItem = new Persona();
  pItem.setCiudad("Madrid");
  pItem.setEdad("20");
  pItem.setId("1");
  pItem.setNombre("Carlos");
  
  p.getPersona().add(pItem);
  
  try {
   ctx = JAXBContext.newInstance(Personas.class);
   Marshaller m = ctx.createMarshaller();
   
   File f = new File("C:/destino.xml");
   m.marshal(p, f);
   
  } catch (JAXBException e) {
   e.printStackTrace();
  }  
 }
}


Saludos.

sábado, 27 de abril de 2013

Bases de datos y Groovy.

El tratamiento de bases de datos en cualquier lenguaje es algo básico. A continuación presento un ejemplo sencillo realizado con Groovy. Hay que destacar que el manejo de bases de datos en java está muy conseguido gracias a frameworks como hibernate, jpa, etc. No obstante creo que conocer esta opción no está de más :D


Pasos previos

He creado un proyecto en Eclipse con el plugin comentado en el anterior post.

En postgres he creado una base de datos vacía. Le he dado acceso al usuario postgres/postgres para que pueda interactuar con la bd.

Como en cualquier programa, lo primero que tenemos que hacer es establer la conexión con la base de datos. El paquete groovy.sql contiene la clase Sql, que es la que nos permite operar contra bases de datos.

En concreto para obtener un conexión nos hace falta el método newInstance. Entre las implementaciones disponibles, la más cómoda en mi opinión es newInstance(url,user,password,driverClassName) throws SQLException, ClassNotFoundException

Los parámetros son evidentes:

url:
Es la url a la bd a la que nos vamos a conectar, en formato jdbc:subprotocol:subname
user:
Usuario de la base de datos con los permisos necesarios.
password:
La contraseña del usuario.
driverClassName:
Nombre del driver.

Esta clase devuelve una instancia de la conexión, con la que ya podremos comunicarnos. Lanza dos tipos de excepciones:

SQLException:
Cualquier tipo de error al interactuar con la base de datos, por ejemplo si el usuario no existe, o no tiene permisos, etc.
ClassNotFoundException:
Si no se ha podido obtener la clase del driver de conexión. Vamos, que no hemos incluido la librería necesaria o que no hemos puesto bien el nombre de la misma.

Obteniendo la conexión

Mi ejemplo va a ser muy sencillo. Voy a crear una clase llamada OperacionesBD.groovy. La cual en el constructor realiza la conexión, y mediante el resto de métodos interactúa con la base de datos.

De esta forma el constructor queda:


public OperacionesBD(String urljdbc, String usuario, String password) {
  super();
  this.connection = Sql.newInstance(urljdbc,usuario,password,Constantes.JDBC_DRIVER);
 }

siendo connection un atributo:

private Sql connection;

Insertando datos

Para ejecutar instrucciones la clase Sql dispone del método execute. Los dos siguientes métodos crean una tabla y insertan valores en ella:


 public void createTablePersons(){
  connection.execute(Constantes.TABLE);
 }



 public void insertValueTest(){
  connection.execute(Constantes.INSERT,[1,'Carlos','M']);
  connection.execute(Constantes.INSERT,[2,'Juan','M']);
  connection.execute(Constantes.INSERT,[3,'María','F']);
  connection.execute(Constantes.INSERT,[4,'Elena','F']);
  connection.execute(Constantes.INSERT,[5,'Pedro','M']);
  connection.execute(Constantes.INSERT,[6,'Rosa','M']);
 }


Mostrando u obteniendo datos

Con el método eachRow se puede iterar sobre los resultados de la consulta sql. El método showFemales imprime en consola todas las mujeres de la tabla person.

 public void showFemales(){
  connection.eachRow(Constantes.FEMALES, {
   println "id: ${it.id}, Nombre: ${it.name}"
   } );
 }

Por consola obtenemos:

 id: 3, Nombre: María
 id: 4, Nombre: Elena
 id: 6, Nombre: Rosa

El método getFemales devuelve una lista de maps con la consulta para realizar un tratamiento posterior.

 public List < Map < Integer,String > > getFemales(){
  List < Map > l = new LinkedList< Map >();
  connection.eachRow(Constantes.FEMALES, {
      Map < Integer,String > m = new HashMap < Integer,String >();
      m.put(it.id.toInteger(), it.name.toString());
      l.add(m);
      } );
  return l;
 }

Actualizando datos

La actualización de datos es bastante sencilla con executeUpdate:

 
public void update(int id, String newName){
  connection.executeUpdate(Constantes.UPDATE, [newName,id]);
 }

Pues esto es todo para este post. A continuación pongo las clases completas del ejemplo.

Fichero de constantes - Constantes.java


package es.test;

public class Constantes {

 protected static String JDBC_DRIVER = "org.postgresql.Driver";
 
 protected static String JDBC_URL = "jdbc:postgresql://localhost:5432/GroovyTest";
 
 protected static String DROP =  "DROP TABLE IF EXISTS  person";
 
 protected static String TABLE = "CREATE TABLE \"person\" "+
       "("+
        " id integer NOT NULL,"+
        " \"name\" character varying(30),"+
        " gender character(1),"+
        " CONSTRAINT pk PRIMARY KEY (id) "+
        ")";

 protected static String INSERT = "INSERT INTO person(id,name,gender)  VALUES (?,?,?)";

 protected static String FEMALES = "SELECT * FROM person WHERE gender = 'F'";
 
 protected static String UPDATE = "UPDATE person SET name=? WHERE id=?";
}

Lógica Groovy - OperacionesBD.groovy


package es.test

import groovy.sql.Sql;

public class OperacionesBD {

 
 private Sql connection;

 
 public OperacionesBD(String urljdbc, String usuario, String password) {
  super();
  
  this.connection = Sql.newInstance(urljdbc,usuario,password,Constantes.JDBC_DRIVER);
  connection.execute(Constantes.DROP);
 }
 

 
 public void createTablePersons(){
  connection.execute(Constantes.TABLE);
 }
  
 public void insertValueTest(){
  connection.execute(Constantes.INSERT,[1,'Carlos','M']);
  connection.execute(Constantes.INSERT,[2,'Juan','M']);
  connection.execute(Constantes.INSERT,[3,'María','F']);
  connection.execute(Constantes.INSERT,[4,'Elena','F']);
  connection.execute(Constantes.INSERT,[5,'Pedro','M']);
  connection.execute(Constantes.INSERT,[6,'Rosa','F']);
 }
 
 
 public void showFemales(){
  connection.eachRow(Constantes.FEMALES, {
      println "id: ${it.id}, Nombre: ${it.name}"
      } );
 }
 
 
 public List < Map < Integer,String > > getFemales(){
  List < Map > l = new LinkedList< Map >();
  connection.eachRow(Constantes.FEMALES, {
     Map < Integer,String > m = new HashMap < Integer,String >();
     m.put(it.id.toInteger(), it.name.toString());
     l.add(m);
     } );
  return l;
 }
 
 
 public void update(int id, String newName){
  connection.executeUpdate(Constantes.UPDATE, [newName,id]);
 }
 

}

Clase principal para probar el ejemplo - Main.java

package es.test;

import java.util.List;
import java.util.Map;

public class Main {

 /**
  * @param args
  */
 public static void main(String[] args) {

  OperacionesBD obd = new OperacionesBD(Constantes.JDBC_URL, "postgres", "postgres");
  
  obd.createTablePersons();
  
  obd.insertValueTest();
  
  obd.showFemales();
  
  List < Map < Integer,String > > l = obd.getFemales();
  
  for(Map < Integer,String > item:l){
   System.out.println(item.toString());
  }
  
  obd.update(6, "Rosa Rosae");
  
  obd.showFemales();  
 }
}

Y por último os comento que el código fuente completo se puede bajar de mi repositorio público de Git.


Referencias

La idea de este post surgió por un problemilla con Groovy, que solucioné gracias a este enlace.

Saludos.

domingo, 21 de abril de 2013

Qttabbar, pestañas en el explorador de windows

Si hay algo que echo de menos en el explorador de archivos de windows son las pestañas.

Durante años he probado muchas soluciones, pero ninguna terminaba de gustarme... hasta ahora.

Qttabbar es un addon para el explorador de archivos. Muy fácil de instalar, con licencia GNU, y muy estable.


Licencia GNU.

Lo puedes descargar desde aquí.

El uso es muy sencillo, puesto que usa la típica combinación de teclas:

  • Ctrl + N : Nueva pestaña.
  • Ctrl + W : Cerrar pestaña.

Y el aspecto del explorador (por lo menos al ocultar la horrible barra de iconos) es elegante :)


¡Pero que elegancia de pestañas!

Saludos.

Related Posts Plugin for WordPress, Blogger...