Conectar MS Access y Java

Posted by manix on jul 21, 2009 in Java | 2 comments

Para establecer una conexion entre estas dos herrmientas solo se necesita unas cuantas lineas de código, a diferencia de otras bases de datos, no se necesita importar ningún paquete especial a nuestro proyecto.

Como no se dispone de ningún paquete especial solo se invoca la siguiente línea:

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

También, necesitamos saber la localización física de la base de datos, se dispone de dos opciones:
• Ubicacición absoluta: “C:\\\\manix\\Escritorio\\mi_db.mdb”
• Ubicacición relativa (la carpeta raíz del proyecto java): “mi_db.mdb”;

Luego debemos crear la url correctamente, esta url es recibida por el objeto conexión junto con el usuario y contraseña de la base de datos a la cual queremos acceder.

La url completa sería:

Entonces, la conexión quedaria de la siguiente forma:

 String url = "jdbc:odbc:MS Access Database;DBQ=mi_db.mdb"; 

En la línea anterior suponemos que mi_db.mdb es el nombre de la base de datos a la que queremos acceder, pero ésta puede cambiar según la dirección física mencionada anteriormente.

La conexión completa sería:

//creamos la url
String url = "jdbc:odbc:MS Access Database;DBQ=mi_db.mdb";

//se carga el driver
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

// se conecta a la base de datos específica en la url, seguidamente el usuario y la
// contraseña de la de la base de datos, en este no se usan y por eso se dejan vacíos
Connection con = DriverManager.getConnection (url, "", "");

A pesar de que ya esta probado muchas veces tiene ciertos conflictos de conexión para Access 2003 y Access 2007. Además debemos configurar desde Access el acceso a los datos desde aplicaciones externas.

Luego de crear la conexión, puedes ver como hacer consultas a una base de datos usando el objeto Connection

Clase Pattern

Posted by manix on jul 21, 2009 in Java | 0 comments

A partir del JDK 1.4 se incluye el paquete java.util.regexp para hacer uso de expresiones regulares en Java. El paquete está formado por dos clases, que explicaré a continuación, la clase Matcher y la clase Pattern y por una excepción, PatternSyntaxException.

• La clase Pattern representa una expresion regular
• La clase Matcher es un tipo de objeto que se crea mediante la invocación del método Pattern.matcher.

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {

public static void main(String[] args) {
String input = "#123$manix@oneble.com";

// comprueba que no empieze por punto o @

/* * El caracter '\' sirve preceder a expresiones con valores de escape, *     así \\ equivale a \ o \{ equivale a { * El caracter '^' indica comienzo de una línea * El caracter '|' representa un O lógico */
Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
if ( m.find() )
System.err.println("La expresion empieza con punto (.) o @");

//comprueba que no empieze con 123.
p = Pattern.compile("^123\\.");
m = p.matcher(input);
if (m.find())
System.out.println("La expresion empieza con123");

// comprueba que contenga @
p = Pattern.compile("\\@");
m = p.matcher(input);
if (!m.find())
System.out.println("La expresion no tiene arroba");

//Comprueba que no contenga caracteres prohibidos
/* * El caracter '+' representa una o más veces * El caracter '^' dentro de los corchetes es un NOT, permite encontrar cualquier *     carácter que NO se encuentre dentro del grupo indicado */
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean resultado = m.find();
boolean caracteresIlegales = false;
while(resultado) {
caracteresIlegales = true;
m.appendReplacement(sb, "");
resultado = m.find();
}

// Añade el ultimo segmento de la entrada a la cadena
m.appendTail(sb);

input = sb.toString();
if (caracteresIlegales) {
System.out.println("La cadena contenía caracteres ilegales que han sido suprimidos");
}
System.out.println("Email: " + input);
}
}

Para finalizar y como referencia, la siguiente tabla resume el significado de los carateres especiales utilizados para la construcción de expresiones regulares. Tener en cuenta que una expresión regular sólo puede contener (aparte de letras y números) los siguientes caracteres: < \$, ^, ., *, +, ?, [, ], \. >

Lógicos:

• x|y: x o y.
• xy: x seguido de y

Intervalos de caracteres:

• [abc]: Cualquiera de los caracteres entre corchetes. Pueden especificarse rangos, por ejemplo, [a-d] que equivale a [abcd]).
• [^abc]: Cualquier carácter que no esté los que están corchetes.

Intervalos de caracteres predefinidos:

