22 may. 2011

Crear archivos jar ejecutables

Entrada extra 

Cuando trabajamos en un proyecto en lenguaje java nos habremos de dar cuenta que hacemos uso de muchos archivos e inclusive directorios para almacenar nuestro trabajo, y sabemos que si deseamos que alguien más pueda ejecutar nuestro proyecto en su computadora tendríamos que enviarle todos estos archivos y directorios para que lo pueda compilar y ejecutar en su computadora.

Entonces surge el ideal de colocar todos estos archivos y directorios en un único fichero comprimido. Java nos ofrece el comando jar, que nos permite hacer esto. Este comando junta todo lo que le indiquemos, ya sean carpetas completas, clases, imágenes o archivos de datos, y todo lo coloca en un archivo nuevo con extensión .jar.

Este nuevo .jar es similar a ficheros que ya conocemos como los .zip, .rar o los .tar que ya hemos manejado antes. Inclusive descompresores winrar o winzip puedes abrir el contenido de nuestro nuevo fichero con extensión jar.

Además Java nos permite ejecutar el contenido del fichero .jar sin necesidad de desempaquetarlo.

El comando jar

$ jar

A este comando desde el terminal podemos incluirle las siguientes opciones:

c - Indica que vamos a crear un archivo, y si existe ya uno se eliminará.
f - Indicar el nombre del fichero, que va inmediatamente después.
v - Indica que queremos obtener información durante el proceso de creación del archivo.
m - Indica al programa que queremos personalizar el archivo de manifiesto para añadir información adicional.
M - Indica que no se cree el archivo de manifiesto.
0 - Indicamos que no queremos que se comprima el contenido del archivo.

Crear un fichero jar

Antes de la creación de nuestro fichero jar, debemos procurar que nuestros archivos estan compilados y funcionan correctamente.

Nota: Ya que el proceso de compilar y ejecutar archivos java ya es un tanto repetitivo a estas alturas, me salto este paso.

Cuando las clases del programa no pertenecen a paquetes

En este caso solo debemos meter las clases en el .jar, así que nos ubicamos en el directorio donde se encuentran contenidas nuestros archivos .class y ejecutamos el siguiente comando desde el terminal:

$ jar -cf Nuevo.jar fichero1.class fichero2.class fichero3.class

La opción "c" indica que queremos crear un fichero.jar nuevo.
La opción "f" sirve para indicar el nombre del fichero.

Finalmente se pone una lista de ficheros .class, o de cualquier otro tipo que queramos meter en nuestro jar.

También se pueden usar comodines, como *.class para meter todos los .class del directorio.

Cuando las clases del programa pertenecen a paquetes

Para esto debemos meter la estructura de directorios equivalente a los paquetes del proyecto completo.

Nos vamos al directorio padre de donde empiece nuestra estructura de paquetes.

$ jar -cf Nuevo.jar nombredelpaquete

Esto colocará el paquete dentro de nuestro jar.

También podemos incluir los .class indicando el camino relativo para llegar a ellos:

$ jar -cf Nuevo.jar nombredelpaquete/Hola.class

Ejecutar el jar

Tenemos que colocar nuestro fichero .jar en el CLASSPATH, para poder recurrir a él.

Para ejecutar el archivo escribiríamos lo siguiente en el terminal:

$ java -cp ./Nuevo.jar prueba.Hola

Ejecutar de esta manera no es lo mejor, ya que tenemos que ponerle opciones al ejecutar, además debemos conocer el nombre de la clase principal y en que paquete se encuentra.

Afortunadamente java nos ofrece otra posibilidad de forma que no ocupemos tanto rollo. Se trata de un fichero de texto donde metemos una línea en la que se ponga cual es la clase principal. Este fichero se conoce como fichero de manifiesto y su contenido es tan simple como este:

Main-Class: prueba.Hola

El archivo de manifiesto es un archivo de texto plano por lo que podrá ser creado con cualquier editor de textos convencional. El archivo podrá tener cualquier nombre y extensión, ya que lo que el programa jar hará, será mezclar el contenido de este archivo con el que se crea por defecto.

Crear jar agregando nuestro archivo manifiesto

Cuando construimos el jar, debemos incluir este fichero de la siguiente forma. Por ejemplo, si el fichero lo llamamos manifiesto.mf y lo ponemos en el directorio donde vamos a construir el jar, el comando para hacerlo sería este:

$ jar cmf manifiesto.mf Nuevo.jar prueba/Hola.class

