Java Curiosities

Marshalling and Unmarshalling

2011-03-06T20:21:00.000-03:00

Hola primero que nada vamos a explicar que significan estas dos palabras y una breve introduccion de porque surgio el post.
Marshalling: Significa crear un documento XML de un árbol de contenido(En nuestro caso el arbol del contenido seria un Objeto Java).
Unmarshalling: Significa crear un árbol de contenido de un documento XML.
Basicamente esto seria serialization y deserialization.
Este post surgió porque hace un tiempo tuve que hacer un desarrollo donde venia la información en un XML y yo debía parsear el XML aplicar cierta lógica de negocio y devolver un XML como respuesta. Para esto lo único que me brindaron fueron un XML llamado request y otro response.

La verdad es que no tenia muchas ganas de hacer las cosas a mano así que me puse a investigar y encontré algunas cosas bastante interesante, como por ejemplo la API JAXB que es la tecnología de java que provee un API y una herramienta para ligar el esquema XML a una representación en código java.
Básicamente esta API nos provee un conjunto de Annotations y clases para hacer el bindeo entre nuestra estructura en los objetos Java y el XML, o mejor aun si nosotros poseemos el XSD del XML podes utilizar la herramienta xjc (Viene por defecto en la distrubución del jdk) para que nos genere la clases del dominio.

XMLs:


request.xml

<?xml version='1.0' encoding='utf-8' ?>
<Parameters>
  <UserId>AH875</UserId>
  <SystemId>Test</SystemId>
</Parameters> 

response.xml

<?xml version='1.0' encoding='utf-8' ?>
<Response>
  <Status>Ok</Status>
  <Data>
   <SubSystem>
    <SubSystemId>1</SubSystemId>
    <Name>SubSystem1</Name>
   </SubSystem>
   <SubSystem>
    <SubSystemId>2</SubSystemId>
    <Name>SubSystem2</Name>
   </SubSystem>
  </Data>
</Response>

Como les dije antes la verdad no tenia muchas ganas de hacerlo a mano así que empece a buscar una herramienta que genere el XSD en base al XML y encontré una muy buena, les dejo el link
Trang(trang20030619.zip).

Si la bajan y la utilizan lograran obtener los XSD de sus XML aquí les dejo los míos

XSDs:


request.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:element name="Parameters">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="UserId"/>
        <xs:element ref="SystemId"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:element name="UserId" type="xs:NCName"/>
  <xs:element name="SystemId" type="xs:NCName"/>
</xs:schema>

response.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
  <xs:element name="Response">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="Status"/>
        <xs:element ref="Data"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:element name="Status" type="xs:NCName"/>
  <xs:element name="Data">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" ref="SubSystem"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:element name="SubSystem">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="SubSystemId"/>
        <xs:element ref="Name"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:element name="SubSystemId" type="xs:integer"/>
  <xs:element name="Name" type="xs:NCName"/>
</xs:schema>

Ahora que tenemos nuestros xsd podemos utilizar xjc para obtener nuestras clases java con sus respectivas annotations.

Les dejo el ejemplo completo para que puedan descargarlo y probarlo. La verdad hay muchas cosas ya resueltas de manera elegante y eficiente solo hace falta conocerlas.

Example.

Saludos,
Luis

Jasper Reports -Virtualizar-

2011-01-02T17:32:00.001-03:00

Hoy les contare sobre un problema que tuve durante estos días, estoy en el desarrollo de una aplicación constituida con Java para el lado servidor y Flex para el lado cliente, últimamente la aplicación había tenido unos problemas con el consumo de memoria luego de analizarla descubrí que esto era básicamente por dos motivos uno de ellos relacionados con Hibernate y el levantamiento de 60000 objetos en memoria lo cual al fin de cuentas lo termine resolviendo con NameQuery, pero aun tenía problemas cuando se ejecutaban varios reportes ya que la memoria del servidor subía inmesuradamente, a continuación les dejo la solución que encontré.

Antes que nada quiero recomendarles que cuando tengan un problema de memoria utilicen jVisualVM es un programa que te deja conectarte al servidor y ver la cantidad de instancias en memoria y así analizar cuál es la que se queda alocada o cuales consumen mucho, como primer paso use el programa y me conecte al servidor (Tomcat) y comencé a arrojar reportes al parecer el GC (Garbage Collector) corría de forma normal pero cuando había muchos reportes al mismo tiempo veía que la cantidad de instancia de JRTemplatePrintText crecía drásticamente.
Luego de investigar un poco encontré que Jasper Report durante su proceso de fill (Obtener los datos y rellenar la plantilla del informe con estos) levantaba los objetos en memoria, entonces la forma de abordar este problema es de dos maneras:
La paginación y la virtualización.
Paginación se refiere a obtener el informe en trozos, en lugar de recoger toda la información de golpe, pero como al final los datos se tienen que mostrar juntos en un único informe, nos introducen la virtualización. La virtualización es una técnica que consiste en serializar los datos, para no saturar la memoria heap.
Cabe aclarar que incluir virtualización conlleva la pérdida de rendimiento.

Aquí un ejemplo de cómo tendríamos que usar la virtualizacion:


JasperPrint jasperprint = null;
JRFileVirtualizer virtualizer = new JRFileVirtualizer(10, "tmp");

long start = System.currentTimeMillis();  

filterParameters.put(JRParameter.REPORT_VIRTUALIZER, virtualizer);

jasperprint = JasperFillManager.fillReport(this.reportFile,this.filterParameters, this.databaseConnection);

virtualizer.setReadOnly(true);
logger.info("Filling time : " + (System.currentTimeMillis() - start));

// Usamos los exportadores para generar el reporte en lo que nosotros queramos.

virtualizer.cleanup();

Se vemos el ejemplo veremos que básicamente creamos un JasperPrint como lo haríamos normalmente pero al momento de generar este JasperPrint por medio del método fillReport de la clase JasperFillManager notamos que en los parámetros le pasamos un Virtualizer esto básicamente quiere decir que Jasper ira creando archivos temporales en la carpeta que le pasamos como segundo parámetro y el primer parámetro es usado para saber el tamaño máximo de los archivos, como ultima línea no debemos olvidar hacer un cleanup del virtualizer para borrar los archivos creados.

Bueno espero que este simple post les sirva como me sirvió a mí encontrar esta técnica para no malgastar memoria durante la generación de reportes ya sean medianos o grandes
Vale recordarles que deben tener en cuenta el balance entre performance y gasto de memoria esto lo pueden manejar con el tamaño máximo de los archivos.

Saludos,
Luis

Semaphores

2010-08-28T14:03:00.002-03:00

Hola como están, hoy estaremos viendo un ejemplo de cómo usar Semaphores en Java, a partir de la versión de 1.5 se hicieron unas extensiones importantes al paquete java.util.concurrent la cual vino acompañada de la clase Semaphore la cual brinda la funcionalidad que necesitaremos.

Para entender su uso lo haremos en base a un ejemplo real, en mi trabajo hace unos días surgió el siguiente issue, tenemos algunas clases singleton que funcionan como Providers, el problema es que a su vez tenemos procesos concurrentes que usan este Provider y cada uno hace un refresh de los datos para tener la ultima versión de los datos. Durante esta semana sucedió que N procesos (Fijaremos N=5) corrieron casi al mismo tiempo por ende cada uno de ellos intento refrescar el singleton todos a la vez como el método que hace el refresh esta sincronizado sucedía que actualizaba los datos para 1 Thread y los otros 4 Thread esperaban, después volvía a refrescar para el siguiente Thread y los restantes esperaban y así sucesivamente, les adjunto una imagen para entender mejor el problema.

Para evitar que los 5 Thread realicen el refresh se decidió ejecutar solo un refresh y encolar los otros 4 esperando que el que está realizando el refresh termine, para esto tuvimos que modificar nuestro singleton y utilizar Semaphores y syncronized por medio de un mutex. Aqui está la clase singleton modificada y ahora explicaremos cada paso.

 
package com.javacuriosities.examples;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;

public class Singleton {

 private static Singleton instance;

 private volatile boolean refreshing = false;

 private Object mutex = new Object();

 private List<Semaphore> pendings = new ArrayList<Semaphore>();

 public synchronized static Singleton getSingleInstance() {
  if (instance == null) {
   instance = new Singleton();
  }
  return instance;
 }

 public void refreshAll(String threadName) {
  if (!checkRefreshingStatus()) {
   refresh(threadName);
  } else {
   Semaphore markPending = addSemaphore(threadName);
   acquireSemaphore(markPending, threadName);
  }
 }

 private void refresh(String threadName) {
  try {
   refreshInfo(threadName);
  } catch (Exception e) {
   e.printStackTrace();
  } finally {
   releasePending();
  }
 }