• .: Cualquier carácter individual, salvo el de salto de línea.
• \d: Cualquier carácter de dígito, equivalente a [0-9].
• \D: Cualquier carácter que no sea de dígito, equivale a [^0-9].
• \s: Cualquier carácter individual de espacio en blanco (espacios, tabulaciones, saltos de página o saltos de línea).
• \S: Cualquier carácter individual que no sea un espacio en blanco.
• \w: Cualquier carácter alfanumérico, incluido el de subrayado, equivalente a [A-Za-z0-9_].
• \W: Cualquier carácter que no sea alfanumérico, equivalente a [^A-Za-z0-9_].

Caracteres:

• \f: Salto de página.
• \n: Salto de línea.
• \r: Retorno de carro.
• \t: Tabulación.

Limites:

• ^: Principio de entrada o línea.
• $: Fin de entrada o línea.
• \b: Límite de palabra (como un espacio o un retorno de carro)
• \B: Fin de palabra.

Cuantificadores:

• {n}: Exactamente n apariciones del carácter anterior.
• {n,m}: Como mínimo n y como máximo m apariciones del carácter anterior.
• *: El carácter anterior 0 o más veces.
• +: El carácter anterior 1 o más veces.
• ?: El carácter anterior una vez como máximo (es decir, indica que el carácter anterior es opcional)

Dar formato a las fechas en java

Posted by manix on jul 2, 2009 in Java | 1 comment

Para dar formatos personalizados a las fechas en java es bastante fácil si se conocen los patrones adecuados para darle una formato a la fecha bastante personalizado.
Veámos un ejemplo sencillo con la ayuda del objeto SimpleDateFormat y usando los patrones de dd, MM y yyyy para representar el día, el mes y el año.

Date fecha = new Date();
SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
String resultado = formato.format(fecha);
System.out.println("formato de la fecha:" + resultado);

El patrón usado dd/MM/yyyy retorna una fecha de la manera:

02/07/2009

Acá dejo una tabla con los demás patrones y su respectivo resultado, de manera, sin importar el orden se puedan combinar a conveniencia…

Conectando PostgreSQL y Java

Posted by manix on jun 26, 2009 in Java | 0 comments

Acá vengo con un ejemplo bastante básico de cómo hace una conexión entre el motor de base de datos llamado PostgreSQL y Java.
Siguiendo con el mismo mismo mecanismo del blog vamos a empezar con el primer paso que sería registrar el driver que puede ser descargado desde la página oficial jdbc de PostgreSQL:

try {
    Class.forName("org.postgresql.Driver");
  } catch (ClassNotFoundException cnfe) {
    System.out.println("NO se puedo encontrar el driver!");
    System.out.println("Vamos a imprimir el error...");
    cnfe.printStackTrace();
    System.exit(1);
  }
System.out.println("El driver se registro correctamente, hagamos una conexion...");

Si no hubo ningún problema se debería imprimir el mensaje “El driver se registro correctamente, hagamos una conexion…“.

Ahora, para crear la conexión se necesitan los datos básicos de siempre: host, nombre de la base de datos, usuario y contraseña, en mi caso la información ha quedado de la siguiente manera:

host: localhost
nombre de la base de datos: myjsp
usuario: postgres
contraseña: DB.cnsl8_2x.mnFRD

La conexión se crea a partir de un objeto Connection así:

Connection c = DriverManager.getConnection("jdbc:postgresql://localhost/myjsp", "postgres", "DB.cnsl8_2x.mnFRD");

Luego se procede a hacer el objeto Statement que se encarga de ejecutar la consulta SQL al motor de PostgreSQL para que luego atrapar el resultado en un objeto ResulSet y apartir de él reccorer el resultado e imprimir su contenido, Quedaría:

PreparedStatement s = c.prepareStatement("select id_hola from hola");
ResultSet r = s.executeQuery();

Ahora con un ciclo se recorre el contenido del ResulSet, el cual tiene el resultado de la consulta a la base de datos:

while (r.next())
          System.out.println(r.getInt(1));

El ejemplo completo quedaría de la siguiente manera:

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

public class Principal {