Agregamos la opción "m" para indicar que vamos a añadir un fichero de manifiesto.
Importante el orden en que colocamos las cosas; como en las opciones colocamos mf, debemos indicar primero lo que requiere "m" en este caso el archivo manifiesto, y después "f" el nombre de nuestro jar.

Ejecutar nuestro jar

Una vez construido, se ejecuta de la siguiente manera:

$ java -jar Nuevo.jar

La opción "-jar" indica que se va a ejecutar el Nuevo.jar que se ponga a continuación haciendo caso de su fichero de manifiesto y como este fichero de manfiesto dice que la clase principal es prueba.Hola, será esta la que se ejecute.

Con esto podemos entregar directamente nuestro fichero jar a un amigo y listo, no tendrá problemas para ejecutarlo.

Ejemplos

Jar con archivo manifiesto



Como ven en la secuencia de comando de la captura de ventana hago lo siguiente:
-Ver los archivos contenidos de la carpeta "hola".
-Visualizar el contenido del archivo "manifiesto.mf".
-Compilar el archivo "Hola.java".
-Ejecutar "Hola" para verificar que funciona.
-Crear el fichero jar.
-Ver nuevamente el contenido de la carpeta.
-Ejecutar el contenido del fichero jar.

Así se ven los archivos finales:


Jar con archivo manifiesto y clases contenidas en un paquete



Ahora una prueba con otro ejemplo, en este caso lo realizado fue:
-Primero compilo los archivos .java contenidos en el paquete "graficador".
-Ejecuto la clase principal del paquete para corroborar que funciona.
-Vemos los archivos contenidos en el directorio actual.
-Creamos el fichero jar.
-Volvemos a ver los archivos contenidos, y vemos que se creo nuestro jar.
.Por último ejecutamos el jar para probar.

Esta es una imagen de como resulta después de la ejecución del jar:


Espero les haya servido para que ustedes hagan sus propios jar y puedan compartir sus proyectos. Cabe mencionar que es posible crear estos jar sin necesidad de incluir los archivos .java para evitar que alguien nos copie, y al solo incluir los .class solo podrán ejecutar y ver como va nuestro proyecto.

Les dejo los .jar de los ejemplos para que prueben verlos.

Descargar ejemplos desde MediaFire:
HolaMundo.jar
Graficador.jar

Referencias:
Ficheros JAR
Jar ejecutable

16 may. 2011

Demostración final

Taller de Programación Orientada a Objetos 
Semana 14 

Diapositivas en persona o video en YouTube.


Demostración final
Ver más presentaciones de Esteban González.





En esta demostración:
- En que lenguaje.
- Porqué.
- Con que herramientas.
- Como obtenerlas.
- Como instalarlas.
- Highlights de código.
- Documentación del código.
- Como compilar/ejecutar (el software y las pruebas).
- Qué hace el programa, qué falta.
- Qué fue difícil, tardado, etc.

Presentación final

Programación Orientada a Objetos 
Semana 14 

Diapositivas en persona o video en YouTube.


Presentación final
Ver más presentaciones de Esteban Gonzalez.


Para esta presentación:
- Para qué sirve tu proyecto.
- Para quién es tu proyecto.
- Porqué.
- Diseño de clases (UML clases).
- Diseño de función (UML secuencia).
- Diseño de pruebas.
- Diseño de pantallas.
- Opcional (Base de datos, serializacion, distribuidos).

12 may. 2011

Guardar archivos en la nube - Ubuntu One

Entrada extra 

Al finalizar nuestros trabajos de Taller de Programación, comúnmente nos olvidamos de los archivos y dónde quedaron guardados, por lo que es bueno tener algún tipo de respaldo que este accesible en Internet. Con esto evitaremos tal y como nos menciono la Dra. Elisa, si un día se nos cae la Laptop al río y nuestro proyecto estaba guardado solamente ahí sería una pérdida muy grande. Afortunadamente existen muchas páginas y aplicaciones que nos permiten guardar archivos en la nube.

Algunos de los servicios que en lo personal yo he usado y recomiendo son:
  1. Google Docs: Servicio que nos proporciona Google con una capacidad de almacenaje de 1GB y que además nos permite crear documentos en línea.
  2. Sky Drive: Es proporcionado por Microsoft dentro se sus servicios de Windows Live y que nos brinda una aplicación para escritorio llamada Mesh. Tenemos una capacidad de 25GB en la web y 5GB extras para la sincronización con Mesh.
  3. Ubuntu One: Precisamente este servicio es de Ubuntu y nos regala 2GB gratis y opciones para expandir a más capacidad con precios accesibles.

