Javadabadu! Blog de desarrollo de software en entornos desktop, web y móviles con Java, PHP, etc.

Interfaces CRUD para Mantenimiento de Bases de Datos (y II)

2009-09-30T23:40:00.008-05:00

Continuando con el post anterior, ahora vamos a crear las acciones que realizan las operaciones de mantenimiento en la tabla de la base de datos Customers. Para esto, vamos a asociar a cada botón de nuestra ventana la correspondiente acción de la manera que ya hemos visto en posts anteriores. La siguiente tabla resume los valores de las propiedades de las acciones Nuevo, Guardar, Actualizar y Eliminar:

PROPIEDAD	Nuevo	Guardar	Actualizar	Eliminar
Método de acción	registrarCliente	guardarCambios	actualizarDatos	eliminarCliente
Segundo plano	No	Sí	Sí	No
Texto	Nuevo	Guardar	Actualizar	Eliminar
Propiedad habilitada	-	necesitaGuardar	-	clienteSeleccionado

Si desean recordar cómo se crean y configuran acciones pueden leer la entrada anterior Desarrollo de aplicaciones con Swing Application Framework. Una vez establecidas las acciones vamos a escribir el código que llevará a cabo cada operación de mantenimiento.

Acción registrarCliente

En esta acción creamos un nuevo cliente, lo persistimos en el administrador de entidades creado en el post anterior y lo agregamos a la lista de resultados, también creada antes. Además debemos seleccionar la fila del objeto JTable asociada al nuevo cliente y activar el indicador necesitaGuardar para que la acción Guardar sea habilitada.

        Customers nuevoCliente = new Customers();
        entityManager1.persist(nuevoCliente);
        list1.add(nuevoCliente);
        int fila = list1.size() - 1;
        jTable1.setRowSelectionInterval(fila, fila);
        jTable1.scrollRectToVisible(jTable1.getCellRect(fila, 0, true));
        setNecesitaGuardar(true);

Acción guardarCambios

El código de está acción debe situarse en el método doInBackground de la clase interna que debería tener el nombre GuardarCambiosTask. Aquí solo confirmamos transacción e iniciamos una nueva. En caso de una excepción (la llamada a commit puede lanzar una RollbackException si la transacción ha sido deshecha anteriormente) “mezclamos” los datos de los clientes con los datos almacenados en la base de datos.

            try {
                entityManager1.getTransaction().commit();
                entityManager1.getTransaction().begin();
            } catch (RollbackException ex) {
                Logger.getLogger(MarcoClientes.class.getName()).log(Level.SEVERE, null, ex);
                entityManager1.getTransaction().begin();
                List<Customers> clientes = new ArrayList<Customers>(list1.size());
                for (Customers cliente : list1) clientes.add(entityManager1.merge(cliente));
                list1.clear();
                list1.addAll(clientes);
            }
            return null;

Además, debemos establecer la propiedad necesitaGuardar en false porque los cambios ya se han guardado. Esto lo vamos a hacer en el método succeeded:

setNecesitaGuardar(false);

Acción actualizarDatos

Para actualizar los datos ignorando todo cambio que se haya hecho solo es necesario deshacer los cambios de la transacción e iniciar una nueva. Luego es necesario “refrescar” la lista de clientes que tenemos con los datos almacenados en la base de datos, recuperándolos nuevamente volviendo a ejecutar la consulta del objeto Query. Al igual que la acción anterior, este código se ubica en el método doInBackground:

            entityManager1.getTransaction().rollback();
            entityManager1.getTransaction().begin();
            List<Customers> clientes = query1.getResultList();
            for (Customers cliente : clientes) entityManager1.refresh(cliente);
            list1.clear();
            list1.addAll(clientes);
            return null;

Acción eliminarCliente

Puede haber más de un cliente seleccionado en el objeto JTable. Por eso, para cada fila seleccionada recuperamos el objeto Customers del modelo de la tabla, no de su vista (puede ser que se haya cambiado de sitio las filas, uno nunca sabe). Los clientes recuperados son eliminados de la lista de clientes y del administrador de entidades.

        for (int indice : jTable1.getSelectedRows()) {
            Customers cliente = list1.get(jTable1.convertRowIndexToModel(indice));
            list1.remove(cliente);
            entityManager1.remove(cliente);
        }
        setNecesitaGuardar(true);

Tokes finales

Hay algunas cosas a considerar antes de terminar. Al momento de crear las acciones se crearon dos propiedades booleanas: necesitaGuardar y clienteSeleccionado. La primera no necesita modificaciones. La segunda no debe ser llamada explícitamente, sino que debe cambiar de acuerdo a la selección del usuario en el objeto JTable. Para esto vamos a eliminar el campo clienteSeleccionado y su método setter, quedándonos sólo con su respectivo getter, el cual modificaremos de la siguiente manera:

    public boolean isClienteSeleccionado() {
        return jTable1.getSelectedRow() != -1;
    }

Para activar esta propiedad cuando el usuario seleccione una fila del objeto JTable (y, por consiguiente, sea habilitada la acción Eliminar) vamos a escribir un método en el cual agregamos un oyente de selección al modelo de selección del objeto JTable, disparando un cambio en la propiedad clienteSeleccionado:

    private void initListeners() {
        jTable1.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
            public void valueChanged(ListSelectionEvent e) {
                firePropertyChange("clienteSeleccionado", !isClienteSeleccionado(),
                        isClienteSeleccionado());
            }
        });
    }

Este método debe ser llamado desde el constructor. Adicionalmente, cada vez que haya un cambio en los datos del cliente seleccionado debe activarse la propiedad necesitaGuardar (para habilitar la acción Guardar). Los cambios pueden ser hechos en el objeto JTable o en los campos de texto que muestran los datos de dirección del cliente, por lo tanto es lógico pensar que se tendría que agregar oyentes al objeto JTable y a cada campo de texto para activar la propiedad ante cualquier cambio.

Un acercamiento más apropiado es utilizar el grupo de enlaces creado cuando enlazamos los componentes con la lista de clientes. Este grupo es un objeto BindingGroup al cual se le puede agregar un oyente de enlace de tipo BindingListener. Para esto agregamos un objeto AbstractBindingListener (que deriva de BindingListener e implementa la funcionalidad básica de notificación de enlaces) y redefimos su método targetChanged (llamado cuando hay un cambio en el bean objetivo del enlace) activando la propiedad necesitaGuardar. Esto lo hacemos en el método recién creado:

       bindingGroup.addBindingListener(new AbstractBindingListener() {
            @Override public void targetChanged(Binding binding, PropertyStateEvent event) {
                setNecesitaGuardar(true);
            }
        });

Y bien, eso es todo. Con esto acaba el desarrollo de esta sencilla ventana de mantenimiento de tipo CRUD. Lógicamente hemos obviado algunas tareas comunes, como búsquedas y otras cosas. Queda como un ejercicio (!) hacer las ventanas de mantenimiento de las demás tablas jejeje. A continuación inserto los videos correspondientes a esta entrada y la anterior, así como el enlace al código fuente del ejemplo. En la siguiente entrada desarrollaremos una ventana más compleja, en la cual se tocarán aspectos más avanzados.

Código fuente de la aplicación de ejemplo en MegaUpload

Interfaces CRUD para Mantenimiento de Bases de Datos (I)

