viernes, 13 de noviembre de 2015

Java: Cadenas con formato: String.format()


String textoFormateado = String.format(Patron, variables,...)

Patron: Cadena que contiene tanto el texto fijo como la ubicacion de las varibles y su formato.
Variables: variables con los valores.

Ejemplo:

String t = String.format("Aqui la var1: %5s y Aqui la var2: %3.2d.", var1, var2);

patron de formato:
%[índice$][opciones][ancho][.precisión]conversión

indice: numero que hace referencia directa a la ubicacion de la variable de la lista de variables.
ancho: numero minimo de caracteres para la variable, si su tamaño es menor se llena con espacios.
precision: numero de desimales.

conversion: tipo de dato, de acuerdo a la tabla:

Especificador Formato
%b Booleano
%h Hashcode
%s Cadena
%c Caracter unicode
%d Entero decimal
%o Entero octal
%x Entero hexadecimal
%f Real decimal
%e Real notación científica
%g Real notación científica o decimal
%a Real hexadecimal con mantisa y exponente
%t Fecha u hora

sábado, 23 de mayo de 2015

Java: Genericos

Para que una clase trabaje con varios tipos de objetos (clases), utilizamos los genéricos.

En este ejempo se puede ver una clase que utiliza genéricos <T> para que se pueda utilizar con tipos de datos especificados en ejecución.

[La palabra abstract (que se puede incluir) indica que no se puede instanciar. En el caso de un método sea abstracto, indica que se debe implementar antes de utilizarlo.]



class [abstract] MiClase<T> {

    public T miMetodo1(T t) {
        T var = t

        return var;
    }

    void abstract miMetodo2(T t);
}

Herencia: En este código se utiliza la clase anterior y se utiliza un <Tipo> definido en tiempo de ejecución.

class MiSubClase extends MiClase<Tipo> {
    Tipo miMetodo2(Tipo tipo) {
       Tipo ret = tipo;

        retrun ret;
    }
}



sábado, 9 de mayo de 2015

Configurar Apache2 en Linux Mint 17.1

Mover el directorio por defecto


desde:
/var/www
a:
cualquier ubicación (para este ejemplo: /home/miusuario/www)


1.- Editar el archivo apache2.conf
sudo nano /etc/apache2/apache2.conf


2.- Cambiar el Directorio
buscar la linea
<Directory /var/www/>
y cambiarla por:
<Directory /home/miusuario/www/>


3.- En el directorio /etc/apache2/sites-available, existen dos archivos default que se deben modificar:
cd /etc/apache2/sites-available

3.1.- para el primero:
sudo nano 000-default.conf
Buscar:
DocumentRoot /var/www/html
y cambiarla por:
DocumentRoot /home/miusuario/www

3.2.- para el segundo:
sudo nano default-ssl.conf

Buscar:
DocumentRoot /var/www/html
y cambiarla por:
DocumentRoot /home/dickneom/www

4.- por ultimo reiniciar apache2:
sudo service apache2 restart



Crear nuevos sitios (virtuales) independiente



El archivo 000-default.conf sirve como base:

1.- Crear el sitio misitio1
sudo cp 000-default.conf misitio1.conf

2.- Editar el archivo misitio1.conf
sudo nano misitio1.conf

Buscar:
DocumentRoot /var/www/html
y cambiarla por:
DocumentRoot /home/miusuario/www/misitio1

3.- En /home/miusuario/www crear el directorio para mi sitio:
cd /home/miusuario/www
mkdir misitio1

4.- Activar el nuevo sitio
sudo a2ensite misitio1

5.- por ultimo reiniciar apache2:
sudo service apache2 restart





Para desactivar un sitio (en este caso el sitio default):
sudo a2dissite default
 

jueves, 7 de mayo de 2015

Cómo configurar Virtual Host de Apache en Ubuntu 14.04 LTS

Documento original


Introducción

El servidor web de Apache es uno de los más populares para proveer contenido web en Internet. Cuenta con más de la mitad de todos los sitios web activos en la red y es extremadamente poderoso y flexible.

Apache divide su funcionalidad y componentes en unidades independientes que pueden ser configuradas independientemente. La unidad básica que describe un sitio individial o el dominio llamado virtual host.

