while(true)

Ricardo says:
 y q carrera es?
Jaap says:
 ya llevo dos años trabajando.
 Ciencias de la Computación
Ricardo says:
 ahh va
 ponme windows 7
 porfa


... Sin comentarios.

Configurando el acceso de un EJB a través de un Firewall en WebSphere.

Hola les dejo una "traducción" que espero que a alguien le sirva.

Descripción: Cando un cliente EJB (Java) se conecta a través de un firewall a un EJB que corre en un Servidor de Aplicaciones WebSphere el cliente necesita comunicarse tanto con el proceso Java "admin server" como con el proceso "application server" que es el encargado de correr el EJB.

Si el firewall filtra el tráfico saliente entre la "caja" del Servidor de Aplicaciones WebSphere y la "caja" del cliente EJB es necesario fijar el "listener port" en el cliente EJB a un valor fijo y abrir dicho puerto en el firewall. Por default este puerto es asignado de manera aleatoria lo cual hace necesario fijarlo a un valor estático. Para hacer esto es necesario agregar la siguiente propiedad a la línea de comando de java que invoca al EJB en el cliente: "-Dcom.ibm.CORBA.ListerPort=aaaa" donde aaaa es un puerto libre mayor a 1023  en la "caja" del cliente EJB.

Por otro lado, si el firewall filtra el tráfico saliente entre la "caja" del cliente EJB a la "caja" del Servidor de Applicaciones WebSphere es necesario abrir varios puertos "a través" del firewall. Es necesario abrir el "listener port", "bootstrap port" y el "LSD port" para el "admin server". Es necesario abrir el puerto para el "application server". Por default los "listener port" son fijados de manera aleatoria y deben ser configurados con valores estáticos los cuales tienen que ser abiertos "a través" del firewall. Para fijar el "listener port" para el "admin server" agregue la siguiente linea en el archivo /bin/admin.config "com.ibm.CORBA.ListernerPort=bbbb". Para fijar el "listener port" en el "application server" encuentre el parámetro de la línea de comandos de Java para el "application server" en la consola de administración y agregue la siguiente propiedad: "-Dcom.ibm.CORBA.ListernerPort=cccc". Por default el "bootstrap port" en el "admin server" es 900 y el puerto "LSD port" es 9000.

Si la seguridad en el Servidor de Aplicaciones WebShpere es activada, la "caja" del Servidor de Aplicaciones WebSphere escuchar en puertos adicionales los cuales deben ser abiertos "a través" en el firewall. El "admin server" escucha "SSL y LSD SSL ports" y el "application server" escucha su propio "SSL port". Por default todos estos puertos son fijados de manera aleatorio y deben ser configurados a valores estáticos que deben ser abiertos "a través" del firewall. Para fijar los "SSL y LSD SSL ports" para el "admin server" agregue las siguiente líneas al archivo /bin/admin.config:

"com.ibm.CORBA.SSLPort=dddd"
"com.ibm.CORBA.LSDSSLPort=eeee"

Para configurar el puerto SSL para el "application server" encuentre el parámetro de la línea de comandos de Java para el "application server" en la consola de administración y agregue la siguiente propiedad:

"-Dcom.ibm.CORBA.SSLPort=ffff"
Asegúrse que los puertos bbbb, cccc, dddd y eeee sean únicos, libres y mayores a 1024 dentro de la "caja" del Servidor de Aplicaciones WebSphere.

Humor javero.

Bueno, jajaja. Ahora después de ver en qué aplicaba el siguiente código me he reído un poco menos, pero lo cierto es que revisarlo en el Netbeans casi hace que me arranque los ojos XD.

return false;//error de sintásis

Implementacion de un Heap de números enteros en Java.

/**
 * Clase para implementar un heap de numeros enteros.
 */
public class Heap {

    /**
     * Aqui guardamos el heap.
     */
    private int[] heap;
    /**
     * Lleva la cuenta del numero de elementos en el heap.
     */
    private int numeroElementos = 0;