2009-09-30T23:34:00.005-05:00

Luego de terminar un ciclo de locos y de aprobar todos mis cursos, por fin hoy puedo publicar una entrada en este blog, continuando con el desarrollo de la aplicación que empece en el último post sobre Java con bases de datos. La última vez se crearon las clases entidad que se mapean con las tablas de la base de datos MySQL de ejemplo y se explicó muchos aspectos sobre este proceso, como la especificación JPA y sus diferentes implementaciones, unidades de persistencia, clases entidad, etc.

Hoy voy a crear una interfaz gráfica de usuario para realizar operaciones de mantenimiento en las tablas de la base de datos. Antes que nada tengo que decir que voy a utilizar bastante el API Beans Binding para enlazar las propiedades de los componentes visuales con las de las clases entidad, y para esto debemos hacer que nuestras clases entidad sean beans “con todas las de la ley”. Esto se consigue agregándoles el soporte de cambio de propiedades.

Esto lo he tocado en un post anterior, pero no esta demás recordarlo. Primero, debemos agregar una instancia de PropertyChangeSupport a cada una de las clases entidad que tengamos. Pero existe una trampa: si la agregamos y nada más, JPA pensará que se trata de un campo más en la tabla correspondiente a la clase entidad y lo mapeará en ella. Para evitar esto, hacemos uso de la anotación @Transient, de la siguiente manera:

@Transient
private PropertyChangeSupport soportePropiedades = new PropertyChangeSupport(this);

A continuación modificamos todos los métodos setter de las propiedades de nuestras clases entidad, disparando un cambio de propiedad con el valor anterior y el nuevo. Por ejemplo:

public void setCustomerID(String customerID) {
        String anterior = this.customerID;
        this.customerID = customerID;
        soportePropiedades.firePropertyChange("customerID", anterior, customerID);
}

Bien, pues ahora sí es hora de crear nuestras ventanas. Como cuando creamos nuestro proyecto lo hicimos utilizando Swing Application Framework, ya tenemos una ventana principal con un menú. Voy a tratar dicha ventana como una ventana MDI, que tiene múltiples ventanas internas y para esto, debemos modificar esa ventana, borrando el panel central y arrastrando y soltando en cualquier lugar del diseñador un objeto JDesktopPane de la paleta de componentes. A continuación, en la ficha Inspector seleccionamos el elemento [FrameView] y luego, en la ficha Propiedades, establecemos la propiedad component con el objeto JDesktopPane que acabamos de agregar.

Además, vamos a agregar un método que permita agregar marcos internos en esta ventana MDI, haciéndolos visibles, seleccionándolos y gestionando sus posiciones iniciales. No voy a explicar el funcionamiento de este método, por que considero que es autoexplicativo:

private void agregarMarcoInterno(JInternalFrame marco) {
        marco.setLocation(xSigMarco, ySigMarco);
        marco.setVisible(true);
        desktopPane.add(marco);

        try {
            marco.setSelected(true);
        } catch (PropertyVetoException ex) {
        }

if (distanciaEntreMarcos == 0)
distanciaEntreMarcos = marco.getHeight() - marco.getContentPane().getHeight();

        xSigMarco += distanciaEntreMarcos;
        ySigMarco += distanciaEntreMarcos;
        if (xSigMarco + marco.getWidth() > desktopPane.getWidth()) xSigMarco = 0;
        if (ySigMarco + marco.getHeight() > desktopPane.getHeight()) ySigMarco = 0;
}

El método recibe un objeto JInternalFrame, que es un marco interno de una ventana MDI. Por lo tanto vamos a crear un Formulario JInternalFrame en el proyecto. Una vez creada, pasamos a diseñarla para que tenga el siguiente aspecto:

Quiero suponer que los componentes que uso son conocidos para los lectores. El objetivo de nuestra interfaz es realizar las operaciones de mantenimiento a la tabla Customers de la base de datos, listando a todos los clientes en el JTable y que, al seleccionar un cliente, se muestre sus datos de dirección en los objetos JTextField. Como dije antes, para esto haremos uso intensivo de Beans Binding. Comencemos.

En primer lugar debemos agregar a la ventana los objetos que nos permitirán persistir y consultar los datos de los clientes de la base de datos. Estos componentes se encuentran en la categoría Persistencia de Java de la paleta. El primero que vamos a agregar (arrastrando y soltando) será un Administrador de entidades, que es un objeto EntityManager que nos permitirá interactuar con la base de datos a través de la unidad de persistencia que creamos en nuestro proyecto en el post anterior. Por esto, debemos asegurarnos que en la propiedad persistenceUnit de dicho administrador de entidades esté el nombre de nuestra unidad de persistencia.

Luego agregamos un objeto Consulta, que es un objeto Query que nos permite realizar una consulta en la base de datos utilizando el lenguaje JPQL, devolviendo un objeto entidad o una lista de ellos. La propiedad query contiene la cadena de consulta JPQL y la propiedad entityManager hace referencia al administrador de entidades que hemos creado antes. Ambas propiedades deben ser establecidas como se muestra en la tabla:

PROPIEDAD	VALOR
query	SELECT c FROM Customers c
entityManager	entityManager1

Después agregamos un objeto Resultado de la Consulta, que es un objeto List que almacena la lista de resultados del objeto Query. Establecemos la propiedad query para que haga referencia al objeto Query que creamos antes. Además, seleccionamos la propiedad observable para que cualquier cambio en la lista sea notificado a los componentes que estén enlazados con ella, como nuestro JTable. También debemos especificar qué tipo de objetos almacenará esta lista y para eso vamos a la pestaña Código y en la propiedad Parámetros de tipo escribimos “<Customers>”.

Ahora podemos enlazar nuestros componentes visuales con los objetos entidad devueltos por los objetos que acabamos de crear. Comenzamos con el JTable enlazando su propiedad elements con el objeto List y seleccionando solo algunas propiedades de la clase Customers.

Alternativamente, podemos modificar el contenido de la tabla, para cambiar, por ejemplo, el título de las columnas. Para esto, hacemos clic derecho sobre la tabla y seleccionamos Contenido de la tabla… En la pestaña Columnas de la ventana abierta podemos especificar el título de las columnas, y si éstas son redimensionables o editables, y otras propiedades que por ahora no voy a explicar.

Es el turno de los campos de texto. Enlazamos su propiedad text con una propiedad especifica del objeto Customers seleccionado en el JTable. Por ejemplo, enlazamos el campo de texto etiquetado como Dirección con la propiedad address de Customers:

Procedemos de la misma forma para los demás campos de texto, que se resume en la tabla:

Campo de Texto	Enlazado de Expresión
jTextField2 (Ciudad)	${selectedElement.city}
jTextField3 (Región)	${selectedElement.region}
jTextField4 (Código postal)	${selectedElement.postalCode}
jTextField5 (País)	${selectedElement.country}

Con la funcionalidad agregada hasta ahora es suficiente para visualizar todos los datos de todos los clientes de la base de datos. Si no me creen, puedo probarlo. Para esto abrimos la ventana principal (la que modificamos para que sea MDI), y agregamos un elemento de menú desde la paleta al menú Archivo y le asignamos una acción, como ya hemos visto en el post referente al framework Swing Application Framework.