    public static void main(String[] args) {
        System.out.println("Chequeando el driver si esta dentro de los manejadores de drivers....");

  try {
    Class.forName("org.postgresql.Driver");
  } catch (ClassNotFoundException cnfe) {
    System.out.println("NO se puedo encontrar el driver!");
    System.out.println("Vamos a imprimir el error...");
    cnfe.printStackTrace();
    System.exit(1);
  }

  System.out.println("El drver se registro correctamente, hagamos una conexion...");

  Connection c = null;

  try {
    // The second and third arguments are the username and password,
    // respectively. They should be whatever is necessary to connect
    // to the database.
    c = DriverManager.getConnection("jdbc:postgresql://localhost/myjsp",
                                    "postgres", "DB.cnsl8_2x.mnFRD");
    PreparedStatement s = c.prepareStatement("select id_hola from hola");
    ResultSet r = s.executeQuery();
    while (r.next())
          System.out.println(r.getInt(1));
  } catch (SQLException se) {
    System.out.println("Couldn't connect: print out a stack trace and exit.");
    se.printStackTrace();
    System.exit(1);
  }

  if (c != null)
    System.out.println("Hooray! We connected to the database!");
  else
    System.out.println("We should never get here.");
  }

}

Acá adjunto la clase completo de la conexión: ejemplo_postgreSQL-java.java

Cargar imagen guardada en MySQL desde java

Posted by manix on jun 18, 2009 in Java | 5 comments

Siguiendo con el tema de cómo guardar una imagen en MySQL desde Java ahora vamos a explicar con un código bastante sencillo cómo recuperar la imagen guarda en bytes en la base de de datos, y guardarla físicamente en algún lugar de nuestro disco duro.

Los pasos para realizar la restauración de la imagenes son los siguientes:
1. crear la conexión
2. ejecuatar la consulta SQL
3. crear un archivo de imagen físico vacio
4. escribir los bytes en el archivo de imagen

Rápidamente creamos la conexión a la base de datos con los datos elementales: host, nombre de la base de datos, usuario y la contraseña. La conexión debería quedar algo así:

Class.forName("org.gjt.mm.mysql.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/myjsp", "root", "adminadmin");

Ahora vamos a ejecutar la consulta. Usando el objeto PreparedStatement para ejecuar la consulta y el objeto ResultSet para almacenar el resultado de la consulta el código quedaría:

PreparedStatement stmt = conn.prepareStatement("SELECT nombre, imagen FROM fotos");
ResultSet resultSet = stmt.executeQuery();

El objeto ResultSet es una tabla que está en memoria y que tiene la estructura de acuerdo a la consulta que se haya realizado, en este caso es una tabla con dos columnas: columna nombre (índice 1) y la columna imagen (índice 2). Lo siguiente es extraer el String de la columna del nombre con resultSet.getString(1) y extraer los bytes de la columna imagen con resultSet.getBinaryStream(2), veamos como queda:

ResultSet resultSet = stmt.executeQuery();
while (resultSet.next()) {
String name = resultSet.getString(1);
File image = new File("C:\\logo2.jpg");
FileOutputStream fos = new FileOutputStream(image);

byte[] buffer = new byte[1];
InputStream is = resultSet.getBinaryStream(2);

EL paso final es tomar el vector de bytes byte [] buffer y escribir esos bytes de uno en uno en el archivo fïsico que se habia creado anteriormente. Para eso vamos a usar el objeto FileOutputStream que esta asocioado a dicho archivo.

byte[] buffer = new byte[1];
InputStream is = resultSet.getBinaryStream(2);
while (is.read(buffer) > 0) {
fos.write(buffer);
}

Y el ejemplo completo quedaría de la siguiente manera:

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.io.File;
import java.io.FileOutputStream;

/**
*
* @author manix
*/
public class CargarImagen {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
try {
Class.forName("org.gjt.mm.mysql.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/myjsp", "root", "adminadmin");

PreparedStatement stmt = conn.prepareStatement("SELECT nombre, imagen FROM fotos");
ResultSet resultSet = stmt.executeQuery();
while (resultSet.next()) {
String name = resultSet.getString(1);
File image = new File("C:\\logo2.jpg");
FileOutputStream fos = new FileOutputStream(image);

byte[] buffer = new byte[1];
InputStream is = resultSet.getBinaryStream(2);
while (is.read(buffer) > 0) {
fos.write(buffer);
}
}

} catch (Exception e) {
}

}
}

Acá dejo adjunto la clase de ejemplo y la estructura de la tabla donde esta alojada la imagen: CargarImagen.java y tabla.txt

Puedes ver támbien el tema de cómo guardar una imagen en MySQL desde Java