    /**
     * Recibe como argumento un arreglo del que extraera sus valores y los
     * copiara uno a uno en el heap usando el metodo inserta.
     * @param array El arreglo que introduciremos al heap.
     */
    public Heap(final int[] array) {
        heap = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            int j = array[i];
            inserta(j);
        }
    }

    /**
     * Hace una copia del heap y lo devuelve.
     * @return Una copia de los valores del heap.
     */
    public final int[] getValue() {
        return heap.clone();
    }

    /**
     * Inserta un entero en el heap en la ultima posicion disponible y reordena
     * el heap para conservar la propiedad de orden se siga cumpliendo.
     * @param elemento El elemento a ordenar.
     */
    public final void inserta(int elemento) {
        if (numeroElementos == heap.length) {
            throw new IllegalStateException("Error, el heap esta lleno. " +
                    "Elemento a insertar: " + elemento + " Heap size: " +
                    numeroElementos);
        }
        // Cuando no hay elementos insertamos el elemento en la
        // primera posicion del arreglo que es la raiz del heap
        if (numeroElementos == 0) {
            heap[0] = elemento;
            numeroElementos++;
            return;
        }
        boolean esPadreMayor = false;
        // indiceHijo es el ultimo lugar del heap. Aqui es donde empezamos
        // a buscar la posicion del elemento a insertar. Posteriormente calcula
        // mos la posicion del padre de este nodo.
        int indiceHijo = numeroElementos;
        // Aqui guardamos el indice del nodo padra del nodo hijo.
        int indicePadre = 0;
        // Calculamos el indice del nodo padre.
        if (indiceHijo % 2 == 0) {
            indicePadre = (int) (Math.ceil(indiceHijo / 2)) - 1;
        } else {
            indicePadre = (int) (Math.ceil(indiceHijo / 2));
        }
        int valorPadre = heap[indicePadre];
        while (true) {
            // Terminamos cuando el padre que estamos analizando es mayor
            // que el valor del hijo actual. O cuando ya llegamos a la raiz
            // del arbol, que es cuando el indiceHijo == 0
            if (esPadreMayor || indiceHijo == 0) {
                break;
            }
            // Si encontramos que el valor del padre del nodo actual
            // es mayor que el valor del elemenot que estamos insertando
            // guardamos el valor del elemento en el nodo actual (indiceHijo)
            // y marcamos la variable esPadreMayor = true para en el siguiente
            // ciclo finalizar.
            if (valorPadre > elemento) {
                heap[indiceHijo] = elemento;
                esPadreMayor = true;
                continue;
            }
            // Sino se cumple ninguna de las condiciones anteriores, intercam
            // biamos el valor del nodo padre con el hijo y actualizamos
            // los indices. 'indiceHijo = indicePadre' para en la siguiente
            // iteracion repetir el mismo proceso.
            heap[indicePadre] = elemento;
            heap[indiceHijo] = valorPadre;
            indiceHijo = indicePadre;
            // Una vez calculado el nuevo indiceHijo, calculamos el nuevo
            // indicePadre.
            if (indiceHijo % 2 == 0) {
                indicePadre = (int) (Math.ceil(indiceHijo / 2)) - 1;
            } else {
                indicePadre = (int) (Math.ceil(indiceHijo / 2));
            }
            if (indicePadre >= 0) {
                valorPadre = heap[indicePadre];
            }
        }
        numeroElementos++;
    }

    /**
     * Obtiene el valor de la raiz del heap y reordena los elementos para
     * mantener la propiedad del heap.
     * @return En cada llamada obtiene el valor maximo del heap, eliminando
     * dicho elemento y reordenando el heap para que en la siguiente
     * llamada obtenga el valor maximo del heap restante.
     */
    public final int quitaRaiz() {
        if (numeroElementos == 0) {
            throw new IllegalStateException("Error, el heap esta vacio");
        }
        int resultado = heap[0];
        heap[0] = heap[--numeroElementos];
        int indiceNodo = 0;
        int indiceHijoMayor = 0;
        while (true) {
            int indiceHijoIzquierdo = indiceNodo * 2 + 1;
            int indiceHijoDerecho = indiceNodo * 2 + 2;
            if (indiceHijoIzquierdo >= numeroElementos) {
                break;
            } else {
                // Determinar cual de los dos hijos es el mayor
                if (indiceHijoDerecho >= numeroElementos) {
                    indiceHijoMayor = indiceHijoIzquierdo;
                } else {
                    if (heap[indiceHijoIzquierdo] > heap[indiceHijoDerecho]) {
                        indiceHijoMayor = indiceHijoIzquierdo;
                    } else {
                        indiceHijoMayor = indiceHijoDerecho;
                    }
                }
            }
            /**
             * Intercambiar los valores del indiceNodo y el indiceHijoMayor
             * si es que el valor del hijo mayor es mayor que el valor del
             * nodo actual. En caso que no sea así terminamos.
             */
            int valorHijoMayor = heap[indiceHijoMayor];
            if (valorHijoMayor > heap[indiceNodo]) {
                heap[indiceHijoMayor] = heap[indiceNodo];
                heap[indiceNodo] = valorHijoMayor;
                // Actualizar el valor del indiceNodo por indiceHijoMayor
                indiceNodo = indiceHijoMayor;
            } else {
                break;
            }
        }
        return resultado;
    }
}

