Programación de un lector de huella

digital en Java. Parte 1.

Como ya lo he mencionado anteriormente, en la actualidad la seguridad en las transacciones
electrónicas se ha vuelto una parte indispensable para los programadores de sistemas, la
identificación para el acceso a los registros y demás cuestiones relacionadas deben de ser
tomadas en cuenta para poder validar que alguna persona está accediendo realmente a lo que
debe acceder, es esencial hacer que (en medida de lo posible) nadie pueda hacerse pasar por
alguien que no es al momento de identificarse en un sistema. Aquí es donde la biometría
juega un papel sumamente interesante (más información sobre la biometría en éste artículo)
así que dedicaré una serie de artículos a tratar de explicar cómo programar un lector de huella
digital en Java utilizando algunas herramientas y API's que nos permitirán realizar todos los
procedimientos

sin

ningún

problema.

Primeramente hablaré de lo que necesitamos para poder empezar a programar un sistema
completo de registro y verificación de identidades por medio de la huella digital:

El JRE (Java Runtime Environment) más reciente, al momento de la publicación de
este artículo es la 1.6.7.

IDE de programación NetBeans en su versión más reciente, al momento de publicar
este artículo es la 6.1. Cabe mencionar que el vínculo que indico contiene varias
versiones, se puede descargar cualquiera que cuente con el Base IDE y Java SE.

Un lector de huella digital de cualquiera de estos modelos.

El API de programación de lectores de huella digital de Griaule para Java.

Un servidor de bases de datos en MySQL.

Una vez que tenemos todo lo anterior procedemos con la instalación del API de programación
de Griaule (asumo que el NetBeans y el servidor MySQL ya están instalados y funcionando sin
problemas). Instalación del API de programación de Griaule:: Una vez que hemos
descargado el API tendremos un archivo llamado Fingerprint_SDK_Java_2007_Installer.jar,
para comenzar la instalación se realiza lo siguiente:
1. Doble clic sobre el archivo, aparecerá una ventana que nos pide elegir el idioma,
selecciona el que desees.
2. Posteriormente aparece la pantalla de bienvenida y si se da clic en Siguiente aparecen
los términos de la licencia, los cuales se debe aceptar para poder continuar.
3. Una vez hecho lo anterior se selecciona la ruta donde se instalará, aquí se dejan los
valores por defecto.
4. Después de la ruta de instalación se debe elegir los elementos que se instalarán, de
igual manera se deja todo marcado y se da clic en Siguiente.

5. Posteriormente se instalan los elementos seleccionados, dejando al final la instalación
del controlador. NOTA: Es de suma importancia tomar en cuenta que antes de la
instalación del lector de huella digital, este se debe de tener desconectado y de
preferencia desinstalar el software y controladores que venían con él de fábrica para
evitar conflictos durante la actual instalación.
6. Ahora aparece una pantalla para seleccionar el idioma de la instalación del
controlador, de igual manera se elige el que más convenga.
7. Después aparece la pantalla de bienvenida...

... aquí se da clic en Siguiente o Next.
8. Se aceptan los términos de la licencia y se da clic en Siguiente un par de veces.
9. Posteriormente presionamos el botón de Instalar o Install para que se realice la
instalación de los controladores del lector.
10. Al terminar el proceso se da clic en el botón de Siguiente y posteriormente en Finalizar
para terminar la instalación del controlador.
11. Una vez hecho esto se sigue con la pantalla del proceso de instalación general...

... y se da clic en Siguiente o Next.
12. Al final se da clic en el botón Done para culminar.
Una vez terminada la instalación del API se puede conectar el lector para terminar su
instalación. Conectar el lector de huella digital:: Ahora continuemos con lo siguiente:
1. Se conecta el lector de huella digital.
2. Aparece el Asistente para Nuevo Hardware de Windows.
3. Se selecciona No por el momento y se da clic en Siguiente.
4. Después se elige Instalar automáticamente el software recomendado y se da clic en
siguiente.
5. Se espera a que termine la instalación, el asistente debe de reconocerlo e instalar los
controladores que previamente hemos agregado junto con el API.

