Glassfish: Pool de conexiones con PostgreSQL desde NetBeans

Hace poco estuve trabajando con un pequeño sistema web con Java y JSP el cual tenia clases que accedían a la base de datos a través de una conexión directa, entonces el sistema creció y me vi en la necesidad de poder utilizar una pool de conexiones para poder mejorar el acceso en rendimiento y tiempo de respuesta a la base de datos. Como siempre he mencionado en en este blog no pretendo darles a conocer la parte teórica dado que eso lo podemos encontrar en la
Wiki o en otras paginas con un mayor detalle, así que iremos directamente al trabajo práctico.

Entonces lo primero que debemos tener es configurado un gestor de base de datos con la respectiva base de datos creada la cual usaremos para realizar la conexión, en este caso PostgreSQL con la base de datos llamada bd_pool.

Una vez creada y configurada nuestra base de datos, lo que haremos ahora sera abrir nuestro NetBeans y poder registrar nuestro driver de conexión JDBC para PostgreSQL y luego crear la conexión que nos servirá de referencia para mas adelante. Entonces para esto dentro de NetBeans nos ubicamos en la pestaña de “services” (o servicios) y desplegamos la opción de “Databases” segun como se muestra en la imagen:

Luego le damos click derecho a “Drivers” y seleccionamos la opción “New Driver” entonces nos aparecerá una ventana en donde seleccionaremos la opcion “Add” y ubicamos el driver de conexión, en mi caso yo tengo el “postgresql-8.2-505.jdbc3.jar” quedando algo como esto:

Entonces solo le damos OK y ya tendremos el driver JDBC registrado y listo para usarse., segun como se muestra en la imagen:

Ahora lo que nos tocaría hacer es crear la conexión que nos servirá de referencia para poder crear el pool de conexiones, entonces en la lista mostrada anteriormente, le damos click derecho a PostgreSQL y seleccionamos la opcion “Connect Ussing” y nos aparecera una ventana en la cual llenaremos todos los datos requeridos, quedando algo como esto:

Le damos OK y luego nos aparecerá una ventana en donde seleccionaremos el esquema, entonces debido a que nosotros estamos utilizando el esquema por defecto entonces desplegamos el combo y seleccionamos “public” y luego veríamos la referencia de conexión dentro de la lista como se muestra en la imagen:

Bueno ya tenemos la primera parte de este proceso terminado, ahora continuaremos creando una aplicación web a la que llamaremos WebAppPool, solo para temas didácticos; creo que ya sabemos como hacerlo, así que no entrare en detalle allí.

Entonces una vez creado el proyecto web, le damos click derecho y nos ubicamos en “New” y luego seleccionamos la opción “Other..” y luego dentro de la opciones  nos ubicamos en Glassfish, quedando de esta manera:

Entonces una vez aquí haremos dos procesos, el primero sera seleccionar la opción “JDBC Connection Pool”, luego click en “Next” y en la siguiente ventana colocaremos como nombre “PoolDemo” y en la relación de conexiones existentes, seleccionamos la conexión activa que habíamos registrando anteriormente tal como se muestra en la figura:

luego le damos click en “Next” y obtendremos una ventana con el detalle de la conexión, tal como la URL, el usuario y el password, pero necesitaremos agregar mas detalle; para esto haremos click en el botón “Add” e iremos agregando el “servername”, “database” y “portnumber” tal como se muestra en la figura:

y luego para terminar esta parte le damos click en “Next” y nos mostrara una ventana con varias opciones de configuración, para lo cual solo cambiaremos la opción de “Steady Pool Size” que no es mas que el numero de conexiones que tendrá nuestro pool, en este caso lo cambiare de 8 a 5; pero hago la aclaracion que esto dependera de cada usuario, puede tener hasta mas conexiones, y luego finalizamos.

Esto nos generara un archivo con extensión *.xml y que estará ubicado dentro del directorio “Server Resources” con el nombre “sun-resources.xml” el cual debería contener lo siguiente:

“sun-resources.xml”

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resources PUBLIC "-//Sun Microsystems, Inc.//DTD Application Server 9.0 Resource Definitions //EN" "http://www.sun.com/software/appserver/dtds/sun-resources_1_3.dtd">
<resources>
  <jdbc-connection-pool allow-non-component-callers="false" associate-with-thread="false" connection-creation-retry-attempts="0" connection-creation-retry-interval-in-seconds="10" connection-leak-reclaim="false" connection-leak-timeout-in-seconds="0" connection-validation-method="auto-commit" datasource-classname="org.postgresql.ds.PGSimpleDataSource" fail-all-connections="false" idle-timeout-in-seconds="300" is-connection-validation-required="false" is-isolation-level-guaranteed="true" lazy-connection-association="false" lazy-connection-enlistment="false" match-connections="false" max-connection-usage-count="0" max-pool-size="32" max-wait-time-in-millis="60000" name="PoolDemo" non-transactional-connections="false" pool-resize-quantity="2" res-type="javax.sql.DataSource" statement-timeout-in-seconds="-1" steady-pool-size="8" validate-atmost-once-period-in-seconds="0" wrap-jdbc-objects="false">
    <property name="URL" value="jdbc:postgresql://localhost:5432/bd_pool"/>
    <property name="User" value="postgres"/>
    <property name="Password" value="mipassword"/>
    <property name="serverName" value="localhost"/>
    <property name="databaseName" value="bd_pool"/>
    <property name="portNumber" value="5432"/>
  </jdbc-connection-pool>
</resources>

luego nos quedaría agregar el recurso o referencia que utilizara el pool para ser llamado desde una clase que necesite la conexión, para esto le damos click derecho al proyecto, seleccionamos “New” y dentro de la ventana de opciones seleccionamos Glassfish y luego seleccionamos la opción “JDBC Resourcce” le damos click en “Next” y nos aparecera una ventana en donde seleccionaremos el pool creado anteriormente y en la opcion “JNDI Name” colocaremos como nombre “jdbc/pooldemo” quedando de la siguiente manera:

y luego finalizamos. Ahora en el archivo “sun-resources.xml” tendremos lo siguiente:

“sun-resources.xml”

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resources PUBLIC "-//Sun Microsystems, Inc.//DTD Application Server 9.0 Resource Definitions //EN" "http://www.sun.com/software/appserver/dtds/sun-resources_1_3.dtd">
<resources>
  <jdbc-resource enabled="true" jndi-name="jdbc/pooldemo" object-type="user" pool-name="PoolDemo">
    <description/>
  </jdbc-resource>
  <jdbc-connection-pool allow-non-component-callers="false" associate-with-thread="false" connection-creation-retry-attempts="0" connection-creation-retry-interval-in-seconds="10" connection-leak-reclaim="false" connection-leak-timeout-in-seconds="0" connection-validation-method="auto-commit" datasource-classname="org.postgresql.ds.PGSimpleDataSource" fail-all-connections="false" idle-timeout-in-seconds="300" is-connection-validation-required="false" is-isolation-level-guaranteed="true" lazy-connection-association="false" lazy-connection-enlistment="false" match-connections="false" max-connection-usage-count="0" max-pool-size="32" max-wait-time-in-millis="60000" name="PoolDemo" non-transactional-connections="false" pool-resize-quantity="2" res-type="javax.sql.DataSource" statement-timeout-in-seconds="-1" steady-pool-size="8" validate-atmost-once-period-in-seconds="0" wrap-jdbc-objects="false">
    <property name="URL" value="jdbc:postgresql://localhost:5432/bd_pool"/>
    <property name="User" value="postgres"/>
    <property name="Password" value="mipassword"/>
    <property name="serverName" value="localhost"/>
    <property name="databaseName" value="bd_pool"/>
    <property name="portNumber" value="5432"/>
  </jdbc-connection-pool>
</resources>

Y ya con esto tenemos la configuración lista para ser desplegada en el servidor para luego poder ser usado desde una clase u otro aplicativo que necesite una conexión.

Entonce ahora le damos clic derecho a nuestra aplicación web y seleccionamos “deploy”, con esto estaremos generando el pool de conexiones y nombre de recurso asignado a ese pool en nuestro servidor de aplicaciones. Esto lo podemos verificar entrando a la consola de administración de Glassfish; una vez dentro nos ubicamos en la opción Recursos, luego en JDBC y luego para ver nuestro pool creado nos ubicamos en Conjunto de Conexiones, y luego dentro de la lista debería estar “PoolDemo”, lo seleccionamos y nos ubicamos en la parte derecha del detalle y hacemos clic en “Sondeo”, si todo marcha bien deberías tener lo siguiente:

y luego para verificar si nuestro recurso se creo nos ubicamos en “Recursos JDBC” y en la lista debemos tener “jdbc/pooldemo”, tal como se muestra en la figura:

Y listo prácticamente eso seria todo con referencia a este tutorial, lo único que faltaría es llamarlo desde una clase cualquiera, cosa que “posteare” mas adelante. Trate de ser lo mas didáctico posible, espero les sirva.

Teclado Virtual Simple con JavaScript

Esta es una forma simple de poder crear un teclado virtual con JavaScript y llamarlo desde una pagina JSP, esto a pedido de un compañero que lo necesitaba :).

Ya saben lo primero es crear un proyecto web desde Netbeans y agregamos un archivos JavaScript y escribimos el siguiente código

Teclado.js

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

function AsignaValor(Nombre,Valor){
    var Campo = document.getElementById(Nombre);
    if(Valor==""){
        Campo.value="";
    }else{
        if(Campo.value!=""){
            Campo.value = Campo.value + Valor;
        }else{
            Campo.value = Valor;
        }
    }
}

function randOrd(){
    return (Math.round(Math.random())-0.5);
}

function marcador(Div,Nombre){
    var resultado = "";
    var num  = new Array('1','2','3','4','5','6','7','8','9','0');
    var key  = new Array('A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z');
    num.sort(randOrd);
    key.sort(randOrd);
    resultado = "<table cellpadding='1' cellspacing='1' width='100'>";
    var ini = 0;
    var fin = 10;
    resultado += "<tr bgcolor='#F0F7FD'>";
    for ( var n=0; n<10; ++n ){
        resultado += "<td align='center'><input type='button' onclick=\"AsignaValor('"+Nombre+"','"+num[n]+"')\" value=" + num[n] + " class='button_key'></td>";
    }
    resultado += "</tr>";
    for ( var i=0; i<3; ++i ){
        resultado += "<tr bgcolor='#F0F7FD'>";
        for ( var j=ini; j<fin; ++j ){
            resultado += "<td align='center'><input type='button' onclick=\"AsignaValor('"+Nombre+"','"+key[j]+"')\" value=" + key[j] + " class='button_key'></td>";
        }
        if(j<20){
            ini = j;
            fin = ini + 10;
        }else if(j==20){
            ini = j;
            fin = ini + 6;
        }else if(j==26){
            resultado += "<td bgcolor='#1C5280' colspan='4' align='center' style='cursor:pointer;' onclick=\"AsignaValor('"+Nombre+"','')\" class='Button'><strong>Limpiar</strong></td>";
        }
        resultado += "</tr>";
    }
    resultado += "</table><br>";
    document.getElementById(Div).innerHTML=resultado;
}

Ahora para poder llamarlo desde una página jsp solo tendriamos el siguiente código
index.jsp

<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>
<html>
    <head>
        <link rel="stylesheet" type="text/css" href="Estilos.css">
        <Script language="JavaScript" type="text/javascript" src="Teclado.js"></Script>
    </head>
    <body onload="marcador('contenedor','campo_clave');">
        <div align="center" valing="center"><br><br>
            <table cellpadding="2" cellspacing="0">
                <tr>
                    <td>Clave de Acceso</td>
                </tr>
                <tr>
                    <td><input type="password" id="campo_clave" style="width:150px" readonly="true" class="caja_secure" /></td>
                </tr>
                <tr>
                    <td align="center">
                        <div id="contenedor"></div>
                    </td>
                </tr>
            </table>
        </div>
    </body>
</html>

y de esta manera estariamos creando un teclado virtual básico y que puede servir para manejar password como podemos observar en la imagen.

Obviamente esto puede mejorarse, pero ya esta propuesto, descarga el codigo aquí

Tutorial:Combos dependientes con JSP, Ajax y Postgresql en Netbeans

Hola otra vez por aqui retomando el blog despues de un largo receso, como comprenderan con la familia y el trabajo se nos hace dificil a veces publicar algun post, pero bueno manos a la obra.

Este post es ha solicitud de unos compañeros que estan aprendiendo a trabajar con jsp, ajax y postgresql y necesitaban alguna guía práctica para trabajar la parte del llenado de combos de forma dependiente justamente utilizando ajax y obteniendo la data desde una base de datos.

Bueno, lo primero que debemos tener en cuenta es la estructura de tablas en la base de datos desde donde obtendremos la informacion. Para este ejemplo tome como ejemplo la siguiente estructura.