En el cuerpo del método de la acción creada, llamamos al método que creamos para agregar marcos internos a la ventana MDI, creando un nuevo marco de clientes:

agregarMarcoInterno(new MarcoClientes());

Al ejecutar la aplicación podemos observar que todo va bien: los clientes son listados en la tabla y al seleccionar uno de ellos se muestran sus datos de dirección en los campos de texto. Pero eso es solo el comienzo. Aún falta implementar las operaciones de mantenimiento; pero como este post ya se hizo grande voy a hacerlo en una segunda parte. Por ahora solo me queda decir: Esta historia continuará!!!

Creación de Clases Entidad a partir de una Base de Datos

2009-08-09T18:34:00.004-05:00

Vuelvo a publicar una entrada en este blog después de dos semanas de ausencia, debido a problemas de salud y de computadora (otra vez!). Pero en fin, en esta ocasión voy a tratar de ilustrar la forma de desarrollar una aplicación que se conecte a una base de datos sin utilizar el asistente que vimos en el post anterior. Esto para dar más flexibilidad a nuestros sistemas de la que nos puede dar el IDE NetBeans con dicho asistente.

Algo de teoría: desde los albores de la POO los programadores han tenido que lidiar con el problema de representar los datos que se tienen en una base de datos, en un modelo de clases y objetos. Esto lleva el término de Mapeo Objeto-Relacional (ORM, por sus siglas en inglés), mecanismo por el cual se puede solucionar este problema. Java tiene una especificación llamada JPA (Java Persistence API) que permite realizar este mapeo.

Pero solo es eso: una especificación que indica el mecanismo necesario para llevar a cabo el mapeo. Existen básicamente cuatro implementaciones de JPA, a saber: Hibernate, TopLink, OpenJPA y EclipseLink. El elegir una u otra implementación depende únicamente del rendimiento, pues gracias a JPA podemos trabajar con cualquiera de estas implementaciones y cambiar entre ellas de manera transparente para nosotros. (Justamente mencione las implementaciones en orden de rendimiento, de acuerdo a unas pruebas hechas por otro blogger).

El mapeo objeto-relacional se realiza a través de las llamadas clases entidad, que son POJO’s que tienen una estructura especial. Un POJO (Plain Old Java Object) es un objeto de una clase simple, que no implementa raras interfaces y que puede ser escrita de la manera convencional. Los POJO’s fueron la respuesta a la tendencia que había de obligar a los programadores a crear clases que implementaran interfaces (como en EJB).

JPA es todo un mundo, sin embargo esta entrada no pretende ser una guía de referencia, así que voy a mostrar como crear clases entidad a partir de la base de datos Northwind, famosa en entornos SQL Server y también disponible para MySQL. Así que para comenzar creamos un proyecto de aplicación de escritorio (para utilizar Swing Application Framework aunque ahora no lo utilicemos, voy a seguir con este ejemplo en los demás post). Además, no vamos a utilizar el shell de aplicación de base de datos, porque vamos a crear las clases entidad y la unidad de persistencia por nuestra cuenta.

Una vez que el asistente ha creado nuestra aplicación, creamos las clases entidad pulsando Ctrl + N, y eligiendo en la ventana resultante la categoría Persistencia y en Tipo de archivo Clases entidad a partir de base de datos.

En el siguiente paso del asistente especificamos la conexión de la que recuperará los datos. Una vez hecho esto, se listan las tablas existentes en la base de datos. Hacemos clic en Agregar todo para crear las clases entidad de todas las tablas de nuestra base de datos. La ventaja de esto es que el asistente crea las clases entidad con toda la funcionalidad necesaria para realizar el mapeo incluyendo las relaciones que pueden haber en nuestra base de datos. Si solo agregamos unas cuantas tablas, y en un momento posterior tenemos que mapear las demás, tendríamos que hacer todo esto nosotros a mano.

El siguiente paso nos muestra las tablas de la base de datos y sus correspondientes clases entidad, permitiendo modificar sus nombres. También nos permite especificar un paquete para las clases que se van a crear (lo cual es recomendable).

En la parte inferior nos dice que el proyecto no tiene una unidad de persistencia. Una unidad de persistencia contiene los parámetros necesarios para realizar la conexión a la base de datos: la clase del proveedor de persistencia (que se encuentra en los jars de la implementación JPA que elijamos), las clases entidad de nuestra aplicación y los parámetros JDBC de acceso a la base de datos. La unidad de persistencia se almacena en un archivo llamado persistence.xml y es la responsable de que podamos cambiar de implementación JPA e incluso de SGBD sin que toquemos el código de nuestra aplicación.

Creamos la unidad de persistencia pulsando el botón Crear unidad de persistencia (obvio no). En la ventana resultante especificamos el nombre de la unidad de persistencia y la biblioteca que vamos a utilizar. Esa es otra ventaja de crear las clases entidad a mano. Utilizando el shell de base de datos, NetBeans trabaja por defecto con TopLink. En este caso tenemos la libertad de escoger nuestra implementación. Hibernate para nosotros. La estrategia de generación de tablas se refiere a la política utilizada para crear nuevas tablas en nuestra base de datos. Como no vamos a hacer esto, lo dejamos con Ninguno.

En el último paso tenemos opciones adicionales. La única que vamos a modificar es el tipo de colección. Para explicar porque tomemos un ejemplo. Existe una relación de uno a muchos entre los clientes y sus pedidos. Un cliente puede hacer muchos pedido, pero cada pedido pertenece a un único cliente. Para realizar el mapeo en estas tablas, JPA incluye en la clase Pedido una referencia al objeto Cliente al que pertenece, mientras que en la clase Cliente agrega una lista de objetos Pedido. Podemos especificar que esta lista sea de tipo Collection, List o Set. Nosotros vamos a decirle a JPA que utilice una referencia List.

Y eso es todo. El asistente se ocupa de crear las clases entidad capaces de realizar el mapeo objeto-relacional en nuestra base de datos por nosotros. Pero esto no es suficiente. En nuestra aplicación debemos crear el código que creara la unidad de persistencia y los objetos que permitirán realizar consultas y persistir objetos en nuestra base de datos. Esto también es muy fácil. Basta con escribir las siguientes líneas de código:

EntityManagerFactory factory =
Persistence.createEntityManagerFactory("UnidadPersistencia");
EntityManager manager = factory.createEntityManager();

El método createEntityManagerFactory toma el nombre de la unidad de persistencia, la crea y devuelve un objeto EntityManagerFactory, que es utilizado para crear objetos EntityManager. Los objetos EntityManager tienen métodos que permiten realizar consultas, persistir, actualizar y eliminar objetos en nuestra base de datos (obviamente lo que se modifican son los registros de las tablas) y muchas otras cosas más. Para realizar una consulta se utiliza el lenguaje JPQL (Java Persistence Query Language), que es similar a SQL, pero trabaja con objetos y sus propiedades. He aquí un ejemplo:

Query consulta = manager.createQuery(“SELECT c.companyName FROM Customers c”);

Vemos que la consulta utiliza una sintaxis orientada a objetos. Como la propiedad companyName de Customers es de tipo String, al ejecutar la consulta nos dará como resultado una lista de objetos String. La recuperamos de la siguiente manera:

List<String> resultados = consulta.getResultList();

