martes, 27 de marzo de 2012

Personalización de un JTable en Java

El JTable es un componente del API Swing de Java para desplegar datos en dos dimensiones. Este componente que está desarrollado bajo el patrón MVC (como el resto de componentes de Java Swing) presenta un modelo y un renderizador los cuales se encargan de mostrar los registros de una forma determinanda, sin embargo en muchas de nuestras aplicaciones queremos personalizar los datos mostrados por lo que se hace necesario escribir nuestras propias clases para renderizar y gestionar la información que queremos mostrar. A lo largo de este artículo les mostraré la forma de cómo hacerlo con unos cuantos sencillos pasos.
Lo primero que debemos hacer es crearnos un proyecto en Netbeans nombrándolo como mejor nos paresca. Luego crear un paquete que en nuestro caso le hemos llamado com.blogspot.rolandopalermo.bean y a continuación crear en ese mismo paquete una clase Cliente tal como se muestra en la figura a continuación:


Y el código de esta clase debe quedar como se muestra  a continuación:

package com.blogspot.rolandopalermo.bean;

/**
 *
 * @author Rolando
 */
public class Cliente {

    private int id;
    private int edad;
    private String nombre;
    private String nombreEmpresa;
    private String nombreContacto;
    private String direccion;

    public Cliente(int id, int edad, String nombre, String nombreEmpresa, String nombreContacto, String direccion) {
        this.id = id;
        this.edad = edad;
        this.nombre = nombre;
        this.nombreEmpresa = nombreEmpresa;
        this.nombreContacto = nombreContacto;
        this.direccion = direccion;
    }

    public String getDireccion() {
        return direccion;
    }

    public void setDireccion(String direccion) {
        this.direccion = direccion;
    }

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getNombreContacto() {
        return nombreContacto;
    }

    public void setNombreContacto(String nombreContacto) {
        this.nombreContacto = nombreContacto;
    }

    public String getNombreEmpresa() {
        return nombreEmpresa;
    }

    public void setNombreEmpresa(String nombreEmpresa) {
        this.nombreEmpresa = nombreEmpresa;
    }
}

Ahora debemos crear una JFrame el cuál se encargará de contener tanto a nuestra tabla como al resto de nuestros componentes Swing de nuestra aplicación. Creamos el JFrame VentanaPrincipal.java como se muestra en el figura siguiente:


Es el turno de nuestro modelo, quién se encargá de manejar las propiedades de tabulación de nuestra tabla  Para esto creamos la clase TablaModeloCliente como se muestra en la figura:


Y su código respectivo:

package com.blogspot.rolandopalermo.gui;

import com.blogspot.rolandopalermo.bean.Cliente;
import java.util.ArrayList;
import java.util.List;
import javax.swing.table.AbstractTableModel;

/**
 *
 * @author Rolando
 */
public class TablaModeloCliente extends AbstractTableModel {

    private String[] columnNames = {"DNI", "Nombre", "Edad", "Dirección", "Empresa", "Contacto"};
    private List<cliente> clientes = new ArrayList<cliente>();

    public void agregarCliente(Cliente cliente) {
        clientes.add(cliente);
        fireTableDataChanged();
    }

    public void eliminarCliente(int rowIndex) {
        clientes.remove(rowIndex);
        fireTableDataChanged();
    }
    
    public void limpiarClientes() {
        clientes.clear();
        fireTableDataChanged();
    }

    @Override
    public String getColumnName(int columnIndex) {
        return columnNames[columnIndex];
    }

    @Override
    public int getRowCount() {
        return clientes.size();
    }

    @Override
    public int getColumnCount() {
        return 6;
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        switch (columnIndex) {
            case 0:
                return clientes.get(rowIndex).getId();
            case 1:
                return clientes.get(rowIndex).getNombre();
            case 2:
                return clientes.get(rowIndex).getEdad();
            case 3:
                return clientes.get(rowIndex).getDireccion();
            case 4:
                return clientes.get(rowIndex).getNombreEmpresa();
            case 5:
                return clientes.get(rowIndex).getNombreContacto();
            default:
                return null;
        }
    }