Estos servicios antes mencionados no tienen ningún consto pero si requieren tener una cuenta creada previamente, o sino la opción de crear una cuenta nueva.

Ubuntu One

Ya que recién cree esta cuenta les hablaré un poquito de ella y los pasos que seguí para hacerlo.

>> Ir a Ubuntu One


Una vez que estemos en la página nos vamos a la opción Join de la barra de menú.


O directamente en el siguiente enlace: Join

Nos desplegará las siguientes opciones de planes, yo por supuesto seleccione la que es Gratis.


Todo es muy simple, ahora solo basta crearnos una cuenta nueva.


Nos nos piden tantos datos, así que no hay que preocuparse porque quieran secuestrarnos o algo parecido.


Cuando tengamos la cuenta creada ya podemos ingresar y empezar a hacer uso de este servicio.


Ya podemos crear carpetas dentro de la opción Files.

Ahora ya tenemos un lugar más donde podemos salvar archivos tan importantes como lo son los de nuestro proyecto y ya no habrá escusas como "Chuck Norris destruyo mi Lap" o "Olvide la USB en casa".

Otra cosa buena es que Ubuntu One tiene una aplicación de escritorio y que nos permite manejar la cuenta desde la misma aplicación así como subir archivos más fácilmente. Lo malo es que al parecer estando dentro de la universidad no se nos permite el acceso por algún motivo.


He probado desde la conexión de mi casa y aquí no me ha dado problemas con la aplicación Ubuntu One. Al abrir por primera vez este programa en la computadora nos pedirá que creemos una cuenta nueva, pero en nuestro caso que ya habíamos creado una anteriormente solo será necesario ingresar nuestros datos y la sincronización con el servidor será automática.


También podemos manejar los sitios donde existe la sincronización de nuestros archivos, con la posibilidad de eliminar un sitio que podría ser una intrusión.


Nos podemos dar cuenta entre nuestras carpetas que después de utilizar esta aplicación, tenemos una nueva con el nombre de Ubuntu One, al abrirla podemos encontrar las carpetas y archivos sincronizados con el servidor que se identifican con un indicador verde.


La finalidad de esta carpeta es la facilidad de respaldo de archivos en la nube, ya que solo arrastrando una carpeta a este lugar, o creando una carpeta nueva y copiando archivos existentes, esta es subida directamente al servidor, y cuando estemos en otro ordenador nuestras carpetas también estarán ahí siempre y cuando se haya configurado la sincronización de archivos.

Por si no lo sabían, espero les sirva.

NOTA: Me gustaría que los puntos obtenidos aquí vayan al Taller, ya que es dónde más me hace falta.

10 may. 2011

Implementación de interfaces gráficas

Taller de Programación Orientada a Objetos 
Semana 13 

Códigos documentados que implementan pantallas gráficas con la funcionalidad correcta de los componentes ya incorporada.

Tal y como había creado mi diseño en papel, lo intente reproducir en Java lo más parecido posible y lo siguiente fue el resultado.

Como ya mencione antes esta es la ventana principal de mi programa, y sus opciones están en la barra lateral izquierda.


El código de esta parte. Es donde están acomodados los paneles, y el uso de acomodo mediante paneles adentro de paneles...


Esta es la segunda ventana que había propuesto. Es donde tenemos las opciones de ver los archivos de datos que tenemos hasta el momento y que se mostrarán a un lado en el panel blanco cuanod se haya seleccionado alguno.


Aquí es la ventana de opciones que se tendrán al tener una gráfica. Como ven le falta meterle más contenido aquí y es porque me falta implementar bien esta parte ya que solo he logrado crear pequeños ejemplos de gráficas pero desde Netbeans.


El código que genera el acomodo de los paneles. Para el cambio de paneles en la ventana sin necesidad de crear una ventana nueva, utilizo un repaint() para actualizar los paneles.


Lo de mostrar la información de un archivo aun no logro acomodarlo en el panel blanco, que más bien sería un JTextArea, y solo me sale en terminal. Espero corregirlo bien para la demostración del jueves.

Ejemplos de gráficas generadas con JFreeChart.

Estas imágenes son ejemplo del uso de la librería JFreeChart en Java para la creación de imágenes.