 private void acquireSemaphore(Semaphore markPending, String threadName) {
  try {
   if (markPending != null) {
    System.out.println("Acquire semaphore: " + threadName);
    markPending.acquire();
   } else {
    System.out.println("Avoid semaphore: " + threadName);
   }
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }

 private Semaphore addSemaphore(String threadName) {
  Semaphore markPending = null;
  synchronized (mutex) {
   if (isRefreshing()) {
    markPending = new Semaphore(0, true);
    pendings.add(markPending);
    System.out.println("Add semaphore to: " + threadName);
   }
  }
  return markPending;
 }

 private void releasePending() {
  synchronized (mutex) {
   System.out.println("Release semaphores");
   for (Semaphore semaphore : pendings) {
    semaphore.release();
   }
   pendings.clear();
   refreshing = false;
  }
 }

 private synchronized boolean checkRefreshingStatus() {
  boolean previousState = refreshing;
  if (!refreshing) {
   refreshing = true;
  }
  return previousState;
 }

 private void refreshInfo(String threadName) {
  for (int i = 0; i < 1000; i++) {
   System.out.println("Executing refresh: " + threadName);
  }
 }

 public boolean isRefreshing() {
  return refreshing;
 }
}

Iré explicando todos los cambios que hemos efectuado para conseguir lo que esperábamos a su vez iremos viendo como seria el flujo de ejecución. Nota: La clase ha sido modifica para que sirva para las pruebas y el ejemplo.
1) El método refreshAll dejo de ser synchronized.
2) Apenas comienza este método tenemos un IF el cual llama a un método synchronized donde se pregunta si se está refrescando y se cambia el estado del flag refreshing.
3) El primer Thread que llegue a esta parte entrara por el IF los demás se irán por el ELSE.
4) El Thread 1 comienza a refrescar la información, los otros van por el lado del ELSE y entran en el método addSemaphore como vemos este método usa sincronización por mutex esto es para asegurarnos que no se agregan semaphores a la lista mientras la estamos liberando por otro lado, si la lista no se esta liberando y además aun está corriendo el refresh creamos un semaphore y lo retornamos.
5) Si se pudo crear el semaphore se intentan hacer acquire del mismo, si no se logro crear significa que el refresh termino y no era necesaria la espera. Usamos el método acquire para decirle a un semaphore que se quede esperando hasta que sea liberado esto sería el equivalente a hacer this.wait() y esperar que por otra parte del código se haga un this.notify().
6) Otro tema importante es que si la lógica del refresh falla igual debemos liberar los semaphores pendientes sino estaremos lockeando el proceso., por eso el releasePending se encuentra en un bloque finally.

Notar que los semaphore son creados con 0 permits lo que signica que al hacer acquire quedaran esperando que la cantidad de permits este en 1, esto se logra por medio del método release que incrementa en 1 los permits del semaphore.

Les adjunto un zip con la clase singleton mas una clase de test que dispara 20 Threads. Espero que este post les sea de ayuda para ver algún ejemplo de concurrencia y threading en Java, cualquier cosa que no se entienda del post todas las preguntas son bienvenidas al igual que las criticas.

Este post es en honor a tuky que últimamente está muy curioso sobre temas varios de programación.

Example

Saludos,
Luis

OSGi (First Steps)

2010-05-09T09:28:00.059-03:00

Decidí hacer este post porque no encontré ningun tutorial que nos explique OSGi desde cero, aclaro que en este post haremos una introducción para que después podamos continuar con algo más avanzado.

¿Que es OSGi?
OSGI (Open Services Gateway Initiative), podríamos definirlo como un sistema (o framework) modular para Java que establece las formas de crear módulos y la manera en que estos interactuaran entre sí en tiempo de ejecución. OSGi intenta solventar los problemas del tradicional "classloader" de la máquina virtual y de los servidores de aplicaciones Java. En OSGI, cada módulo tiene su propio classpath separado del resto de classpath de los demás módulos.

Este framework proporciona a los desarrolladores un entorno orientado a servicios y basado en componentes, ofreciendo estándares para manejar los ciclos de vida del software.
OSGi esta divido en capas que en proximo post iremos cubriendo por ahora se mencionan para que se conozca la existencia de ellas.

Security Layer.
Module Layer.
Life Cycle Layer.
Service Layer.
Execution Environment.

OSGi Alliance
La OSGi Alliance es un consorcio de empresas tecnológicas a nivel mundial que trata de asegurar la interoperabilidad de las aplicaciones y servicios basados en esta plataforma entre las empresas que componen este consorcio, podemos encontrar compañías de diversa índole: automoción, aeronáutica, fabricantes de electrodomésticos, telecomunicaciones, fabricantes de teléfonos... Algunos ejemplos de miembros: Motorola, Nokia, Mitsubishi Electric Corporation, Vodafone Group Services, LinkedIn, LG Electronics...
La alianza proporciona las especificaciones, las implementaciones de referencia, las suites de prueba y la certificación.

Especificacion OSGi
OSGI proporciona un marco de trabajo java de uso general, seguro y administrado que
soporta el despliegue dinámico de aplicaciones conocidas como "Bundles" o módulos.
Algunas de las características que componen este marco de trabajo:

Es un sistema de módulos para la plataforma java.
Incluye reglas de visibilidad, gestión de dependencias y versionado de los bundles.
Es dinámico.
La instalación, arranque, parada, actualización y desinstalación de bundles se realiza dinámicamente en tiempo de ejecución sin tener que detener por completo la
plataforma.
Se trata de una arquitectura orientada a servicios.
Los servicios pueden ser registrados y consumidos dentro de la VM.

Implementacones OSGi
Lo bueno de tener una aplicación modular es que a diferencia de una aplicación web nosotros vamos deployando unidades independientes las cuales se pueden cambiar con gran facilidad, esto quiere decir que si necesitáramos reemplazar un modulo por otro muchas veces no sería necesario detener toda la aplicación sino ciertos módulos y todo seguiría andando, además tenemos versionado de Bundles (Módulos) lo cual es muy útil para poder ir haciendo que nuestros módulos usen otros pero de alguna versión especifica.
Podemos encontrar varias plataformas certificadas en OSGi las cuales cumplen con la especificación de modo que si nosotros desarrolláramos nuestros módulos ellos podrían correr en cualquiera de estas implementaciones, algunas de ellas son:

Apache Felix.
Eclipse Equinox.
Knopflerfish.
Newton Project.

Preparando mi entorno OSGi
Para este post utilizaremos la implementación de Eclipse Equinox para nuestros ejemplos, nos dirigimos a Eclipse Equinox desde aquí podremos realizar la descarga del entorno de trabajo, tenemos varias opciones:

Descarga de la implementación OSGI base: Se trata de un fichero .jar (bundle),
que contiene los elementos básicos para poder ejecutar nuestro entorno.

Descarga completa de equinox: Se trata de un fichero .zip que contiene el bundle
base comentado anteriormente, más todas las configuraciones e implementaciones
de los servicios OSGI.

Descarga de los bundles opcionales: Mediante esta opción podremos descargar
uno a uno los bundles de equinox que implementan los diferentes servicios de
OSGI.

Para este ejemplo bajaremos la descarga completa para facilitar las cosas, luego podremos descomprimir este zip en nuestro disco. Dentro de la carpeta plugins del zip que descargamos encontraremos un jar llamado org.eclipse.osgi_3.x.x_xxx.jar el cual es util para dos cosas la primera levanta el entorno OSGi y desde aqui podremos instalar, iniciar, detener, desinstalar nuestros módulos, y además podremos usar este jar para desarrollar en el eclipse ya que contiene las clases/interfaces de la implementación OSGi. Les dejo un print screen de mi eclipse con el desarrollo del ejemplo que sigue.

OSGiEclipse.png

Ejemplo Basico
Como es típico empezaremos con un Hello World, ósea aquí no estaríamos construyendo una aplicación que nos diga Hello World sino que estaríamos creando un modulo el cual por vivir en un contender OSGi tiene un ciclo de vida completo. Básicamente crear un modulo sería crear un jar con nuestras clases y un archivo MANIFEST.MF

Entendiendo el MANIFEST.MF
El Manifesft.mf no es más que un archivo de texto en el cual se agregan directivas del tipo clave: valor, las cuales juegan un papel muy importante ya que son las que irán diciéndole al marco de trabajo OSGi algunas de las cosas importante sobre nuestro modulo a continuación muestro un Manifest de ejemplo y explico sus directivas.


Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: HelloWorld
Bundle-SymbolicName: com.javacuriosities.osgi.helloworld
Bundle-Version: 1.0.0
Bundle-Activator: com.javacuriosities.osgi.helloworld.Activator
Import-Package: org.osgi.framework;specification-version="1.4.0"

Manifest-Version
Define la versión del archivo MANIFEST.MF.

Bundle-ManifestVersion
Indica la especificación de OSGi sobre la que está basada el bundle. Por defecto, si no se indica nada, el valor es 1. Este valor indica que el bundle se basa en las reglas de la especificación OSGI 3. Si tiene valor 2, se tratará de la especificación de OSGI 4.

Bundle-Name
Indica el nombre corto del Bundle debe ser human-readable.