    @Override
    public Class getColumnClass(int columnIndex) {
//        return getValueAt(0, columnIndex).getClass();
        return String.class;
    }

    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        return false;
    }

    @Override
    public void setValueAt(Object value, int rowIndex, int columnIndex) {
        Cliente cliente = clientes.get(rowIndex);
        switch (columnIndex) {
            case 0:
                cliente.setId((Integer) value);
            case 1:
                cliente.setNombre((String) value);
            case 2:
                cliente.setEdad((Integer) value);
            case 3:
                cliente.setDireccion((String) value);
            case 4:
                cliente.setNombreEmpresa((String) value);
            case 5:
                cliente.setNombreContacto((String) value);
        }
        fireTableCellUpdated(rowIndex, columnIndex);
    }
}

Y para renderizar los datos en la grilla, crearemos la clase TablaRenderizadorCliente la cuál determinará las propiedades gráficas y el comportamiento gráfico de las celdas que van a componer la tabla.


Lo que debemos hacer es implementar la interfaz TableCellRenderer.
package com.blogspot.rolandopalermo.gui;

import java.awt.Color;
import java.awt.Component;
import javax.swing.JLabel;
import javax.swing.JTable;
import javax.swing.table.TableCellRenderer;

/**
 *
 * @author Rolando
 */
public class TablaRenderizadorCliente implements TableCellRenderer {

    @Override
    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
        JLabel etiqueta = new JLabel();
        etiqueta.setOpaque(true);
        if (row % 2 == 0) {
            etiqueta.setBackground(new Color(255, 255, 200));
        } else {
            etiqueta.setBackground(Color.white);
        }
        if (column == 1) {
            String nombre = (String) value;
            etiqueta.setHorizontalAlignment(javax.swing.SwingConstants.LEFT);
            if (nombre.startsWith("#")) { //Hombre
                etiqueta.setIcon(new javax.swing.ImageIcon(getClass().getResource("/com/blogspot/rolandopalermo/recursos/user.png"))); // NOI18N
            } else if (nombre.startsWith("&")) { //Mujer
                etiqueta.setIcon(new javax.swing.ImageIcon(getClass().getResource("/com/blogspot/rolandopalermo/recursos/user2.png"))); // NOI18N
            }
            etiqueta.setText(value.toString().substring(1, nombre.length()));
        } else {
            etiqueta.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
            etiqueta.setText(value.toString());
        }
        if (isSelected) {
            etiqueta.setBackground(new Color(151, 193, 215));
        }
        return etiqueta;
    }
}

Con esto ya deberiamos tener la tabla como se muestra en la siguiente figura:


Para establecer el modelo y el renderizador a nuestra tabla deberíamos hacer lo siguiente:

TablaModeloCliente modelo = new TablaModeloCliente();
TablaRenderizadorCliente renderizador = new TablaRenderizadorCliente();
tablaClientes.setModel(modelo);
tablaClientes.setDefaultRenderer(String.class, renderizador);

Y para finalizar les dejo el enlace del proyecto para descargar.

Photobucket

viernes, 16 de marzo de 2012

Puente H con reles

En este post voy a explicar la forma de cómo diseñar un puente H basado en relés. Los puentes H son circuitos electrónicos ampliamente usados en robótica para el control de motores u otros actuadores que requieran de convertidores de potencia. Los circuitos de puente H son tan populares que incluso los tenemos en circuitos integrados como el L293 o el L298. El hecho de construirlos nosotros mismos surge como respuesta a la necesidad de querer usar motores u otros acutadores que requieran manejar grandes cantidades de corriente como por ejemplo cuando queremos diseñar un warbot cuyos motores consumen entre 20A y 30A con picos de hasta 50A. Existen en el mercado puentes H que soportan esta carga de corriente, pero su precio es elevado. Por eso, frente a ello les muestro el esquema de un sencillo puente H basado en relés pues estos permiten manejar corrientes elevadas sin precisar de mucho dinero en comparación con los Puentes H basados en mosfets.

El esquema que muestro en la Figura 1 corresponde a un circuito de Puente H el cual utiliza 2 relés de 5V para controlar el sentido de giro de un motor de corriente continua.

Figura 1. Diagrama esquemático de un puente H

Luego de armar el circuito debería quedarnos como en la Figura 3.

Figura 3. Circuitos de Puente H

Estos circuitos fueron desarrollados como parte de mi tesis sobre el telecontrol de robots móviles. Aquí les dejo un video en donde se muestra parte de las funcionalidades del robot.


Y aquí el diagrama para realizar el PCB del circuito junto a otro diagrama para ver la disposición de los componentes así como también el archivo del circuito hecho en PCBWizard si es que necesitan hacer modificaciones.

Photobucket 

Cualquier duda no duden en comentarla. Espero que les sea de utilidad y hasta la próxima.

jueves, 15 de marzo de 2012