En la anterior me hace idea a lo que quiero llegar... un botón al final para guardar la gráfica.

Aquí los otros dos tipos de gráficas que tengo pensado incluir:

Lineal:

Pastel:

Poco a poco va tomando forma.

Diseño de interfaces gráficas

Programación Orientada a Objetos 
Semana 13 

Dibujos de diseños de pantallas que identifican los componentes utilizados, su posicionamiento y función.

Primero... ¿Qué es la interfaz gráfica?

La interfaz gráfica de usuario, conocida también como GUI (Graphical User Interface) es un programa informático que actúa de interfaz de usuario, utilizando un conjunto de imágenes y objetos gráficos para representar la información y acciones disponibles en la interfaz.

Su principal uso, consiste en proporcionar un entorno visual sencillo para permitir la comunicación con el sistema operativo de una máquina o computador.

Habitualmente las acciones se realizan mediante manipulación directa, para facilitar la interacción del usuario con la computadora. Surge como evolución de los intérpretes de comandos que se usaban para operar los primeros sistemas operativos y es pieza fundamental en un entorno gráfico. Como ejemplos de interfaz gráfica de usuario, cabe citar los entornos de escritorio Windows, el X-Window de GNU/Linux o el de Mac OS X, Aqua.

En el contexto del proceso de interacción persona-ordenador, la interfaz gráfica de usuario es el artefacto tecnológico de un sistema interactivo que posibilita, a través del uso y la representación del lenguaje visual, una interacción amigable con un sistema informático.

Dibujos de ventanas

Aquí les muestro los dibujos de las pantallas tal y como yo quiero que queden, por lo menos hasta este momento.

En la primer ventana desplegada quiero que se muestre una barra lateral a la izquierda que muestre las opciones en este caso del menú principal: Ver bases de datos, Crear nueva, Recientes. Abajo se encuentra el botón Salir con la misma función del cierre de la ventana con la tacha de la esquina superior izquierda. El nombre del programa es desplegado en la ventana. A un lado esta un panel blanco que da la bienvenida mientras no se tenga que mostrar nada ahí.


El botón de bases de datos debe mostrarte en la ventana los archivos que se tienen disponibles para abrir y visualizar en pantalla.


Vemos que se tiene bajo la lista de archivos el botón Menú que te hace regresar a la ventana anterior.

Así es como se mostraría una tabla con los datos del archivo, no serían en celdas como lo es habitual en Excel pero si nos permite ver que información se encuentra ahí.


Vemos que al final se encuentra el botón graficar que nos permite precisamente crear una gráfica con los datos mostrados en la tabla.

Al crear la gráfica esta se muestra con las opciones predeterminadas y nos permite en la lista de opciones hacer cambios a esta misma.


Falta también un botón al final de la gráfica que nos permita guardar la gráfica como una imagen con el formato .png o .jpg y que estas se puedan mostrar en una ventana que se despliegue al presionar Recientes de la ventana principal.

Referencias:
Definición de interfaz gráfica

4 may. 2011

Implementación de sistemas distribuidos

Taller de Programación Orientada a Objetos 
Semana 12 

Implementación de por lo menos un prototipo pequeño para lograr la operación distribuida por lo menos parcial del sistema bajo desarrollo.

Para esta semana donde tratamos sistemas distribuidos decidí hacer un programa que aplicará a mi proyecto tal y como lo mencione en la entrada anterior. Este trata de el envío de un archivo desde el servidor hasta el cliente cuando este hace solicitud de el.

En mi programa solo tengo tres clases, que son las siguientes:

Servidor: El servidor se encarga de abrir el socket necesario para la comunicación con el cliente, que en este caso se espera a que solicite un archivo que se encuentra almacenado. Para este ejemplo coloque el nombre de un archivo que yo cree con el nombre de Enviado.txt.

Cliente: Este entra en comunicación con el servidor mediante el socket abierto y la dirección IP del servidor, para este ejemplo deje que solo funcionara en localhost, ya que solo lo probé desde un terminal a otro de una misma computadora.

TomaArchivo: Este archivo tiene en un string la ruta del archivo que se enviará, y otras variables necesarias para el envío de los datos en paquetes separados. Aquí es donde se implementa la serialización.

Para lograr la funcionalidad trabaje con el código visto en el taller y junto con la explicación que encontré en el siguiente blog.

Les muestro la parte del código que corresponde a la parte del socket y lo necesario para la transferencia de datos.