Estas asignaciones permiten al administrador utilizar un servidor para alojar varios dominios o sitios en una simple interface o IP utilizando un mecanismo de coincidencias. Esto es relevante para cualquiera que busque alojamiento para más de un sitio en un solo VPS.

Cada dominio que es configurado apuntará al visitante a una carpeta específica que contiene la información del sitio, nunca indicará que el mismo servidor es responsable de otros sitios. Este esquema es expandible sin limites de software tanto como el servidor pueda soportar la carga.

En esta guía, te diremos como puedes configurar tus virtual hosts de Apache en tu VPS con Ubuntu 14.04. Durante este proceso, tu aprenderás como configurar diferente contenido para diferentes visitantes dependiendo del dominio que soliciten.

Pre-Requisitos

Antes de empezar este tutorial, deberías crear un usuario no-root siguiendo los pasos del 1 al 4 en esa guía.

Además necesitas tener instalado Apache para poder continuar los siguientes pasos. Si no lo has hecho aún, puedes instalar Apache en tu servidor mediante

apt-get:
sudo apt-get update
sudo apt-get install apache2
 
Después de completar estos pasos, podemos espezar.

Para propósitos de ésta guía, mi configuración creará un virtual host para ejemplo.com y otro para pruebas.com. Se hará referencia a ellos en esta guía, pero tu deberías sustituirlos por tus propios dominios durante el proceso.

Para aprender como configurar tus dominios con DigitalOcean, sigue ese enlace. Si no tienes dominios disponibles para utilizar, puedes usar valores cualquiera.

Te mostraremos como editar tus archivos locales posteriormente, en la prueba de configuración si estás utilizando valores cualquiera. Esto te permitirá probar tu configuración desde casa, aún si tu contenido no está disponible a través del dominio para otros visitantes.

Paso Uno - Crear la Estructura del Directorio

El primer paso que necesitamos es crear la estructura de directorios que mantendrán la información de nuestro sitio.

Nuestro documento raíz (el directorio principal en el cual Apache busca el contenido para mostrar) será configurado en directorios individuales dentro de la ruta /var/www. Crearemos los directorios aquí para los dos virtual hosts que pretendemos configurar.

Dentro de cada uno de estos directorios crearemos un directorio denominado public_html el cual mantendrá la información pública del sitio y sus respectivos archivos. Esto nos dará más flexibilidad en nuestro alojamiento.

Para asegurarnos, para cada uno de nuestros sitios, vamos a crear los directorios así:

For instance, for our sites, we're going to make our directories like this:

sudo mkdir -p /var/www/ejemplo.com/public_html
sudo mkdir -p /var/www/pruebas.com/public_html
 
Las marcas en rojo representan el dominio que esperamos que sirva nuestro VPS.

Paso Dos - Otorgar Permisos

Ahora tenemos la estructura de los directorios para neustros archivos, pero el usuario root es el propietario de ellos. Si queremos que nuestro usuario regular pueda modificar los archivos en nuestro directorio web, necesitamos cambiar el propietario haciendo lo siguiente:

sudo chown -R $USER:$USER /var/www/ejemplo.com/public_html
sudo chown -R $USER:$USER /var/www/pruebas.com/public_html
 
La variable $USER tomará el valor del usuario con el cual actualmente estás identificado. Al hacer esto, nuestro usuario regular ahora es propietario de los directorios public_html donde se almacenará nuestro contenido.

Debemos además modificar los permisos un poco para asegurarnos que el permiso de lectura pueda ser aplicado a archivos y directorios para que las páginas puedan ser desplegadas correctamente:

sudo chmod -R 755 /var/www
 
Tu servidor ahora tiene los permisos necesarios para mostrar el contenido, y el usuario deberá ser capaz de crear contenido en los directorios a medida que sea necesario.

Paso Tres — Crear una Página de Prueba para cada Virtual Host

Actualmente tenemos la estructura en su lugar. Vamos a crear contenido para mostrar.

Solo vamos a hacer una demostración, así que nuestras páginas serán muy simples. Solo crearemos un archivo index.html para cada sitio.