Implementacion de Merge Sort en Java

private int[] mergeSortImpl(int[] array) {
        // Caso base. Un arreglo de cero o un elemento ya esta ordenado,
        // asi que lo regresamos.
        if (array.length <= 1) {
            return array;
        }
        int puntoMedio = array.length / 2;
        // Creamos subarreglo izquierdo
        int[] izquierdo = new int[puntoMedio];
        for (int i = 0; i < puntoMedio; i++) {
            izquierdo[i] = array[i];
        }
        // Creamos el subarreglo derecho
        int[] derecho = new int[array.length - puntoMedio];
        for (int i = 0; i < array.length - puntoMedio; i++) {
            derecho[i] = array[puntoMedio + i];
        }
        // Ordenamos las dos mitades recursivamente
        int[] izquierdoOrdenado = mergeSortImpl(izquierdo);
        int[] derechoOrdenado = mergeSortImpl(derecho);
        //Mezclamos la solucion---
        // El indice i es para recorrer el subarreglo izquierdo
        int i = 0;
        // El indice j es para recorrer el subarreglo derecho
        int j = 0;
        // En 'resultado' guardamos el resultado de la mezcla de los dos
        // subarreglos
        int[] resultado = new int[izquierdoOrdenado.length + derechoOrdenado.length];
        /**
         * Terminamos de mezclar cuando i + j ya recorrieron todos los elementos
         * de los dos subarreglos
         */
        while (i + j < izquierdoOrdenado.length + derechoOrdenado.length) {
            // a) Si i ya llego al ultimo elemento del subarreglo izquierdo
            // copiamos el valor del siguiente elemento del subarreglo
            // derecho e incrementamos el indice j para, en el siguiente,
            // ciclo copiar el elemento de subarreglo derecho que sigue
            if (i == izquierdoOrdenado.length) {
                resultado[i + j] = derechoOrdenado[j];
                j++;
                continue;
            }
            // Lo mismo que a) pero para el subarreglo derecho
            if (j == derechoOrdenado.length) {
                resultado[i + j] = izquierdoOrdenado[i];
                i++;
                continue;
            }
            int elementoIzquierdo = izquierdoOrdenado[i];
            int elementoDerecho = derechoOrdenado[j];
            // Comparamos cual de los elementos que siguen es menor y ese
            // lo copiamos en resultado
            if (elementoIzquierdo <= elementoDerecho) {
                resultado[i + j] = elementoIzquierdo;
                i++;
            } else {
                resultado[i + j] = elementoDerecho;
                j++;
            }
        }
        return resultado;
    }

Problema con Netbeans 6.7.1 y Sybase. Conexiones SQL

Hace poco que actualicé mi versión de Netbeans de la 6.5 a la 6.7.1 y para ser sinceros mi vida era muy feliz. La interfaz no ha cambiado mucho y sin embargo han agregado un buen número de nuevos plug-ins dentro de la lista inicial y han actualizado la mayoria de los frameworks con los que trabaja. Aunque aún no logro entender por qué no pusieron la última versión de Struts (2.0), pues al menos lo actualizaron a 1.8 o algo así.

