CRUD de usuarios en el servidor LDAP + JAVA

En esta clase se va a realizar una clase completa para realizar una búsqueda, inserción, eliminación y modificación de los datos de los usuarios de un servidor LDAP desde el lenguaje de programación JAVA, al final de este post se pondrá el link para descargar el proyecto completo para que les quede como referencia de como es que yo lo hice, espero que les sirva, ojala puedan mejorar este código espero que lo compartan para poder ir aprendiendo todos...

[sourcecode language='java']
import com.novell.ldap.LDAPAttribute;
import com.novell.ldap.LDAPAttributeSet;
import com.novell.ldap.LDAPConnection;
import com.novell.ldap.LDAPEntry;
import com.novell.ldap.LDAPException;
import com.novell.ldap.LDAPModification;
import com.novell.ldap.LDAPSearchResults;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
* @author christian
*/

public class CRUD {
private Conexion conLDAP = new Conexion();
private LDAPConnection lc = new LDAPConnection();

/**
* Metodo paraañadir un nuevo usuario, la persona que realice esta
* transaccion debe tener los permisos para
* @param strUIDManager
* @param strPass
*/

public void Añadir(String strUIDManager, String strPass) {
try {
LDAPEntry usuario = Datos();
lc = conLDAP.ConexionManager(strUIDManager, strPass);
lc.add(usuario);
conLDAP.CerrarConLDAP(lc);
System.out.println("Usuario
Ingresado Correctamente...");
} catch(LDAPException ex) {
if (ex.getResultCode() == 68) {
System.err.println("ERROR:El Usuario ya se encuentra ingresado...");
}
Logger.getLogger(CRUD.class.getName()).log(Level.SEVERE,null, ex);
}
}

/**
* Datos del  usuario a ser Ingresado
* @return LDAPEntry
*/

public LDAPEntry Datos() {
LDAPAttributeSet setAtr = new LDAPAttributeSet();
setAtr.add(new LDAPAttribute("objectclass", new String("person")));
setAtr.add(new LDAPAttribute("objectclass", new String("organizationalPerson")));
setAtr.add(new LDAPAttribute("objectclass", new String("inetOrgPerson")));
setAtr.add(new LDAPAttribute("objectclass", new String("posixAccount")));
setAtr.add(new LDAPAttribute("objectclass", new String("top")));
setAtr.add(new LDAPAttribute("userpassword", new String("newpassword")));
//setAtr.add(new LDAPAttribute("uidnumber", new String("555")));
setAtr.add(new LDAPAttribute("givenname", new String("Jim")));
//setAtr.add(new LDAPAttribute("loginshell", new String("/dev/null")));
//setAtr.add(new LDAPAttribute("gecos", new String("arroyo carvache carlos")));
setAtr.add(new LDAPAttribute("gidNumber", new String("100")));
setAtr.add(new LDAPAttribute("sn", new String("Smith")));
setAtr.add(new LDAPAttribute("cn", new String("Jim Smith")));
setAtr.add(new LDAPAttribute("mail", new String("JSmith@Acme.com")));
//setAtr.add(new LDAPAttribute("homeDirectory", new String("/public/centros/carroyo")));
setAtr.add(new LDAPAttribute("telephonenumber", new String("1 801 555 1212")));
String dn = "uid=jsmith,ou=People,o=utpl,c=ec";
LDAPEntry newEntry = new LDAPEntry(dn, setAtr);
return newEntry;
}

/**
* Metodo para buscar un usuario dentro del servidor LDAP
* Filtro es el username a buscar
* @param LDAPConnection lc
* @param String strFiltro
*/

public void Buscar(String strUser, String strPass, String strFiltro) {
String filtro;
LDAPSearchResults searchResults;
String searchBase = "o=utpl,c=ec";
int searchScope = LDAPConnection.SCOPE_SUB;
filtro = "(uid=" + strFiltro + ")";
try {
lc = conLDAP.ConexionUser(strUser, strPass);
searchResults = lc.search(searchBase, searchScope, filtro, null, false);
//Recorre Todos los Usuarios de la Base
while (searchResults.hasMore()) {
LDAPEntry nextEntry = null;
try {
nextEntry = searchResults.next();
} catch (LDAPException e) {
System.out.println("Error: " + e.toString());
continue;
}
LDAPAttributeSet attributeSet = nextEntry.getAttributeSet();
Iterator allAttributes = attributeSet.iterator();
//Recore los atributos del usuario
while (allAttributes.hasNext()) {
LDAPAttribute attribute = (LDAPAttribute) allAttributes.next();
String attributeName = attribute.getName();
Enumeration allValues = attribute.getStringValues();
if (allValues != null) {
while (allValues.hasMoreElements()) {
String value = (String) allValues.nextElement();
System.out.println(attributeName + ": " + value);
}
}
}
System.err.println("------------------------------");
}
conLDAP.CerrarConLDAP(lc);
} catch (LDAPException ex) {
Logger.getLogger(Buscar.class.getName()).log(Level.SEVERE,null, ex);
}
}

/**
* Metodo Para Eliminar un usuario mandando como parametro el "uid"
* @param strUser
* @param strPass
* @param strUIDEliminar
*/

public void EliminarPorUID(String strUser, String strPass, String strUIDEliminar){
String dn = "uid="+ strUIDEliminar + ",ou=People,o=utpl,c=ec";
try {
lc = conLDAP.ConexionManager(strUser, strPass);
lc.delete(dn);
System.out.println("\nEntry: " + dn + " Fue Eliminado Correctamente...");
conLDAP.CerrarConLDAP(lc);
} catch (LDAPException e) {
if (e.getResultCode() == LDAPException.NO_SUCH_OBJECT) {
System.err.println("Error: NO existe ese usuario...");
} else if (e.getResultCode() == LDAPException.INSUFFICIENT_ACCESS_RIGHTS) {
System.err.println("Error: NO tiene permisos suficientes para realizar esta transaccion...");
} else {
System.err.println("Error: " + e.toString());
}
}
}

/**
* Enviar Usuario a Modificar
* @param strUser
* @param strAtributo
*/

public void Modificar(String strUser,String strAtributo) {
try {
LDAPAttribute atrubuto;
lc = conLDAP.ConexionManager("Manager", "ibmlnx");
atrubuto = new LDAPAttribute("mail", strAtributo);
String dn = "uid="+strUser+",ou=People,o=utpl,c=ec";
lc.modify(dn, new LDAPModification (LDAPModification.REPLACE, atrubuto));
System.out.println("Atributo Modificado OK...");
} catch (LDAPException ex) {
if (ex.getResultCode() == LDAPException.INSUFFICIENT_ACCESS_RIGHTS) {
System.err.println("Error: NO tiene permisos suficientes para realizar esta transaccion...");
}
}
}

public boolean ValidarPassWord(String strUser, String strPass) {
boolean correct = false;
String dnc = "uid=+" + strUser + ",ou=People,o=utpl,c=ec";
try {
lc.bind(LDAPConnection.LDAP_V3, dnc, strPass.getBytes("UTF8"));
LDAPAttribute attr = new LDAPAttribute("userPassword", strPass);
correct = lc.compare(dnc, attr);
System.err.println(correct ? "El Password es correcto" : "El Password NO es correcto.\n");
} catch (LDAPException ex) {
Logger.getLogger(CRUD.class.getName()).log(Level.SEVERE,null, ex);
} catch (UnsupportedEncodingException ex) {
Logger.getLogger(CRUD.class.getName()).log(Level.SEVERE,null, ex);
}
return correct;
}
}

[/sourcecode]

Vea también:

Conexión al servidor LDAP desde JAVA

Busqueda de usuarios en el servidor LDAP

CRUD de usuarios en el servidor LDAP

Descargar Proyecto JAVA - Netbeans

Busqueda de Usuarios en el Servidor LDAP + JAVA

Continuando con el ejemplo anterior, una ves realizada la conexión en el servidor LDAP, desde nuestra clase java, vamos a probar una clase que nos permita realizar búsquedas de usuarios ingresados en este servidor.

Esta clase seria así:

[sourcecode language='java']

/*
* Clase para Buscar Usuarios el Filtro es el usuario que se desea buscar.
*/

package conexionldap;
import com.novell.ldap.*;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
* @author christian
*/

public class Buscar {
private String searchBase = "o=utpl,c=ec";
private int searchScope = LDAPConnection.SCOPE_SUB;
private String filtro;
private LDAPSearchResults searchResults;

/**
* Metodo para buscar un usuario dentro del servidor LDAP
* @param LDAPConnection lc
* @param String strFiltro
*/

public Buscar(LDAPConnection lc, String strFiltro) {
filtro = "(uid="+ strFiltro + ")";
try {
searchResults = lc.search(searchBase, searchScope, filtro, null, false);
//Recorre Todos los Usuarios de la Base
while (searchResults.hasMore()) {
LDAPEntry nextEntry = null;
try {
nextEntry = searchResults.next();
} catch (LDAPException e) {
System.out.println("Error: " + e.toString());
continue;
}
LDAPAttributeSet attributeSet = nextEntry.getAttributeSet();
Iterator allAttributes = attributeSet.iterator();
//Recore los atributos del usuario
while (allAttributes.hasNext()) {
LDAPAttribute attribute = (LDAPAttribute) allAttributes.next();
String attributeName = attribute.getName();
Enumeration allValues = attribute.getStringValues();
if (allValues != null) {
while (allValues.hasMoreElements()) {
String value = (String) allValues.nextElement();
System.out.println(attributeName + ": " + value);
}
}
}
System.out.println("------------------------------");
lc.disconnect();
}
} catch (LDAPException ex) {
Logger.getLogger(Buscar.class.getName()).log(Level.SEVERE,null, ex);
}
}
}

[/sourcecode]

Vea también:

Conexión al servidor LDAP desde JAVA

Busqueda de usuarios en el servidor LDAP

CRUD de usuarios en el servidor LDAP

Descargar Proyecto JAVA - Netbeans

Conexión a Servidor LDAP desde JAVA

Hola en en trabajo me pidieron realizar una conexión a un servidor LDAP desde una aplicación java, esto me pareció algo difícil en un principio ya que no tenía idea de como realizar algo parecido, con algunas sugerencias de parte de mi jefe decidimos usar la librería de novell para java jLDAP, esta librería es muy completa y permite realizar todas las posibles transacciones dentro de un servidor LDAP, novell también tiene bien documentado esto hasta con ejemplos todo el API esta aquí, una ves que te familiarizas con el código vas a ver que todo es muy fácil, pero es esta serie de posts vamos a ejemplificar como se podría hacer un CRUD dentro de nuestro servidor.

Para realizar la conexión aremos lo siguiente:

[sourcecode language='java']

/*
* Clase de Conexion Servidor LDAP
*/

package conexionldap;
import com.novell.ldap.LDAPConnection;
import com.novell.ldap.LDAPException;
import java.io.UnsupportedEncodingException;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
* @author christian
*/

public class Conexion {

private int ldapPort;
private int ldapVersion;
private LDAPConnection lc;
private String login;
private String ldapHost = "172.16.30.162";

public Conexion() {
}

/**
* Este método permite realizar la conexión al servidor de LDAP
* Para el usuario manager
* @param strManager
* @param strPassword
*/

public LDAPConnection ConexionManager(String strManager, String strPassword) {
login = "cn=" + strManager + ",o=utpl,c=ec";
System.out.println("" + login);
ldapPort = LDAPConnection.DEFAULT_PORT;
System.out.println("puerto: " + ldapPort);
ldapVersion = LDAPConnection.LDAP_V3;
System.out.println("Vesion: " + ldapVersion);
System.out.println("HOST: " + ldapHost);
try {
lc = new LDAPConnection();
lc.connect(ldapHost, ldapPort);
System.out.println("====Conectado al Servidor LDAP====");
lc.bind(ldapVersion, login, strPassword.getBytes("UTF8"));
System.out.println("Autenticado en el servidor....");
} catch (UnsupportedEncodingException ex) {
Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE,null, ex);
} catch (LDAPException ex) {
Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE,null, ex);
}
return lc;
}

