Evaluar extensión de archivo con java

Una forma simple de poder hacer esta validación es implementando el método accept de la clase FilenameFilter, entonces imaginemos que queremos saber si tenemos uno o mas archivos “zip” en el directorio “/home/nachxs/Documentos/ClasesPrueba”, para esto solo haremos lo siguiente:

package evalextension;

import java.io.File;
import java.io.FilenameFilter;

/**
*
* @author nachxs
*/
public class Main {

  public static void main(String[] args) {
    String path = "/home/nachxs/Documentos/ClasesPrueba";
    File fi = new File(path);
    File[] listaObjetos = fi.listFiles();
    for (int i = 0; i < listaObjetos.length; i++) {
        if (new EvaluaExtension().accept(listaObjetos[i], ".zip")) {
           System.out.println("Se encontro archivos zip: " + listaObjetos[i].getPath());
        }
    }
  }
}

class EvaluaExtension implements FilenameFilter {

    public boolean accept(File dir, String extension) {
        return dir.getName().endsWith(extension);
    }
}

Este es el directorio en donde realizmos la busqueda:

Básico para muchos, pero para otros espero les sirva.

Anuncios

TIP: Obtener valor Radio Button con JQuery

Hace poco revisando algo de validación para un pequeño sistema web que estoy desarrollando con JSP, me vi en la necesidad de querer obtener el valor de un Radio Button seleccionado y no encontre mejor forma de hacerlo que con JQuery, aqui coloco el código:

function getRadioButtonSelectedValue(objeto){
 return $("input[@name="+ objeto + "]:checked").val();
}

Donde, objeto por ejempo deberia ser algo como esto:

document.form.nombre_radio_button

De seguro hay mejores formas de hacerlo, pero para el que recien se inicia espero les sea de utilidad.

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.

TripleDES con Java

Hace poco revisando algo de información acerca de métodos de encriptación o cifrado, revisaba básicamente acerca de DES y TripleDES, especificamente por temas laborales, bueno encontre muchas clases y formas de poder trabajar con DES desde Java pero muy pocas con TripleDES y me preguntaba porque, pues bueno, resulta que TripleDES es una “mejora” del DES obviamente y como su propio nombre lo dice es generar cadenas cifradas utilizando tres veces el algoritmo DES pero teniendo en cuenta algunos parametros, para algunos quizas esto sea algo risorio pero creanme, hay gente que no conoce estos temas. No voy ha entrar a temas teóricos para eso tenemos la wiki :).

Escribi una clase simple de ejemplo que muestra la forma de hacerlo, aqui lo propongo , espero obtener mejoras en base a comentarios y si hay que hacer correcciones tambien y ademas espero sea utilidad para muchos.

Para esto utilize una libreria para DES que la descargue de aqui

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

package com.encripta;
import java.security.InvalidKeyException;

/**
 *
 * @author nachxs
 */

public class TripleDES {
    DES tdes = new DES();
    private static final int BLOCK_128 = 16;
    private static final int BLOCK_192 = 24;

    public String encrypt3DES(String str, String key) throws Exception {
        String enc = null;
        try {
            if (key.length() == 32) {
                byte[] keys = new byte[BLOCK_128];
                keys = FunctionByte.hex2byte(key);
                byte[] k1 = new byte[8];
                byte[] k2 = new byte[8];
                System.arraycopy(keys, 0, k1, 0, 8);
                tdes.setKey(k1);
                byte[] encode_1 = tdes.encrypt(FunctionByte.hex2byte(str));
                System.arraycopy(keys, 8, k2, 0, 8);
                tdes.setKey(k2);
                byte[] encode_2 = tdes.decrypt(encode_1);
                tdes.setKey(k1);
                byte[] encode_3 = tdes.encrypt(encode_2);
                enc = FunctionByte.toHEX1(encode_3);
                System.out.println("Encripta TipleDES: " + str + " --> " + enc);
            } else if (key.length() == 48) {
                byte[] keys = new byte[BLOCK_192];
                keys = FunctionByte.hex2byte(key);
                byte[] k1 = new byte[8];
                byte[] k2 = new byte[8];
                byte[] k3 = new byte[8];
                System.arraycopy(keys, 0, k1, 0, 8);
                tdes.setKey(k1);
                byte[] encode_1 = tdes.encrypt(FunctionByte.hex2byte(str));
                System.arraycopy(keys, 8, k2, 0, 8);
                tdes.setKey(k2);
                byte[] encode_2 = tdes.decrypt(encode_1);
                System.arraycopy(keys, 16, k3, 0, 8);
                tdes.setKey(k3);
                byte[] encode_3 = tdes.encrypt(encode_2);
                enc = FunctionByte.toHEX1(encode_3);
                System.out.println("Encripta TipleDES: " + str + " --> " + enc);
            } else {
                throw new InvalidKeyException("ERROR: Longitud de la llave incorrecta");
            }
        } catch (Exception ex) {
            throw ex;
        }
        return enc;
    }

    public String dencrypt3DES(String str, String key) throws Exception {
        String denc = "";
        try {
            if (key.length() == 32) {
                byte[] keys = new byte[BLOCK_128];
                keys = FunctionByte.hex2byte(key);
                byte[] k1 = new byte[8];
                byte[] k2 = new byte[8];
                System.arraycopy(keys, 0, k1, 0, 8);
                tdes.setKey(k1);
                byte[] decode_3 = tdes.decrypt(FunctionByte.hex2byte(str));
                System.arraycopy(keys, 8, k2, 0, 8);
                tdes.setKey(k2);
                byte[] decode_2 = tdes.encrypt(decode_3);
                tdes.setKey(k1);
                byte[] decode_1 = tdes.decrypt(decode_2);
                denc = FunctionByte.toHEX1(decode_1);
                System.out.println("Desencripta TipleDES: " + str + " --> " + denc);
            } else if (key.length() == 48) {
                byte[] keys = new byte[BLOCK_192];
                keys = FunctionByte.hex2byte(key);
                byte[] k1 = new byte[8];
                byte[] k2 = new byte[8];
                byte[] k3 = new byte[8];
                System.arraycopy(keys, 16, k3, 0, 8);
                tdes.setKey(k3);
                byte[] decode_3 = tdes.decrypt(FunctionByte.hex2byte(str));
                System.arraycopy(keys, 8, k2, 0, 8);
                tdes.setKey(k2);
                byte[] decode_2 = tdes.encrypt(decode_3);
                System.arraycopy(keys, 0, k1, 0, 8);
                tdes.setKey(k1);
                byte[] decode_1 = tdes.decrypt(decode_2);
                denc = FunctionByte.toHEX1(decode_1);
                System.out.println("Desencripta TipleDES: " + str + " --> " + denc);
            } else {
                throw new InvalidKeyException("ERROR: Longitud de la llave incorrecta");
            }
        } catch (Exception ex) {
            throw ex;
        }
        return denc;
    }
}

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í