Añadir librerías dinámicas (*.dll, *.so) en Glassfish

Hola de nuevo por aqui retomando el blog ya que lo he tenido un poco olvidado, pero no por no querer postear si no que el trabajo me esta consumiendo lamentablemente y casi no he tenido tiempo de poder escribir algo. Pero bueno trataremos en lo posible de seguir aportando en el poco tiempo que podamos tener. En esta oportunidad estuve trabajando con un servicio web sobre glassfish, el cual este servicio hacia uso de una libreria que esta a su vez utilizaba librerías del tipo *.so, esto obviamente sobre linux, el tema es que me dedique a buscar informacion para poder ver la forma de como agregar esta librerias al library_path para que se puedan utilizar desde glassfish, y era tan simple como parece.

Esto lo realice sobre un servidor RHEL 5.4 x64, y con la version 2.1.1 de glassfish. Entonces para esto solo tendremos que acceder a la configuración del servidor por intermedio del administrador web y ubicarnos en “Application Server” luego nos dirigimos a la pestaña “Configuración JVM” y luego en “Configuración de Ruta”, una vez alli nos ubicamos en el ultimo cuadro de texto que dice “Sufijo de ruta de biblioteca nativa” y alli agregamos la ruta de las librerias que utilizaremos

y prácticamente eso seria todo. Ojo que esto es una forma de hacerlo, no trato de decir que sea la única, tal vez alguien conoce de alguna otra manera de hacerlo y lo pueda compartir.

Anuncios

Como usar XMLGregorianCalendar en Java

Hace poco desarrollando un aplicacion en Java el cual consistia en consumir un servicio web para realizar una operación puntual, se me presenta un pequeño detalle; resulta que una de la operaciones de este servicio web tenia dos de los parametros de ingreso con el tipo date y time respectivamente, entonce cuando se realiza la “importación” de toda esta estructura mediante el archivo WSDL, estos tipos de datos pasan a ser del tipo XMLGregorianCalendar, esto debido al mapeo que se proporciona a traves del API JAXB el cual es utilizado para el desarrollo de servicios web, esto con la finalidad de vincular el XML con Java  (mas detalle aqui).

Entonces teniendo la fecha y hora con el formato yyyy-MM-dd y hh:mm:ss respectivamente, vamos a realzar una manera simple de poder setear esta variales de la operacion de este servicio web. Para esto lo primero que tendriamos que hacer seria lo siguiente:

GregorianCalendar gcal = new GregorianCalendar();
XMLGregorianCalendar fec = DatatypeFactory.newInstance().newXMLGregorianCalendar(gcal);
XMLGregorianCalendar hor = DatatypeFactory.newInstance().newXMLGregorianCalendar(gcal);

Entonces de esta manera creamos dos variables (fec y hor) las cuales seran usadas para “setear” la variables de ingreso de la operacion del servicio web. Entonces ahora solo tendrias que llenar esas variables con los valores tanto de fecha a si como de hora, supongamos que tenemos la fecha 2010-04-26 y la hora 17:41:20 entonces solo hariamos lo siguiente

  String fecha_actual = "2010-04-26"
  String hora_actual = "17:45:20"
  String[] fec_part = fecha_atual.split("-");
  String[] hor_part = hora_actual.split(":");

  hor.setHour(Integer.parseInt(hor_part[0]));
  hor.setMinute(Integer.parseInt(hor_part[1]));
  hor.setSecond(Integer.parseInt(hor_part[2]));

  fec.setYear(Integer.parseInt(fec_part[0]));
  fec.setMonth(Integer.parseInt(fec_part[1]));
  fec.setDay(Integer.parseInt(fec_part[2]));

Y listo ya tenemos las variables con los valores necesarios para ser enviadas como parametros al servicio web. Por lo menos esta es una forma simple de poder trabajar con estos tipos de datos, tal vez existe alguna otra, solo me lo comentan. Espero les sirva.

Actualizar certificados de Glassfish V2

Hace poco revisando información con respecto a los certificados que utiliza Glassfish para el tema de seguridad, me entero que los mecanismos de seguridad para la transmisión de mensajes requieren de los certificados con el estándar X.509 en su versión 3 y Glassfish trae por defecto dichos certificados pero en su versión 1, hago la aclaración que estoy trabajando con Glassfish V2. Entonces veremos una forma rápida y práctica de actualizar dichos certificados; para esto descargaremos este paquete que contiene dichos certificados y el script correspondiente para su actualización.