Los objetos Query poseen métodos que permiten devolver un único objeto y especificar parámetros en la consulta, pero los veremos más adelante (si no tengo problemas con mi computadora). Eso es todo amigos. Hasta otra oportunidad.

Código fuente del ejemplo en MegaUpload

Desarrollo de Aplicaciones con Conexión a Bases de Datos con NetBeans

2009-07-20T13:45:00.003-05:00

Hoy empezare con una serie de entradas que tienen un único fin: ilustrar la manera de desarrollar aplicaciones en Java que se conecten a una base de datos utilizando el IDE NetBeans. Para empezar, la aplicación de hoy es bastante sencilla, ya que primero debemos aprender el uso de los asistentes de NetBeans para conexiones a BD.

La base de datos que voy a utilizar contiene información sobre grupos de rock, sus integrantes y géneros, etc.. El modelo relacional de la base de datos lo hice utilizando MySQL Workbench y se muestra aquí:

En este blog voy a utilizar el servidor MySQL para los ejemplos. La manera en que se creen las bases de datos en el servidor, y cómo se puebla ésta de datos, se escapa del alcance de este blog. Suponiendo que ya tenemos configurado nuestro servidor, hemos creado la base de datos y sus tablas, y ya tenemos datos en ella, podemos continuar.

Una vez que estamos en el IDE, tenemos que registrar el servidor de bases de datos (si no lo está). Para esto, vamos a la pestaña Prestaciones y hacemos clic derecho en el nodo Bases de datos. En el menú contextual, hacemos clic en Registrar servidor MySQL. Se mostrará una ventana en la que ingresaremos la configuración del servidor, que normalmente es como se muestra en la figura:

En la pestaña Propiedades de administración podemos especificar la ruta de las herramientas que utilizamos para administrar el servidor. Una vez que hemos hecho esto, podemos observar las bases de datos de nuestro servidor. Para conectarnos a una de ellas, hacemos clic derecho en su nombre y seleccionamos Conectar. En la ventana que aparece a continuación, debemos ingresar el nombre y la contraseña del usuario que utilizaremos para realizar la conexión. Después de hacer clic en Aceptar veremos que en Prestaciones se ha agregado un nuevo nodo que representa la conexión hecha, mediante la cual podemos acceder a las tablas de la base de datos y los datos que contiene.

Vamos a crear un nuevo proyecto de tipo Aplicación de escritorio Java. Luego de darle un nombre, especificamos que utilizará el intérprete de órdenes Aplicación de bases de datos, para que cree la funcionalidad básica por nosotros, como se muestra abajo:

En la lista Conexión con base de datos del siguiente paso podemos elegir una conexión o crear una nueva. Vamos a escoger la que acabamos de crear. Inmediatamente, se listan las tablas disponibles, de la cual vamos a elegir grupo.A continuación, se listan los campos de la tabla para especificar cuales se van a incluir. Todos en este caso.

En el siguiente paso podemos especificar las opciones de detalle, las cuales son dos:

Cuadros de texto. Crea un objeto JTable en el que se muestran los registros de la tabla grupo, y una serie de campo de texto que muestran los detalles de los registros por cada campo de la tabla.
Tabla. Crea un objeto JTable en el que se muestran los registros de la tabla grupo, y otra tabla que contiene los registros de una tabla de detalle (generalmente correspondiente a una relación 1-n) para el registro seleccionado en la tabla maestra (grupo).

Para hacerlo más interesante vamos a escoger la última opción y vamos a seleccionar la tabla musicosgrupos en la lista para mostrar el detalle de los grupos y sus músicos:

Hacemos clic en Finalizar. Eso es todo. El asistente generará una aplicación completamente funcional por nosotros haciendo uso del framework Swing Application Framework y el API Beans Binding (por eso desarrolle esas librerías en entradas anteriores). Si ejecutamos la aplicación, podremos ver los resultados esperados.

Con esta aplicación podemos hacer muchas cosas, como insertar, editar, actualizar y eliminar registros de las tablas de la base de datos (la clásica aplicación CRUD). El asistente también hace uso de JPA (Java Persistence API), que es la especificación estándar para el manejo de la persistencia en Java. Pero solo es una especificación. La implementación concreta es TopLink, una librería de Oracle (también existen otras como Hibernate e iBatis).

Sin embargo, hay muchos problemas con esta aplicación. Si nos damos cuenta, la tabla de detalles no muestra el nombre de los integrantes de cada grupo. El asistente no es lo suficientemente inteligente para hacer estos enlaces. Sin embargo esto es fácil de resolver gracias al soporte de NetBeans para Beans Binding, y lo demostraré en otra entrada.

Un problema peor es que es difícil ampliar la aplicación. Lo más común es tener una ventana MDI desde la cual acceder a través de un menú o una barra de herramientas a otras ventanas que contienen los detalles de las tablas de nuestra base de datos. Con solo modificar lo que ha creado el asistente no basta para este propósito.

En las siguientes entradas veremos como crear una aplicación que se conecte a una base de datos sin utilizar el asistente de NetBeans, para realizar aplicaciones más complejas y ricas y resolver estos problemas. Como prometí, cada entrada tendrá un video tutorial y ahí va:

También coloco a continuación los enlaces al código fuente de la aplicación, junto con el script de la base de datos. Conmigo será hasta otra oportunidad.

Código fuente y script de la base de datos del ejemplo

Los primeros videotutoriales

2009-07-11T17:56:00.002-05:00

La última vez que fui a Lima adquirí unos auriculares con micrófonos para empezar con unos planes que tenía hace mucho tiempo. El primero era el de hablar con mis contactos mediante Skype y ya lo hice: hace unos días estuve hablando con una buena amiga mexicana. La segunda razón, la más importante, era tener la posibilidad de crear mis propios videotutoriales sobre tecnología Java. A pesar de algunos inconvenientes (mi voz y mis perros, por ejemplo), esta semana hice dos, que explican el desarrollo de ejemplos de entradas anteriores en este blog. Y como, si una imagen vale más que mil palabras, entonces 30 imágenes por segundo valen mucho más, aquí los publico.

Además, también he subido los códigos fuentes de los ejemplos, que los pueden encontrar en las siguientes direcciones:

Espero les guste y sea de su agrado.

Resumen de un fin de semana con Spring e Hibernate

2009-07-08T11:59:00.002-05:00

Hace menos de un mes iba a haber un curso sobre tecnología Java en la ciudad donde vivo, Chimbote, organizado por el Colegio de Ingenieros del Perú. Muchos temas de los que iban a tocar ya me eran familiares, pero yo deseaba tener una certificación (porque con decir que sí sabes no basta para un empleador). Así que me preinscribí en el curso y fui a pagar a dos días de empezar el curso. Mi sorpresa fue grande cuando me dijeron que no se iba a abrir el curso porque solo yo estaba inscrito. Eso me hizo dar cuenta de la realidad de mi ciudad. La mayoría de desarrolladores y empresas utilizan PowerBuilder para sus sistemas, y los que no lo hacen en .NET. Parece que con Java no tengo futuro en Chimbote.

Por suerte, en la capital Lima sí es más difundida la tecnología Java, y este fin de semana hubo un taller sobre Spring en una organización llamada CJava, que es el partner peruano de Sun Microsystems. Aproveché que tenía ahorrado el dinero del primer curso fallido y me inscribí en éste, así que me escape de las obligaciones universitarias un rato para aprender este framework, del cual solo había escuchado.