tablascomo podemos observar la base de datos se llama bd_tutorial y las tablas serian productos y detalle_producto respectivamente.

Una vez creado las tablas, ahora lo que hacemos es crear nuestro proyecto web al cual llamaremos webapp_ajaxDemo y comenzar armar nuestra estructura de archivos jsp, javascript y clases java, las cuales accederan a la informacion de la base de datos. Creamos el proyecto y generamos la siguiente estructura propuesta:

proyectoAhora, lo que haremos sera ver como obtener la informacion de la base de datos, para esto vamos a trabajar nuestras clases java empezando por los beans en donde almacenaremos la informacion  y terminando por las clases  DAO , las cuales seran las que recogeran la informacion de la base de datos.  Lo primero es tener la estructura de los archivos productoBean.java y detalleProductoBean.java, mas o menos seria la siguiente:

producto1

detalleproducto

Una vez detallada la clases Bean, ahora nos enfocamos en las clase BO y DAO, yo siempre hago esta distribucion para tener en cuenta el manejo de capas, esto ayuda mucho. Ahora veremos la estructura de la clase productoBo.java, aqui es donde definiremos los metodos que tendran acceso a los métodos de las clase DAO.

productobo

Los métodos que usaremos getProducto y getDetalleProducto los cuales nos devuelven como resultado un ArrayList de Beans esto con la finalidad de poder tener toda la informacion y poder seleccionar lo necesario. Ademas hacen referencia a métodos de las clases DAO la cuales ya tenemos definidas.

Ahora, veremos las estructuras y codificacion de las clases  que obtienen la información de la BD productoDao.java y detalleProductoDao.java respectivamente:

Para las clases productoDao.java y detalleProductoDao.java, por cuestiones de espacio solo estoy mostrando los métodos que acceden a la información, se asume que ustedes ya tienen definido los métodos de conexion y desconexion respectivamente.

productoDao.java:

productodao

detalleProductoDao.java:

detalleproductodao

Una vez ya completada la estructura y codificacion de las clases java, ahora pasaremos a codificar las paginas JSP, lo primero que haremos sera mostrar el primer combo que serian los productos, para esto mostraremos una parte de la codigo del archivo index.jsp la cual sufrira alguna moficiacion mas adelante, por el momento tenemos lo siguiente:

 

combo_1

Fijemos en los recuadros de color rojo, en el primer recuadro lo que hago es importar la clase productoBo y productoBean, dado que en el primero se tiene el metodo que obtendria la informacion de los productos, y en el segundo recuadro es donde muestro los productos los cuales son almacenados en beans del tipo productoBean por eso la declaracion en el primer recuadro.

Deben tener en cuenta que en la linea de código en donde muestro el detalle del producto en la opcion value el combo se esta poniendo el id del producto, esto para que cuando mandemos el producto se tome el id para poder realizar la busqueda en el detalle y no el nombre del producto.

Ahora veremos la parte de AJAX, para esto tenemos un archivo javascript ajax_producto.js en el cual tendremos el siguiente código:

ajax_producto1

Vemos que estamos declarando la funcion getDetalleProducto al cual le estamos enviando como parametro id_pro, luego en la parte mas abajo vemos que hacemos la referencia a la pagina ajax_detalleProducto.jsp, que en la que recuperaremos la informacion de la tabla de detalles enviando como parametro el id_pro y ademas un identificador para hacer refresco a nuestras busquedas, esto por un problema en algunos navegadores con el manejo de su cache. Y la funcion resultado_detalle que es donde le indicamos donde mostrarnos el resultado.

Fijarse bien en esto ultimo ya que como veran estamos utilizando el identificador del elemento en donde pondremos el resultado que para este caso es result_detalle.

una vez terminado esto lo que haremos sera codificar la pagina que obtendra la informacion del detalle de producto, que en este caso es ajax_detalleProducto.jsp

detalle_ajax

Ahora solo nos queda adecuar la pagina index.jsp para que pueda hacerse la invocación, mostraremos el codigo segmentado por cuestiones de espacio.

index_1

En este primer segmento, podemos ver que aqui se hace la llamada a la libreria javascript ajax_producto.js la cual contiene a la función getDetalleProducto, fijense en el evento onchange del combo, alli es donde llamamos a la funcion que retornaria la informacion del detalle.