Entonces desempaquetamos el archivo y nos ubicamos dentro de ese directorio, en este caso tiene por nombre copyv3 y luego debemos tener en cuenta que si nosotros hemos cambiado la clave del keyStore anteriormente en algun momento configurando Glassfish, debemos modificar el archivo build.xml en la opción AS_KEYSTORE_PASSWORD y colocar dicha clave, si no en todo caso dejar todo por defecto (clave por defecto: changeit). Y luego hacemos lo siguiente tal como se muestra en la imagen:

Como pueden observar el primer comando que utilizo es export AS_HOME=/opt/glassfish esto por que el script busca esa variable de entorno seteada con la ruta de instalación de Glassfish, como pueden observar en mi caso yo lo tengo en /opt/glassfish. Luego el comando /opt/glassfish/lib/ant/bin/ant, esperamos unos segundos mientras se configura, luego lo que tenemos que hacer es iniciar el servicio y listo. Lo que ahora queda es verificar si se actualizo correctamente, para esto haremos lo siguiente:

Y listo eso seria todo. Espero les sea de utilidad, por el momento estoy trabajando esto como paso inicial para poder configurar webservices seguros.

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: Una forma rápida de usar Ibatis, Postgresql con Netbeans 6.7

Este es un pequeño tutorial en el cual trato de mostrar una forma rápida de como utilizar IBatis desde java para manejar persistencia de datos utilizando nuestro favorito postgresql como gestor de base de datos. Como siempre he dicho este blog no pretende mostrar la parte teórica, para eso ya existen varios sitios en donde podemos leerlo de forma debida, solo tratamos de mostrar el trabajo de manera rápida y practica. Bueno  manos a la obra; lo primero que debemos tener en cuenta que trabajaremos con la versión 2.3.4 de IBatis, hago esta aclaración debido a que actualmente existe una versión beta 5 de esta librería y aparentemente estas difieren por lo menos a la hora de la instancia y en la configuración de los xml, eso lo veremos en un post mas adelante. Una vez validado lo anterior, lo que debemos tener es la base de datos creada, para este caso por temas didácticos, utilizaremos la base de datos IBatisDemo la cual contiene una tabla llamada Productos con los campos mostrados en la imagen

Una vez creado la BD y la tabla, creamos el proyecto web al cual lo llamaremos WebAppIBatis y lo que haremos seria crear la siguiente estructura:

Como podran observar, ire indicando que significa cada archivo y mostrando el contenido para asi se pueda entender. Si se fijan en la parte de librerías ya tenemos anexadas las librerías de IBatis y el driver jdbc para postgresql respectivamente. Bueno según la estructura observamos un clase llamada ProductoBean, esta clase contiene los atributos necesarios para poder almacenar un registro de tipo Producto y asi ser mas manipulable, entonces la clase contendra la siguiente estructura:

package org.demo.bean;
/**
*
* @author nachxs
*/
public class ProductoBean {

    private int id_producto;
    private String desc_pro;
    private int stock;
    private String ind_vig;

    public int getId_producto() {
       return id_producto;
    }

    public void setId_producto(int id_producto) {
      this.id_producto = id_producto;
    }

    public String getDesc_pro() {
      return desc_pro;
    }

    public void setDesc_pro(String desc_pro) {
      this.desc_pro = desc_pro;
    }

    public int getStock() {
      return stock;
    }

    public void setStock(int stock) {
      this.stock = stock;
    }

    public String getInd_vig() {
      return ind_vig;
    }

    public void setInd_vig(String ind_vig) {
      this.ind_vig = ind_vig;
    }
}

Luego nos ubicamos en los archivos Conexion.xml que es el encargado de los parámetros de conexión a la base de datos  y tambbien el encargado de las referencias a todos los archivos xml que se puedan crear para mapear los consultas sql , como es el caso de Producto.xml el cual es el encargado de mapear las consultas sql que usaremos en este caso para la obtención de la información respectivamente:

Conexion.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig
   PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
   "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
 <transactionManager type="JDBC" >
   <dataSource type="SIMPLE">
    <property name="JDBC.Driver" value="org.postgresql.Driver"/>
    <property name="JDBC.ConnectionURL" value="jdbc:postgresql://localhost:5432/IBatisDemo"/>
    <property name="JDBC.Username" value="postgres"/>
    <property name="JDBC.Password" value="sistemasx"/>
   </dataSource>
 </transactionManager>
 <sqlMap resource="org/demo/xml/Producto.xml" />