Y pues que puedo decir, fue una experiencia muy enriquecedora en mi relación con esta tecnología. Descubrí muchas cosas nuevas y también me siento orgulloso de haber respondido a los requisitos previos del curso. El tema central fue la utilización de los frameworks Spring e Hibernate en el desarrollo de aplicaciones, aunque se mencionó sobre otras tecnologías como Struts, iBatis, ExtJS. Hay mucho para aprender.

Aunque la potencia de Spring se ve en aplicaciones Web, también puede ser utilizado en aplicaciones de escritorio (de hecho, debería utilizarse, porque introduce al programador en las buenas prácticas para hacer software de calidad). Tiene una gran similitud con Struts (y eso fue un problema para mí, porque no he utilizado Struts) y es muy fácil de utilizar. Por otra parte, Hibernate es un framework para persistencia de Java que se ajusta al API JPA (como TopLink, que es el que utilizo yo). Ambos frameworks trabajan bastante con archivos de configuración XML, lo cual solo resulta más fácil de utilizar.

Asistiendo a este tipo de eventos, uno puede darse cuenta de si estás yendo por el camino correcto, y también lo que te falta por recorrer. Además pude ver las tecnologías que usan otros programadores. Por ejemplo, los otros participantes (por cierto, solo fuimos 3 asistentes, una cosa impresionante) utilizaban iBatis para manejar la persistencia de objetos, a diferencia mía que yo utilizo TopLink. Ellos estaban utilizando Struts en sus aplicaciones Web. Yo solo trabajo con el patrón DAO y para la interfaz utilizo JavaServer Faces.

Además de estos frameworks también hablamos sobre otros temas como JavaFX, JasperReports y iReport, ExtJS (un rica librería de controles para interfaces web hecha en JavaScript) y otras. Conforme avance con los temas de este blog, también hare un par de entradas sobre estos frameworks, algo sencillo nomás. Fue un fin de semana rico en conocimientos y espero tener tiempo para practicar más.

Enlace de datos con Beans Binding

2009-06-14T15:15:00.003-05:00

Después de escribir dos entradas sobre MySQL, hoy voy a continuar haciendo lo propio con Java. Cuento con poco tiempo, así que decidí tocar un tema que, por ahora, se presenta pequeño. Digo por ahora porque más adelante, cuando hable sobre aplicaciones con conexión a bases de datos con Java voy a utilizar bastante este tema.

En muchas ocasiones, necesitamos sincronizar datos en varios componentes, de modo que, al cambiar los datos en un componente, se esto se refleje en los demás componentes. Para esto, normalmente se escriben oyentes de eventos, los cuales se agregan a los componentes para que reciban una notificación al realizarse un cambio.

Por ejemplo, podemos tener una lista de personas en un JComboBox. Se desea que, al seleccionar una persona en el combo, se muestren sus datos en componentes JTextField. Para esto, se asocia un oyente de acción (ActionListener) con el combo, y tenemos que escribir el código que muestre los datos en los campos de texto.

No es cuestión de tener pereza de escribir código, sino que a veces es mejor olvidarse de estos detalles para centrarse en la funcionalidad propia de la aplicación. Afortunadamente, gracias a una librería llamada Beans Binding y a su fabulosa integración con NetBeans, esto es posible. Para aclarar, no es mi intención hacer una descripción detallada de esta API, sino deseo mostrar como utilizarla a través del soporte que tiene NetBeans para no tener que escribir código.

Para empezar, necesitamos crear un nuevo proyecto. Luego creamos la clase Persona, que implementa la interfaz Serializable (esto es importante para convertir nuestra clase en un bean). Para agregar una propiedad, pulsamos las teclas Alt + Insert, lo cual despliega un menú en el que seleccionamos Agregar Propiedad. En la ventana, establecemos los atributos de la propiedad, como se muestra en la figura:

En la figura se resalta que debemos marcar la opción Generar soporte para cambio de propiedad. Esto también es necesario para tratar a la persona como un bean. Sin embargo, la notificación a los oyentes de cambio no es automática, así que la agregaremos nosotros. Para esto, solo es necesario modificar el método setter de cada propiedad (en este caso, el método setter de “nombre” es “setNombre”), escribiendo el siguiente código (las líneas azules son la que escribiremos):

public void setNombre(String nombre) {
        String anterior = this.nombre;
        this.nombre = nombre;
        propertyChangeSupport.firePropertyChange("nombre", anterior, nombre);
}

Ahora debemos agregar y modificar de la misma manera las siguientes propiedades (todas las propiedades son privadas):

NOMBRE	TIPO
edad	int
varon	boolean

Finalmente, vamos a crear unas personas predefinidas para mostrarlas en nuestra interfaz. Primero creamos un constructor pulsando Alt+Insert y seleccionando la opción Constructor. En la ventana emergente seleccionamos las tres propiedades que hemos creado. Luego, escribimos el siguiente método:

public static List<Persona> crearPersonas() {
        List<Persona> personas = new ArrayList<Persona>();
        personas.add(new Persona("Bill Gates", 45, true));
        personas.add(new Persona("Jennifer López", 32, false));
        personas.add(new Persona("Linus Torvalds", 37, true));
        return personas;
}

Una vez que tenemos nuestra clase Persona, vamos a trabajar con Beans Binding. Creamos un nuevo Formulario JFrame y le agregamos los siguientes componentes:

Un componente JList para mostrar a las personas
Un componente JTextField para mostrar los nombres.
Un componente JSlider para visualizar la edad.
Un componente JCheckBox para indicar si es varón o no.
Componentes JLabel para etiquetar los demás componentes.

El diseño de nuestro formulario, después de ajustar el texto de los componentes, debe parecerse a la siguiente figura:

Ahora vamos a agregar al formulario una propiedad que contenga la lista de personas creada anteriormente. Para esto, vamos a la pestaña Fuente y agregamos la propiedad pulsando Alt+Insertar:

Esta vez no marcamos la opción Generar soporte para cambio de propiedad, porque la clase JFrame ya tiene este soporte incorporado. También debemos cambiar el método setter de esta propiedad, sin embargo, en el momento de cambiar el método setter de esta propiedad, en la última línea solo debemos escribir:

firePropertyChange("listaPersonas", anterior, listaPersonas);

Bien, ahora que ya tenemos el origen del enlace, vamos a enlazar nuestros componentes a esta lista. En primer lugar vamos a enlazar el JList con la lista de personas para que se muestren al ejecutar la aplicación. Para algunos componentes, como JList y Jtable, Beans Binding define unas propiedades virtuales para utilizarlas en el enlace. En ambos componentes, se añaden las siguientes propiedades:

PROPIEDAD	DESCRIPCIÓN
elements	Una lista que contiene los elementos del componente.
selectedElement	Una referencia al elemento seleccionado en el componente.
selectedElements	Una lista que contiene los elementos seleccionados en el componente.

Nosotros vamos a utilizar la propiedad elements para enlazarla con la lista de personas. Para esto hacemos clic derecho en el JList y seleccionamos la opción elements del submenú Enlazar. Esto nos lleva a la siguiente ventana:

En la lista desplegable Código fuente de enlace seleccionamos el item Form, para indicar que la propiedad a la que vamos a enlazar pertenece al objeto formulario. En la lista desplegable Expresión de enlace, seleccionamos la propiedad listaPersonas. En la lista desplegable Mostrar expresión encontramos las propiedades de la clase Persona. Seleccionamos la propiedad nombre para mostrar el nombre de las personas que están en la lista en el JList.

Ahora vamos a enlazar los demás componentes. Al seleccionar una persona en el JList se debe mostrar sus datos en los otros componentes. Empecemos por el componente JTextField. Abrimos la ventana Enlazar de la misma forma como lo hicimos con el JList. En la lista desplegable Código fuente de enlace seleccionamos el item jList1 (que es el nombre del componente JList). En la lista desplegable Expresión de enlace buscamos la propiedad virtual selectedElement y desplegamos sus nodos para seleccionar la propiedad nombre de la clase Persona. Esto es porque el JList contiene una lista de objetos Persona, y el elemento seleccionado es un objeto de esta clase. Esto genera una expresión de la forma ${selectedElement.nombre}.

Vamos a hacer lo mismo para los demás componentes, utilizando la información de la siguiente tabla:

Componente	Propiedad	Expresión
JSlider	value	${selectedElement.edad}
JCheckBox	selected	${selectedElement.varon}

Para probar que el mecanismo de enlace funciona, ejecutamos la aplicación. Si todo ha ido bien el resultado debe parecerse a la figura:

Y eso es todo. El API Beans Binding nos libera de crear oyentes e implementar sus métodos para enlazar componentes, y el soporte de NetBeans para esta librería hace esto por nosotros sin escribir código. Puede que el ejemplo sea muy sencillo y trivial, pero de la misma forma como hemos enlazado componentes con una clase común, también podemos hacerlo con una clase entidad que ataque una base de datos, o cualquier cosa. Además, si modificamos las propiedades de las personas con los componentes, por ejemplo si cambiamos el nombre, estos cambios se reflejan automáticamente en los demás componentes y en el objeto Persona modificado.

Mas adelante, cuando escriba sobre aplicaciones con Bases de Datos con Java, vamos a ver otras funcionalidades avanzadas de esta API.

Continuación: MySQL Cluster y MySQL Proxy

2009-06-05T22:47:00.003-05:00

Esta entrada responde a un pregunta hecha en un comentario hecho en la entrada anterior acerca de estas dos tecnologías que, la verdad, se explican por si solas debido a sus nombres.

MySQL Cluster es una nueva tecnología que permite gestionar varios servidores MySQL convencionales como un cluster, a través de un nuevo motor de almacenamiento en memoria llamado NDB, preparado exactamente para trabajar en estos entornos. La ventaja de este servidor se da en sistemas que requieren de una enorme potencia de almacenamiento, así como la utilización óptima de los recursos disponibles. MySQL Cluster gestiona los cambios hechos en cualquier nodo del cluster para reflejarlos en los demás nodos automáticamente. La siguiente figura muestra un bosquejo de la arquitectura de MySQL Cluster:

Como se puede apreciar, en el sistema existen diversos nodos NDB que interactúan entre sí para satisfacer las peticiones de los servidores MySQL. El mantenimiento de los datos se realiza a través de aplicaciones cliente comunes y corrientes. A continuación, viene un video más informativo sobre MySQL Cluster:

Por otra parte, MySQL Proxy es un middleware que se sitúa entre una aplicación cliente y un servidor MySQL para realizar labores de seguimiento y optimización de la comunicación entre nuestro cliente y nuestro servidor. Permite hacer balance de carga, monitorización de consultas, etc.

Paréntesis: Datawarehouse con MySQL y PostgreSQL

2009-05-29T00:18:00.002-05:00

Como bien indica el título de esta entrada, voy a hacer un paréntesis en el objetivo de este blog, para responder un comentario de un lector, el cual hace la siguiente pregunta:

“Que tal!!..

Primeramente te felicito x tu blog esta muy bueno. Posteas muy buenos temas... Mi pregunta es la siguiente: cual crees que es el mejor dbms para implementar un datawarehouse y que sea bueno con transacciones: mysql o postgresql??

gracias”

Bien, empezaré diciendo que antes de preocuparse de que DBMS vamos a utilizar, se debe tener cuidado en el diseño del Datawarehouse y su interacción con los Data Marts. Otra recomendación es que siempre es preferible utilizar la tecnología que dominemos mejor. Así obtendremos mejores resultados con mayor facilidad.

MySQL posee por defecto el motor de almacenamiento MyISAM que fue pensado desde el inicio para trabajar con Datawarehouses. MySQL optimiza el uso de la memoria y el espacio de almacenamiento para realizar consultas rápidas sobre grandes repositorios de datos. Además posee características que lo hacen ideal para su utilización con Datawarehouses, como la gestión de almacenamiento automático prácticamente sin límites, soporte robusto de indexación, carga paralela de datos, etc.

Por otro lado, aunque no conozco muy bien a PostgreSQL, tengo entendido que tiene un modo Datawarehouse y además, es bien sabido que PostgreSQL es el DBMS de software libre que más se acerca a DBMSs más experimentados en Business Intelligence, como Oracle y MS SQL Server. Sin embargo, para optimizarlo para trabajar con Datawarehouse hay que ajustar algunos parámetros del servidor a mano. Además, existe una especie de “distro de PostgreSQL” llamada Bizgre que está más enfocada al trabajo con Datawarehouse.

En conclusión, en mi humilde opinión, es mejor utilizar MySQL para implementar un DataWarehouse, pues está mejor preparado para estos menesteres. Espero haber ayudado y gracias por el comentario. En estas semanas he estado algo ocupado con el inicio de clases, y parece que este ciclo va a estar duro, pero me voy a dar un tiempo para postear algo la próxima semana. Promesa es deuda.

Desarrollo de aplicaciones con Swing Application Framework

2009-04-20T17:49:00.002-05:00

Seguramente lo que todos los programadores empezamos haciendo es desarrollar aplicaciones de escritorio. Sean programas que realizan cálculos simples o sistemas completos con conexión a una base de datos, estas aplicaciones poseen un conjunto de características comunes:

Tienen interfaces gráficas (GUI).
Tienen un ciclo de vida, desde la carga hasta la finalización de la aplicación.
Manipulan recursos como imágenes, fuentes, colores, etc.
Ejecutan acciones en respuesta a ciertos eventos lanzados por el usuario.
Tienen un estado de sesión (hay programas que recuerdan el tamaño que tuvo la ventana en la última ejecución).

Muchas veces sin darnos cuenta cada vez que creamos una aplicación escribimos código que hace estas tareas de manera repetitiva. De esto se dieron cuenta en la comunidad de java.net y desarrollaron un API muy útil que se encarga de gestionar estos aspectos. El objetivo de este tutorial es demostrar cómo se puede desarrollar una aplicación de escritorio utilizando el API Swing Application Framework con las herramientas de NetBeans disponibles para esto.

Empecemos. Debemos crear un nuevo proyecto de tipo Aplicación de Escritorio, como se muestra en la figura. Luego escribimos un nombre para el proyecto y especificamos que es una aplicación básica (utilizaremos una aplicación de base de datos en otro tutorial). Finalmente terminamos el asistente y tendremos una aplicación completamente funcional que ya tiene algunas características especiales.