El chiste es que luego de tener que descargar la Struts 1.7 y agregárselo a mis proyectos web, ya que Netbeans no me indicaba problemas de referencias, pero no podía incluir el mentado Struts 1.7 sin que yo lo hiciera manualmente, me di a la tarea de dejar mi ambiente de trabajo más o menos igual al que tenía antes del cambio; lo cual no fue tan complicado como esperaba.

Bueno, salvo dicho problema y algúno que otro plugin que perdí con el cambio de mi compu a una Vostro 1520; no hubo muchos problemas con el netbeans 6.7.1. Claro, hasta hoy!!!

No puedo creer que algo tan simple como un:

select * from tabla

no pueda funcionar. El problema sucede en particular con una conexión a una base de datos Sybase y antes de venir y gritarlo, pues hice mis pruebas con dos versiones del driver de Sybase; en particular 5.5 y 6.0.1 y con ninguno llegó a funcionar. Por otro lado las conexiones con MySql, Oracle y Postgres funcionan igual que antes. Cabe mencionar que dicha conexion con Sybase ya la tenía funcionando con el driver 5.5 que acabo de mencionar. Es decir, no es el dirver y no es la base de datos; quizá mi instalación aunque sigo pensando que es un bug del Netbeans. La conexión también se realiza sin problemas y la ventana de Servicios y el navegador de bases de datos muestra perfectamente el esquema de la base e incluso soy capaz de consultar las propiedades de las tablas y las columnas, todo el problema sucede cuando quiero ejecutar cuaquier línea de SQL.

Espero que para el siguiente release del Netbeans corrijan todos sus problemas con las conexiones y el manejo de base de datos, que hasta hace poco yo consideraba lo suficientemente sencillo como para tareas básicas y ejecutar código SQL.

En fin, dejo el mentado error por si a alguien le interesa:

Line 1, column 1

Execution finished after 0.016 s, 1 error(s) occurred.

Por supuesto el código de error no deja lugar a dudas que lo que está mal está en la línea 1 y en la columna 1. jeje. :p

Saludos y espero poder reportar este bug a la lista correspondiente.

Agregando un applet a una aplicacion web. Netbeans 6.5

En esta entrada explicaré cómo agregar un applet a una aplicación web hecha con Netbeans, en particular con Netbeans 6.5.

Suponiendo que tenemos nuestro proyecto web como un proyecto en Netbeans lo siguiente es agregar el applet al archivo war final, esto lo logramos modificando las propiedades de nuestro proyecto:

En la ventana de Proyects:

- Click derecho sobre nuestro proyecto
- Properties
- Expandimos la opción de Build


- Packaging:


- En esta ventana seleccionamos la opción Add File/Folder y buscamos el archivo jar de nuestro applet e indicamos la ruta dentro de la aplicación web donde quedará guardado el jar del applet. Esta ruta será la opción que le debemos pasar a la etiqueta del applet en la página web que lo desplegará.

Suponiendo que escogemos la ruta: / como ubicación final dentro del war entonces, usando un jsp para desplegar el código de la página web este quedaria como sigue:

- Por último: de las opciones de la etiqueta del applet debemos tener cuidado con los atributos:

• archive="GeoLab.jar" que indica el nombre del jar que contiene el applet a cargar, en nuestro caso GeoLab.jar
• code="geolab.AppletGeolab.class" que indica el nombre de la clase de java que extiende de la clase Applet de java.
• name="PruebaAppletGeolab" que indica un nombre lógico con el cual javascript y otros elementos identificarán a nuestro applet.

Espero que esta entrada sea útil para alguien ya que a mi me costó un poco de trabajo entender estas etiquetas resultando en incontables excepciones sobre todo de clases java perdidas entre otras.

Saludos.

Misterio de 5 minutos.

Ambiente: Aplicación web en Java y struts.

La excepción:

javax.servlet.jsp.JspException: Invalid argument looking up property: rol.tipoRol of bean: "org.apache.struts.taglib.html.BEAN"

Descripción.

Pues bueno resulta que haciendo unas pruebas aqui en el trabajo un amigo se encontró con el la excepción anterior mientras usaba una forma de struts del tipo RegistrarCedulaAF que contenía un objeto del tipo Rol que dentro de él contenía la propiedad tipoRol y la estaba usando en una etiqueta del jsp del siguiente modo:

<html:text property="rol.tipoRol" readonly="true"/>

Por supuesto que habíamos declarado la forma en el struts-config y todos los getters y setters se encontraban bien escritos, pero al momento de correr la prueba nos aparecía el misterioso mensaje anterior. Luego de unos minutos tratando de adivinar si nuestras clases tenían sus respectivos métodos de get y set bien construidos y descubrir que estaban como deberían de estar, tanto con las clases como con el archivo de struts-config de la aplicación y que todo estuviera en orden, estuvimos a punto de darnos por vencidos cuando descubrimos la causa del problema.

Resulta que la forma RegistrarCedulaAF se inicializaba correctamente, pero en ningún momento inicializamos su atritubo Rol por lo que éste se encontraba en null cuando la forma era creada por struts y al parecer struts no es tan listo como para diferenciar entre que queremos utilizar una propiedad de un objeto en null o que queremos buscar un atributo de la forma que no existe, por lo que envía un error de que no encuentra la propiedad rol.tipoRol en la forma, en lugar de mandarnos un mensaje de nullpointer excepcion (aunque a decir verdad no sé que tan dificil sea notar la diferencia entre estas dos situaciones.)

Para resolver el problema basta con tener inicializado el objeto Rol que pertenece a la forma en el momento de solicitar su propiedad tipoRol, de otra manera aparecerá el mensaje mencionado.

Esa fue la lección de hoy. Espero pronto poder escribir otra lección aprendida sobre struts y unos cambios en una forma que no son registrados mediante un html:link y javascript.

Saludos.

Mi encuentro con EJB's.

Hace ya más de un año que empecé a trabajar como becario en una empresa llamada Root y para ser sinceros, cuando entré no sabía mucho de Java (no porque ahora sí, sino que antes de verdad no había hecho nada demasiado interesante) sobre todo de sus "tecnologías" (Beans, Entity Beans, JAAS) y mucho menos de cómo se pueden utilizar diferentes frameworks que andan circulando por la red (Hibernate, Tapestry, Spring, entre otros).

Para ser sinceros tuve que aprender a punta de golpes y quebraderos de cabeza cosas tan "simples" (básicas sería un mejor término) como el concepto de un Java Bean (o Bean para los cuates, "frijolito", según Oswaldo). Y sí, es un camino tortuoso, divertido, absorbente, lleno de frustraciones y de un sentimiento de orgullo cuando se descubre que las cosas que cuenta la gente sí se pueden hacer, y aun más,... dejan dinero :D

Así es, entonces en entradas futuras tendré que dedicarle algunas líneas a cada uno de estos temas.

Siendo tu propio seguidor.

Bueno, al parecer puedo ser siguidor de un blog mío. Al menos ya tengo un seguidor para este blog... y vamos por dos.! :)

Hola Mundo!

Sí, a veces programo y pues para aprovechar el tiempo en que el Glassfish hace el deploy de mis hermosos EJB's pues aprovecho para escribir aquí.

Primero, tristemente últimamente sólo he estado jugando con Java, Struts y EJB's para una aplicación administrativa. La vdd es que al principio estaba chido, justo ahora está de hueva, pero bueno, entre encontrar cómo se hacen deploys de ejbs en Netbeans sin que salgan excepciones me entretengo bastante.

Sigo pensando de qué manera voy a organizar este blog para que sea algo de utilidad... no lo sé. Tendré que revisar en el internet ( que hueva ) cómo se le hace para ese tipo de cosas, lo único que se me viene a la mente es usar las etiquetas para los post y, mientras no encuentre nada más fácil, tomaré ese camino.