/**
* Este metodo permite realizar la conexion al servidor de LDAP
* Para el usuario manager
* @param strUser
* @param strPassword
*/

public LDAPConnection ConexionUser(String strUser, String strPassword) {
login = "uid=" + strUser + ",ou=People,o=utpl,c=ec";
System.out.println("" + login);
ldapPort = LDAPConnection.DEFAULT_PORT;
System.out.println("puerto: " + ldapPort);
ldapVersion = LDAPConnection.LDAP_V3;
System.out.println("Vesion: " + ldapVersion);
System.out.println("HOST: " + ldapHost);
try {
lc = new LDAPConnection();
lc.connect(ldapHost, ldapPort);
System.out.println("====Conectado al Servidor LDAP====");
lc.bind(ldapVersion, login, strPassword.getBytes("UTF8"));
} catch (UnsupportedEncodingException ex) {
Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE,null, ex);
} catch (LDAPException ex) {
Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE,null, ex);
}
return lc;
}

public void CerrarConLDAP(LDAPConnection lc) {
try {
lc.disconnect();
System.out.println("Conexion Cerrada Correctamente...");
} catch (LDAPException ex) {
Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE,null, ex);
}

}

}

[/sourcecode]

Continuar:

Busqueda de usuarios en el servidor LDAP

CRUD de usuarios en el servidor LDAP

