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:

Tutorial: EJB, Persistencia y PostgreSQL en NetBeans 6.5

Hola a todos de nuevo por aquí retomando la creación de pequeños tutoriales en base a las prácticas desarrollando en mi diario aprendizaje. Esta vez veremos una forma rápida de como crear y usar un EJB utilizando persitencia de datos con TopLink y nuestro querido gestor de base de datos, PostgreSQL. No hablare sobre la parte teórica, porque como dije anteriormente eso lo podemos encontrar en cualquier página de internet que trate el tema. Bueno entonces manos a la obra…

Para empezar lo primero que debemos tener es una conexión activa a nuestra base de datos creado desde Netbeans; para este caso trabajare con una base de datos bd_tutorial que tengo de prueba, la cual tiene 2 tablas (Productos y DetalleProductos) y la que muestro a continuación.

tablasUna vez validado esto, ahora crearemos nuestro modulo EJB; para esto lo hacemos desde nuestro NetBeans, click en nuevo y luego seleccionamos Java EE y dentro de esta opción escogemos “EJB Module”, ponemos el nombre, del módulo en este caso EJBDemo, seleccionamos como servidor a GlassFish y finalizamos.

crearejb

Ya tenemos nuestro módulo EJB listo para crearle toda la lógica necesaria para obtener la información de las tablas de nuestra base de datos.

Ahora lo que haremos sera crear las clases entidad que representaran a nuestras tablas de la base de datos. Para esto hacemos click derecho en el módulo creado y nos dirigimos a la opción “Other” y luego en la ventana de opciones, seleccionamos “Persitence” y una vez alli seleccionamos “Entity Classes From DataBase”

entitdad

Le damos click en siguiente y nos aparecera una ventana en donde podemos ver la opción “Data Source”, desplegamos y seleccionamos “New Data source” y luego alli se nos mostrara una pequeña ventana en donde ingresaremos el nombre que reprentara a nuestro “Data Source”, que en este caso le pondremos jdbc/ejb y el “Database Connection” que es en donde escogeremos la conexión a la base de datos que habiamos agregado al inicio.

conexion

Una vez realizado este proceso, automaticamente se nos mostrara en el panel izquierdo todas las tablas creadas en esta base de datos. Ahora seleccionaremos la(s) tabla(s) con la que trabajaremos; para este caso seleccionaremos solo la tabla “Productos”, y ésta como se muestra en la imagen pasaria al panel derecho.

entidadproducto

Le damos click en siguiente y a continuación se nos muestra una ventana en donde tenemos el nombre de la tabla (lado izquierdo) y el nombre de la clase que representa a esta tabla (lado derecho), el nombre del proyecto, ingresaremos el nombre del paquete en donde se guardara la clase al cual llamaremos org.ejb.entidad.

entidadproducto_1

fijense que en la parte de abajo tenemos un boton que dice “Create Persistence Unit” le damos click alli y se nos mostrara una ventana con lo siguiente

unit

Alli podemos ver el nombre de la unidad de persistencia, el framework que proporcionara la persitencia y el Data Source que habiamos creado en un paso anterior; y luego click en crear.

Una vez hecho esto le damos click en siguiente a la ventana activa y alli vemos el tipo de mapeo de los datos, que para este caso lo dejamos por defecto y luego finalizar. Luego de esto tendremos la siguiene estructura

ejbcreadoVemos el “persistence.xml” que es en donde tenemos referencia a la base de datos mediante el DataSource, el nombre del proveedor para la persistencia (TopLink) y el nombre de unidad de persistencia, observamos las tablas de la base de datos y la clase “Productos.java”.

Ahora lo que haremos sera crear las clases que implementaran los métodos para toda la lógica, estas clases serán del tipo SessionBean, entonces lo que haremos es darle click derecho al proyecto, New y nos ubicamos en “persistence” y luego seleccionamos “Session Beans For Entity Classes”, que como nos podemos dar cuenta, creara las clases en base a la clase que representa la entidad, que en este caso es “Productos.java”, le damos click en siguiente y vemos la clase  Producto en el panel izquierdo, lo seleccionamos y damos click en Add para pasarlo al panel derecho. Luego click en siguiente y nos aparecera una ventana con los datos recogidos anteriormente, si gustan el nombre del paquete lo pueden cambiar para de esta forma tener estas clases separadas de las entidades, para este caso le puse  org.ejb.beans y luego seleccionamos Remote para el tipo de interface y finalizar.

sessionbean2

Ahora tendremos la siguiente estructura, ya con las clases del tipo SessionBean creadas y los métodos implelementados.

estructura1

Una vez hecho todo esto, solo nos quedaria deployarlo, para esto click derecho en el proyecto y seleccionamos deploy, si todo salio bien ya tendremos desplegado nuestro EJB en nuestro servidor Glassfish como podemos ver en la imagen.

glassfish

Bueno, con esto ya tenemos desplegado nuestro EJB pero ahora necesitamos utilizarlo en algún sitio. Para esto crearemos un proyecto web (imagino que ya saben como xD) al que llamaremos “AppWeb_EJB” y luego dentro del  proyecto crearemos un servlet al que llamaremos “appservlet_ejb” el cual es el que se encargaria de invocar a nuestro EJB.

Para esto dentro del método processRequest del servlet hacemos click derecho y seleccionamos la opción “Insert Code” y nos aparecera un menú emergente en el que escogemos la opción “Call Enterprise Bean..” y luego alli escogemos nuestro bean que en este caso es ProductosFacade como indica la figura

call1

Le damos click en OK y veremos que se agregó la referencia del EJB a nuestro proyecto en la parte de las librerias asi como en nuestro servlet como se puede observar en la figura

referenciaEntoces solo nos quedaria utilizar los metodos proporcionado por este EJB, para este caso utilizaremos el método “findAll” que es el que se encargaría de mostrarme toda la lista de productos, el cual mostramos en el siguiente código

servlet

Y luego desde nuestra página index,jsp solo crearemos la referencia a este servlet de la siguiente manera

index

Y listo, ejecutamos el proyecto web y estaremos mostrando los productos existentes.

Bueno, espero se haya entendido, trate de hacerlo lo mas “explicable” posible; como entenderan a veces es algo dificil poder plasmar en palabras este tipo de procesos, pero se hace lo que se puede.

Descarga el ejemplo: EJB