</sqlMapConfig>

Productos.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap
   PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
   "http://ibatis.apache.org/dtd/sql-map-2.dtd" >
    <sqlMap namespace="Productos">
        <typeAlias alias="Productos" type="org.demo.bean.ProductoBean"/>

        <select id="getProducto" parameterClass="int" resultClass="Productos">
          SELECT id_producto, desc_pro FROM "Productos" WHERE id_producto = #value#
        </select>

        <select id="getProductos" resultClass="Productos">
          SELECT id_producto, desc_pro FROM "Productos"
        </select>
    </sqlMap>

Como podemos observar en este último archivo, estamos mapeando las consultas sql que utilizaremos, vemos que cada tag select tiene un id que es el identificador de cada consulta, tiene un parameterClass, el cual este nos ayuda a enviar parámetros de entrada ya sea datos primitivos como int, long, etc. así como también clases ya sea un bean por ejemplo y el resultClass el cual permitirá almacenar las respuestas a la consultas, en este caso estamos usando ProductoBean, el cual lo asociamos a un alias llamado Productos, según como se indica en el archivo Productos.xml.

Una vez terminado de revisar los archivos mostrados anteriormente, lo que hacemos ahora es crear un Servlet, el cual lo utilizaremos para poder invocar a nuestra consultas, según sea el caso; para esto haremos lo siguiente:

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

package org.demo.action;
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Reader;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.demo.bean.ProductoBean;

/**
 *
 * @author nachxs
 */

public class Consultar extends HttpServlet {

    /**
     * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            String resource = "org/demo/xml/Conexion.xml";
            Reader reader = Resources.getResourceAsReader(resource);
            SqlMapClient sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);
            String idPro = request.getParameter("id_pro");
            ProductoBean producto = (ProductoBean) sqlMap.queryForObject("getProducto", Integer.parseInt(idPro));
            out.println("<table border='1'>");
            out.println("<tr>");
            out.println("<td>ID</td>");
            out.println("<td>Producto</td>");
            out.println("</tr>");
            out.println("<tr>");
            out.println("<td>" + producto.getId_producto() + "</td>");
            out.println("<td>" + producto.getDesc_pro() + "</td>");
            out.println("</tr>");
            out.println("<table>");
        } catch(Exception ex)  {
            out.println(ex.getMessage());
        } finally {
            out.close();
        }
    }

    /**
     * Handles the HTTP <code>GET</code> method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Handles the HTTP <code>POST</code> method.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Returns a short description of the servlet.
     * @return a String containing servlet description
     */
    @Override
    public String getServletInfo() {
        return "Short description";
    }// </editor-fold>
}

Como podrán darse cuenta dentro de la variable resource tenemos la ruta en donde se encuentra ubicado el archivo xml con los parametros de conexion, en este caso Conexion.xml, y luego en esta linea sqlMap.queryForObject(“getProducto”, Integer.parseInt(idPro)) podemos observar como invocamos a la consulta que se encuentra dentro del archivo xml Productos.xml, identificado con getProducto enviando como parametro de entrada el código de producto y eso se recepciona en ProductoBean para luego ser leido mas facilmente.

Ahora solo nos queda ir al archivo index.jsp y solo invocar al servlet de esta manera tan simple:

<%--
    Document   : index
    Created on : 28/11/2009, 10:10:19 AM
    Author     : nachxs
--%>

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <form action="Consultar" method="POST">
            ID Producto: <input type="text" name="id_pro" />
            <input type="submit" value="Consultar" />
        </form>
    </body>
</html>

y prácticamente eso seria todo, como verán no es nada difícil, y mas o menos esto seria el resultado:

Certificados Digitales y Glassfish

Hace poco por cuestiones laborales estuve buscando la forma de como configurar glassfish para que te pueda aceptar peticiones seguras (https) utilizando certificados digitales, que en este caso la empresa que validaría los certificados seria con VeriSign. Bueno revisando algunas paginas encontré una interesante en donde propone un pequeño script que prácticamente te haría todo el trabajo. El blog que propone este script es Jrod Blog, la única diferencia es que el script utiliza como empresa identificadora a CACert.org, pero no seria problema para nuestro caso, solo tendríamos que cambiar esa opción y colocar con la que trabajaríamos. Y luego solo quedaria configurar glassfish con los algoritmos de autenticación que utilizaría.

server_config