Gráficas con Matlab

En este post vamos a ver la forma de realizar graficación de datos utilizando Matlab. Estudiaremos la amplia gama de funciones que Matlab pone a nuestra disposición para realizar gráficos de curvas, superficies, barras, líneas, gráficos polares, pies, etc.;

Plot(x,y) nos permite dibujar el conjunto de puntos X,Y en un plano cartesiano. La forma de utilizarlo se muestra a continuación:

x=-1:0.1:5;
y=sin(x.^2);
plot(x,y);

Bar(x,y) grafica barras verticales, donde y representa las frecuencias y x define los espacios en el eje x.
x=-3:0.2:3;
y=exp(-x.^2);
bar(x,y);


Barh(x,y) grafica barras verticales, donde x representa las frecuencias y y define los espacios en el eje x.
x=-3:0.2:3;
y=cos(x.^3)-2*x+1;
barh(x,y);


Stairs(x,y) se utiliza para graficar curvas escalonadas.
x=0:0.2:10
y=sin(x);
stairs(x,y);
Polar(x,y) se utiliza para graficar curvas en coordenadas polares.
t=0:0.1:2*pi;
y=abs(sin(2*t).*cos(2*t));
polar(t,y);
 
Pie(x) realiza un gráfico de sectores o de torta relativo al vector x.
x=1:2:9;
pie(x);
 

Rosex) realiza el histograma angular relativo al vector x. 
x=[ 1 3 6 7 4 7 4 12];
rose(x);
Matlab  también nos permite personaliar nuestros gráficos de funciones utilizando diferentes colores, caracteres y tipos de líneas. Las tablas a continuación nos muestran los valores que podemos utilizar para indicar los puntos de nuestra función.

Caracteres
Descripción
.
Punto
+
Más
*
Asterisco
O
Circunferencia
X
Equis


Líneas
Descripción
-
Continua
--
Guiones
:
Punteada
-.
Guiones y punto


Color
Descripción
r
Rojo
y
Amarillo
g
Verde
b
Azul
w
Blanco
m
Magenta
c
Turquesa
k
Negro

 Las imágenes a continuación muestran el resultado de aplicar los valores de la tabla anterior.
x=-2:0.2:2;
y=abs(cos(x));
plot(x,y,'+');
 

x=-3:0.2:4;
y=sin(x).^3-x;
plot(x,y,'O');


x=-3:0.2:3;
y=x^.2+3*abs(x)+8;
plot(x,y,'r');
 

Matlab también tiene la opción para realizar simultáneamente la gráfica de varias curvas. La función plot(x,y,x,z) grafica dos curvas con dos colores o tipos distintos.
x=0:0.05:5;
y=sin(x);
z=cos(x);
plot(x,y,x,z);
 

También podemos realizar gráficas en múltiples ejes. La función subplot(a,b,c) divide la pantalla del gráfico de a por b gráficas en una sola pantalla, en donde c es la secuencia o de las gráficas. En el siguiente ejemplo podemos ver el uso de la función subplot:
t=0:0.3:5;
x=t.^2;
y=2*t-5;
z=sin(t);
u=cos(t);
v=abs(t);
w=sqrt(t);
subplot(3,2,1), plot(t,x), title('gráfico 1');
subplot(3,2,2), plot(t,y), title('gráfico 2');
subplot(3,2,3), plot(t,z), title('gráfico 3');
subplot(3,2,4), plot(t,u), title('gráfico 4');
subplot(3,2,5), plot(t,v), title('gráfico 5');
subplot(3,2,6), plot(t,w), title('gráfico 6');


Y en el siguiente post dedicado a Matlab veremos cómo generar animaciones y películas.

Descargar videos de youtube en Linux

Buen dia a todos, hoy le toca el turno al Software Libre. En este post voy a mostrar cómo descargar videos de youtube usando Linux (En este caso Debian). A pesar de tener años usando Debian nunca se me había presentado la necesidad de descargar videos de Youtube. Y a pesar de haber muchas formas de hacer esto (incluso sin la necesidad de un programa) la manera que voy a mostrarles ha resultado muy cómoda para mí. Aquí les muestro los comandos que se deberán ejecutar en consola:

# apt-get update
# apt-get install clive
# exit
$ clive [URL del video]
# apt-get install mplayer
//Para reproducir el video
$ mplayer [nombre_del_video_descargado.flv]
//Para convertir el fichero a otro formato
# apt-get install ffmpeg
//Convertir a MPG
$ ffmpeg -i [nombre_del_video_descargado.flv] [video_salida.mpg]
//Convertir a MP3
$ ffmpeg -i [nombre_del_video_descargado.flv] -acodec copy [fichero_salida.mp3]

