Una vez dominado el tema de Axis y Tomcat, toca poner en marcha una base de datos (lo siento Nelson, es lo que hay, incluso siendo Java el lenguaje a usar). ¿Porqué? Pues sencillamente porque cuando nuestro servicio web atienda a un cliente, deberá acceder a una base de datos (en la versión final, serán bases de datos distribuidas, pero hay que empezar poco a poco :-). El acceso a dicha base de datos se hará usando JDBC, y la base de datos a usar será PostgreSQL (quedaría bonito decir que la usamos porque es el gestor de bases de datos libre más avanzado del mundo, pero la explicación es más sencilla: el jefe lo quiso así :-).

Instalando PostgreSQL

Bueno, yo no sé que sistema operativo usarás tú, pero en mi caso (Ubuntu GNU/Linux) fue tan sencillo como lo siguiente:
# apt-get install postgresql-8.1
Esto instala el servidor y el cliente en modo texto (al final, el más útil, ya se sabe). PostgreSQL, por lo que he podido probar, tiene un sistema de usuarios “mixto”. Para usar el gestor, necesitas un usuario propio del gestor (no vale el de Unix), sin embargo si ese usuario coincide con el de Unix, te da por autenticado (un poco raro pero bueno, creo que se puede cambiar en el fichero pg_hba.conf). Por defecto, PostgreSQL crear en el sistema un usuario postgres, así como en el gestor de la base de datos. Este usuario tiene login desactivado, y no tiene contraseña en el gestor, así que deberíamos crearnos un usuario en el gestor para manejar nuestras bases de datos. Para ello, podemos hacer algo parecido a lo que sigue:
$ sudo su postgres
$ createuser -P
Entramos como usuario postgres a través del usuario root y creamos un usario con su password correspondiente. Me parece una locura haber llamado al mandato createuser sin más (¿creerán que son la única aplicación del universo que tiene un sistema de usuarios?), pero luego comprobareis que no es el único mandato con un nombre demasiado “universal”. Por cierto que por defecto el acceso remoto esta deshabilitado. Como yo no lo necesito, no he tocado nada, pero basicamente es modificar listen_addresses en el fichero postgresql.conf. En cualquier caso podeis consultar la documentación de PostgreSQL online.

Trabajando con PostgreSQL

Una vez instalado PostgreSQL y teniendo nuestro usuario, lo primero que debemos hacer es es crear una base de datos para trabajar. Con el usuario que hemos creado, haremos algo parecido a lo siguiente:
$ createdb sdft
$ psql sdft
Lo primero sirve para crear una base de datos (¿no podían haberlo llamado pgcreatedb o algo así?) con nombre sdft (en mi caso, estas son las siglas de la asignatura para la que debo hacer esta práctica), y lo segundo es el típico cliente en modo texto. Llegados a este punto entra en juego el SQL. Os recomiendo instalar el paquete de documentación de PostgreSQL para entrar en más detalles. Como supongo que a nadie le gusta mucho los clientes en modo texto (¡si son geniales!), he probado pgadmin3 y phppgadmin. El primero es una aplicación de escritorio. Supongo que es completa y tal, pero no me gusta, no me siento cómodo. Ultimamente donde me siento más cómodo trabajando (a parte de la terminal) es sobre el navegador, y precisamente la segunda aplicación es administración vía web. Yo me he quedado con esta (para gustos colores), para la que he hecho lo siguiente:
$ sudo apt-get install phppgadmin
$ sudo ln -s /usr/share/phppgadmin/ /var/www/
$ firefox localhost/phppgadmin

Instalando JDBC

Nuevamente, en Ubuntu fue una sencillísima tarea:
$ apt-cache search jdbc postgre | grep -i jdbc
libpg-java - Java database (JDBC) driver for PostgreSQL
libpgjava - Java database (JDBC) driver for PostgreSQL - transitional package
$ sudo apt-get install libpg-java
Además, debemos asegurarnos de que nuestro classpath está al corriente de la instalación, y fijarnos en que nuestra base de datos esté codificada en Unicode. En Ubuntu (supongo que en otros ocurrirá lo mismo), lo segundo se hizo por defecto, mientras que el classpath hay que hacerlo de la forma habitual de cada uno.

Creando un programa en Java que acceda a PostgreSQL mediante JDBC

Bueno, pues una vez que tenemos PostgreSQL y JDBC instalados, no queda más que crear un programa que lo pruebe. Para ello he creado una tabla prueba con un campo de tipo entero, y he insertado algunos valores. Una vez hecho esto, toca programar. Primero, importamos lo que necesitamos, damos nombre a la clase, y decidimos qué vamos a hacer. En mi caso, simplemente me conectaré a la base de datos y haré la sentencia:
SELECT * FROM prueba
Además, pasaré como parámetros al programa el usuario y el password para conectar con la base de datos. Por lo tanto:

import java.sql.*;

class Prueba {

 public static void main (String args[]) {
  // Comprobamos que nos han pasado el user y el password
  if (args.length != 2) {
   System.out.println("Error: prueba  ");
   System.exit(1);
  }

Lo primero que debemos hacer es cargar el driver JDBC. Podemos hacerlo en la terminal, en tiempo de ejecución (pasándole a java el argumento -Djdbc.drivers=org.postgresql.Driver), lo cual es muy cómodo si queremos usar nuestro código fuente con distintas bases de datos, o directamente en el código fuente, algo como lo que sigue:

  // Cargamos el driver para postgresql
  try {
   Class.forName("org.postgresql.Driver");
  } catch (ClassNotFoundException e1) {
   System.out.print("Prueba (cargando driver): ");
   e1.getMessage(); e1.printStackTrace(); System.exit(1);
  }

A continuación debemos conectar con la base de datos. Existen varias formas de hacerlo, la más sencilla es la siguiente: Connection db = DriverManager.getConnection
("jdbc:postgresql://localhost:5432/sdft", args[0], args[1]);
Donde el primer parámetro es la base de datos (en el formato driver:gestor://host:puerto/base_de_datos, pudiendo ignorar el host y el puerto para que queden con valor por defecto localhost y 5423), el segundo el usuario y el tercero el password. Existen otras maneras para conectarse forzando unas determinadas propiedades, pero de momento no lo necesito. Lo siguiente es hacer la consulta:

   Statement st = db.createStatement();
   ResultSet rs = st.executeQuery("SELECT * FROM prueba");

   db.setAutoCommit(false);
   Statement st = conn.createStatement();
   st.setFetchSize(5);
   ResultSet rs = st.executeQuery("SELECT * FROM mytable")

   // Consultamos los datos devueltos
   for (int i = 1; rs.next(); i++) {
    System.out.print("En la columna " + i + " tenemos un ");
    System.out.println(rs.getInt(1));
   }
   // Cerramos la peticion y los datos
   rs.close();
   st.close();
  } catch (Exception e) {
   System.out.print("Prueba (accediento a la base de datos): ");
   e.getMessage(); e.printStackTrace(); System.exit(1);
  }
 }
}