Se da clic en Finalizar para terminar la instalación. si se ha dejado por defecto aparecerá enC:\Archivos de programa\Griaule\Fingerprint SDK Java 2007\bin 2.6. si tienes varias se puede colocar en todas) y en la carpeta C:\Archivos de programa\Java\ jre*\lib\ext (donde jre* es la versión más reciente). Se copia el archivo grfingerjava. Nombre de campo: huenombre .jar hacia las carpetas C:\Archivos de programa\Java\ jdk*\jre\lib\ext (donde jdk* es la versión que tienes instalada. Nombre de campo: ID . ¿Alguna duda o algo qué decir? Deja tu comentario. un ID. tipo: INT (autoincrement) 2. . Para efectos de este ejemplo usaremos una base de datos de nombre huellas y una tabla dentro de dicha base de nombre somhueque contendrá los datos descritos a continuación: 1.dll que se encuentran en la carpeta de las librerías del API y se pegan en C:\Windows\System32 Preparación de la base de datos:: Ya realizados los pasos anteriores únicamente nos falta crear una base de datos que almacene los registros de las huellas. Preparación de las librerías y archivos necesarios:: Una vez que se tiene todo lo anterior correctamente instalado y configurado se deben de preparar las librerías y los archivos colocándolos en los directorios que deben de estar. tipo: VARCHAR(100) 3. 3. el nombre de la persona y la huella registrada. Nombre de campo: huehuella . Se abre la carpeta de las librerías del API. en este caso prepararemos dentro de dicha base una tabla sencilla que contenga únicamente 3 datos. para ello se realiza lo siguiente: 1. Se seleccionan y se copian todos los archivos . tipo: BLOB Ya tenemos todo para comenzar a programar nuestra aplicación de reconocimiento de huella digital pero eso lo dejaremos para la siguiente parte.

correspondientes imports.grfingerjava. Continuando con la programación de un lector de huella digital en Java procederemos en este caso ya directamente con el código. import com.grfingerjava. Al implementar dichas interfaces nos pedirán implementar todos sus métodos abstractos.FingerprintImage.Programación de un lector de huella digital en Java. import com. entenderla y realizarla primero antes de proceder con esto ya que de lo contrario no funcionará la aplicación... Parte 2. lo . con Creamos un las indicaciones.griaule.grfingerjava.griaule. En definición la procedimientos IImageEventListener. Util implements IStatusEventListener. 3.IImageEventListener.IFingerEventListener. 2. IFingerEventListener{ .griaule. . la entrega anterior se refirió meramente a la preparación del entorno para el desarrollo. 5. public class IImageEventListener.griaule.grfingerjava. Dentro de 4.IStatusEventListener. import com. si no la has leído te recomiendo verificarla. Comenzando 1. Dentro del proyecto crear un paquete de nombre procedimientos y otro de nombreinterfaz. de la crear clase una util IFingerEventListener y clase (Java agregar implements sus Class) llamada Util. IStatusEventListener. proyecto en NetBeans con haremos el lo siguiente: nombre EjemploLectorHuellas. import com.

Modificamos los métodos onSensorPlug y onSensorUnplug para que queden de la siguiente manera: public void onSensorPlug(String idSensor) { . 6. huella FingerprintImage huellaDigital) // evento que se genera al obtener una imagen de la huella public void onFingerDown(String idSensor) // evento que se genera al colocar un dedo en public void onFingerUp(String idSensor) levantar el el lector // evento que se genera al dedo del lector Cabe mencionar que no utilizaremos todos los eventos en este ejemplo pero se deben de implementar para que el compilador no marque errores ya que provienen de una interface.hacemos dando un clic en el foco que aparece del lado izquierdo y seleccionando "Implement all abstract methods" lo cual generará la implementación de 5 métodos (modifica el nombre de los argumentos para mejor referencia) : public void onSensorPlug(String idSensor) // evento que se genera al conectar el lector de huella public void onSensorUnplug(String idSensor) // evento que se genera al desconectar public void el lector onImageAcquired(String de idSensor.

7.printStackTrace(). (GrFingerJavaException this).GrFingerJavaException. e) { e. import com.GrFingerJava..griaule. Los demás métodos que se implementaron deben de quedar vacíos (por el momento). Ahora creamos un método estático que nos permita establecer el directorio de las librerías del SDK /** * Establece el directorio donde se ubican las librerías nativas del SDK */ public directorio) static void setFingerprintSDKNativeDirectory(String { .try { GrFingerJava..stopCapture(idSensor). } catch this.printStackTrace(). para que el compilador no marque errores debemos importar las clases GrFingerJavay GrFingerJavaException. } catch (GrFingerJavaException e) { e.grfingerjava.griaule.startCapture(idSensor. } } Lo anterior es para evitar problemas en la captura al momento de conectar y desconectar el lector.grfingerjava. import com. } } public void onSensorUnplug(String idSensor) try { { GrFingerJava.

} catch (GrFingerJavaException e) { e. try { GrFingerJava. extracción y coincidencia de huellas digitales private */ MatchingContext fingerprintSDK. GrFingerJava.File directory = new File(directorio). /**Interfaz de usuario donde se muestra la imagen de la huella*/ private /** Indica PantallaPrincipal si la plantilla o ui. .io.File.setNativeLibrariesDirectory(directory). template debe ser extraída automáticamente*/ private /** Contiene boolean localmente private /**Contiene private autoExtract los datos de la = huella ByteArrayInputStream la longitud int del true. dato de la huella*/ fingerprintDataLength. capturada */ fingerprintData. Posteriormente agregamos los siguientes objetos y variables inmediatamente después de la definición de la clase: /**Contexto utilizado para la captura. } } y el import de la clase File correspondiente: import java. 8.setLicenseDirectory(directory).printStackTrace().

para ello damos clic derecho en el paquete interfaz y seleccionamos New -> JFrame Form. 9. imagen de huella capturada Template con sus */ */ template.io.ByteArrayInputStream. import java.grfingerjava.MatchingContext. 10. import interfaz. Identificar... como se muestra en la imagen) y 4 botones (Verificar.' aún cuando no existe actualmente ya que se creará en los pasos siguientes./** La imagen de private /** última huella digital capturada.PantallaPrincipal. Guardar y Salir) de manera que queden parecido a lo siguiente: .PantallaPrincipal. le damos por nombre 'PantallaPrincipal'. Nota: se debe agregar 'import interfaz. Agregamos dos paneles (Huella Digital y Acciones.griaule. correspondientes imports .. import com. FingerprintImage La plantilla de public . la la última fingerprint.. Ahora crearemos la interfaz de usuario.

el panel de Huella Digital lo nombramos 'panelContenedor'. Nombramos los botones tal cual su etiqueta pero anteponiendo las letras btn. 12. es decirbtnVerificar.11. Establecemos el panelContenedor con un BorderLayout dando un clic derecho sobre él -> Set Layout -> Border Layout . btnIdentificar y así sucesivamente.

. .12.. la huella fingerprintViewPanel la digital = huella fingerprintImage null. //objeto usado para realizar todas las operaciones relacionadas al Fingerprint-SDK private //Panel private //Imagen private para Util mostrar JPanel de BufferedImage procedimientosSDK. Ya que tenemos lo anterior nos vamos a la vista de código y agregamos los siguientes objetos. actual = null.

con sus correspondientes imports .exit(1). Por último en la clase Util (por el momento) agregamos un método que nos permita inicializar la captura de las huellas.image.swing.awt. import procedimientos. } 14.. System.printStackTrace(). e....BufferedImage. import javax.Util.. } } .ui manera: ui) { = ui. .initializeCapture(this). GrFingerJava. deberá de quedar así: /** * Inicializa el Fingerprint SDK y habilita la captura de huellas.JPanel. captura de huella digital. import java. los objetos deben ir dentro de la clase pero fuera de cualquier método. } //Si catch ocurre un (Exception error se e) cierra la { aplicación. 13... */ public void inicializarCaptura() try fingerprintSDK //Inicializa la = { { new MatchingContext(). Nuevamente modificamos la clase Util agregando un constructor sobrecargado que reciba un objeto de public tipo PantallaPrincipal de la siguiente Util(PantallaPrincipal this.

err.15. y su import import correspondiente: javax. lo que haremos es crear un método para inicializar la forma. } .UIManager.. **/ public void inicializar() { try { UIManager.. . estableciendo el estilo visual y creando una instancia de la clase Util. Ahora trabajaremos con la clase PantallaPrincipal.procedimientosSDK = new de Util Util(this). } //Crea una instancia this.println("No se pudo aplicar el estilo visual"). 16.getSystemLookAndFeelClassName()).swing.setLookAndFeel(UIManager. Agregamos una llamada al método inicializar() dentro del constructor de la clase y antes del /* método initComponents() de Crea una nueva public tal forma manera de que quede PantallaPrincipal PantallaPrincipal() así: */ { inicializar(). Deberá quedar de la siguiente manera: /** * Se establece el estilo visual de la aplicación y se realiza la inicialización * de que la contiene los clase procedimientos principales. } catch (Exception e) { System.

insets.right - getInsets().getInsets().top.. en los comentarios se va explicando las funciones de cada línea. //Si hay una if imagen para ser mostrada (fingerprintImage!=null) { //Calcula el tamaño y posición de la imagen para ser pintada //el tamaño es ajustado para que ocupe todo el tamaño del Insets int int int width panel insets transX transY = getWidth() = = = getInsets().paintComponent(g). Ahora hacemos un método para crear el contenedor de la imagen de la huella digital. int height = getHeight() .top.bottom getInsets().initComponents(). . insets.getInsets(). } 17. .left. /** * Crea el panel que contendrá la imagen de la huella digital */ private //Crea JComponent un panel crearPanelHuella() nuevo para fingerprintViewPanel //Se mostrar = sobreescribe el la new método { huella JPanel(){ paintComponent //para habilitar la muestra de la imagen de la huella public void paintComponent(Graphics g) { super.left..

CompoundBorder.swing.. if(fingerprintViewPanel==null) { return }else{ // de lo contrario null.border.JComponent...awt.swing. . imagen transX. import java. import javax. } } }. import javax.setBorder(new new new del panel CompoundBorder EmptyBorder ( (2.//Se dibuja la g. width.. height.BevelBorder.awt.swing. } } . //Se agrega un borde alrededor fingerprintViewPanel.swing.EmptyBorder.2). devuelve return el panel mismo fingerprintViewPanel.2. y se agregan los imports correspondientes para evitar errores .. //si no hay existe el panel de la huella no devuelve nada. transY.border.Graphics.Insets. BevelBorder(BevelBorder. null).2.. import javax. import java.border.drawImage(fingerprintImage.LOWERED))). import javax.

-> código de la clase... lo cual nos -> llevará a Window la vista de WindowActivated .18. dentro del métodoformWindowActivated.event.awt..add(crearPanelHuella()).. } 19. Una vez hecho esto nos vamos a la vista de diseño de la clase PantallaPrincipal.WindowEvent evt) { this.panelContenedor. El método debe quedar de la siguiente manera: /** . ahí agregamos el código de manera que quede de la siguiente private forma: void formWindowActivated(java. sin seleccionar ningún elemento damos clic derecho sobre el JFrame y posteriormente seleccionamos Events . Ahora creamos el método showImage que nos permitirá mostrar la imagen capturada por el lector en el panel correspondiente.

} 20. Ahora en el constructor de la clase PantallaPrincipal agregamos las siguientes 3 líneas: /*Inicializa la captura de huellas*/ procedimientosSDK. //Muestra la imagen obtenida ui.inicializarCaptura(). */ public void onImageAcquired(String idSensor.showImage(huellaDigital).* Método utilizado * en para mostrar el la imagen panel de la huella correspondiente.fingerprint=huellaDigital. el método debe quedar así: /** * Este método es llamado cada vez que la imagen de una huella ha sido capturada. nueva imagen repaint(). Una vez hecho esto vamos a la clase Util y agregamos el código correspondiente al método onImageAcquired que se ha creado al implementar las interfaces. */ public void showImage(BufferedImage image) { //Utiliza el imageProducer para crear una imagen de la huella digital fingerprintImage //Se dibuja la = image. FingerprintImage huellaDigital) //Almacena { la imagen de la huella this. . } 21.

PantallaPrincipal p = new PantallaPrincipal(). en este caso además de llamar a la ventana se necesita establecer el directorio de las librerías. Util./*centra la ventana en la pantalla*/ setLocationRelativeTo(null). 23.getAbsolutePath(). identificar y guardar las huellas pero eso lo dejaremos para la próxima entrega. } Una vez hecho esto podemos correr la aplicación con F6 y verificar que realmente funcione. Agregamos el evento ActionPerformed del botón 'Salir' dando clic derecho sobre él en vista de diseño y seleccionando Events -> Action -> ActionPerformed y dentro del código generado agregamos el método dispose(). activar el lector de huellas y obtener la lectura de la huella que se ha colocado en el lector. 22. Parte 3. el static método main de void String la clase main main(String[] grFingerNativeDirectory debe quedar así: args) = { new File(". /*hace visible la ventana*/ setVisible(true). hasta este momento. si has realizado los pasos tal cual podrás. Para que nuestro programa pueda ejecutarse necesitamos mandarlo llamar desde la clase main. public en conjunto. . Programación de un lector de huella digital en Java.setFingerprintSDKNativeDirectory(grFingerNativeDirectory). aún nos falta especificar cómo verificar.").

Los objetos anteriores se utilizarán para crear la conexión a la base de datos y realizar consultas en la misma.  ¿Hasta aquí todo bien? Si tu respuesta es afirmativa continúa con los siguientes pasos. * eliminar y modificar los datos */ private void initDB() { try { . de lo contrario regresa a las partes anteriores y verifíca que no tengas errores en la codificación..Siguiendo con el tutorial para la programación de un lector de huellas en Java (si no has leído la parte 1 y parte 2 te recomiendo hacerlo antes de proceder) en este caso explicaré cómo almacenar los registros de las huellas en una base de datos en MySQL. Se tienen únicamente 3 clases en el proyecto: la clase ejemplolectorhuellas. anteriormente en la parte 1 hemos creado la base de datos con 3 columnas (el id.PantallaPrincipal y procedimientos. private PreparedStatement identificarStmt. PantallaPrincipal es la interfaz y Util es la clase que contiene los procedimientos.Main. Recapitulando.  Al realizar todos los procedimientos de la parte 2 del tutorial y ejecutar el programa se debe de enceder el lector de huellas. Util. al colocar el dedo sobre el lector debe de aparecer la imagen de la huella capturada. para poder realizar lo anterior debemos de crear un par de métodos como se muestran a continuación: /** * Inicializa la conexión a la base de datos y prepara las operaciones para insertar. private PreparedStatement verificarStmt. los datos de la huella y el nombre de la persona que la registró) ahora pasemos al código. Agregar los objetos para las consultas en procedimientos..Util y agregamos al inicio de la misma los siguientes objetos: /**Conexión a la base de datos*/ private Connection dbConnection. donde Main es a través de la cual se arranca el programa. /**Consultas preparadas**/ private PreparedStatement guardarStmt.Util:: Abrimos la clase procedimientos. interfaz.

close(). Statement stm = dbConnection. //Se conecta a la bd dbConnection = DriverManager.prepareStatement("SELECT huehuella FROM somhue").//Carga el driver ODBC Class. } catch (Exception e) { e.prepareStatement("INSERT INTO somhue(id. } catch (Exception e) { e.prepareStatement("SELECT huehuella FROM somhue WHERE huenombre=?").close(). //Cierra la conexión a la base dbConnection.printStackTrace().close().forName("com.jdbc. } } /** * Cierra la conexión a la base de datos y libera los recursos empleados.createStatement().mysql."usuario". */ private void destroyDB() { try { //Se cierran todas las sentencias guardarStmt. verificarStmt = dbConnection.?)"). huenombre.?. huehuella) values(?. identificarStmt = dbConnection. //Prepara las consultas/sentencias que se utilizarán guardarStmt = dbConnection.printStackTrace(). "contrasena").Driver"). } } .getConnection("jdbc:mysql://servidor:3306/huell as". identificarStmt.

si se plantea utilizar para corroborar una considerable cantidad de huellas el proceso se vuelve inoperable. basta con la plantilla que se extraerá. Una vez que tenemos la conexión a la base de datos debemos hacer que el programa se conecte al inicializar la clase procedimientos. para ello debemos de agregar una llamada al método initDB() dentro del constructor de la misma para que al final quede de la siguiente manera: public Util(PantallaPrincipal ui) { this.Util.ui = ui. //Inicializa la conexión a la BD. //Muestra la plantilla en la imagen .extract(fingerprint). No es necesario tener la imagen de la huella para compararla con otra. */ public void extract() { try { //Extrae la plantilla de la imagen.Las partes en rojo deben ser remplazadas por aquellas que correspondan a tu configuración del servidor MySQL.Util de la manera siguiente: /** * Extrae la plantilla de la imagen de la huella actual. Una imagen ocupa muchísimo más espacio en la base de datos. } Antes de poder guardar la huella (o la información de la huella) en la base de datos debemos de extraer el llamado Template o plantilla de la huella que es una representación matemática de un mapa de la huella. initDB(). 3. template = fingerprintSDK. es importante aclarar que no vamos a guardar la imagen de la huella sino este mapa a partir del cual se pueden comparar varias huellas o verificar a quién pertenece. 1. Una vez aclarado el punto anterior procedamos a extraer la plantilla de la huella capturada agregando el método extract() a la clase procedimientos. 2. existe la manera de guardar la imagen pero no se realizará dicho proceso en este tutorial debido a las siguiente razones: No es seguro tener la imagen de una huella capturada.

dichas líneas son la representación de la plantilla que hemos extraído. } Una vez hecho lo anterior podemos correr el programa y capturar una huella. } } Ya que hemos creado el método extract() basta con mandarlo llamar desde el método onImageAcquired() para que este último quede de la siguiente manera: public void onImageAcquired(String idSensor. } catch (GrFingerJavaException e) { e.ui. Lo primero que hacemos es agregar el método guardarHuella() a procedimientos.printStackTrace(). FingerprintImage huellaDigital) { //Almacena la imagen de la huella this.Util de tal forma que quede de la siguiente manera: /* * Guarda los datos de la huella digital actual en la base de datos */ public void guardarHuella(){ //Obtiene los datos del template de la huella actual . //Muestra la imagen obtenida ui. notaremos que se dibujan algunas líneas verdes sobre la misma.fingerpr int)).showImage(GrFingerJava.showImage(huellaDigital). Ahora viene la parte donde guardamos la plantilla de la huella en la base de datos.getBiometricImage(template. //Muestra la plantilla en la imagen actual extract().fingerprint=huellaDigital.

err.getData()).println("Error al guardar los datos de la huella.ActionEvent evt) { procedimientosSDK.showInputDialog("Nombre:"). para ello nos situamos en la pantalla principal y damos doble clic sobre el botón Guardar lo cual automáticamente nos crea el método que se efectúa al presionar el botón. fingerprintDataLength = template.setString(1. guardarStmt.event."). fingerprintData. //Ejecuta la sentencia guardarStmt.nombre). ex.length.awt.setString(2.JOptionPane Lo único que resta por hacer es mandar llamar el método guardarHuella() por medio del botón Guardar que aparece en la pantalla principal.printStackTrace(). ahora solo basta mandar llamar el método de la siguiente manera: private void btnGuardarActionPerformed(java. fingerprintDataLength).fingerprintData = new ByteArrayInputStream(template. try { //Establece los valores para la sentencia SQL guardarStmt.guardarHuella(). guardarStmt. } } Tras realizar lo anterior debemos de realizar import correspondiente a la clase JOptionPane: import javax."default").swing. } catch (SQLException ex) { //Si ocurre un error lo indica en la consola System.setBinaryStream(3.getData().execute(). } . //Pregunta el nombre de la persona a la cual corresponde dicha huella String nombre = JOptionPane.

pero al momento de verificar solamente tomamos un registro de huella filtrando con el nombre de la persona a quien pertenece. posteriormente. procedamos pues a analizarlo en base al código que hemos agregado para las consultas en la parte 3 del tutorial. Parte 4. Anteriormente agregamos un método de nombre initDB() que es por medio del cual se inicializa la conexión y se preparan las consultas a la base de datos. Nota: anteriormente en la sentencia identificarStmt se tenía huehuella en lugar de *. una credencial. para fines de esta aplicación debemos de cambiarlo para que quede tal cual se muestra en las líneas anteriores. Anteriormente hemos visto cómo capturar y guardar huellas digitales en una base de datos en MySQL (si no sabes a lo que me refiero lee las partes Uno. Sigamos con el código que va a realizar la primer función: Verificar. CURP. por ejemplo: coloco mi huella digital y el sistema automáticamente sabe que soy Juan Pérez. Aquí diferenciamos claramente que al momento de identificar una huella seleccionamos todas las huellas de la base de datos (que posteriormente compararemos una por una con la que tenemos actualmente para identificar a quién pertenece dicha huella). ¿Todo perfectamente claro? Ok. verificarStmt = dbConnection. Una vez aclarado lo anterior. /** * Verifica la huella digital actual contra otra en la base de datos . al ejecutar el programa. las siguientes líneas: identificarStmt = dbConnection. podremos realizar operaciones de comparación y verificación de identidades. Antes de continuar cabe aclarar(y con verificación e identificación: diferenciar) a lo que me refiero  Verificación: Es el corroborar la identidad de una persona por medio de un dato previamente dado (como el nombre. por ejemplo: yo digo que soy Juan Pérez y lo confirmo con mi huella digital. dicho método tiene. capturar una huella y presionar el botón Guardar podremos almacenar los datos de la huella digital en la base de datos y. Dos y Tres de este tutorial) ahora toca el turno a la verificación de una identidad por medio de la huella e identificación de una persona. etc) y su huella digital. entre otras cosas.Tras realizar lo anterior. Programación de un lector de huella digital en Java.prepareStatement("SELECT * FROM somhue"). pero esto lo dejaremos para la siguiente entrega.prepareStatement("SELECT huehuella FROM somhue WHERE huenombre=?").  Identificación: Es el corroborar la identidad de una persona utilizando solamente su huella digital.

ResultSet rs = verificarStmt. JOptionPane.referenceTemplate).showMessageDialog(ui. para realizarlo correctamente se debe dar doble clic sobre el botón y posteriormente agregar el código dentro del método creado de tal manera que quede así.next()){ //Lee la plantilla de la base de datos byte templateBuffer[] = rs.showMessageDialog(ui.verify(template. } else { //De no ser así lo indica con un mensaje JOptionPane.setString(1. "Error". "No corresponde la huella con "+nom.showImage(GrFingerJava.showMessageDialog(ui. //compara las plantilas (actual vs bd) boolean fingerprintSDK. //Si se encuentra el nombre en la base de datos if (rs. JOptionPane. coinciden = //Si corresponden.printStackTrace(). private void btnVerificarActionPerformed(java. dibuja el mapa de correspondencia y lo indica con un mensaje if (coinciden){ ui.sql. fingerprintSDK)).*/ public void verify(String nom) { try { //Obtiene la plantilla correspondiente a la persona indicada verificarStmt.showInputDialog("Nombre a verificar:"). "Error". } //Si no encuentra alguna huella correspondiente //al nombre lo indica con un mensaje } else { JOptionPane. } } Al realizar lo anterior es posible que necesites importar como java. } } catch (SQLException e) { e.ERROR_MESSAGE).. . JOptionPane.getBiometricImage(template.getBytes("huehuella").executeQuery(). "Las huellas sí coinciden").printStackTrace().ERROR_MESSAGE). fingerprint. } catch (GrFingerJavaException e) { e. algunas clases Ahora solo se debe de agregar una llamada al método verificar() desde el botón de Verificar en la clase interfaz.. //Crea una nueva plantilla Template referenceTemplate = new Template(templateBuffer).PantallaPrincipal.nom).awt.ResultSet para que todo funcione correctamente.event.ActionEvent evt) { String nombre = JOptionPane. "No existe el registro de "+nom.

tres y cuatro te recomiendo que lo hagas antes de continuar).. dos. } Si corremos la aplicación tras realizar lo anterior podremos verificar la huella capturada actualmente contra otra en la base de datos y el sistema nos indicará si la huella coincide o no. . En este caso toca el turno a la identificación de personas por medio de su huella digital.Util así que vayamos a dicha clase y creamos un método de nombre identificarPersona() que no recibe argumentos de ningún tipo. realizando en la clase procedimientos. Después de una larga espera seguimos con el tutorial en su quinta parte (si no has leído las partes uno. Hasta el momento ya tenemos resueltas las funciones para guardar y verificar así que falta poco para culminar con las Recordemos que todos los funciones procedimientos los estamos básicas. Para identificar una persona se necesita tomar una muestra de la huella digital y posteriormente compararla con todas aquellas entre las cuales se encuentra la persona. en este caso.procedimientosSDK. Programación de un lector de huella digital en Java. si lo deseas. si encontramos un registro que coincida entonces tenemos a la persona que buscamos. puedes esperar a la próxima entrega en la cual lo explicaré paso a paso. Hasta aquí le dejamos en esta parte. entre todas las huellas registradas. si le has entendido correctamente a la lógica del código no te será difícil crear el método de identificar(). en un principo quedará de la siguiente manera: /** * Identifica a una persona registrada por medio de su huella digital */ public void identificarPersona(){ } Ya que tenemos la definición del método debemos de brindarle un comportamiento pero para decirle qué hacer primero debemos entenderlo.verify(nombre). Parte 5..

. fingerprint.. ResultSet rsIdentificar = identificarStmt.ya que tenemos la plantilla de la base de datos la comparamos con la actual almacenando el resultado de la comparación en una variable. fingerprintSDK)). if (coinciden){ ui.getString("huenombre")). huella almacenada. .si coinciden hacemos lo pertinente y rompemos el ciclo de iteración y lo cerramos.verify(template... JOptionPane.y la creamos para posteriormente utilizarla.showImage(GrFingerJava... "La huella es de "+rsIdentificar...executeQuery().getBytes("huehuella"). ...en cada iteración obtenemos la plantilla de la byte templateBuffer[] = rsIdentificar...next()){ ..showMessageDialog(ui. . while(rsIdentificar. . return..... } } .posteriormente iteramos a través de todos los resultados.En código Primero se obtenemos traduce todas las a huellas lo de la base siguiente: de datos.referenceTemplate).... boolean coinciden = fingerprintSDK.. .. Template referenceTemplate = new Template(templateBuffer).si hemos buscado en todas las huellas y no se encuentra se lo indicamos al usuario.....getBiometricImage(template.

.next()){ //Lee la plantilla de la base de datos byte templateBuffer[] = rsIdentificar. //Crea una nueva plantilla Template referenceTemplate = new Template(templateBuffer). //compara las plantilas (actual vs bd) boolean coinciden = fingerprintSDK.. "No existe ningún registro que coincida con la huella.getBytes("huehuella").showMessageDialog(ui. fingerprint. el método completo queda así: /** * verifica la huella digital actual contra otra en la base de datos */ public void identificarPersona() { try { //Obtiene todas las huellas de la bd ResultSet rsIdentificar = identificarStmt. //Si encuentra correspondencia dibuja el mapa //e indica el nombre de la persona que coincidió.showImage(GrFingerJava."). "La huella es de "+rsIdentificar. //Si se encuentra el nombre en la base de datos while(rsIdentificar. JOptionPane.JOptionPane. . if (coinciden){ ui.getBiometricImage(template.. fingerprintSDK)).y listo! Al finalizar debemos de encerrar el código entre algunos try-catch para evitar errores al momento de compilar.executeQuery().verify(template.referenceTemplate).getString("huenombre")).showMessageDialog(ui.

sin embargo. } catch (GrFingerJavaException e) { e. } catch (SQLException e) { e.printStackTrace().printStackTrace(). solo necesitas adaptar estos métodos a tu aplicación y tendrás funcionalidad total. :::Actualización::: A petición de algunos de ustedes. aquí les dejo una liga para descargar el proyecto en formato comprimido: .return. } } Posteriormente lo único que debemos hacer es mandarlo llamar desde el botón de 'Identificar' y listo! hemos terminado con las 3 funciones principales de un sistema de identificación de huellas digitales.. "No existe ningún registro que coincida con la huella. espero sus comentarios y opiniones al respecto.showMessageDialog(ui.. y si tienen alguna consulta dejen su correo para hacerles llegar mi respuesta lo antes posible ya que no he podido contestar los comentarios aquí directamente. El plan no es terminar con esta serie de tutoriales con este artículo sino ahondar en procedimientos un tanto más especializados como comparaciones realizadas directamente por el servidor (en aplicaciones cliente-servidor) para quitar tráfico a la red por medio de un servidor de aplicaciones."). } } //Si no encuentra alguna huella que coincida lo indica con un mensaje JOptionPane.