Ahora para el segundo segmento vemos el id=”result_detalle” que es el identificador que se utiliza para mostrar el combo con el detalle.

index_2Y practicamente esto seria todo. Se debe tener en cuenta que esto se hizo de forma rápida solo para cuestiones de enseñanza, esto se puede mejorar notablemente tal vez utilizando algun framework como jQuery o mejorando el código propuesto. Espero les sea de utilidad para algunos que recien empiezan con esto

PD: Los errores ortográficos son aproposito.

Descarga el ejemplo: webapp_ajaxDemo (Ejemplo modificado para trabajar con 3 combos)

Autocomplete = “off” con Struts

Uno de los pequeños inconvenientes que se me presento al desarrollar aplicaciones web y utilizar etiquetas struts, era la compatibilidad con algunos atributos. Regularmente cuando trabajo con cuadros de texto siempre agrego el atributo “autocomplete = off” esto para que no se almacene el texto que haya escrito con anterioridad (en algunos casos es necesario). Pero al utilizar etiquetas struts este atributo no esta o por lo menos no encontre alguno analogo a este; entonces decidi probar un codigo en javascript y agregarlo dentro de mi formulario quedando de la siguiente forma.

Para empezar este es el código javascript 

autocomplete_01

Una vez que tenemos ya el código lo que hacemos ahora es agregarlo en el “body” dentro del atributo “onload” de la siguiente manera:

autocomplete_02

y ahora solo nos queda agregarlo en el formulario que tiene etiquetas struts para que todos lo cuadros de texto cumplan este atributo, quedando de la siguiente forma:

autocomplete_03

De esta manera pude utilizar este atributo, espero les sea de utilidad.

PD: Fijense que en struts para representar el atributo “Id” se hace con “styleId”, esto para que no haya confusiones.

Leer un Bean con etiquetas JSP – NetBeans 6.5

Una forma de poder acceder a un bean con etiquetas JSP de manera rapida seria de la siguiente manera:

Lo primero que tendriamos que hacer obviamente seria tener un proyecto web y luego creamos el bean cliente con las variables descritas a continuacion.

bean_1

Una vez realizdo esto, solo nos quedaria llamar a nuestro bean desde una pagina JSP, para este caso solo edite la pagina que se crea por defecto (index.jsp) y agregue el siguiente codigo:

bean_2

Que quede claro que los datos lo muestro en este caso solo en una pagina eso no indica que no lo puedan llamar desde otra, eso tambien se puede, ingrear datos en una pagina y desde otra la llaman. De esta manera podriamos usar las etiquetas JSP para llamar a los beans de manera practica.

Corrigiendo el error “getOutputStream() has already…”

En el post anterior mencione una manera de poder crear un código captcha para trabajar con paginas jsp. Bueno, revisando este código me tope con que el log del servidor(GlassFish) me arrojaba un error que quizas para muchos que trabajen con esto les sea algo familiar:

error_getoutputstream

En mi caso esto solo me aparecia en el log del servidor pero en algunos casos la excepción no deja cargar la página (Error 500). Parte del código para generar el captcha es el siguiente:

response

El cual a este punto es donde me genera el error. Ahora, para poder corregir esto lo que tendriamos que agregar seria lo que esta en el recuadro de color rojo en la imagen siguiente:

response_01

De esta manera estariamos dando una posible solución a este problema; por lo menos a mi me funcionó :).

Creando un “CAPTCHA” con JSP

Quizas algunos ya conozcan este término, pero para los que no lo conozcan, Captcha es el acrónimo de Completely Automated Public Turing test to tell Computers and Humans Apart (Prueba de Turing pública y automática para diferenciar a máquinas y humanos).

Se trata de una prueba desafío-respuesta utilizada en computación para determinar cuándo el usuario es o no humano. (Fuente: Wikipedia). En algunos casos (por no decir la mayoria) es una forma de seguridad, el de tratar de evitar o reducir de alguna manera el ataque de sites que solicitan datos para acceso ya sea usuario y contraseñas, para la realización de algun tipo de operacion.

Este código esta hecho para trabajar con JSP, y lo encontre en la web y le hice unas pequeñas modificaciones para poder adaptarla a mi proyecto.

captcha

Descarga el código captcha

PD: Se me olvido, para poder llamar al codigo desde una pagina jsp lo hacemos de la siguiente manera <img src=’Captcha.jsp’>

