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

Guardar imagen en MySQL desde Java

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

Siguiendo con algo más de MySQL en java vamos a guardar una imagen en la base de datos desde una aplicación hecha en java.  La idea es hacer la conexión básica siguiendo con los pasos acontinuación:

1. crear la conexión
2. Cargar la imagen la imagen a partir de FIeInputStream
3. Pasar la imagen a un flujo binario
4. Guardar la imagen

Lo primero es crear la conexión que comúnmente hacemos para conectarse con MySQL. Para ello necesitamos los datos elementales: host, nombre de la base de datos, usuario y la contraseña. Veamos como quedaría:

Class.forName("org.gjt.mm.mysql.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://host/nombre-base-de-datos", "usuario", "contrasena");

Preparamos la consulta a partir de la conexión creada, esta es una instruccion en SQL que el motor de mysql va a procesar, el único detalle que hay que tomar es que vamos a usar le signo ? (signo de interrogación) que sirve para informarle al objeto consulta que, ese valor será asigando mas adelante, pues primero hay que cargar la imagen y luego guardarla como bytes:

PreparedStatement ps = conn.prepareStatement("insert into fotos(id_foto, nombre, imagen) values (001, 'name', ?)");

Seguidamente hay que cargar el archivo con un objeto FileInputStream para que la imagen quede como un objeto de tipo File y por último pasar los bytes de la imagen al valor faltante de la consula:

File file = new File("logo.jpg");
FileInputStream fis = new FileInputStream(file);
ps = conn.prepareStatement(insertar_imagen);
ps.setBinaryStream(1, fis, (int) file.length());

En el código anterior se carga la imagen llamada logo.jpg que esta en nuestra pc. Con el objeto FileInputStream ya podemos procesar esa imagen para que al usar el método setBinaryStream() el objeto File que contiene la imagen pueda se convierta en un flujo de bytes que se almacenará en la base de datos.
Y por últmimo ejecutamos la consulta ya totalmente completa:

ps.executeUpdate();
conn.commit();

El código completo se debería ver algo así:

public class GuardarImagen {

    public static void main(String[] args) throws Exception, IOException, SQLException {

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

        PreparedStatement ps = conn.prepareStatement("insert into fotos(id_foto, nombre, imagen) values (001, 'name', ?)");
        try {
            conn.setAutoCommit(false);
            File file = new File("logo.jpg");
            FileInputStream fis = new FileInputStream(file);
            ps.setBinaryStream(1, fis, (int) file.length());
            ps.executeUpdate();
            conn.commit();
        } finally {
            ps.close();

        }

    }
}

Acá dejo el código completo y también la estructura de la tabla donde se guarda la imagen:

GuardarImagen.java y estructuraTabla

Tambíen puedes ver el tem de como cargar una imagen guardada en MySQL desde Java

Conexión entre Oracle y Java

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

Este ejemplo de conexión a Oracle es basado con el el motor Oracle Enterpriese Edition 10g. Antes que todo, te puedes bajar la base de datos desde la página oficial de Oracle, y descargar el driver desde la página de conectores. Soloa hay que recordar descargar el driver adecuado.

Como toda conectividad a base de datos, necesitamos crear la conexión. Para una conexión con Oracle, es necesario conocer 5 datos bastante necesarios que vamos a nombrar acontinuacion:

- host: la pc donde esta esta la base de datos, por lo general se una localhost o el nombre de la máquina
- puerto: el puerto donde está escuchando Oracle, en mi caso, durante la instalación de Oracle se ha especificado por defecto el valor 1521, pero puede cambiar
- service o SID: el nombre de la base de datos
- user: el usurio que se conecta a la base de datos, por defecto Oracle trae los usuarios SYS, SYSTEM, SYSMAN, DBSNMP. Comúnmente se usa el usuario SYSTEM.
- password: el password que asiganamos a los usuarios de Oracle durante la instalación del mismo

Ahora veamos como se aplican los anteriores datos a la hora de cargar el driver y crear la conexión. Se carga el dirver:

//esta es la una forma de cargar el dirver, la más usada
Class.forName("oracle.jdbc.driver.OracleDriver");

//esta es la segunda forma de cargar el driver en caso de que la primera no de resultado
/*
DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
*/

Ahora se crea la conexión, acá se usan los datos mencionados según como explica el siguiente código, también hay dos formas de hacerlo:

// primera opcion:
String url = "jdbc:oracle:thin:@//delDB:1521/catalogo";
//    jdbc:oracle:thin:@//host:puerto/service

// segunda opcion:
/*
String url = "jdbc:oracle:thin:@delDB:1521:catalogo";
*/
//    jdbc:oracle:thin:@host:port:SID

Y por último se crea el objeto Connection usando la url que se creo anteriomente, junto con el user y el password respectivamente:

Connection conn = DriverManager.getConnection(url,"usuario", "contraseña");

Ahora lo que queda es probar la conexión haciendo una pequeña consulta a al base de datos, para ello hacemos un objeto Statement a partir del objeto Connection para hacer la consulta:

Statement stmt = conn.createStatement();

Ejecutamos la consulta. La consulta es de tipo Select, por lo tanto nos va retornar alguna tabla donde ira el resultado de la consulta, este resultado se va a guardar en una variable tipo ResulSet:

ResultSet rset = stmt.executeQuery("select nombre from tabla_personas");

Finalemente desplegamos el resultado:

while (rset.next()) {
System.out.println (rset.getString("nombre"));
}

Aca dejo la clase de ejemplo: Principal.java