Descargar Proyecto JAVA - Netbeans

Levantar Glassfish por consola en UBUNTU

Vamos ha ver como se hace para levantar un proyecto web, en el servidor de aplicaciones Glassfish desde la consola, regularmente como desarrolladores nos hemos encontrado con paquetes *.war, los cuales son el empaquetado de toda la aplicación web lista para funcionar, cuando instalamos netbeans también se instala glassfish pero a veces es demasiado pesado arrancar primero el IDE y después levantar el servidor de aplicaciones, para se cuenta con uno practico comando para solo levantar el servidor.

Debemos ir primero a la carpeta donde tenemos instalado glassfish y a bin, algunos lo podemos tener instalado por defecto en esta ruta:

$ cd glassfish-v2ur2/bin/

o

$ cd /usr/local/glassfish/bin/

Allí ponemos:

$ ./asadmin start-domain domain1

y esperamos un momento y ya está:

Ahora solo nos toca abrir un navegador y poner:

http://localhost:4848/

para entrar a la interfaz de administración de glassfish recuerda que cuando se instaló netbeans nos pidió un user y un password allí van, por defecto son "user: admin" y "password: adminadmin", desde allí ya podremos gestionar todos los proyectos *.war que tengamos.

Para detener Glassfish pondremos los mismo solo que con la palabra stop:

$ ./asadmin stop-domain domain1

Eso es todo, por cierto este mismo comando lo podemos usar en Window$ solo debemos ponerlo en la consola dentro de la carpeta bin de glassfish de archivos de programa, espero que les sirva tanto como a mi.

Saludos...

christmo

Leer un archivo properties desde un proyecto web + JSF

Hola en este post voy a mostrar como se debe hacer para leer un archivo *.properties de java, puesto dentro de un proyecto web JSF, es interesante mencionar que la forma de llamar a estos archivos difiere un poco de como se lo hace comúnmente en un proyecto swing de escritorio común y corriente,  ya que en este solo se pone el path relativo desde el pack del proyecto y ya, pero en un proyecto web no funciona así, por eso he decidido mostrarlo a continuación, esta es la forma que descubrí para hacerlo y me funcionó, pero si existe una forma mejor o más optima de realizarlo res ruego comentarlo para así aprender todos algo más.

Dentro de nuestro proyecto web se nos crean comunmente las páginas jsp, y su contraparte en código java dentro de un paquete en la carpeta Source Packages, dentro de ese paquete vamos a colocar el archivo .properties, teniendo en cuenta que este se va a llamar igual que la clase que lo va a leer, (por ejemplo: En mi paquete tengo una clase llamada Reportes.java, dentro del mismo paquete pondré un archivo de propiedades llamado reportes.properties), el código para ller este archivo quedaria así:

[sourcecode language='java']
String nombrePROP = Reportes.class.getSimpleName().toLowerCase() + ".properties";
Properties props = new Properties();
props.load(Reportes.class.getResourceAsStream(nombrePROP));
String strPathOrigen = props.getProperty("pathORI");
String strPathXLS = props.getProperty("pathXLS");
[/sourcecode]

Con esto ya podriamos leer las propiesades que se tenga dentro de nuestro archivo properties.

Ahora para poder poner las propiedades sacadas del archivos en variables globales, tendremos que hacer lo siguiente, fuera de cualquier método y dentro de la clase vamos a poner esto, como un método más.

[sourcecode language='java']
private static String strPathOrigen;
private static String strPathXLS;