Manejo de Sesiones con Struts en NetBeans 6.1

Retomando el blog luego de un pequeño receso, seguiremos viendo alguna formas simples de poder trabajar con sesiones, como vimos en un post anterior lo trabajamos de manera basica con servlets, ahora veremos como es que podemos trabajarlo utilizando Struts, no detallo la teoria sobre este framework dado que lo podemos encontrar en la web, pasaremos defrente a la parte práctica.

Bueno para eso ya sabemos que hacer, abrimos nuestro Netbeans y creamos un proyecto web al cual llamaremos LoginStruts, seleccionamos el server con el que trabajaremos (Apache Tomcat) y luego en la parte donde dice seleccionar framework, escogemos Struts 1.29 nos mostrara un detalle como este:

loginstruts_01

Para este pequeño articulo no tocaremos esta parte, solo lo dejaremos por defecto y finalizamos. Una vez realizado este proceso tendriamos la siguiente estructura creada.

loginstruts_02

Al abrir el archivo “index.jsp” nos damos cuenta que tenemos solo la siguiente linea: <jsp:forward page=”Welcome.do”/>, el cual indica que lo unico que haria es un redireccionamiento a la pagina “Welcome.do”, pero se preguntaran ¿de donde sale la pagina “Welcome.do”?, alli es donde entra a tallar el archivo de configuración “struts-config.xml”:

loginstruts_03

En el circulo de color rojo que muestro en la figura es lo que nos interesa. Alli podemos obervar la accion que se realiza al utilizar “Welcome.do“, el de redireccionar a la pagina “welcomeStruts.jsp”. Para que no haya confusion podemos borrar el forward que dentro de los tags “<global-forwards>”, dado que es suficiente con el action.

Ya sabemos como parte inicial para que sirve el action en el archivo de configuracion, ahora pasamos a  crear una pagina jsp a la que llamaremos “menu.jsp” la que nos servira como pagina de carga luego del logueo correcto.

Luego pasamos a crear nuestra primera clase (Bean), la que manejaria las variables de usuario y password, las cuales la  “seteariamos” utilizando etiquetas struts desde el archivo “welcomeStruts.jsp”. A esta clase la llamaremos “LoginForm.java” y la crearemos dentro del paquete que se creo por defecto o de lo contrario creamos nuestros propios paquetes y lo creamos alli, para este caso utilizare el paquete por defecto, quedando la clase de la siguiente manera.

loginstruts_042

Fijense en la parte superior que esta con el recuadro de color rojo, eso es muy importante dado de que esta manera haremos que los valores que se “seteen” desde la pagina principal “welcomeStruts.jsp” puedan ser utilizados desde nuestra clase que haria el action.

Bueno, ya creamos el bean que almacenaria la informacion inicial, ahora lo que tenemos que hacer es registrar este bean dentro del archivo de configuracion “struts-config.xml” y lo ubicamos dentro de los tags “<form-beans>”. Para eso podemos hacer manualmente o tambien dentro del archivo de configuracion hacemos click derecho y elegimos el menu struts y luego escogemos “Add ActionForm Bean” de la siguiente manera:

loginstruts_06

Y luego nos aparecera la siguiente ventana en la cual agregaremos el nombre del bean y la clase que lo contiene.

loginstruts_07

Una vez realizado este proceso ya tendriamos el bean registrado en el archivo de configuracion quedando de la siguiente forma:

<form-beans>
<form-bean name=”LoginForm” type=”com.myapp.struts.LoginForm”/>
</form-beans>

Ahora, nos toca crear la clase que haria la accion, para eso nos ubicamos en el proyecto y le damos click derecho; seleccionamos “Struts Action” de la siguiente forma:

loginstruts_05

Se nos abrira un ventana en la cual nos pedira que agreguemos el nombre de la clase que haria la accion, para este caso le pondremos “LoginAction.java” y en el Action Path le pondremos “/Login”. Este ultimo parametro lo utilizaremos para registrarlo en archivo de configuracion y tambien para utilizarlo en action del formulario de nuestra pagina principal.

loginstruts_08

Le damos click en siguiente y tendremos el siguiente cuadro

loginstruts_09

En donde pueden observar que en el “ActionForm Bean Name” esta seleccionado nuestro bean “LoginForm”, en la opcion “Input Resource” borramos el “/” y listo le damos click en finalizar; podemos ver que en el archivo de configuracion esta registrado nuestro “Struts Action” de la siguiente forma