Empecemos con ejemplo.com. Podemos abrir un archivo index.html mediante un editor escribiendo:

nano /var/www/ejemplo.com/public_html/index.html
 
En este archivo, crea un documento HTML simple que indicara que el sitio está conectado. Mi archivo quedó así:

<html>
  <head>
    <title>Bienvenido a Ejemplo.com!</title>
  </head>
  <body>
    <h1>Éxito! El Virtual Host ejemplo.com esta funcionando!</h1>
  </body>
</html>
 
Guarda y cierra el archivo cuando termines.
Podemos copiar este archivo y usarlo de base para nuestro segundo sitio escribiendo:

cp /var/www/ejemplo.com/public_html/index.html /var/www/pruebas.com/public_html/index.html
 
Ahora podemos abrir el archivo y modificar la información relevante:

nano /var/www/pruebas.com/public_html/index.html
<html>
  <head>
    <title>Bienvenido a Pruebas.com!</title>
  </head>
  <body>
    <h1>Éxito! El Virtual Host pruebas.com esta funcionando!</h1>
  </body>
</html>
 
Guarda y cierra como el en caso anterior. Ahora tienes páginas suficientes para probar tu configuración.

Paso Cuatro — Crear Nuevos Archivos Virtual Host

Los archivos Virtual Host son archivos que contienen información y configuración específica para el dominio y que le indican al servidor Apache como responden a las peticiones de varios dominios.

Apache incluye un archivo Virtual Host por defecto denominado 000-default.conf que podemos usar para saltarnos al punto. Realizaremos una copia para trabajar sobre ella y crear nuestro Virtual Host para cada dominio.

Iniciaremos con un dominio, configuralo, copialo para el segundo dominio, y después realiza los ajustes necesarios. La configuración por defecto de Ubuntu requiere que cada archivo de configuración de Virtual Host termine en .conf.

Crear el Archivo Virtual Host

Empezando por copiar el archivo para el primer dominio:

sudo cp /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/ejemplo.com.conf

Abre el nuevo archivo con tu editor como usuario root:

sudo nano /etc/apache2/sites-available/ejemplo.com.conf
 
Este archivo se verá algo como esto (he removido los comentarios aquí para hacer el archivo más legible):

<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www/html
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
 
Como puedes ver, no hay mucho aquí. Personalizaremos los datos aquí para nuestro primer dominio y agregaremos algunas directivas adicionales. Esta sección del Virtual Host coincide cualquier peticion que es solicitada al puerto 80, el puerto por defecto de HTTP.
Primero, necesitamos cambiar la directiva ServerAdmin por un correo del administrador del sitio que pueda recibir correos.

ServerAdmin admin@ejemplo.com
 
Después de esto, necesitamos agregar dos directivas. La primera llamada ServerName, que establece la base del dominio que debe coincidir para este Virtual Host. Esto será como tu dominio. La segunda, llamada ServerAlias, determina nombres futuros que pueden coincidir y servirse como el nombre base o dominio principal. Esto es útil para host tipo www:

ServerName ejemplo.com
ServerAlias www.ejemplo.com
 
Lo que resta por cambiar para la configuración básica de un Virtual Host es la ubicación del directorio raíz para el dominio. Ya hemos creado lo que necesitamos, así que solo necesitamos modificar DocumentRoot para apuntarlo al directorio que hemos creado:

DocumentRoot /var/www/ejemplo.com/public_html
 
En total, nuestro archivo de Virtual Host debe verse así:

<VirtualHost *:80>
    ServerAdmin admin@ejemplo.com
    ServerName ejemplo.com
    ServerAlias www.ejemplo.com
    DocumentRoot /var/www/ejemplo.com/public_html
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
 
Guarda y cierra el archivo.

Copia el primer Archivo Virtual Host y cambialo para el Segundo Dominio

Ahora que tenemos nuestro primer archivo Virtual Host configurado, podemos crear el segundo copiando el primero y realizando los cambios necesarios.
Empecemos por copiarlo:

sudo cp /etc/apache2/sites-available/ejemplo.com.conf /etc/apache2/sites-available/pruebas.com.conf