Y como una imagen vale más que mil palabras aquí les muestro cómo descargar un video en imágenes:

Primero copiamos la URL del video de youtube a descargar y ejecutamos clive del siguiente modo:


Y esperamos que termine la descarga. Luego podemos visualizar el video en formato flv usando mplayer.


Y lo convertimos a mp3.


Hecho esto, a disfrutar de la buena música.


Saludos y hasta otra oportunidad.

martes, 6 de marzo de 2012

Conectándose a una cámara IP con Java

La tecnología IP aplicada a la vigilancia de recintos ha proliferado en los últimos años en gran medida debido a los incrementos de ancho de banda en las redes ip actuales y al bajo costo de los equipos que la soportan. La gran mayoría de cámaras IP traen consigo Applets y Controles ActiveX para poder conectarnos a estas, sin embargo un gran problema es que este tipo de controles no soportan trabajar fuera del contexto de algún navegador web. Otro problema es cuando queremos acceder a los frames o imágenes adquiridas por estos dispositivos para realizar algún tipo de procesamiento. Las cámaras IP se caracterizan por la movilidad (Sobre todo las cámaras IP con soporte para la tecnología 802.11x) e independencia de funcionamiento pues solo será necesario de un dispositivo de capa de red para operar. Por otro lado las cámaras web siempre dependerán de la existencia de un computador así como los escasos 5 metros que nos proporcionan los estándares USB.
Todos lo descrito anteriormente ha representado siempre una dificultad cuando se quiere interactuar con estos dispositivos ya no a nivel de un simple usuario sino que queremos acceder a la información que nos proporcionan e ir un poco más allá. Java nos permite conectárnos al módulo CGI que poseen estas cámaras y obtener las imágenes de forma continua para realizar el procesamiento necesario sobre estas. Lo único que tenemos que hacer es acceder a este módulo cgi de forma continua e ir mostrando las imágenes a modo de secuencia lo cuál dará una apariencia de ser el video en sí.

Lo primero que tenemos que hacer es sobreescribir el método paintComponent de un JPanel del siguiente modo:

public class PanelVideo extends javax.swing.JPanel {

    private boolean hayConexion = false;
    private String direccionIP = "";
    public BufferedImage frame = null;

    /** Creates new form PanelVideo */
    public PanelVideo() {
        initComponents();
    }

    public boolean isHayConexion() {
        return hayConexion;
    }

    public void setHayConexion(boolean hayConexion) {
        this.hayConexion = hayConexion;
    }

    public String getDireccionIP() {
        return direccionIP;
    }

    public void setDireccionIP(String direccionIP) {
        this.direccionIP = direccionIP;
    }

    @Override
    public void paintComponent(Graphics g) {
        Graphics2D g2 = (Graphics2D) g;
        g2.setColor(Color.white);
        g2.fillRect(0, 0, getWidth(), getHeight());
        if (hayConexion) {
            try {
                URL nUrl = new URL(direccionIP);
                frame = ImageIO.read(nUrl);
                if (frame != null) {
                    g2.drawImage(frame, 0, 0, this);
                    repaint();
                }
            } catch (MalformedURLException ex) {
                hayConexion = false;
                g2.drawString(ex.toString(), 5, 15);
            } catch (IOException ex) {
                hayConexion = false;
                g2.drawString(ex.toString(), 5, 15);
            }
        } else {
            g2.setColor(Color.black);
            g2.drawString("No se ha establecido conexión con el dispositivo.", 5, 15);
        }
    }
}

Luego agregamos este panel a un JFrame y voilà, tenemos nuestra aplicación funcionando, podemos acceder a la secuencia de imágenes cuando se quiera, procesarlas, enviarlas por correo con información adicional, almacenarlas en una base de datos... en fin, un sinnúmero de posibilidades!!!

Aquí tenemos un screenshot de la aplicación ejecutándose:


Y como siempre el código fuente listo para descargar, reutilizar, mejorar, compartir!

Photobucket

Es importante saber la dirección correcta del módulo cgi de nuestras cámaras ip para lo cuál debemos acceder a su página de configuración. En mi caso la dirección es la siguiente: http://192.168.1.150/image/jpeg.cgi. De todos modos cualquier duda, la comentan.