Bundle-SymbolicName
Esta etiqueta define un nombre único para el bundle. Con este nombre es con el que trabajaremos en el entorno de ejecución.

Bundle-Version
Indica la versión de nuestro bundle, dentro de nuestro entorno podríamos tener diferentes versiones de un mismo bundle.

Bundle-Activator
Indica que clase funcionara como Activator, la cual es una clase que debe implementar la interfaz BundleActivator de modo que podamos entrar dentro del ciclo de vida de nuestro Bundle.

Import-Package
Por medio de esta directiva le decimos que paquetes queremos importar, si nos ponemos a pensar esta línea es muy importante porque nuestro jar solamente tendra nuestras clases pero por ejemplo la interfaz BundleActivator ya es parte del modulo core de OSGi asi no estaría dentro de nuestro jar así que por medio de esta directiva la importamos para que todo funcione.

Implementando nuestro Activator


package com.javacuriosities.osgi.helloworld;

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;

public class Activator implements BundleActivator{
@Override
public void start(BundleContext arg0) throws Exception {
 System.out.println("Hello World"); 
}

@Override
public void stop(BundleContext arg0) throws Exception {
 System.out.println("Bye Bye"); 
}
}

Empaquetando e instalando
Luego de poder crear nuestro modulo deberemos empaquetarlo como un jar podríamos usar el eclipse o el comando jar que viene con java, el jar nos debería quedar de la siguiente forma


com.javacuriosities.osgi.helloworld_1.0.0.jar
    com\javacuriosities\osgi\helloworld\Activar.class
    META-INF\MANIFEST.MF

Debemos iniciar nuestro entorno OSGi para esto haremos lo siguiente iremos al directorio donde descomprimimos el entorno Eclipse Equinox y dentro de la carpeta plugins ejecutaremos la siguiente línea de comando, luego veremos que el prompt cambia a osgi> y ahí pondremos ss para ver nuestros bundles instalados.

java -jar org.eclipse.osgi_3.x.x_xxx.jar -console

Ahora instalaremos nuestro bundle(.jar) copiaremos nuestro bundle al Disco C:\ y ejecutaremos el comando

install file:c:\com.javacuriosities.osgi.helloworld_1.0.0.jar

si todo va bien aparecerá un mensaje del tipo Bundle id is XX, ahora con este id ya podremos iniciar, detener y desinstalar nuestro modulo. Para probar ejecutaremos estos dos comandos.

start XX --> Ahi veremos nuestro mensaje del método start de la clase Activator.
stop XX --> Ahi veremos nuestro mensaje del método stop de la clase Activator.

Adjunto un screen de la consola con los comandos.

OSGiConsole.png

Bueno esto ha sido por este post, espero haber sido lo suficientemente claro para que se entienda el ejemplo y los conceptos básicos de OSGi, cualquier pregunta o sugerencia es bien recibida.

Saludos y hasta pronto.

Java Best Practices

2010-03-13T16:22:00.007-03:00

Después de mucho tiempo de no realizar ningún post vuelvo para compartir una presentación que estoy realizando sobre buenas prácticas de programación espero les sea útil.

La idea de estar presentación es ir actualizándola lo más que se pueda, así queda como un documento de referencia para las personas que estén interesadas en ir programando cada día mejor.
Aclaro que no soy ningún experto acepto cualquier comentario que puede ir mejorando la presentación ya que esto está pensado para todos y la idea es que si alguien tiene alguna idea que agregar me avise y la agregamos.

Best Practices

View more presentations from Luis De Bello.

Download Best Practices

Saludos

JavaFX Sintaxis Declarativa

2009-08-04T15:26:00.167-03:00

En el post anterior hemos visto un ejemplo sobre cómo realizar un Hello World con JavaFX pero sin entrar en mucho detalle sobre algunas líneas del código, ahora seguiremos con algunos ejemplos más y explicando un poco sobre esto de Sintaxis Declarativa, por ejemplo un objeto puede ser creado con un Objeto Literal. Lo que significa una sintaxis declarativa concisa parecida a javascript, en lugar de explicar "como" realizar algo (el algoritmo, en los lenguajes imperativos), deberemos describir "que" es ese algo. Por ejemplo, en HTML, se declara el contenido de la página, pero no se explica cómo este será mostrado en la pantalla. Ahora veremos algunos ejemplos para aclarar esto.

Iremos desarrollando un ejemplos casi línea por línea para ir notando la simpleza del lenguaje e ir viendo algunos efectos, para este ejemplo usaremos una imagen que la pueden encontrar en el siguiente link ,comencemos.

Paso 1:


import javafx.stage.Stage;

Stage {
    width: 400
    height: 400 
}

con las pocas líneas de arriba ya hemos definido una instancia de un objeto Stage, el cual es necesario para renderizar una ventana.

Paso 2:


import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.Image;

var image = Image {
    url: "{__DIR__}JavaFX.png"
}

Stage {
    width: 400
    height: 400 
    scene: Scene {
        content: [
            ImageView {
                x: 75
                y: 60
                image: image
            }
        ]
    }
}

aquí hemos complicado un poco la cosa, pero veremos cada detalles, los primeros import de Scene, Image e ImageView son necesarios por los siguiente motivos.
Scene es el objeto el cual nos permite renderizar elementos gráficos dentro de el, el ImageView es el contenedor para una determinada imagen, y por último el Image es la imagen en sí. Si notamos la definición de Scene, vemos que a su propiedad content(Aquí dibujamos los elementos gráficos), hemos agregado una instancia de ImageView y a esta le hemos asignado la imagen previamente cargada en la variable image. Como podrán notar toda la sintaxis es muy simple y siempre nos preocupamos en la declaración de lo que deseamos y no en como generar todo esto.
El código hasta ahora nos generaría una ventana, con la imagen posicionada en el centro, pero nuestra Scene por defecto tiene un color blanco de fondo, si vemos en posts anteriores veremos que podíamos asignar colores en forma de gradientes, pues bueno eso haremos como siguiente paso.

Paso 3:


import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.Image;
import javafx.scene.paint.LinearGradient;
import javafx.scene.paint.Stop;
import javafx.scene.paint.Color;

/**
 * @author softdesigner
 */

var image = Image {
    url: "{__DIR__}JavaFX.png"
}

Stage {
    width: 400
    height: 400 
    scene: Scene {
        content: [
            ImageView {
                x: 75
                y: 60
                image: image
            }
        ]
        fill: LinearGradient {
            startX : 0.0
            startY : 0.0
            endX : 0.0
            endY : 1.0
            stops: [
                Stop {
                    color : Color.WHITE
                    offset: 0.0
                },
                Stop {
                    color : Color.BLACK
                    offset: 1.0
                }
            ]
        }
    }
}

Si vemos la propiedad fill del objeto Scene, nos damos cuenta que estamos asignando un LinearGradient a esta propiedad, como podemos deducir esto generara un Gradiente linear por medios de las propiedades startX, startY, endX, endY definimos la dirección lineal y por medio de los stops definimos que distintos Stop usar, cada Stop define necesita su propiedad color y su propiedad offset la cual indicada cuando se detendrá ese gradiente.

Muchas veces cuando estamos retocando imágenes o logrando algún efecto se nos plantea la necesidad de lograr un efecto de reflejo sobre el agua o algún material, JavaFX viene con muchas de estas dificultades resueltas ya que brinda diversos efectos para ser aplicados a nuestras imágenes, para ver esto usaremos un efecto de Reflection para lograr reflejar nuestra imagen.

Paso 4:



import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.Image;
import javafx.scene.paint.LinearGradient;
import javafx.scene.paint.Stop;
import javafx.scene.paint.Color;
import javafx.scene.effect.Reflection;

/**
 * @author softdesigner
 */

var image = Image {
    url: "{__DIR__}JavaFX.png"
}

Stage {
    width: 400
    height: 600
    scene: Scene {
        content: [
            ImageView {
                x: 75
                y: 60
                image: image
                effect: Reflection {
                        fraction: 0.75
                        topOffset: 0.0
                        topOpacity: 0.5
                        bottomOpacity: 0.0
                    }
            }
        ]
        fill: LinearGradient {
            startX : 0.0
            startY : 0.0
            endX : 0.0
            endY : 1.0
            stops: [
                Stop {
                    color : Color.WHITE
                    offset: 0.0
                },
                Stop {
                    color : Color.BLACK
                    offset: 1.0
                }
            ]
        }
    }
}

Ahora tenemos nuestra imagen con un efecto de Reflection, este es asignado al ImageView ya que es el contenedor de la imagen y ahora explicaremos cada propiedad de este efecto.
fraction: Es la fracción que se muestra reflejada en base a la imagen original(Valor porcentual).
topOffset: Es la distancia entre la imagen y el comienzo de su reflejo(Valor libre).
topOpacity: Es la opacidad del comienzo del reflejo(Valor porcentual).
bottomOpacity: Es la opacidad del final del reflejo(Valor porcentual).

Para ir terminando el ejemplo como último detalle, queremos mostrar dos efectos al mismo tiempo, los cuales serán una DropShadow y un efecto Reflection.