Vemos que la aplicación creada tiene una clase principal (NombreProyectoApp), un marco principal con un menú y una barra de estado (NombreProyectoView) y una ventana de diálogo Acerca de (NombreProyectoAboutBox). Si ejecutamos la aplicación, veremos que el marco principal se centra en la pantalla, y los menús tienen la funcionalidad para salir de la aplicación y mostrar el diálogo Acerca de. Además, si cambiamos el tamaño del marco principal, salimos de la aplicación y la ejecutamos de nuevo, veremos que la aplicación recuerda el tamaño anterior.

Vamos a diseñar el marco principal. Agregamos una etiqueta desde la paleta y la expandimos para que ocupe la mayor parte del panel central. En la pestaña Propiedades podemos personalizar esta etiqueta de la siguiente manera, haciendo clic en el botón … de cada propiedad:

PROPIEDAD	VALOR
background	negro
font	Segoe UI 24 Negrita
foreground	blanco
icon	Al gusto
text	Hola mundo
opaque	true

El resultado se puede parecer a la figura anterior. Si se habrán fijado, cuando personalizamos una propiedad en su ventana, en la parte inferior existe una opción que dice “Definir como un recurso”. El API Swing Application Framework gestiona estas propiedades como recursos de la aplicación en archivos de propiedades, uno por cada clase, con nombres jerárquicos, como “etiqueta.texto = Hola Mundo”. De esta manera, se puede personalizar también el menú principal y el diálogo Acerca.

Debido a que el framework se encarga del ciclo de vida de la aplicación, también se encarga de la finalización de ésta, de modo que podamos realizar cualquier tarea antes de salir del programa de manera segura. Esto resulta vital para liberar recursos, cerrar conexiones a bases de datos o pedir al usuario una confirmación. Esto se hace agregando un oyente ExitListener a la clase principal (la que termina en App) en el método startup (que es el método que inicializa la aplicación), antes de llamar al método show. El código es el siguiente (las líneas de azul son las que escribiremos):

@Override protected void startup() {
        addExitListener(new ExitListener() {
            public boolean canExit(EventObject event) {
                return JOptionPane.showConfirmDialog(getMainFrame(),
                        "¿Desea salir?") == JOptionPane.YES_OPTION;
            }

            public void willExit(EventObject event) {}
        });
        show(new AplicacionEscritorioView(this));
    }

Si ejecutan la aplicación e intentan salir, sea por la opción de menú Exit o cerrando la ventana, aparece el mensaje de confirmación.

Como mencioné antes, todas las aplicaciones ejecutan acciones como respuesta a eventos generados por los componentes de la interfaz de usuario. Podemos especificar estas acciones de manera más orientada a objetos a través de la anotación @Action, creando un método que tenga esta anotación y asociando dicho objeto a los componentes que deban ejecutar esa acción.

Para ejemplificar esto, agregaremos una opción de menú al menú File del marco de la aplicación. Pero el texto del menú no debe ser tratado como un recurso, pues estos datos se obtienen de la acción, y la acción es tratada como un recurso más. Debemos especificar que no se desea que el texto sea un recurso en la ficha de Propiedades. El aspecto del diseño debe parecerse al de la figura:

Luego, en la propiedad action hacemos clic en el botón ‘…’. En el diálogo resultante podremos elegir una acción o definir una nueva, seleccionando la opción Crear acción nueva del cuadro combinado Acción. En clase de acción podemos dejar la clase del marco. En método de acción, ingresamos el nombre del método que soportará la acción. También podemos especificar los atributos de la acción como un nombre, una sugerencia, una combinación de teclas aceleradoras y un ícono.

Al aceptar y crear la acción vemos que el diseño del marco se actualiza. También vemos que el método solicitarMensaje se ha creado y está listo para escribir código en él. Vamos a hacerlo:

@Action public void solicitarMensaje() {
        String mensaje = JOptionPane.showInputDialog("Ingrese un mensaje");
        jLabel1.setText(mensaje);
    }

Ahora ejecute su aplicación y verá los resultados esperados. Una gran ventaja que obtenemos del uso de las acciones es que podemos reutilizar el código en otro componente que tenga que ejecutar la misma acción. Podríamos tener un botón de una barra de herramientas que haga lo mismo, y sólo tendríamos que asociar la acción creada a la propiedad action de éste.

En ocasiones, podemos necesitar acciones que se ejecuten en un hilo diferente al de la manipulación de eventos, quizá porque la tarea a realizar va a requerir un largo tiempo porque debe acceder al sistema de ficheros o a la red. En estos casos debemos definir tareas que se ejecuten en segundo plano. El proceso es el mismo que para definir una acción, solo que debemos marcar la casilla “Tarea en segundo plano”. Agreguemos una opción de menú para visualizar este concepto.

Vemos que se agrega código adicional en la clase. Se ha creado una acción que devuelve un objeto que deriva de Task, que representa una tarea monitorizable que se ejecuta en segundo plano. Dicho objeto sobreescribe dos métodos de su superclase. El más importante es doInBackground, en el cual se sitúa el código que se desea ejecutar en segundo plano. Vamos a hacer algo sencillo. Cada segundo se mostrará un conteo en la barra de estados. El código es el siguiente:

@Override protected Object doInBackground() throws InterruptedException {
            for(int i = 0; i < 1000; i++) {
                setMessage("Contando... [" + i + "]");
                Thread.sleep(1000);
                setProgress(i, 0, 999);
            }
            Thread.sleep(1000L);
            return null; // return your result
        }

Al ejecutar la aplicación podemos apreciar que, al hacer clic en la opción de menú, se inicia un conteo en la barra de estado que , incluso activa una barra de progreso y una animación conforme avanza el conteo. Lo que sucede es que NetBeans ha agregado por nosotros un monitorizador de tareas, que se encarga de mostrar el progreso de cada tarea en la barra de estados con estos efectos. Además, si intentamos cambiar el mensaje de la etiqueta, o salir de la aplicación, se puede hacer, debido a que el conteo corre en segundo plano y no bloquea el hilo de manipulación de eventos de Swing.

En conclusión, con el API Swing Application Framework y el IDE NetBeans podemos crear aplicaciones de escritorio con características y comportamiento profesionales de manera más práctica y eficiente. Con un poco de imaginación se pueden hacer grandes cosas con lo que hemos visto en este tutorial. La mayoría de aplicaciones del mercado se benefician de esta API, ¿por qué nosotros no? Suerte.

Desarrollo de aplicaciones móviles con Java ME, MIDP 2.0 y CLDC 1.1

2009-04-19T20:55:00.002-05:00

Uno de los objetivos principales que Sun Microsystems tuvo al crear el lenguaje Java, fue que se pudiera ejecutar en dispositivos electrónicos pequeños como electrodomésticos inteligentes y kioscos de Internet. Aunque nunca llegó a ser un estándar en estos entornos, cuando se produjo el bum de los dispositivos móviles, como teléfonos celulares, PDAs y Pocket PCs, la tecnología Java no se quedó atrás y se adaptó para ayudar a que esta naciente industria se asentará en el mercado. Hoy en día, no hay celulares que no tengan una KVM (Kilo Virtual Machine, la máquina virtual de Java para móviles) con una implementación de Java ME; y la mayoría de los juegos disponibles están desarrollados con esta plataforma.