static {
try {
String nombrePROP = Reportes.class.getSimpleName().toLowerCase() + ".properties";
Properties props = new Properties();
props.load(Reportes.class.getResourceAsStream(nombrePROP));
strPathOrigen = props.getProperty("pathORI");
strPathXLS = props.getProperty("pathXLS");
} catch (IOException ex) {
Logger.getLogger(Reportes.class.getName()).log(Level.SEVERE, null, ex);
}
}
[/sourcecode]

Así todo lo que se saque del archivo properties se almacenará globalmente y se podrá usar dentro de toda la clase si es necesario.

Espero que les haya servido...

Saludos christmo...

Descargar un archivo .XLS o .PDF con JSF

Hola había tenido problemas al tratar de descargar un archivo desde el servidor, para que sea visualizado en los computadores clientes del sistema usando JSF, pero buscando un poco por allí pude encontrar como hacerlo, este método sirve para descargar archivos *.XLS y *.PDF con los que he probado, pero me imagino que debe funcionar para cualquier tipo de archivo, lo importante es reconocer que MIME Type tiene este archivo eso lo podremos encontrar en esta página.

File ficheroXLS = new File(strPathXLS);
FacesContext ctx = FacesContext.getCurrentInstance();
FileInputStream fis = new FileInputStream(ficheroXLS);
byte[] bytes = new byte[1000];
int read = 0;

if (!ctx.getResponseComplete()) {
   String fileName = ficheroXLS.getName();
   String contentType = "application/vnd.ms-excel";
   //String contentType = "application/pdf";
   HttpServletResponse response =
   (HttpServletResponse) ctx.getExternalContext().getResponse();

   response.setContentType(contentType);

   response.setHeader("Content-Disposition",
                      "attachment;filename=\"" + fileName + "\"");

   ServletOutputStream out = response.getOutputStream();

   while ((read = fis.read(bytes)) != -1) {
        out.write(bytes, 0, read);
   }

   out.flush();
   out.close();
   System.out.println("\nDescargado\n");
   ctx.responseComplete();
}

Saludos y espero que sea de utilidad para ustedes...

CLIENTE DE GOOGLE MAPS PARA LOS CENTROS DE LA UTPL UTILIZANDO REST, MYSQL Y NETBEANS 6.1

REST Y APLICACIONES WEB LIGERAS!...

La Transferencia de Estado Representacional (REST),  es una técnica de arquitectura software para sistemas hipermedia distribuidos como la World Wide Web, en la actualidad se utiliza para describir cualquier interfaz web simple que utiliza XML y HTTP.

[caption id="" align="aligncenter" width="485" caption="Transacciones REST"][/caption]

Un concepto importante en REST es la existencia de recursos que pueden ser accedidos utilizando un Identificador Uniforme de Recurso (URI).  Para manipular estos recursos, los componentes de la red (clientes y servidores) se comunican a través de un interfaz estándar (HTTP) e intercambian representaciones de estos recursos (los ficheros que se descargan y se envían).

La petición puede ser tramitada por cualquier número de conectores (por ejemplo clientes, servidores, cachés, túneles, etc.) pero cada uno lo hace sin "ver más allá" de su propia petición (lo que se conoce como separación en capas, otra restricción de REST, que es un principio común con muchas otras partes de la arquitectura de redes y de la información). Así, una aplicación puede interactuar con un recurso conociendo por la URI y la acción requerida, no necesitando conocer si existen cachés, proxys, cortafuegos, túneles o cualquier otra cosa entre ella y el servidor que guarda la información. La aplicación, sin embargo, debe comprender el formato de la información devuelta (la representación), que es por lo general un documento HTML o XML, aunque también puede ser una imagen o cualquier otro contenido.

Mediante XML, nuestra aplicación hace el consumo del servicio del servidor de Google Maps , se le envía algunos parámetros y el servidor GOOGLE nos devolverá el respectivo mapa ubicando el lugar que se desea localizar.

Ahora que ya tenemos una ligera idea de lo que es REST, vamos ha detallar el proyecto que hemos realizado con esta tecnología:

El proyecto que se ha desarrollado hace uso de varias tecnologías y herramientas que están siendo utilizadas actualmente para el desarrollo de aplicaciones Web, grandes empresas han hecho uso de ellas teniendo un gran éxito en Internet tales como: eBay, Amazon.com, Yahoo, y muchas más; es por ello que hemos creído conveniente emplearlas en nuestro proyecto, el cual será de mucha importancia para nuestro desarrollo intelectual con lo cual nos hemos introducido en el manejo de herramientas Web 2.0. La elaboración de éste proyecto lo hemos conseguido utilizando el servicio de Google Maps, para obtener a partir del: país, provincia y cantón, la ubicación correspondiente a la ciudad en donde se encuentra ubicado cada centro universitario de la UTPL en todo el mundo, la información de cada uno de estos centros, se tiene almacenada en una base de datos elaborada en MySQL, de la cual se extraen los datos para complementarse con la ubicación en el mapa y poder dar una información correspondiente y adecuada de cada centro.

Las herramientas empleadas en el proyecto son:

Netbeans 6.1: en éste IDE, ya viene integrado el plugin para el trabajo con REST, pero es necesario actualizarla, ya que es una versión anterior la que viene integrada de la que se trabajó, en el primer vídeo se muestra como hacer esto.

MySql 5.0: se deberá cargar el scrip con los datos proporcionados en este proyecto para el optimo funcionamiento de la aplicación, en el primer vídeo se muestra como realizar esta operación .

Experiencias Comentarios y Problemas:

Es necesario que trabajen con la versión actualizada del REST (versión 0.7) en Netbeans, por lo que podrían tener problemas al realizar la conexión con el Google Maps, ya que podría cambiar la forma de realizar la conexión al trabajar con la versión anterior.

Es interesante trabajar con este tipo de aplicaciones, ya que con las herramientas que se cuenta actualmente se facilita mucho el trabajo en el desarrollo de éstas.

Vídeo demostrativo, se explica a detalle los pasos para hacer funcionar la aplicación correctamente, también se hace un análisis a a breves rasgos del contenido del proyecto para el uso de REST con nuestro proyecto de Netbeans, también se explica la elaboración del cliente y unión con el proyecto que hace de servidor de recursos mediante los Stubs de Netbeans.

[vimeo 1433197]

Este Video se muestra en si el resultado de todo el proyecto, la aplicación 100% funcional.

[vimeo 1433170]

Aquí tienes las fuentes de consulta utilizadas para hacer este proyecto: http://del.icio.us/christmo/rest

Download Código fuente de la aplicación:

Google Maps Centros UTPL

JavaCup 2008

Nuestros amigos de javahispano, organizan nuevamente JavaCup 2008, un torneo virtual de fútbol JavaCup donde cada equipo es una clase Java que implementa una interfaz predefinida.

Premios

El ganador del concurso recibirá 1500 €, el segundo clasificado recibirá 1000 €, el tercero 500 € y el cuarto 250 €. Además, todos ellos recibirán una suscripción anual a la revista Sólo Programadores. Los ganadores del concurso se anunciarán en el evento tecnológico OpenJavaDay, que se celebrará a finales de junio en España, Madrid.

Puedes visitar estos enlaces
Comienza JavaCup 2008
Sitio Oficial

Todos tenemos que participar, haber si se representa a nuestra ciudad y país...

Como crear un “Pool de Conexiones” en NetBeans 6.0 usando Java Server Faces (JSF) y MySQL

En este tutoríal vamos ha mostrar como realizar un POOL de conexiones para tener centralizada nuestra conexión a una base de datos MySQL, hay que tener en cuenta que este proceso se realiza totalmente igual si queremos conectarnos a ORACLE o a cualquier otra base de datos, esto nos evitara hacer una conexión nueva cada vez que queramos hacer una consulta nueva a la base.

Antes de empezar vamos a utilizar las siguientes herramientas:

• NetBeans 6.0

• MySQL

Vamos a tener creada previamente en MySQL una base de datos llamada “prueba” y dentro de ella una tabla llamada “roles” con dos columnas con las filas de datos que usted prefiera ingresarle a esta tabla, este detalle pasa por cuenta de la persona que sigue este tutorial.

¿Pero qué es un Connection Pool o Pool de conexiones?

Un JDBC connection pool es un grupo de conexiones reutilizables que el servidor de la aplicación mantiene para una base de datos en particular. Cuando una aplicación cierra una conexión, regresa a la piscina. Las conexiones agrupadas reducen el tiempo de la transacción al conectarse a una base de datos por medio de compartir el objeto de acceso a la conexión a la base de datos, esto a su vez evita una nueva conexión física o crear cada vez una conexión nueva.