Paso 5:


import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.image.ImageView;
import javafx.scene.image.Image;
import javafx.scene.paint.LinearGradient;
import javafx.scene.paint.Stop;
import javafx.scene.paint.Color;
import javafx.scene.effect.Reflection;
import javafx.scene.effect.DropShadow;

/**
 * @author softdesigner
 */

var image = Image {
    url: "{__DIR__}JavaFX.png"
}

Stage {
    width: 400
    height: 600
    scene: Scene {
        content: [
            ImageView {
                x: 75
                y: 60
                image: image
                effect: Reflection {
                        fraction: 0.75
                        topOffset: 0.0
                        topOpacity: 0.5
                        bottomOpacity: 0.0
                        input: DropShadow {
                                offsetX: 10
                                offsetY: 10
                                color: Color.BLACK
                                radius: 10
                            }
                    }
            }
        ]
        fill: LinearGradient {
            startX : 0.0
            startY : 0.0
            endX : 0.0
            endY : 1.0
            stops: [
                Stop {
                    color : Color.WHITE
                    offset: 0.0
                },
                Stop {
                    color : Color.BLACK
                    offset: 1.0
                }
            ]
        }
    }
}

Si leemos acerca de la propiedad effect del ImageView descubriremos que solo acepta un objeto effect, y aquí nos entra la duda de cómo haremos mas agregar dos efectos al mismo tiempo, para esto casi todos los efectos tiene una propiedad input la cual recibe un effect, así que si nosotros quisiéramos ir encadenando efectos deberíamos hacerlo por medio de esta propiedad, en la parte superior del código se nota que el efecto Reflection recibe un input de un DropShadow, las propiedades del DrowShadow son las siguientes:
offsetX: Cantidad de pixeles sobre el eje x.
offsetY: Cantidad de pixeles sobre el eje y.
color: Color de relleno de la sombra.
radius: Radio del difuminado para la sombra.

Con esto daremos por finalizada esta mínima explicación y demostración sobre la Sintaxis declarativa que ofrece JavaFX y la simplicidad y poder de este lenguaje.
Les dejo un link al ejemplo del proyecto netbeans, luego intentare dejar el jnlp para que lo puedan descargar.

Proyecto
DeclarativeSyntax.rar

Saludos

JavaFX GUI

2009-08-02T20:19:00.034-03:00

El Api de JavaFX brinda a los desarrolladores la posibilidad de crear interfaces UI que seran independientes del dispositivo, podemos definir una division entre lo que seria un Common profile y un Desktop profile. El Common profile puede ser usado en aplicaciones de escritorio asi como en aplicaciones para mobiles. En cambio el Desktop profile es espefico de aplicaciones de escritorio.El SDK de JavaFX posee un JavaFX Mobile Emulator en el cual podemos ver como quedan nuestras aplicaciones sobre telefonos mobiles, en algun post veremos como usar esto. Daremos una breve explicacion sobre la separacion de categorias y que paquetes entran en juego, y dejaremos un link a los archivos de ejemplo de Sun.Este post sera una presentacion sobre el mundo JavaFX y dejaremos un videotutorial sobre como crear el indispensable HelloWorld para no fracasar en un nuevo lenguaje.

Contenidos

Common Profile:

User Interface Elements
Charts
Colors
Shapes
Fill Styles
Line Cap and Join Style
Text
Transformations
Layout

Desktop Profile:

Effects
Cursors

Common Profile:

User Interface Elements
Aqui encontraremos todos los componentes para poder crear interfaces de usuario,todos estos componentes se hayan en el paquete javafx.scene.control.

Archivo de ejemplo:
UIControls.fx

Charts
JavaFX ya provee muchos tipos de graficas prefabricadas, estas las podemos encontrar en el paquete javafx.scene.chart veremos una lista de las graficas disponibles:
Graficas de Area
Graficas de Barras
Graficas de Burbujas
Graficas de Lineas
Graficas de Pastel
Graficas de Dispersion

Colors
JavaFX nos provee una clase que se haya en el paquete javafx.scene.paint.Color la cual posee constantes de los colores predefinidos y a su vez metodos especificos para trabajar con ellos.

Archivo de ejemplo:
Colores

Shapes
Los Shapes son las formas basicas que podemos realizar obviamente que mezclandolas entre si podremos obtener otras figuras mas complejas. Esta se encuentra en el paquete javafx.scene.shape.

Archivo de ejemplo:
Shapes

Fill Styles
Los Fill son los tipos de relleno que podemos aplicar cuando pintamos ciertos elementos, a estos le podemos agregar patrones para lograr efecto de pintado ya sea degrade ya sea del tipo radial o lineal, y tambien colores solidos.

Archivo de ejemplo:
Fill Styles

Line Cap and Join Styles
Cuando construimos figuras geometricas muchas veces juntamos lineas y distinos estilos, esto es posible en base a las clases del paquete javafx.scene.shape el cual provee las herramientas necesarias para esto.

Archivo de ejemplo:
Line Cap and Join Styles

Text
Cuando escribimos texto, podemos asignar distintos formatos, estas caracteristicas estan englobadas en el paquete javafx.scene.text, podremos rotar las letras, moverlas de posicion, asignar distinas tipografias, etc.

Archivo de ejemplo:
Text

Transformations
Podemos aplicar diversas transformaciones por ejemplo rotaciones, translaccion de coordenadas, escalado de imagenes, etc.

Archivo de ejemplo:
Transformations

Layout
Los layout nos marcan la distribuccion de los elementos por la ventana, hay diversos tipos y estan almacenados en el paquete javafx.scene.layout.

Archivo de ejemplo:
HBox
VBox

Desktop Profile:

Effects
Podemos aplicar distintos efectos que ya vienen incorporados con JavaFX, estos efectos pueden ser aplicados a los elementos JavaFX UI.

Archivo de ejemplo:
Effects

Cursors
Podemos asignar distintos cursores sobre los elementos de JavaFX.

Archivo de ejemplo:
Cursors

Link General
Les dejo un link con un rar que posee todos los ejemplos de la pagina de Sun, por si el link de algun ejemplo no anda aca estan todos juntos.
Ejemplos

Después de esta pequeña introducción sobre los elementos gráficos y distintas caracterizas incluidas en JavaFX procederemos a hacer el primer ejemplo de nuestro largo camino de aprendizaje, sin más palabras el Hello World!!!
Espero el video tutorial sea entendible ya que este es el primero que hago y hay demasiados errores, espero pueda serle de utilidad y les sirva.

Saludos

Binding And Triggers

2009-07-31T23:09:00.073-03:00

Hoy hablaremos de una de las características más poderosas de JavaFX la cual consiste en el binding entre datos, esto nos brinda la posibilidad de vincular dos variables entre si ya sea por el cambio de valor de una, o por la evaluación de una expresión. Además tenemos la posibilidad de asignar triggers que son bloques de códigos los cuales se ejecutan al cambiar el valor de una variable.

Contenidos

Binding Overview
Binding and Objects
Binding and Functions
Binding with Sequences
Replace Triggers

Binding Overview
Empezaremos diciendo que para poder realizar el binding entre variables debemos usar la keyword bind, también existe una expresión bound que ahora veremos la cual crea una relación más amplia.

Binding and Objects
Veamos un ejemplo donde creamos un binding entre dos variables.

var x = 0;
def y = bind x;
x = 1;
println(y); // y ahora vale 1
x = 50;
println(y); // y ahora vale 50

Aquí se nota como nosotros solo modificamos los valores de la variable x esto automáticamente se ve reflejado en la variable y.
Ahora veremos un binding parecido pero cuando queremos hacer binding entre objetos.

var myStreet = "1 Main Street";
var myCity = "Santa Clara";
var myState = "CA";
var myZip = "95050";

class Address{
var street;
var city;
var state;
var zip;
}

def address = bind Address {
street: myStreet;
city: myCity;
state: myState;
zip: myZip;
};

println("address.street == {address.street}");
myStreet = "100 Maple Street";
println("address.street == {address.street}");

Aquí definimos la clase Address y luego definimos, 4 variables para iniciar este objeto, al crear nuestro objeto lo hacemos con la palabra bind, esto quiere decir que nuestra variable address siempre tendrá sus atributos actualizado en base a los valores de las variables con cuales fue iniciado.
Si ejecutamos el ejemplo veremos que el resultado es
address.street == 1 Main Street
address.street == 100 Maple Street
Un dato importante que debemos considerar es que con este tipo de binding por cada modificación, se genera un nuevo objeto Address y se asigna nuevamente a la variable.
Otra forma de realizar este binding sin generar un nuevo objeto es de la siguiente manera


var myStreet = "1 Main Street";
var myCity = "Santa Clara";
var myState = "CA";
var myZip = "95050";

class Address{
var street;
var city;
var state;
var zip;
}

def address = Address {
street: bind myStreet;
city: bind myCity;
state: bind myState;
zip: bind myZip;
};