Resulta interesante poder programar para nuestro propio celular de manera fácil y elegante, y es muy emocionante jugar con un programa de tu “puño y tecla”. Por eso, voy a compartir esta sensación en varios tutoriales que visualizan de manera general como se desarrolla una aplicación para un celular utilizando la plataforma Java ME, las especificaciones MIDP y CLDC, y el IDE NetBeans. Es demás decir que estos tutoriales muestran cómo hacer esto de manera fácil y rápida, valiéndose de las herramientas disponibles en el IDE. Además, para ver las aplicaciones corriendo en la vida real, necesitarán un celular con un cable de conexión USB. Para un análisis más detallado de las APIs, existe una infinidad de información en Internet.

Para empezar, debemos crear un nuevo proyecto de tipo Mobile Application, como se ve en la figura. Luego de darle un nombre al proyecto y aceptar las opciones por defecto, podemos apreciar la clase HelloMIDlet creada, que es la clase principal de la aplicación, en cuatro vistas diferentes:

Source: Permite modificar el código fuente de la clase HelloMIDlet.
Screen: Permite modificar el diseño de la interfaz gráfica de la aplicación.
Flow: Muestra el flujo de la interacción entre los objetos de la aplicación.
Analyzer: Sólo muestra algunas notificaciones. No usaremos esta vista.

Como vemos en la vista Screen, la aplicación mostrará por defecto el archiconocido mensaje “Hola Mundo”. Por ahora, lo único que haremos es personalizar este mensaje; en otros tutoriales veremos cómo hacer aplicaciones más complejas que está. El objetivo es ver cómo se crean aplicaciones móviles con NetBeans, cómo se ejecutan con el emulador de Sun y cómo preparar e instalar una aplicación en un celular real.

Sin embargo, podemos personalizar un poco el formulario y el mensaje mostrado sin salir de la vista Screen, utilizando la ficha Propiedades a la derecha del IDE, como vemos a continuación:

Asimismo, podemos personalizar la configuración principal del proyecto en la ficha Proyectos a la izquierda del IDE, haciendo anticlic en el nombre del proyecto y eligiendo Propiedades, como se aprecia en la figura:

Para ejecutar la aplicación, se puede hacer clic en el botón verde la barra de herramientas o presionar F6. Los resultados se muestran en la figura:

Los archivos que se instalan en el celular se encuentran en la carpeta dist, dentro de la carpeta del proyecto. Son los archivos .jar y .jad los que serán copiados al celular. El proceso de instalación de estos archivos difiere debido a las diversas marcas y modelos de celulares (en algunos sólo es necesario copiar el archivo jar), pero básicamente solo es necesario una copia común de estos archivos a la unidad de almacenamiento del celular.

Y eso es todo, espero que les sirva de introducción a la programación móvil. Como dije, más adelante escribiré más detalladamente las APIs necesarias para una programación más seria.

Instalación de NetBeans™ IDE

2009-04-19T14:19:00.002-05:00

Aunque a algunas personas les parezca una exageración esta entrada, voy a hacer un tutorial de como instalar el IDE NetBeans™ por dos razones. Una es que en un grupo de Sonico encontré una chica paraguaya que pedía ayuda en este tema. La segunda es que, como mencioné en la entrada anterior, voy a utilizar esta herramienta para el desarrollo de todos los temas de este blog, y no quiero arriesgarme a que alguna persona tenga problemas al respecto.

Cabe mencionar que antes de instalar NetBeans™ debemos tener instalado el JDK (Java Development Kit). La versión actual es la 6 Update 13 y es la que tengo en mi ordenador. En la página de descarga del JDK existen diversas opciones para descargar, incluso hay se puede descargar un instalador que incluye tanto al JDK como al NetBeans™.

Bien, la versión más reciente, estable y en español de NetBeans™ es la 6.5 y esa es la que voy a utilizar. La versión 6.5.1 sólo está soportada en inglés. También esta disponible la versión 6.7, pero es una versión Milestone, que es como una beta, así que no es recomendable su instalación en un entorno de producción. Existen dos formas de instalar este entorno de manera completa: descargando el paquete completo; o descargando e instalando uno por uno los paquetes individuales. Para hacer las cosas fáciles vamos a descargar e instalar el paquete completo, después de todo el instalador es configurable y después de la instalación se pueden quitar algunos módulos.

Primero descargaremos el paquete de instalación de NetBeans™ 6.5 en español. La versión que utilizaremos es la de 199 MB, que incluye el soporte para Java SE, Web y EE, ME y los servidores Tomcat y Glassfish. En Windows, el instalador es un archivo .exe convencional. En Linux, el instalador es un archivo .sh que se ejecuta en el terminal con el comando sh de la siguiente forma:

sh netbeans-6.5-ml-java-linux.sh

Al iniciar el instalador, se puede hacer clic en el botón Personalizar para elegir los módulos que se desea instalar como se puede apreciar en la figura. Los más importantes, y los que voy a utilizar en este blog, son los que están marcados en la figura

Luego de seguir con los pasos del asistente se tendrá el IDE NetBeans completa y correctamente instalado. Si se presentará algún problema, por favor, comentarlo en esta entrada o mandarme un mensaje a mi correo.

Introducción

2009-04-19T11:48:00.001-05:00

Hola, que tal a todos los que se den un tiempo para leer este blog, les doy la bienvenida y los felicito por su interés en lo que pueda ofrecerles para aprender algo más de esta hermosa tecnología llamada Java.

Mi objetivo es cubrir varios aspectos de las tres plataformas conocidas: Java SE, ME y EE, y cubrir temas de diversa complejidad, desde lo básico como la utilización de las APIs, programación en AWT y Swing, multithreading, conexiones a BD, i18n, XML, y utilización de APIs externas para facilitar su trabajo. En cuanto a Java ME se verá como escribir aplicaciones para móviles utilizando MIDP 2.0 y CLDC 1.1. También realizaré tutoriales sobre Java en la Web, desde utilización de Servlets y JSP hasta, si se puede, desarrollo de sistemas utilizando un servidor de aplicaciones como Glassfish y algún framework como JSF, Struts o Spring.

Cabe mencionar que no es mi intención desarrollar estos temas en una gran profundidad, pues, por una parte, para eso es necesario un conocimiento avanzado de las características del lenguaje y de las APIs básicas de Java; por otro lado, en mi modesta experiencia, para comprender a fondo estos temas es necesario programar “a mano”, o sea, sin ayuda de un IDE y esto, para muchos, es aburrido y anticuado; además a menudo se cuenta con poco tiempo para desarrollar un proyecto y es mejor echar mano de un buen IDE.

En conclusión, el desarrollo de los temas se hará utilizando un IDE, explícitamente, emplearé NetBeans™ y me enfocaré en cómo se puede sacar más provecho a las características mencionadas antes en este excelente IDE. Sería demasiado para este blog tratar de conectarse a una BD “a mano” utilizando la API de JDBC, pudiendo utilizar NetBeans™ con un framework como TopLink (aunque es emocionante hacerlo: nunca olvidaré la primera vez que lo hice).

Espero que este blog resulte provechoso para todos, solo les pido que si tienen algún comentario, lo hagan en cada entrada, o me manden un mensaje a mi correo. Muchas gracias.