Además si han tenido problemas con la ventana de autenticación de usuario aquí les dejo una solución:

URL nurl = null;
try {
nurl = new URL("http://169.254.1.240/cgi/jpg/image.cgi");
} catch (MalformedURLException e) {
e.printStackTrace();
}
Authenticator au = new Authenticator() {
@Override
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication ("user", "pass".toCharArray());
}
};
Authenticator.setDefault(au);

Saludos, hasta un próximo post.

lunes, 5 de marzo de 2012

Introducción a los EJB

En primer lugar un saludo a todos los lectores de este blog y las disculpas del caso por haber estado retirado tanto tiempo. Lo que sucede es que estuve dedicado de lleno al desarrollo de mi tesis de grado. Sumado a esto el tema laboral he tenido poco tiempo para volver a postear... pero aquí estamos de nuevo, listos para seguir compartiendo el conocimiento y eso es lo más importante. Para volver a tomar el ritmo quiero presentarles en esta oportunidad un artículo dedicado a uno de los componentes más interesantes de la edición empresarial de Java: !Los EJB! - Y es que últimamente el desarrollo de aplicaciones compartidas es el común denominador al que tenemos que hacer frente la gente que estámos inmersos en el mundo Java.
Una aplicación compartida es aquella aplicación en la cuál no todos sus componentes se encuentran en la misma computadora, es decir no corren bajo la misma máquina virtual.
Y esta tendencia a desarrollar este tipo de aplicaciones se debe a una serie de factores derivados de buenas prácticas y patrones de desarrollo, entre ellos la reutilización de componentes, que ha sido una práctica que ha venido siendo aplicada desde la génesis de la programación (de diferentes maneras obviamente). Sin embargo los EJB llevan esto a otro nivel y en este post hablaremos de ello.

Para entender mejor lo que son los EJB y su arquitectura (Figura 1) vamos a poner un ejemplo sencillo. Supongamos que queremos desarrollar una aplicación para la autenticación de usuarios de un banco.

Figura 1. Arquitectura de los EJB 

Lo primero que se nos ocurre es desarrollar una aplicación la cuál preguntará al usuario su número de cuenta y su clave bancaria, luego se conectará a la base de datos y comprobará la existencia de por lo menos un registro perteneciente a este usuario. Con esto nuestra aplicación tendría la arquitectura mostrada en la Figura 2.

Figura 2. Arquitectura un sistema transaccional tradicional

A pesar de ser un sistema funcional lo primero que podemos notar es que no se trata de una aplicación compartida pues todo se ejecuta dentro del ámbito de una sola aplicación. Es una arquitectura sencilla, es cierto!!!... pero esta facilidad de implementación podría llevarnos a futuros problemas frente a cambios en las especificaciones de la aplicación que estamos desarrollando. Toda la funcionalidad del software se encuentra altamente acoplada por lo que se necesitará distribuir las funciones en diferentes componentes específicos. A estos componentes se les conoce como Enterprise JavaBeans (EJB). Los EJB vienen al rescate presentándonos una arquitectura distinta, en donde se dividirá la aplicación en distintos dominios. Cada dominio será gobernado por EJB's que se encargarán de realizar determinada tarea como el establecer la conexión a bases de datos, otros se encargarán de manejar las sesiones y otros de la presentación de la información y el modo en que esta es accesada. 

!La solución está dada! - Evidentemente la documentación sobre esto es abundante y creo que con lo que se ha comentado anteriormente es suficiente para comprender un poco de lo que son los EJB y la forma en que segmentan la lógica de nuestras aplicaciones. Quizás lo tratado anteriormente carece de importancia para muchos pero considero que un ejemplo práctico, para aclarar el panorama, siempre es bueno antes de adentrarnos en el desarrollo en sí.

Bueno, ahora vamos a desarrollar una aplicación en donde usaremos EJB para autenticarnos como usuarios para lo cuál usaremos un EJB de Sesión sin Estado (Stateless) [Más acerca de los EJB] pues el usuario realiza una consulta, recibe el resultado y ahí finaliza todo el proceso.

Para empezar vamos a crear una aplicación empresarial en Netbeans para lo cuál hacemos lo siguiente:

Abrimos el asistente para la creación de proyetos y seleccionamos Enterprise Application:


Le colocamos un nombre a nuestro proyecto (BancoBean).


Seleccionamos nuestro servidor (Glassfish 3.1 en nuestro) caso y finalizamos el asistente.


Realizados todos estos pasos debemos tener algo como esto:


El primer proyecto es el que se encarga de gestionar y contener a los otros proyectos que se muestran bajo este (BancoBean-ejb y BancoBean-war). En el proyecto contenedor no se agregará ninguna clase java pues este solo manejará a los otros dos proyectos para lo cuál necesitará solamente algunos detalles de configuración. Ahora agregamos un nuevo paquete en nuestro proyecto BancoBean-ejb el cuál se encargará de la validación de nuestro usuario.


Ahora creamos nuestro EJB (AutenticadorBean) usando el asistente tal como se muestra en la siguiente figura:


Será un EJB de sesión sin estado por la razón que ya se comentó anteriormente. Podemos observar, además, que existe la posibilidad de crear una Interfaz, ya se Local, Remota o ambas. Cada EJB ofrece determinados métodos que pueden ser llamados por un cliente. También debe haber algunos métodos que naturalmente no deben ser públicos. Es por esta razón que un EJB debe implementar al menos una de estas interfaces, en donde se representarán los métodos públicos. La Interface Local posee métodos que pueden ser accedidos desde la misma máquina virtual mientras que la Interface Remota es para llamadas de métodos remotos. Como en nuestro caso usaremos nuestro EJB desde la misma aplicación, seleccionamos la opción Local.


Dentro de la Interface AunteticacionBeanLocal debe ir lo siguiente:
@Local
public interface AunteticacionBeanLocal {

    public boolean esUsuarioValido(String numeroCuenta, String password);
}
Y ahora la implementación del método:
@Stateless
public class AunteticacionBean implements AunteticacionBeanLocal {

    // Add business logic below. (Right-click in editor and choose
    // "Insert Code > Add Business Method")
    @Override
    public boolean esUsuarioValido(
            String numeroCuenta, String password) {
        if (numeroCuenta.equals("test") && password.equals("123456")) {
            return true;
        }
        return false;
    }
}
Evidentemente en lugar de usar ese código podemos autenticar a nuestros usuarios utilizando información de una base de datos.

Ahora vamos a crear un paquete llamado com.blogspot.rolandopalermo.servlets en nuestro proyecto BancoBean-war de la siguiente manera:


Dentro de este paquete van a ir las clases que se van a encargar de invocar a los métodos de la interfaz local de nuestro EJB. Ahora con ayuda del asistente vamos a crear un servlet llamado ServletValidador.


Y configuramos los parámetros del servlet de la siguiente manera:
  • Name = ServletValidador
  • UrlPatterns: /servletValidador

Editamos el archivo index.jsp en nuestro proyecto BancoBean-war para el ingreso de los datos por parte del usuario.
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>JSP Page</title>
 </head>
 <body>
  <form action="servletValidador">
   <table border="0">
    <tbody>
     <tr>
      <td>Numero de cuenta</td>
      <td><input type="text" name="numeroCuenta" value="" /></td>
     </tr>
     <tr>
      <td>Contraseña</td>
      <td><input type="password" name="claveCuenta" value="" /></td>
     </tr>
    </tbody>
   </table>
   <input type="submit" value="Ingresar" />
  </form>
 </body>
</html>
Ahora en nuestro servlet agregamos el siguiente atributo con su respectiva anotación:
@EJB
private AunteticacionBeanLocal autenticador;
Y el método processRequest de nuestro servlet autenticador debe quedar así:
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    PrintWriter out = response.getWriter();
    try {
        String usuario = request.getParameter("numeroCuenta");
        String pass = request.getParameter("claveCuenta");
        if (autenticador.esUsuarioValido(usuario, pass)) {
            out.println("Correcto");
        } else {
            out.println("Incorrecto");
        }
    } finally {
        out.close();
    }
}

El proyecto que se debe ejecutar es el proyecto contenedor pues en caso contrario la aplicación no se desplegará correctamente. Lo que debemos observar es algo como esto:

Numero de cuenta
Contraseña


Al completar los campos requeridos nuestro servlet realizará la autenticación pero quien manejará la lógica de cómo se realizará este proceso es un EJB.

No es necesario profundizar más sobre los EJB para comprender su funcionamiento. Este solo ha sido un ejemplo básico del uso de los EJB que espero pueda servir de introducción a este componente que nos abre un mundo de posibilidades. Más adelante estaré posteando más artículos relacionados a los EJB y su integración con otras tecnologías como JPA y JSF 2.0.

Descarga el proyecto en el siguiente enlace:

Photobucket

Espero sus comentarios y sugerencias.