println("address.street == {address.street}");
myStreet = "100 Maple Street";
println("address.street == {address.street}");

La única diferencia es que acá no se hace el bind sobre el objeto sino sobre cada atributo.

Binding and Functions
Aquí es donde entra en juego la keyword bound, no debemos confundir esto con el bind son dos cosas distintas que en combinación nos ofrecen alguna funcionalidad especifica.
Veamos un ejemplo de bind y bound para entender cómo funciona y como usarlo

// Paso 1
var scale = 1.0;

// Paso 2
class Point {
 var x : Number;
 var y : Number;
}

// Paso 3
bound function makePoint(xPos : Number, yPos : Number) : Point {
 Point {
      x: xPos * scale
      y: yPos * scale
 }
}

// Paso 4
var myX = 3.0;
var myY = 3.0;
def pt = bind makePoint(myX, myY);
println(pt.x);

// Paso 5
myX = 10.0;
println(pt.x);

// Paso 6
scale = 2.0;
println(pt.x);

Entendamos este ejemplo paso por paso.
Paso 1:
Aquí definimos una variable del tipo Number y la inicializamos en 1.0

Paso 2:
Definimos la clase Point

Paso 3:
Creamos una función la cual la marcamos con el atributo bound, aquí debemos saber que hay dos tipos de funciones las bound y las not-bound que se comportan de manera distinta si tan con binding sobre una variable.
Las funciones not-bound solo se ejecutan si sus parámetro cambian, en caso contrario las funciones bound siempre se ejecutan

Paso 4:
Creamos las variables las inicializamos y hacemos un bind entre la función y una variable del tipo Point.

Paso 5:
Cambiamos el valor de myX como esta variable fue usada como parámetro de la función con bind se dispara la función y cambia los valores del Point

Paso 6:
Cambiamos el valor de la scale y como esta es una función bound también se vuelve a ejecutar la función y nos cambia los valores de Point
Si ejecutamos el ejemplo el resultado será:
3.0
10.0
20.0
Si sacáramos el bound de la función el resultado sería:
3.0
10.0
10.0

Binding with Sequences
Aquí usaremos un bind entre secuencias pero además usando la expresión for. Tranquilamente podríamos hacer un bind común entre dos secuencias como si fueran variables, pero para ver el poder de esto usaremos una expresión for de la siguiente manera

// Definimos la secuencia 1
var seq1 = [1..10];

// Definimos la secuencia 2, pero con la diferencia que cada ítem será multiplicado por dos
def seq2 = bind for (ítem in seq1) ítem*2;
printSeqs();

function printSeqs() {
 println("First Sequence:");
 for (i in seq1){println(i);}
 println("Second Sequence:");
 for (i in seq2){println(i);}
}

Si ejecutamos el ejemplo el resultado será el siguiente:
First Sequence:
1
2
3
4
5
6
7
8
9
10
Second Sequence:
2
4
6
8
10
12
14
16
18
20

Se nota claramente como la secuencia 2 está relacionada con la secuencia 1,pero además aplica una multiplicación sobre cada ítem, para confirmar el bind vamos a insertar un elemento en la secuencia 1 y este debería estar presente en la secuencia 2

// Definimos la secuencia 1
var seq1 = [1..10];

// Definimos la secuencia 2, pero con la diferencia que cada ítem será multiplicado por dos
def seq2 = bind for (ítem in seq1) ítem*2;
insert 11 into seq1;
printSeqs();

function printSeqs() {
 println("First Sequence:");
 for (i in seq1){println(i);}
 println("Second Sequence:");
 for (i in seq2){println(i);}
}

Si volvemos a correr el ejemplo veremos que ahora la secuencia 1 tiene el ítem 1 y la secuencia 2 tiene el ítem 22.

Replace Triggers
Se le llama Replace Triggers a bloques de códigos que podemos asignar a las variables para que se ejecuten cuando sus valores cambien. Aquí debemos usar la sentencia on replace para poder definir el bloque de código que queremos ejecutar

var password = "foo" on replace oldValue {
 println("\nALERT! Password has changed!");
 println("Old Value: {oldValue}");
 println("New Value: {password}");
};
password = "bar";

Primero creas la variables password donde la inicializamos con el valor "foo"(Supuestamente -Ahora explicare porque pongo esto-) y usamos la sentencia on replace seguido de un nombre a elección del valor anterior y luego definimos el código a ejecutar. al correr el ejemplo veremos lo siguiente

ALERT! Password has changed!
Old Value:
New Value: foo

ALERT! Password has changed!
Old Value: foo
New Value: bar

Vemos que se ejecuta dos veces ya que la variable en un comienzo esta inicializa en Null por eso nuestra inicialización en "foo" es supuesta.

Bueno con esto daremos por finalizada la introducción a las características de JavaFX en lo que sería la parte de scripting, ahora nos dedicaremos a la parte más visual donde empezaremos a usar todos estos conocimientos.

Saludos

Secuencias JavaFX

2009-07-27T23:41:00.163-03:00

En esta ocasión hablaremos de las secuencias, estas son una adicción a los tipos básicos de JavaFX, el lenguaje nos provee de una estructura llamada secuencias la cual representa una lista ordenada de objetos (Aunque no sean solamente objetos), cada objeto dentro de la secuencia es llamado ítem. Para declarar una secuencia debemos usar [] y dentro introducir cada ítem separado por comas.

Contenido

Creating Sequences
Using Predicates
Accessing Sequence Items
Inserting Items into a Sequence
Deleting Items from a Sequence
Reversing the Items in a Sequence
Comparing Sequences
Using Sequences Slices

Creating Sequences
Tenemos varias formas de declarar una secuencia por ejemplo podríamos encerrar los ítem entre [] separados por coma.

def weekDays1 = ["Lunes","Martes"];    // Aquí no definimos el tipo de Dato
def weekDays2: String[] = ["Miercoles","Jueves","Viernes"];   // Aquí informamos el tipo de los Items

Una cualidad importante de las secuencias es que pueden ser construidas en base a otras secuencias, para el ejemplo anterior podríamos hacer realizado la siguiente combinación

// Aquí obtendríamos una secuencia con todos los días
def days = [weekDays1, weekDays2, ["Sabado", "Domingo"]];
println(days) // Print [ Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo ]
tipo de los Items

Aquí en realidad el compilador aplana las secuencias anteriores para generar la nueva secuencia. JavaFX script también nos provee una forma más simple de trabajar con secuencias aritméticas.
Ejemplo

def nums = [1..100];

Esto crearía una secuencia la cual poseería los números del 1 al 100

Using Predicates
Nos referimos a predicados cuando usamos una expresión booleana para generar una nueva secuencia que sea formada por un sub conjunto de la secuencia original.
Ejemplo:

def nums = [1,2,3,4,5];
def numsGreater = nums[n | n > 2];
println(numsGreater); // Esto imprimiría [3, 4, 5]

Aquí estamos creando una nueva secuencia en base a una existente y un predicado, analicemos mejor este ejemplo, para esto desglosáremos la siguiente sentencia
nums[n | n > 2]

nums // Selecciono la secuencia previa
[ // Abro [ para marcar mi predicado
n // Defino la variable n
| // Se encarga de separar la variable del predicado
n // Indico un criterio de filtrado, que sería propiamente el predicado
] // Cierro el predicado

Accessing Sequence Items
Muchas veces nos vemos en la necesidad de acceder a los ítem que están almacenados en nuestras secuencias y para esto podemos usar los indexes de la secuencia.

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
println(days[0]);
println(days[1]);
println(days[2]);
println(days[3]);
println(days[4]);
println(days[5]);
println(days[6]);

En este caso no habría problemas porque nosotros conocemos la cantidad de ítems, que hay en nuestra secuencia si nosotros quisiéramos conocer la cantidad de ítems que hay deberíamos usar la palabra reservada sizeof

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
println(sizeof days);  // Esto imprimiría el numero 7

Inserting Items into a Sequence
Otra palabra reservada del lenguaje es la palabra insert, esta es usada para lograr insertar elemento en una secuencia. Aquí debemos tener en cuenta un dato que no es menor y es que las secuencias realmente son inmutables(Inmutables quiere decir que después de estar creadas nunca se modifican), entonces nosotros en realidad al insertar un ítem en una secuencia en verdad por debajo se crea una nueva secuencia y se reasigna automáticamente, dando la impresión que modificamos la secuencia existente.

// Inicializamos la secuencia con un solo ítem
var days = ["Lunes"];
// Insertamos dos ítem al final de la secuencia
insert "Martes" into days;
insert "Jueves" into days;
// Insertamos un ítem antes que el ítem de la posición 2
insert "Miercoles" before days[2];
// Insertamos un ítem después que el ítem de la posición 3
insert "Viernes" after days[3];

Si usamos posiciones invalidas no sucede nada y los ítem son insertado al final o al comienzo dependiendo el caso, por ejemplo si insertáramos un ítem after days[24] veríamos que realmente se inserta al final de la secuencia o un ítem before days[-1]
este se inserta al comienzo.