Connection.DataSource.naming.sql. import java. /** * . import javax.sql.gaso / SingletonJDBC. import javax.JOptionPane .InitialCont ext. import java.Context.naming.PreparedStatem ent. Download Gist SingletonJDBC.sql. import java. import javax.swing. import javax.gith You can clone with HTTPS orSSH.sql.java Created on 29 Apr 2013  Code  Revisions1 Embed URL <script src= HTTPS clone URL https://gist.java Raw 123456789101112131415161718192021222324252627282930313 233343536373839404142434445464748495051525354555657585 960616263646566676869707172737475767778798081828384858 68788899091929394 import java.sql.SQLException.DriverManager.

sino uno llega a existir private static Connection connection = null.getConn ection(url. String usuario = "postgres". usuario. } catch (ClassNotFoundExceptio n e) { . } //Obtener las instancias de Conexion JDBC private static void contruyendoConexion() { try { Class. String url = "jdbc:postgresql://localh ost:5432/bd? allowEncodingChanges= true".connection = DriverManager. /** * * @return Devuelve la instancia unica de Conexion */ public static Connection getConexion() { //Si la instancia no ha sido creado aun.* @author PCGASO */ public class bd { //Instancia estatica de la conexion.connection.connection == null) { contruyendoConexion(). } return bd. String clave = "gidsoft". se crea if (bd. bd. clave).forName("org.post gresql.Driver").

println(esta dosSQL.println("Clas sNotFoundException(co ntruyendoConexion) : " + e. } } /** * Cierra la conexion.getMessage())).getMessage()). en realidad no se * esta cerrando. La llamada a close() le indica al BasicDataSource que * hemos terminado .out. "No fue Posible Conectar con la Base de Datos".getSQL State().gc(). } } public static void liberarConexionS(Conne ction conex) { try { conex.getM(ex. System.getMessage()).ERROR_ME SSAGE).out.System.getMessage(). } catch (Exception e) { System.out.gc(). System.showMessa geDialog(null. JOptionPane.close(). JOptionPane.out. System.println(" Exception General (contruyendoConexion) : " + e.exit(0).println("SQL Exception(contruyendoC onexion) : " + e.gc(). } catch (SQLException e) { System. } catch (SQLException ex) { System.getMessage()). ex. e. System. Al provenir de BasicDataSource.

printStackTrace(). solo libera la conexion. } } catch (SQLException e) { e. pero no se esta usando public static void liberaConexion(Connecti on conexion) { try { if (null != conexion) { // En realidad no cierra.close(). } } public static void liberarStatement(Prepar edStatement p){ try{ if(null != p){ p. conexion.con dicha conexion y que puede asignarsela a otro que la * pida.close(). } } catch (SQLException e) { e. } } } .printStackTrace(). * * @param conexion */ //esto es un pool de conexiones.