Abre el nuevo archivo con privilegios root en tu editor:

sudo nano /etc/apache2/sites-available/pruebas.com.conf

Ahora tenemos que modificar todas las piezas de información para referirnos al segundo dominio. Cuando hayas terminado, deberá verse algo así:

<VirtualHost *:80>
    ServerAdmin admin@pruebas.com
    ServerName pruebas.com
    ServerAlias www.pruebas.com
    DocumentRoot /var/www/pruebas.com/public_html
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
 
Guarda y cierra al concluir.

Paso Cinco — Habilita los nuevos Archivos Virtual Host

Ahora que hemos creado nuestros archivos virtual hosts, debemos habilitarlos. Apache incluye herramientas que nos permiten hacer esto.
Podemos usar la herramienta a2ensite para habilitar cada uno de nuestros sitios haciendo esto:

sudo a2ensite ejemplo.com.conf
sudo a2ensite pruebas.com.conf
 
Cuando hayas concluido, deberás reiniciar Apache para asegurarte de que tus cambios surtan efecto:

sudo service apache2 restart
 
Deberás recibir un mensaje de información similar a esto:

* Restarting web server apache2
 AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.0.1. Set the 'ServerName' directive globally to suppress this message

Este mensaje no afecta nuestro sitio.

Paso Seis — Configura Archivos Locales (Opcional)

Si aún no estás utilizando nombres de dominio de tu propiedad para este procedimiento y utilizaste dominios ejemplo en su lugar, puedes al menos hacer pruebas de funcionalidad de este proceso modificando temporalmente el archivo hosts de tu computadora local.
Esto interceptará cualquier petición a los dominios que configures y apunten a tu VPS, solo si estas utilizando dominios registrados.
Esto solo funciona a través de tu computadora, y es simplemente útil para propósitos de prueba.
Asegúrate de estár trabajando en tu computadora local para los siguientes pasos y no en tu VPS. Deberás conocer la contraseña del administrador o ser miembro del grupo administrativo.
Si estas en una Mac o una computadora con Linux, edita tu archivo local con privilegios de administrador escribiendo:
sudo nano /etc/hosts
Si estás en una máquina con Windows, puedes buscar las instrucciones para modificar tu archivo hosts aquí.
Los detalles que necesitas agregar son la IP pública de tu VPS seguido del dominio que deseas apuntar a ese VPS.
Para los dominios que utilizamos en esta guía, asumiremos que la IP de nuestro VPS es 111.111.111.111, podemos agregar las siguientes líneas al final del archivo hosts:

127.0.0.1   localhost
127.0.1.1   guest-desktop
111.111.111.111 ejemplo.com
111.111.111.111 pruebas.com
 
Esto apuntará directamente cualquier petición para ejemplo.com y pruebas.com en nuestra computadora y enviarlas a nuestro servidor en 111.111.111.111. Esto es lo que queremos si no somos propietarios de esos dominios aún, solo con fines de prueba para nuestros Virtual Hosts.
Guarda y cierra el archivo.

Paso Sierte — Prueba tus Tesultados

Ahora que tenemos nuestros Virtual Hosts configurados, podemos realizar pruebas de configuración simplemente visitando el dominio que hemos configurado mediante nuestro navegador web:

http://ejemplo.com
 
Deberás ver algo como esto:
Ejemplo Virtual Host de Apache
Del mismo modo, si visitamos la segunda página:

http://pruebas.com
 
Podrás observar el archivo que has creado para el segundo sitio:
Prueba de Virtual Host de Apache
Si en ambos sitios funciona bien, entonces has configurado correctamente dos Virtual Hosts en el mismo servidor.
Si necesitas ajustar el archivo hosts de tu computadora, probablemente solo deberás borrar las líneas que has agregado y verificar que tu configuración funciona. Esto previene que tu archivo hosts se llene de entradas que no son necesarias.
Si necesitas acceso constante a estos Virtual Host, considera adquirir dominios para cada sitio y configurarlos para que apunten a tu VPS.

Conclusión