En seguida esta una captura de los archivos antes de ser compilados y ejecutados.


El archivo Enviado.txt contiene lo siguiente.


Una vez compilados los archivos, así se ve la ejecución simultanea del cliente y el servidor.




Ya por último la muestra de como quedaron los archivos, y ver como los datos recibidos desde el servidor se guardan en un archivo creado con el nombre de Recibido.txt.


Aunque podría ser muy útil, hasta el momento no lo pienso integrar realmente a mi proyecto, ya que me falta entrarle más con el aspecto de la toma de datos y la forma de graficar.

Sistemas distribuidos

Programación Orientada a Objetos 
Semana 12 

Texto con diagramas que explica la operación del software de manera distribuida.

¿Qué es un sistema distribuido?

Un sistema distribuido se define como una colección de computadoras separadas físicamente y conectadas entre sí por una red de comunicaciones; cada máquina posee sus componentes de hardware y software que el usuario percibe como un solo sistema. El usuario accede a los recursos remotos de la misma manera en que accede a recursos locales, o un grupo de computadores que usan un software para conseguir un objetivo en común.


Los sistemas distribuidos deben ser muy confiables, ya que si un componente del sistema se descompone otro componente debe de ser capaz de reemplazarlo, esto se denomina tolerancia a fallos.

El tamaño de un sistema distribuido puede ser muy variado, ya sean decenas de hosts en una red de área local o millones de hosts como en Internet.

Características

Concurrencia: Esta característica de los sistemas distribuidos permite que los recursos disponibles en la red puedan ser utilizados simultáneamente por los usuarios o agentes que interactúan en la red.

Carencia de reloj global: Las coordinaciones para la transferencia de mensajes entre los diferentes componentes para la realización de una tarea, no tienen una temporización general, esta más bien distribuida a los componentes.

Fallos independientes de los componentes: Cada componente del sistema puede fallar independientemente, con lo cual los demás pueden continuar ejecutando sus acciones. Esto permite el logro de las tareas con mayor efectividad, pues el sistema en su conjunto continua trabajando.

¿Cómo debe estar creado?

  • Para cada uno de los usuarios debe de ser similar al trabajo en el sistema centralizado.
    Seguridad interna en el sistema distribuido.
  • Se ejecuta en múltiples computadoras.
  • Entorno de trabajo cómodo.
  • Dependiente de redes (LAN/WAN).
  • Compatibilidad entre los dispositivos conectados.
  • Transparencia, el uso de múltiples procesadores y el acceso remoto debe de ser invisible.
  • Interacción entre los equipos.
  • Diseño de software compatible con varios usuarios y sistemas operativos.

Herramientas para crear un sistema distribuido

RMI (Remote Method Invocation) es parte de la librería de clases de Java que permite la creación de sistemas distribuidos en Java.

RMI fue el primer framework para crear sistemas distribuidos que apareció para Java. Además, viene integrado en cualquier máquina virtual Java posterior a la 1.0 y está pensado para hacer fácil la creación de sistemas distribuidos a partir de una aplicación cuyas clases ya estén implementadas.

Características particulares de RMI.
Al contrario que otras tecnologías de sistemas distribuidos, RMI no busca la colaboración de objetos de distintas plataformas, programados en diferentes lenguajes, Java se encarga de solucionar los problemas de heterogeneidad. Así, su API es más sencillo y natural al no contemplar que tipos de datos existan o no en los lenguajes en los que se implementan cliente y servidor.

¿Cómo podría aplicarlo a mi proyecto?

Retomando que mi proyecto es de un programa que cree gráficas a partir de archivos de datos, que en primera idea solo tenia pensado en que los archivos fueran locales en la computadora, con un sistema distribuido podría aprovechar el uso de cliente-servidor.

En esto el cliente que es el usuario del programa solicite un cierto archivo de datos concentrado en un servidor, y que este pueda ser recibido desde ese servidor, para ser guardado en la computadora del usuario.


El ideal es que si el usuario modifica algo en la tabla de datos, este archivo sea regresado modificado al servidor, para que cuando otro usuario necesite el mismo archivo para crear cierta gráfica, este tenga la versión mas reciente.

Sistemas distribuidos también podría aplicar creando en el servidor las clases para la creación de la gráfica y que el cliente solo haga solicitud de ella y por medio de RMI se haga la transferencia del objeto.

Enlaces:
Definición de sistema distribuido
Desarrollo de sistemas distribuidos
Más de sistemas distribuidos