Al ejecutar esto es lo que pasa cuando una aplicación se conecta a la base de datos.

1. Lookup JNDI nombre de los recursos de JDBC. Para conectar a una base de datos, la aplicación busca el JNDI nombre del recurso de JDBC (Data Source) asociado con la base de datos. El API de JNDI permite a la aplicación localizar el recurso de JDBC.

2. Localizar el JDBC connection pool. El recurso de JDBC especifica qué piscina de conexiones va a usar. La piscina define los atributos de conexión como la base de datos nombre (el URL), nombre del usuario, y contraseña.

3. Recupere la conexión del connection pool. El servidor de la aplicación recupera una conexión física de la piscina de conexiones que corresponde a la base de datos. Ahora que la aplicación esta conectada a la base de datos, la aplicación puede leer, modificar y agregar los datos a la base de datos. Las aplicaciones acceden la base de datos haciendo las llamadas al API de JDBC.

4. Cerrado de la conexión. Cuando el acceso a la base de datos a terminado, la aplicación cierra la conexión. El servidor de la aplicación devuelve la conexión a la piscina de conexión. Una vez regresada a la piscina, la conexión está disponible para una próxima aplicación.

Nombre JNDI. Cada recurso tiene un único nombre de JNDI que especifica su nombre y situación. Porque todo el recurso que los nombres de JNDI están en el contexto del java:comp/env, los nombres JNDI de un recurso de JDBC se espera en el contexto del java:comp/env/jdbc.

Creación de un Nuevo Proyecto JSF en NetBeans 6.0

Como primer paso vamos a crear un nuevo proyecto de JSF, vamos a file -> New Poyect -> Web -> Web Application -> y clic en Next

Le ponemos un nombre en este caso le vamos a poner “PoolConnection” y luego clic en Next

Elegimos el Framework que vamos a utilizar “Visual Web JavaServer Faces” y no cambiamos nada más, clic en Finish.

Una vez dentro de la parte de diseño de NetBeans vamos a arrastrar de la paleta un botón “Button” el cual va a ser el que nos conecte con la base MySQL y le vamos a poner de nombre conectar… Con esto realizado vamos a pasar a preparar la conexión a la base con la que vamos a trabajar.

Creación del Conector para la Base de Datos

Primero tenemos que ir a la parte de servicios (Ctrl + 5) en NetBeans y en Databases damos un clic derecho y ponemos en la opción de New Connection…

En la ventana de New Database Connection vamos a poner lo siguiente:

Name: MySQL (Connector/J driver)

Driver: com.mysql.jdbc.Driver

Database URL: jdbc:mysql://localhost:3306/prueba

En esta parte ponemos el host donde va a correr la aplicación que va a ser en “localhost”, al poner el puerto debemos tener cuidado porque el puerto 3306 es el puerto por defecto de MySQL, pero debemos ponerle el puerto que le pusimos en la instalación de MySQL si por si acaso lo cambiamos, y ponemos el nombre de la base a la que queremos tener acceso que en este caso va a ser “prueba”…

Por ultimo ponemos el User y el Password con el cual entramos a MySQL… Si queremos que recuerde NetBeans el Password le ponemos Remember Password caso contrario no (No es recomendable hacerlo por problemas de seguridad) y terminamos presionando OK.

Nos aparecerá una nueva base en el recuadro de Servicios, podremos conectarnos a ella y revisar los datos.

Creación del Pool de Conexiones para nuestro proyecto.

Lo que vamos a hacer primero es ir a File --> New File o directamente (Ctrl + n), en la ventana de New File, en Project escogemos el proyecto con el que estamos trabajando en nuestro caso “PoolConnection”, en el lado izquierdo en Categories vamos a escoger “GlassFish” y al lado derecho en File Types vamos a escoger la primera opción que es “JDBC Connection Pool” y clic en Next.

En la siguiente ventana nos pide como campo obligatorio o requerido un nombre para el pool de conexiones, le podemos dejar el que nos pone por defecto o simplemente lo cambiamos, nosotros lo vamos a dejar por defecto.

En el siguiente casillero de Extract from Existing Connection escogemos el conector que realizamos anteriormente para nuestra base de datos, y damos clic en Next.