Si me has seguido, deberás tener un servidor respondiendo a dos dominios separados. Ahora puedes expandir este procedimiento siguiendo los pasos que hemos llenado arriba para crear Virtual Hosts adicionales.
No hay limite de software en el número de dominios que Apache pueda manejar, así que eres libre de agregar tantos como tu servidor pueda soportar.

martes, 7 de abril de 2015

phppgadmin on Ubuntu 14.04 LTS

Doc Original

(20150407)

On Ubuntu 14.04 LTS, when "phppgadmin" was installed using following command,

sudo apt-get install phppgadmin

By default it was not running, and was showing 404 error in browser. Had to execute following command,

  • sudo cp /etc/apache2/conf.d/phppgadmin /etc/apache2/conf-enabled/phppgadmin.conf
  • sudo /etc/init.d/apache2 restart
Ref: http://askubuntu.com/questions/451378/phppgadmin-not-working-in-ubuntu-14-04

lunes, 6 de abril de 2015

Configurar IP estática en Ubuntu Server 12.04 LTS

Doc Original

(20150706)

En otras entradas anteriores os comentaba como instalar Ubuntu Server 12.04 LTS (aquí) y además os comentaba como instalar el servidor Open SSH (aquí), pues ahora os enseñaré como configurar la IP de forma estática. Esto es imprescindible sino queremos que se nos cambie la IP del servidor cada vez que lo reiniciamos. Para ello tenemos que modificar el fichero /etc/network/interfaces y cambiar lo que hay por:

iface eth0 inet static
address 192.168.1.50
netmask 255.255.255.0
network 192.168.1.0
broadcast 192.168.1.255
gateway 192.168.1.1
dns-nameservers 208.67.222.222 208.67.220 220

Aunque claro, debemos de cambiar los valores por lo que nos interese:
address: la dirección IP que tendrá nuestra máquina
netmask: la máscara de red. Si usamos una dirección IP de clase C, habitual en redes pequeñas, del tipo 192.168.1.x la máscara de red será 255.255.255.0
nerwork: la dirección de la red. Será nuestra dirección IP pero con el último valor acabado en 0. broadcast: la dirección de broadcast. Será nuestra dirección IP pero con el último valor acabado en 255. gateway: la puerta de enlace, es decir, la IP del router de salida.
dns-nameservers: la dirección IP de los servidores DNS. En este caso he usado los del proyecto OpenDNS.
En este caso tengo que darle miles de gracias a Pedro Espín López que ha sido quién se ha currado esta entrada. Además yo no tenía ni idea del proyecto OpenDNS por lo que ya aprendí algo en el día de hoy ;-)
 ---------------------------------------------
PD: Un buen libro para aprender sobre Ubuntu Server (aunque un poco caro) es:  El libro oficial de Ubuntu Server de Kyle Rankin y Benjamin Mako Hill.

domingo, 1 de febrero de 2015

Java: Manejo de fecha II

Documento original: Manejo De Fechas En Java I, Por Carlos Zuluaga (Mayo 1 de 2007).

(2015-01-15)

Trabajar con fechas en java no es algo del otro mundo ni tiene demasiadas complicaciones, pero la cantidad de formas que hay para hacerlo puede confundirnos, o peor aún, puede que sólo conozcamos la más mala para hacerlo. Con estos artículos pretendo explicar un poco que clases tiene el lenguaje para trabajar con fechas, los métodos más usados y algunas sugerencias para realizar un trabajo adecuado que nos facilite el mantenimiento de nuestras aplicaciones.

1. Las clases java.util.Date y java.sql.Date. Son dos de las clases más usadas cuando una aplicación implica el trabajo con fechas:

java.util.Date: Según la documentación "La clase java.util.Date representa un instante de tiempo específico, con precisión de milisegundos"; esto más que ser una especie de "autoadulación" para la clase, quiere decir que no solo se trata de una simple cadena al estilo yyyy/MM/dd, sino que almacena hasta milisegundos y que es posible trabajar con ellos.
Antes del jdk1.1 la clase java.util.Date tenía dos funciones adicionales a la que conocemos ahora, una de ellas era la interpretación de datos que tenían que ver con fechas, como años, días, segundos, entre otros. La otra era el formateo (la forma como se muestra) y parseo (convertir un String a java.util.Date). Pero debido a las dificultades que presentaban estas funcionalidades a la hora de internacionalizar los programas, esos métodos ya está obsoletos y la clase java.util.Calendar se encargó de esto; así que en este momento esta clase, sólo hace lo que se mencionó al principio: "representa un instante de tiempo específico, con precisión de milisegundos"; más adelante veremos como ampliar esta funcionalidad. Por ahora veamos las convenciones que sigue esta clase:

* El año "y" está representado por un entero igual a ("y" - 1900). Por ejemplo el año 2004 se representa como 104 (2004 - 1900).
* Los meses son representados por números entre 0 y 11, donde enero es 0 y diciembre es 11.
* Los días y minutos se representan de forma corriente. Entre 1 - 31 y 0 - 59 respectivamente.
* Las horas van entre 0 y 23, donde la medianoche es 0 y el medio día 12.
* Los segundos van entre 0 y 61. 61 solo ocurre cuando se agrega el segundo adicional para ajustar la diferencia entre el reloj atómico y el tiempo de rotación de la tierra.
No sobra mencionar que los métodos para obtener el año, mes y día de esta clase ya están obsoletos y lo único que hacen es llamar a la clase java.util.Calendar para que esta se encargue de hacerlo (una delegación).

java.sql.Date: Esta clase hereda de java.util.Date y es la representación de la fecha cuando trabajamos con JDBC (Java DabaBase Connectivity), es decir, son los campos almacenados en una base de datos cuyo tipo es una fecha que puede o no incluir la hora, aunque la clase java.sql.Date siempre lo hace. Al igual que su clase padre, tiene una precisión de milisegundos, con la excepción que al mostrarla en la salida estándar con el formato por defecto solo muestra el día, mes y año. Hay que anotar también que para campos que almacenen solamente horas existen otras clases para manejarlos.
En resumen ambas clases, sólo se encargan de almacenar la cantidad de milisegundos que han pasado desde las 12 de la noche del primero de enero de 1970 en el meridiano de Greenwich. Aquí vienen dos puntos importantes:

a) Si la fecha que almacena cualquiera de las clases es menor a las 00:00:00 enero 1 de 1970 GMT, su valor el milisegundos será negativo.
b) La fecha es susceptible a la zona horaria. Por ejemplo en Colombia los milisegundos no se empiezan a contar desde enero 1 de 1970, sino a partir de las 19:00 de diciembre 31 de 1969. Esto es importante por que si transportamos una fecha relativa de una zona a otra, podemos llegar a tener problemas al confiar en los milisegundos que se tienen; además como la clase intenta representar el "Tiempo Universal Coordinado" (UTC) suma 0.9 segundos cada año para ajustar la diferencia entre el reloj atómico y la velocidad de rotación de la tierra. Esto se traduce en que muy dificilmente podemos basarnos en valores como 0 o 60000 para realizar validaciones, pues esos milisegundos no son controlables cuando creamos la instancia de una fecha, peor aún, los milisegundos no son ni siquiera iguales para la misma fecha en la misma zona horaria.
Ambas clases se pueden instanciar directamente mediante new(), pero la clase java.sql.Date necesita un parámetro en el constructor: el tiempo en milisegundos, así que las siguientes instrucciones son válidas:

java.util.Date fechaActual = new java.util.Date(); //Fecha actual del sistema
java.sql.Date inicioLocal = new java.sql.Date(0); //Milisegundo cero
 
//también se puede crear una instancia de java.util.Date con parámetros iniciales
java.util.Date otraFecha = new java.util.Date(1000); //El primer segundo a partir del inicio

Prueba a imprimir cada uno de estos valores y fíjate en la diferencia de formatos entre java.sql.Date y java.util.Date. Se puede pasar de java.sql.Date a java.util.Date de dos fomas, una de ellas es con una asignación simple:

java.util.Date utilDate = null;
java.sql.Date sqlDate = new java.sql.Date(0);
utilDate = sqlDate;
/* aunque es java.util.Date, 
 si la imprimes tendrá el formato de java.sql.Date, recordemos que java.sql.Date hereda de 
 java.util.Date */