loginstruts_12

Ahora lo que haremos seria agregar dos forward al action uno que indicaria que hacer cuando el login sera correcto y otro cuando es incorrecto. Para esto damos click derecho sobre el archivo de configuracion y vamos al menu “struts” -> “Add forward” al cual llenamos los campos segun la figura:

loginstruts_10

y lo mismo hacemos para cuando es incorrecto quedando el archivo de configuracion de la siguiente manera:

loginstruts_11

Ahora nos metemos en el archivo LoginAction.java y escribimos el siguiente codigo:

loginstruts_13

Como podran darse cuenta tengo dos variables, usuario y password, el cual sus valores lo obtego instanciando al bean “LoginForm” y asi poder validar.

Si el usuario y clave es correcto se realizaria el envio de la variable SUCESS o en caso contrario se enviaria FAILURE, para cualquiera de estos casos se sabria que hacer de acuerdo a lo indicado en el archivo de configuracion (con los forward).

Ahora para terminar, se tendria que ingresar esos valores al bean; recuerdan que teniamos una pagina llamada “welcomeStruts.jsp” aqui es donde enviaremos los datos modificando el codigo, borramos todo el contenido del body y agregamos lo siguiente:

loginstruts_141

hay que fijarse en la parte resaltada con los recuadros de color rojo, ya que es muy importante, vemos que en el action tenemos “/Login” que es lo que tenemos registrado en el archivo de configuracion. y los campos property del text y password deben ser los mismos que del bean. Ya dependera de uds. que poner en el archivo “menu.jsp” 😛

Bueno, hasta aqui llego con el manejo de sessiones con struts espero haberme explicado con esto, cualquier comentario o duda solo postearlo.

PD: Disculpen, los errores ortograficos son a proposito.

Manejo de Sesiones con Servlets en NetBeans 6.1

Regularmente cuando realizaba pequeños proyectos web y trabajaba con sesiones siempre todo lo manejaba en archivos JSP, pero esta vez decidi probar un servlet para el manejo de sesiones y mostrar lo facil que puede resultar. Lo que comunmente hacemos es trabajar con el famoso cuadro de logueo, en donde colocamos el usuario y el password para luego ser validado y crear la sesion. Bueno lo primero que tenemos hacer es crear el proyecto dentro de NetBeans (ya saben como aplicativo web) y luego escribir algo de código basico HTML dentro del archivo “index.jsp” creando el cuadro de logueo mas o menos quedando asi:

El diseño queda a disposicion de ustedes, ahora hay un sin fin de herramientas que permiten realizar este tipo de trabajo, esto es solo para uso didactico. obviamente esta tabla de logueo lo mantendremos dentro de un “form” dado que utilizaremos el metodo POST y en el action colocaremos el Servlet al cual llamaremos “GeneraSession”.

Una vez hecho esto, creamos el archivo “principal.jsp” el cual nos servira para mostrar el resultado luego de realizar el logueo.

Luego creamos nuestra clase que actuara como servlet. Hacemos click derecho sobre nuestro proyecto y elejimos New –> Servlet, le damos el nombre (GeneraSession.java) y se nos mostrara un cuadro en donde nos dice que este nombre del servlet sera añadido al archivo de configuración “web.xml” el cual servira para poder ubicarlo y luego le damos click en terminar

Una vez hecho esto solo quedaria agregar el codigo dentro del metodo “processRequest”, quedando algo como esto:

Podemos observar que estamos obteniendo los datos del formulario mediante el request para ser validado y asi poder generar la sesion, para luego enviarnos a la pagina principal. Ahora esto no quedaria alli; en la pagina “principal.jsp” que ha sido creada tendriamos que realizar tambien la validacion de la sesion, dado que como sabemos las sesiones tienen un tiempo de vida, si sobrepasa este tiempo la sesion automaticamente se destruye (a no ser que personalize el tiempo de vida), entonces en la pagina “principal.jsp” tendriamos algo como esto:

De esta forma validamos si la sesion persite, en caso contrario te enviaria a la pagina de inicio para volver ha realizar el logueo.

Como veran es una forma practica de trabajar con sesiones mediante un servlet; obviamente esto tendria que mejorarse, pero esto puede ser un punto de partida para muchos.