En la siguiente ventana nos aparece Datasource Classname con un nombre bastante largo, este esta determinado por la conexión seleccionada anteriormente, nosotros lo vamos a dejar por defecto, le vamos a poner una descripción, en la tabla de propiedades podemos revisar los datos de ingreso a la base, para comprobar que estén correctos y terminamos dándole un clic en Next. (Si deseamos modificar las propiedades por defecto de la conexión, nosotros podemos cambiarlas luego editando el archivo sun-resources.xml, que se encuentra en la carpeta Server Resources de nuestro proyecto).

En la última Ventana que nos aparece con muchos campos todos los dejamos por defecto y ponemos un clic en Finish, con esto ya tenemos realizado nuestro pool de conexiones…

Acceder al Connection Pool desde una clase de Java

A través de este proceso podremos obtener un DataSource.

Lo primero que tenemos que hacer es crear el acceso a la base, vamos al código de la aplicación desde la cual queremos acceder a la base de datos, hacemos un clic derecho en el editor à escogemos Enterprise Resources à Use Database

Nos aparece la ventana para escoger la base de datos, hacemos un clic en Add, nos aparecerá una nueva ventana para configurar el Data Source, le ponemos un Nombre de Referencia en este caso le vamos a poner “conBasePrueba”, luego escogemos el Project Data Source como no tenemos creado un data source anterior, le ponemos clic en Add y se nos vuelve a abrir una nueva ventana, Create Data Source en el JNDI Name le ponemos el mismo nombre anterior “conBasePrueba” y elegimos el conector de la base a la que vamos a acceder, finalmente damos un clic en OK…

Regresamos a la ventana anterior y ya se nos carga el nombre de DataSource que ingresamos y creamos anteriormente y damos un clic en OK para confirmar…

Finalmente regresamos a la ventana de Choose DataBase ya se nos cargara la referencia a la base de datos y confirmamos haciendo un clic en OK…

Con este último paso estamos listos para realizar una prueba de conexión desde el código…

Probemos nuestro Pool con una conexión rápida.

Vamos hacer una prueba rápida de conexión y vamos a visualizar por consola nuestro resultado, regresaremos a nuestra interfaz de Diseño de NetBeans y vamos a hacer doble clic en el botón que colocamos al inicio de este tutorial, nuestro proyecto se ve más o menos así ahora.

Una vez hecho doble clic en el botón, esta acción nos lleva al código de la aplicación, directamente al método del botón button1_action() el cual lo vamos a programar en este momento para hacer la conexión nuestro código debería quedar así.

[sourcecode language='java']
public String button1_action() {
Connection con = null;
try {
InitialContext ic = new InitialContext();
//en esta parte es donde ponemos el Nombre
//de JNDI para que traiga el datasource
DataSource ds = (DataSource) ic.lookup("java:comp/env/conBasePrueba");
con = ds.getConnection();
Statement st = con.createStatement();
System.out.println("Se ha realizado con exito la conexión a MySQL");
//el resultSet es el encargado de traer los datos de la consulta
ResultSet rs = st.executeQuery("select * from roles");
while(rs.next()){
System.out.println(" "+rs.getString(1)+" "+rs.getString(2));
}
}catch (SQLException ex) {
Logger.getLogger( Page1.class.getName() ).log(Level.SEVERE, null, ex);
}catch (NamingException ex) {
Logger.getLogger( Page1.class.getName() ).log(Level.SEVERE, null, ex);
}finally {
try {
con.close();
System.out.println("Conexion Cerrada con Exito...");
}catch (SQLException ex) {
Logger.getLogger( Page1.class.getName() ).log(Level.SEVERE, null, ex);
}
}
}
[/sourcecode]

Tenemos en nuestra base una tabla llamada “roles” la cual tiene 2 columnas, en el resultSet se almacena los datos obtenidos de la consulta y mientras haya datos en él se lo puede ir descomponiendo en columnas, con un while lo podemos ir recorriendo hasta llegar a la última fila…

Se debe hacer estas importaciones para que la aplicación pueda funcionar sin ningún problema aparte de las que ya aparecen al crear el nuevo proyecto.

[sourcecode language='java']
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Resource;
import javax.faces.FacesException;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
[/sourcecode]

Tutorial creado por:

christmo