System.out.println(utilDate);

También se pueden tomar los milisegundos de java.sql.Date y pasarlos al constructor de java.util.Date:

java.util.Date utilDate = null;
java.sql.Date sqlDate = new java.sql.Date(0);
utilDate = new java.util.Date(sqlDate.getTime());
//esta vez se mostrará con el formato de java.util.Date
System.out.println(utilDate);

Para pasar de java.util.Date a java.sql.Date se deben tomar los milisegundos de la primera y pasarlos al constructor de la segunda:

java.util.Date utilDate = new java.util.Date();
java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
//Con formato de java.sql.Date
System.out.println(sqlDate);

Para comparar fechas usamos el método compareTo() que internamente compara los milisegundos entre ellas usando directamente los métodos getTime() de ambas clases.

java.util.Date utilDate = new java.util.Date(); 
java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
if (utilDate.compareTo(sqlDate) == 0){
   System.out.println("IGUALES"); 
}else{ 
   System.out.println("DIFERENTES"); 
} 
 
O lo que es equivalente:

java.util.Date utilDate = new java.util.Date();
java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
if (utilDate.getTime() == sqlDate.getTime()){
  System.out.println("IGUALES");
}else{
  System.out.println("DIFERENTES");
} 
 
2. Las clases Time y Timestamp.
Ambas clases pertenecen al API JDBC y son la encargadas de representar los campos de estos tipos en una base de datos. Esto no quiere decir que no se puedan usar con otros fines. Al igual que java.sql.Date, son hijas (heredan) de java.util.Date, es decir, su núcleo son los milisegundos.
La clase Time es un envoltorio de la clase java.util.Date para representar los datos que consisten de horas, minutos, segundos y milisegundos, mientras Timestamp representa estos mísmos datos más un atributo con nanosegundos, de acuerdo a las especificaciones del lenguaje SQL para campos de tipo TIMESTAMP.
Como ambas clases heredan del java.util.Date, es muy fácil pasar de un tipo de dato a otro; similar a la clase java.sql.Date, tanto Time como Timestamp se pueden instanciar directamente y su constructor tiene como parámetro el número de milisegundos; como es de imaginarse, cuando se muestra alguna de las clases mediante su método toString() se ven los datos que intentan representar; La clase Time sólamente muestra la hora, minutos y segundo, mientras timestamp agrega fracciones de segundo a la cadena.
Para convertir entre tipos de datos diferentes debemos usar los milisegundos de una clase y asignarlos a las instancias de las otras, y como la clase java.util.Date es superclase de todas, a una instancia de esta podemos asignar cualquiera de las otras, manteniendo los métodos de la clase asignada, es decir, si asignamos un Time a una java.util.Date, al imprimir se verá el mismo formato de la clase Time.

Con este código:

  java.util.Date utilDate = new java.util.Date(); //fecha actual
  long lnMilisegundos = utilDate.getTime();
  java.sql.Date sqlDate = new java.sql.Date(lnMilisegundos);
  java.sql.Time sqlTime = new java.sql.Time(lnMilisegundos);
  java.sql.Timestamp sqlTimestamp = new java.sql.Timestamp(lnMilisegundos);
  System.out.println("util.Date: "+utilDate);
  System.out.println("sql.Date: "+sqlDate);
  System.out.println("sql.Time: "+sqlTime);
  System.out.println("sql.Timestamp: "+sqlTimestamp); 
 
Se obtiene la siguiente salida: 

util.Date: Thu May 20 19:01:46 GMT-05:00 2004
sql.Date: 2004-05-20
sql.Time: 19:01:46
sql.Timestamp: 2004-05-20 19:01:46.593


Note que aún cuando todos los objetos tienen los mismos milisegundos el formato con el que se muestran dependen de la clase que realmente los contiene. Es decir, no importa que a un objeto del tipo java.util.Date se le asigne uno del tipo Time, al mostrar a través de la consola se invocará el método toString() de la clase time:
 
utilDate = sqlTime;
System.out.println("util.Date apuntando a sql.Time: ["+sqlTime+"]");
utilDate = sqlTimestamp;
System.out.println("util.Date apuntando a sql.Timestamp: ["+sqlTimestamp+"]");