Deleting Items from a Sequence
Como ya hemos insertado ítem también debe existir la posibilidad de borrarlos y esto se puede realizar por medio del keyword delete usando en distintas formas

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
// Borramos el ítem "Lunes"
delete "Lunes" from days;
// Borramos el ítem de la posición 0
delete days[0];
// Borramos todos los ítem, pero la secuencia sigue siendo útil
delete days;

Esto es muy similar a lo anterior, cabe destacar que si elemento marcado o la posición seleccionada para borrar no existen, no se realiza ninguna acción de borrado.

Reversing the Items in a Sequence
Esta técnica nos permite invertir una secuencia en su totalidad usando tan solo la keyword reverse. Veamos un ejemplo para aclarar esto

// Iniciamos la secuencia con los números del 1 al 5
var nums = [1..5];
// Damos vuelta la secuencia
reverse nums;
// Esto imprime [ 1, 2, 3, 4, 5 ]
println(nums);
// Invertimos la secuencia pero ahora si asignamos su resultado
nums = reverse nums;
// Esto imprime [ 5, 4, 3, 2, 1 ]
println(nums);

El ejemplo de arriba nos muestra como las secuencia no se auto asignan su reverse y en este caso debe ser explicito por el programador, no funciona como los delete o insert donde se hace automáticamente.

Comparing Sequences
Para comparar las secuencias se tienen en cuenta dos puntos, el primero su longitud y el segundo la correspondencia entre sus ítem. Al cumplirse estos dos hitos podemos asegurar que las secuencias son iguales.

// Creamos dos secuencias iguales
def seq1 = [1,2,3,4,5];
def seq2 = [1,2,3,4,5];
// Comparamos y esta comparación retorna true
println (seq1 == seq2);

Ahora insertaremos un ítem a la seq2 para lograr que sea diferente que la otra y poder volver a ejecutar la comparación.

// Creamos dos secuencias iguales
var seq1 = [1,2,3,4,5];
var seq2 = [1,2,3,4,5];
// Insertamos un elemento en la seq
insert 6 into seq2;
// Imprimimos la seq2 para comprobar que cambio
println(seq2);
// Comparamos y esta comparación retorna false
println (seq1 == seq2);

Hasta aquí vimos el caso de igualdad y el caso donde la longitud es mayor, ahora nos queda pendiente ver cuando sus ítems tienen otra posición y esto también genera una desigualdad entre secuencias.

// Creamos dos secuencias iguales
var seq1 = [1,2,3,4,5];
var seq2 = [1,2,3,4,5];
// Insertamos un elemento en la seq
seq2 = reverse seq2;
// Imprimimos la seq2 para comprobar que cambio su orden
println(seq2);
// Comparamos y esta comparación retorna false
println (seq1 == seq2);

Aquí cubrimos los 3 casos de comparación entre secuencias, ahora vallamos al último punto

Using Sequences Slices
Antes proceder a explicar las distintas formas de conseguir un slice, deberíamos entender que es un slice, un slice básicamente consiste en una porción de alguna secuencia en base a un criterio o selección, se podría definir un slice como un subconjunto de la secuencia, un slice es una secuencia.
Podemos definir slice de las siguientes maneras
seq[a..b]
seq[a..<b]
seq[a..]
seq[a..<]

En las definiciones de arriba seq seria la secuencia que queremos obtener un slice y a y b los indexes de comienzo y fin, expliquemos cada uno

seq[a..b]

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
// La nueva secuencia tendría los ítem "Sabado" y "Domingo"
def weekend = days[5..6];

Esta forma de crear un slice incluye ambos indexes

seq[a..<b]

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
// La nueva secuencia tendría todos los ítem menos "Sabado" y "Domingo"
def weekdays = days[0..<5];

En este caso solo la primer posición es incluida y el otro no.

seq[a..]

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
// La nueva secuencia tendría los ítem "Sabado" y "Domingo"
def weekend = days[5..];

Aquí estamos definiendo un slice que comience en la posición 5 y que incluya dicha posición hasta el final de la secuencia inclusive.

seq[a..<]

def days = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"];
// La nueva secuencia tendría todos los ítem menos el "Domingo"
def days2 = days[0..<];

Este tipo de slice es similar al anterior ya que comienza en la primera posición inclusive y va hasta el final de la secuencia pero sin incluir el último elemento

Hasta aquí hemos analizados las distintas acciones y tipos referido a las secuencias ya en el próximo post estaremos analizando el binding y los trigger en JavaFX, me voy despidiendo y espero el post les sea de utilidad

Saludos

Operadores

2009-07-25T13:39:00.062-03:00

Los operadores son símbolos especiales que nos brindan los lenguajes para interactuar con uno o dos operando y devolver un resultado, en base al tipo de operador que usemos, veremos si funciona con un solo operando o son ambos requeridos.
Como venimos haciendo hasta ahora presentaremos una lista con los distintos tipos de operadores y luego entraremos en los detalles de cada uno.

Operadores:

Assignment Operators
Arithmetic Operators
Unary Operators
Equality and Relational Operators
Conditional Operators
Type Comparison Operator

Assignment Operators
Este es uno de los operadores más comunes que podremos encontrar, básicamente se usa para asignación entre las variables y lo datos que queremos almacenar en ella. Este operador está representado con el símbolo "=".

var example1 = 2;
var example2 = "Test";

En este caso vemos dos asignaciones en el ejemplo 1 guardamos el valor 2 en la variable example1, y en el segundo caso guardamos la cadena de caracteres example2 (En realidad hablamos que guardamos las referencias ya que son objetos, pero no me parece importante para este tema igual quería dejarlo aclarado).

Arithmetic Operators
Los operadores aritméticos son utilizados para los cálculos entre las variables.
+ (additive operator)
- (subtraction operator)
* (multiplication operator)
/ (division operator)
mod (remainder operator)
Estos operadores cubren las 4 operaciones básicas y la operación del resto por medio del modificador mod

Ejemplo

var example = 1 + 2;
println(example);      // example vale 3

example = example - 1;
println(example);      // example vale 2

example = example * 2;
println(example);      // example vale 4

example = example / 2;
println(example);      // example vale 2

example = example + 8;
println(example);      // example vale 10

example = example mod 7;
println(example);      // example vale 3

Unary Operators
Los operadores unarios son aquellos que se puede usar teniendo un solo operando.

example = 0;
example += 1;
println(example); // result vale 1

example -= 1;
println(example); // result vale 0

example = 2;
example *= 5;
println(example); // result vale 10

example /= 2;
println(example); // result vale 5

Equality and Relational Operators
Aquí están los operadores que usamos para las comparaciones y relaciones del tipo, es más grande que, es distinto que, etc.

== // Igual que
!= // Distinto que
> // Mayor que
>= // Mayor o igual que
< // Menor que
<= // Menor o igual que

def num1 = 1;
def num2 = 2; 
println(num1 == num2); // False
println(num1 != num2); // True
println(num1 > num2);  // False
println(num1 >= num2); // False
println(num1 < num2);  // True
println(num1 <= num2); // True

Conditional Operators
En esta sección contamos con dos operadores para las condiciones estos son el operador AND y el operador OR, estos tiene un comportamiento denominado "short-circuiting" lo cual quiere decir que si en una expresión que utilizamos el operador AND y el primer termino es false ya se deja de evaluar el resto, y si usamos un operador OR si el primero termino es verdadero tampoco se evalúa el resto.

def username = "foo";
def password = "bar";

if ((username == "foo") and (password == "bar")) {
println("Test 1: username AND password are correct"); // Test 1: username AND password are correct
}

if ((username == "") and (password == "bar")) {
println("Test 2: username AND password is correct"); // No se ejecuta este código
}

if ((username == "foo") or (password == "bar")) {
println("Test 3: username OR password is correct"); // Test 3: username OR password is correct
}

if ((username == "") or (password == "bar")) {
println("Test 4: username OR password is correct"); // Test 4: username OR password is correct
}

Type Comparison Operator
Este operador es usado para comprobar si un object es instancia de una clase o una subclase en particular. El operador instanceof devuelve true si el objeto es una instancia de la clase especificada. Devuelve false si el objeto no es una instancia de la clase especificada, o si objeto es null.

def str1="Hello";
println(str1 instanceof String); // True

def num = 1031;
println(num instanceof Integer); // False

Bueno esto fue una rápida revisión sobre los operadores en JavaFX, ahora seguiremos viendo secuencias y luego binding y triggers entre funciones para poder irnos introduciendo en la parte grafica de este poderoso lenguaje de scripting.

Saludos hasta la próxima

Modificadores de visibilidad

2009-07-23T16:59:00.071-03:00

En este post veremos los distintos tipos de visibilidad que podemos usar para las clases, variables y métodos explicaremos que modificadores aplican a cada uno y sus diferencias, como primer paso comenzaremos nombrando cuales están presente en JavaFX.

Modificadores:

Default Access

The package Access Modifier

The protected Access Modifier

The public Access Modifier