Arroja:
util.Date apuntando a sql.Time: [19:29:47]
util.Date apuntando a sql.Timestamp: [2004-05-20 19:29:47.468]
Pero si en vez de solo apuntar, creamos nuevas instancias con los milisegundos los formatos con que se muestran son los mismos. Note que lo verdaderamente importante ocurre cuando creamos la instancia de java.util.Date usando los milisegundos del objeto sqlTime, pues aunque este último únicamente muestra horas, minutos y segundos, siempre ha conservado todos los datos de la fecha con que se creó.

utilDate = new java.util.Date(sqlTime.getTime());
System.out.println("util.Date con milisegundos de sql.Time: ["+utilDate+"]");
utilDate = new java.util.Date(sqlTimestamp.getTime());
System.out.println("util.Date con milisegundos de sql.Timestamp: ["+utilDate+"]");

Fíjese en el formato de salida:
util.Date con milisegundos de sql.Time: [Thu May 20 19:54:42 GMT-05:00 2004]
util.Date con milisegundos de sql.Timestamp: [Thu May 20 19:54:42 GMT-05:00 2004]
Para finalizar esta primera entrega veamos el código para mostrar la diferencia entre dos fechas en horas, minutos y segundos. Esta no es la mejor forma para hacerlo, pero cabe bien para mostrar de forma práctica todos los conceptos anteriormente estudiados.

 import java.util.HashMap;
 import java.util.Map;
 public class Prueba {
  public static Map getDiferencia(java.util.Date fecha1, java.util.Date fecha2){
   java.util.Date fechaMayor = null;
   java.util.Date fechaMenor = null;
   Map resultadoMap = new HashMap();
 
   /* Verificamos cual es la mayor de las dos fechas, para no tener sorpresas al momento
    * de realizar la resta.
    */
   if (fecha1.compareTo(fecha2) > 0){
    fechaMayor = fecha1;
    fechaMenor = fecha2;
   }else{
    fechaMayor = fecha2;
    fechaMenor = fecha1;
   }
 
  //los milisegundos
   long diferenciaMils = fechaMayor.getTime() - fechaMenor.getTime();
 
   //obtenemos los segundos
   long segundos = diferenciaMils / 1000;
 
   //obtenemos las horas
   long horas = segundos / 3600;
 
   //restamos las horas para continuar con minutos
   segundos -= horas*3600;
 
   //igual que el paso anterior
   long minutos = segundos /60;
   segundos -= minutos*60;
 
   //ponemos los resultados en un mapa :-)
   resultadoMap.put("horas",Long.toString(horas));
   resultadoMap.put("minutos",Long.toString(minutos));
   resultadoMap.put("segundos",Long.toString(segundos));
   return resultadoMap;
}
 
  public static void main(String[] args) {
   //5:30:00 de Noviembre 10 - 1950 GMT-05:00
   java.util.Date fecha1 = new java.util.Date(-604070999750L);
 
   //6:45:20 de Noviembre 10 - 1950 GMT-05:00
   java.util.Date fecha2 = new java.util.Date(-604066478813L);
 
   //Luego vemos como obtuve esas fechas
   System.out.println(getDiferencia(fecha1, fecha2));
  }
}
DIFERENCIA ENTRE FECHAS
Fecha1: Fri Nov 10 05:30:00 GMT-05:00 1950
Fecha2: Fri Nov 10 06:45:21 GMT-05:00 1950
{segundos=20, horas=1, minutos=15}
Notas:

1. Existe un error de un segundo, lo cual no sucede cuando trabajamos con fechas posteriores a 1970, ¿Por qué?.
2. Este procedimiento funciona igual para todos los hijos de java.util.Date: java.sql.Date, java.util.Time y java.util.Timestamp.
3. Todos los ejemplos los hemos hecho creando nuevas instancias de las clases. He omitido el traer información desde una base de datos para no complicar el código; pero todo lo que hemos hecho debe funcionar igual de ambas formas (con base de datos y usando constructores).
En la próxima entrega veremos como realizar operaciones completas entre fechas utilizando las clases Calendar y GregorianCalendar.