The public-read Access Modifier

The public-init Access Modifier

Default Access
Este modificador es uno que sin saberlo lo usamos en todos los ejemplos anteriores e hicimos mención a él cuando dijimos que se lo conoce como el modificador "script-only", esto quiere decir que cualquier clase, variable o función que no le definamos una visibilidad por defecto podrá ser vista desde cualquier parte del mismo script y de ningún otro lado

The Package Access Modifier
El modificador por package nos permite definir visibilidad de paquete en clases, variables o funciones , ósea nosotros podríamos tener dos archivos .fx los cuales estén el mismo paquete así que podríamos usar las cosas de uno en el otro siempre y cuando hayamos definido su visibilidad en package

Ejemplo:

script1.fx

// Aquí definimos el paquete de este script
package tutorial;

// Definimos la var message con visibilidad de paquete
package var message = "Hello from script1.fx!";

// Definimos la función también con visibilidad de paquete
package function printMessage() {
     println("{message} (in function printMessage)");
}

script2.fx

// Aquí definimos el paquete de este script
package tutorial;

// acedemos a la var message del script1
println(script1.message);

// Llamamos a la función del script1
script1.printMessage();

En el ejemplo se ve como desde un script podemos acceder a las variables o funciones de otro script si están definidos en el mismo paquete y si esas variables o funciones tienen definida una visibilidad de paquete.

The Protected Access Modifier
Con este modificador podremos definir visibilidad en variables y funciones entre el mismo paquete y entre subclases.

Ejemplo:

one.fx

// Aquí definimos el paquete de este script
package tutorial;

public class one {
protected var message = "Hello!";
}

two.fx

style="font-size:100%;">// Importamos el script one
import tutorial.one;

// Como two hereda de one y message esta
// definida como protected puede hacer a su valor
class two extends one {
function printMessage() {
println("Class two says {message}");
}
};
var t = two{};
t.printMessage();

The public Access Modifier
Al usar este modificador estamos dando la posibilidad de acceder ya sea desde cualquier clase o paquete a las clases, variables y funciones que hayan sido expuestas como públicas.
Ejemplo:

One.fx

package tutorial;
public def someMessage = "This is a public script variable, in one.fx";
public class one {
     public var message = "Hello from class one!";
     public function printMessage() {
         println("{message} (in function printMessage)");
}
}

Two.fx

import tutorial.one;
println(one.someMessage);
var o = one{};
println(o.message);
o.printMessage();

The public-read Access Modifier
Bueno los dos últimos modificadores son los más complicados a mi parecer así que prestemos atención como funciona.
Public read nos da la posibilidad que a las variables les digamos que son de solo lectura desde cualquier lado pero funciona para la escritura desde el mismo paquete, pero acá es donde está la trampa nosotros también podríamos definir que sea de solo lectura pública y definir otro scope para la escritura, esto lo logramos de tres maneras.


// Aquí estamos en el caso donde la variable
// es de solo lectura, excepto en el mismo script
public-read var example1 = 'Test';

// Aquí estamos en el caso donde la variable
// es de solo lectura, excepto para los script del mismo paquete
package public-read var example2 = 'Test';

// Aquí estamos en el caso donde la variable
// es de solo lectura, excepto para los script
// del mismo paquete o de subclases
protected public-read var example3 = 'Test';

Me parece que viendo las tres variantes de arriba nos debería quedar una idea clara de cómo funciona este modificador pero si surge alguna duda, no duden en comentar.

The public-init Access Modifier
Este es muy parecido al modificador anterior con la diferencia que este lo usamos para definir donde podemos iniciar nuestra variable.

Ejemplo

Two.fx

import tutorial.one;
var o = one {
     message: "Initialized this variable from a different package!"
}

// No compila, ya que no se definió su escritura
// así que por defecto es el mismo script
o.message = "Changing the message...";
println(o.message);

Bueno con esto hemos echado un vistazo a cada uno, en esta parte no dimos una gran explicación teórica porque creo que los ejemplos reflejan bien los conceptos y además no hay mucho más que decir acerca de estos modificadores.

En el próximo post nos concentraremos en los operadores del lenguaje veremos que son muy similares a Java, pero conviene explicarlo aunque sea brevemente y marcar las diferencias.

Saludos

Clases JavaFX

2009-07-21T20:13:00.047-03:00

El API de JavaFX ya nos provee de un gran número de clases que podemos usar en nuestras aplicaciones, sin embargo además podemos definir nuestras propias clases, en esta parte nos concentraremos en definir algunas clases y ver que nuevas variantes nos provee este lenguaje.

Una clase se declara usando la keyword class y el nombre de la clase

class Address {
var street: String;
var city: String;
var state: String;
var zip: String;
}

Como podemos observar aquí estamos definiendo la clase Address la cual consta de 4 variables que por ahora al no definir ningún modificador de visibilidad (Próximo tema ;)) tendrá la visibilidad default que se conoce como "script-only". Esto también aplica para la clase ya que no definimos su modificador de visibilidad y solo podrá ser usada desde el mismo script. Un detalle muy importante es que las clases no poseen constructores la manera de crear una instancia de alguna clase es por medio del nombre de la clase y abrir " { ... } " e inicializar las propiedades que nosotros queramos, podemos imaginar esto como que dentro del closure poseemos un Map de propiedades y ahí asignamos sus valores

def address = Address {
street: "1 Main Street";
city: "Santa Clara";
state: "CA";
zip: "95050";
}

Arriba esta la creación de una instancia de la clase Address, en la cual inicializamos sus distintas propiedades.
Clases abstractas
Al igual que en el lenguaje Java podemos definir una clase como abstracta, recordemos que una clase es abstracta si está definida como abstract class ya sea porque tiene uno o mas métodos(Funciones si nos referimos a JavaFX) , así como si no los tuviera y solo marcara la clase como abstracta.

abstract class Account {
var accountNum: Integer;
var balance: Number;

function getBalance(): Number {
   return balance;
}

function deposit(amount: Number): Void {
   balance += amount;
}

function withdraw(amount: Number): Void {
   balance -= amount;
}
}

Aquí acabamos de definir nuestra clase abstracta que provee toda la funcionalidad necesaria pero por algún motivo hemos decidido marcarla como abstracta, igual eso no nos interesa para el ejemplo, pero es bueno aclarar que esta clase podría ser concreta. Para lograr que una clase herede de otra debemos usar la palabra extends
y luego de esto ya podremos agregar más propiedades o sobre escritura de funciones o lo que necesitemos hacer.


class SimpleAccount extends Account {
   var hasOverDraftProtection: Boolean;

   override function withdraw(amount: Number) : Void {
     if(balance-amount < 0 and hasOverDraftProtection){
         balance = 0;
     } else {
         balance -= amount; // may result in negative account balance!
     }
   }
}

En el ejemplo de SimpleAccount vemos como aplicar herencia, además podemos ver el modificador override que es el encargado de sobrescribir una función, dentro de la misma función que estamos sobrescribiendo vemos como usamos a super para poder acceder a la implementación de la clase padre.

Hasta aquí no hemos encontrado muchas diferencias con Java pero ha llegado el momento de hablar de las clases Mixin.

Clases Mixin
Las clases mixin serian una mezcla de las interfaces Java junto con las clases abstracta ya que están dejan implementar y definir la implementación de las funciones, pero no podemos instanciar clases mixin.

Ejemplo:


package classpkg;

mixin class MyNameMixin {
var firstName = "John";
var lastName = "Doe";
function printName(){
    println("My name is: {firstName} {lastName}");
}
}

mixin class MyAddressMixin {
var address = "1 Main Street, Anytown USA";
function printAddress(){
    println("My address is: {address}");
}
}

class MyContact extends MyNameMixin, MyAddressMixin { }

def myContact = MyContact{};
myContact.printName();
myContact.printAddress();

En este ejemplo estamos definiendo dos clases mixin las cuales tiene propiedades y funciones propias y aunque no se puede crear nuevas instancias de ellas podemos usarla para lograr una herencia múltiple.

Les dejo una lista de reglas sobre las clases:

Las clases Mixin no pueden ser instanciadas
Las clases Mixin solo pueden heredar de clases Mixin o interfaces
Las clases Mixin permiten extender cualquier numero de interfaces o clases Mixin
Las clases JavaFX solo pueden heredar de una clase JavaFX ya que está basado en Java

Bueno con esto terminamos este post, el proximo tema sera sobre los modificadores de visibilidad, espero se haya entendido todo y no hayan quedados dudas, cualquier cosa comenten

Saludos

Tipos de datos

2009-07-19T12:10:00.047-03:00

Hola como están, seguimos acá investigando JavaFX y empezaremos a ver sus tipos de datos y aprenderemos como trabajar con ellos.
Bien, comencemos

Tipos de datos:

String
Number and Integer
Boolean
Duration
Void
Null

String:
Es el tipo de dato que debemos usar para guardar representación de caracteres, prácticamente funcionan igual que en java pero aquí encontraremos algunas diferencias.

Declaración e inicialización

var cadena1 = 'Cadena 1';
var cadena2 = "Cadena 1";

Como podemos notar aquí esta permitido inicializar o asignar un String ya sea con comillas dobles o comillas simples en cambio en Java solo podíamos hacerlo con comillas dobles. Además si notamos no es necesario decirle que es del tipo String y este tipo ya se asigna automáticamente.

Muchas veces deseamos concatenar distintas variables del tipo String, en JavaFX esto se puede
resolver usando dentro de los " " un closure en el cual se evalúa el String y este es concatenado
en la nuevo String, veamos un ejemplo para aclarar esto

def nombre = 'Joe';
var resultado = "Hello {nombre}";
println(resultado);

Si ejecutamos este código veremos que aparece por consola la frase "Hello Joe" ya que la variable resultado es una referencia al nuevo String que se genera

Nota: Se le llama closure al hecho de que se creen referencias de las variables locales de donde se definió el closure, en el propio closure -Mínima explicación-

def valor = true;
var respuesta = "The answer is {if (valor) "Yes" else "No"}";

Como vemos aquí estamos definiendo un closure con un if que devuelve "Yes" or "No" podríamos pensar esto como una función que recibe como parámetro la variable valor, en cambio aquí simplemente el closure tiene acceso a las referencias desde donde el ha sido definido.

Para no hacerla largo con los String mostraremos el último ejemplo donde veremos como se concatenan dos referencias a String

def frase1 = "This example ";
def frase2 = "joins two strings.";
def fraseFinal = "{frase1}{frase2}";
println(fraseFinal);

Number and Integer:
Estos tipos de datos son los referidos a los tipos numéricos y vamos a distinguir dos tipos los números enteros y los de punto flotante.

def numeroUno = 1.0; // Aquí el compilador infiere el tipo de dato Number
def numeroDos = 1;   // Aquí el compilador infiere el tipo de dato Integer

// Aquí hacemos una declaración explicita
def numeroTres : Number = 1.0;
def numeroCuatro : Integer = 1;

Usualmente se recomienda usar el tipo Integer y dejar el tipo Number solo para
los casos realmente necesarios.

Boolean:
Este valor es igual al tipo Boolean de Java y acepta los valores true/false.

if (isAsleep) {
  wakeUp();
}

El código que ingresemos dentro de "( )" será evaluado en cambio el código ingresado dentro de "{ }" será ejecutado

Duration:
Este es un tipo especial de JavaFX que se encarga de representar una unidad de tiempo

5ms; // 5 milliseconds
10s; // 10 seconds
30m; // 30 minutes
1h;  // 1 hour

Veremos con mayor detenimiento este tipo cuando empecemos a usar Animaciones ya que ahí queremos que en distintos momentos de un Time Line se ejecuten diversas acciones.

Void:
Creo que este ya es conocido por todos, pero diremos que es el tipo que usamos para indicar que una función no retorna ningún valor.

function imprimir() : Void {
  println("Esta funcion no retorna nada!");
}
function imprimir() {
  println("Esta funcion no retorna nada!");
}

Como podemos notar tenemos dos formas que son validas para indicar que la función no retorna ningún valor, ya sea explícitamente con el : Void o implícitamente sin indicar su tipo de retorno

Null:
Este tipo es especial ya que nos permite indicar la falta de un valor normal, cuando declaramos variables están podrían estar referenciando datos no validos.

Estos serian los 6 tipos de datos que se encuentran dentro de JavaFX, ahora solo nos queda empezar a trabajar mas con ellos e ir conociéndolos, ya veremos como son declarados dentro de clases y sus formas de acceso.

Saludos

Comenzando con JavaFX en Windows

2009-07-18T15:56:00.051-03:00

Bueno empezaremos con una serie de post acerca de JavaFX. Esta tecnologia sale al mercado para competir contra Flex y Silverlight, todavía está en duda si esta tecnología lograra el lugar que busca, pero me parece un buen momento para empezar a descubrirla.

Partiremos desde lo mas básico, instalando las librerías y buscando que IDE usar hasta que podamos hacer ejemplos donde podamos ir viendo el poder que nos ofrece este nuevo lenguaje de scripting. Para no hacer más largo este primer post paso a comentarles los pasos necesarios para preparar nuestras maquinas para trabajar

Pasos:

Entraremos al sitio oficial para ver las versiones y hacer las descargas correspondientes
http://www.javafx.com/

En la página de JavaFX encontraremos diversas cosas que podremos bajarnos, daremos una breve explicación de cada una (JavaFX versión 1.2 al momento de escribir esta nota)

JavaFX 1.2 SDK: Al bajar esto estamos bajando el Software Development Kit el cual es un instalador parecido al que ejecutamos al instalar el JDK en nuestras maquinas donde se copiaran las librerías necesarias para desarrollo y además podremos ejecutar los comandos de JavaFX desde la consola de Windows
JavaFX 1.2 Production Suite: Esto es un conjunto de herramientas para los diseñadores que facilita el proceso de incorporación de imágenes en aplicaciones JavaFX
NetBeans IDE 6.5.1 for JavaFX 1.2: Bueno como ya sabrán unos de los IDE más populares para Java en su versión 6.5.1 trae incorporado JavaFX con algunas facilidades para el desarrollo, también hay un plugin para el eclipse pero ciertamente no lo he probado.

Haremos un ejemplo básico para mostrar algunas características básicas y usaremos la consola para compilar y ejecutar nuestro ejemplo, veremos que los archivos no tienen una extensión java sino que poseen su propia extensión .fx igual estos son compilados a bytecode que quedan en archivos .class y luego serán ejecutados por la JVM.
Como primer paso debemos instalar el SDK y probar que la consola nos reconoce lo comandos javafxc y javafx, no debería haber problema alguno con esto pero si alguien tiene algún problema que comente y buscamos el porqué.

Para el ejemplo yo eh creado una carpeta llamada JavaFX donde dejare la siguiente estructura de directorios

C:\JavaFX\maintest\Main.fx

Archivo Main.fx:



package maintest;
// Define Address class.
class Address {
var street: String;
var city: String;
var state: String;
var zip: String;
}

// Create the first Address object instance.
var addressOne = Address {
street: "1 Main Street";
city: "Santa Clara";
state: "CA";
zip: "95050";
}

// Create the second Address object instance.
def addressTwo = Address {
street: "200 Pine Street";
city: "San Francisco";
state: "CA";
zip: "94101";
}

function run(args : String[]) {
for (arg in args) {
  println("Parameters = {arg}");
}
println("Street One = {addressOne.street}");
println("Street Two = {addressTwo.street}");
}

Ahora más adelante explicaremos cada parte del código, este sería nuestro archivo Main.fx ahora lo compilaremos por medio de la consola, abrimos una consola de comandos y nos situaremos en C:\JavaFX.

Compilar paso 1:
Situados en el directorio anteriormente dicho escribimos lo siguiente
javafxc "maintest/Main.fx" esto nos genera los .class necesarios para poder ejecutar el ejemplo

Ejecutar paso 2:
Situados en el mismo directorio anterior escribimos
javafx maintest.Main 9 2 de esta forma estaremos ejecutando nuestro ejemplo pasándole dos parámetros el primero un String que contiene 9 y el segundo un String que contiene el 2.

Explicación básica del código:

Parte 1:


class Address {
var street: String;
var city: String;
var state: String;
var zip: String;
}

Aquí estamos definiendo la clase Address la cual tendrá 4 variables que se indican con la palabra reservada var "elNombreDeLaVariable" : "suTipoDeDato"

Parte 2 y 3:


// Create the first Address object instance.
var addressOne = Address {
street: "1 Main Street";
city: "Santa Clara";
state: "CA";
zip: "95050";
}

// Create the second Address object instance.
def addressTwo = Address {
street: "200 Pine Street";
city: "San Francisco";
state: "CA";
zip: "94101";
}

En ambos casos estamos declarando referencias a objetos del Tipo Address donde usamos { ... } como se usaría un constructor donde inicializamos los distintos valores de la clase, la diferencia importante entre estas dos referencias son que una se declaro con la palabra reservada var y la otra con def. Esto quiero decir que la que se declaro con def seria una referencia del tipo final y no puede cambiar durante la ejecución del script.

Parte 4:


function run(args : String[]) {
for (arg in args) {
  println("Parameters = {arg}");
}
println("Street One = {addressOne.street}");
println("Street Two = {addressTwo.street}");
}

Aquí estamos definiendo la función run que sería el equivalente al main de una clase Java y recibe un array de argumento de longitud variable, en la primer línea iteramos sobre los argumentos y mostramos sus valores en las otras dos imprimimos los valores de las distintas direcciones para lograr imprimirlo se usa {addressOne.street} de manera que fuera un closure.

Bueno esto fue todo por este post por cualquier duda que posiblemente haya espero los comentarios y en qué forma se podría mejorar el post.
En próximas entradas veremos los tipos de datos de JavaFX así como en más detalles sus distintas características.

Saludos