jueves, 20 de noviembre de 2008

¡Qué movida de semana en Adobe Labs! (parte 2)

Me he enterado ahora mismo... y sirve para demostrar lo que he comentado en un artículo anterior sobre el frenesí en la liberación de nuevas versiones de productos por parte de Adobe Labs.

Han liberado nuevas versiones de Blaze DS (la 3.2) y también de LCDS, este último me interesa mucho menos.

Lo sorprendente es que no añaden nada nuevo, simplemente solucionan algunos bugs de la versión anterior (y no muchos, además). Mira las notas de la revisión.

Flex 3.2 y locale es_ES... por fin, Flex 3.2 en español!

En el siguiente enlace FLEXSDK32-framework-locale-es_ES.zip
os dejo un .zip que podéis descomprimir en el directorio de vuestro Flex SDK 3.2 (primero creáis un directorio "es_ES" dentro del directorio "frameworks/locale" y luego copiáis allí los tres ficheros .swc que os dejo dentro del .zip) y simplemente añadiendo la siguiente opción al compilador "-locale es_ES" tendréis resuelto el asunto... al menos, el asunto español ;-)

También podéis modificar el fichero /frameworks/flex-config.xml para activar esta localización como la localización por defecto de vuestras compilaciones (es sencillo encontrar el lugar).

También podemos activar esta localización en el Flex Builder 3.0.2, que realmente utiliza un SDK que viene dentro del directorio "sdks" donde esté instalado este impresionante entorno de desarrollo.

Os dejo las versiones anteriores de estas "localizaciones" en:

¡Qué movida de semana en Adobe Labs!

Parece que en épocas de crisis económicas los empleados de las grandes compañías se ven obligados a rendir al máximo de sus posibilidades, para que sus contratos no se vean "comprometidos" y demostrar así, a sus jefes, la necesidad de su existencia.

Esto es lo que debe estar ocurriendo con la gente de Adobe, sino no se entiende lo que ha ocurrido esta semana en estos laboratorios:
  • Han liberado una nueva versión del Flex SDK (la 3.2) y del Flex Builder (la 3.0.2)
  • Han liberado una nueva versión de AIR y del Air SDK (la 1.5)
  • Han liberado una herramienta de apoyo a desarrolladores TourDeFlex desarrollada en Air. Es un repositorio lleno de ejemplos y soluciones.
  • Anuncian Genesis como una nueva iniciativa para unir aplicaciones, documentos, conocimientos y facilitar la colaboración.
ADEMÁS, liberan o anuncian nuevas versiones de: PixelBender (para procesar video e imagen), Flash Player 10 para Linux, Wave (una aplicación y un servicio para habilitar notificaciones en escritorio), Cocomo (para añadir capacidades sociales en nuestras aplicaciones RIA), Stratus (un servicio para establecer comunicaciones entre Flash Player endpoints), Catalyst antes Thermo (una herramienta para la creación de interfaces sin necesidad de utilizar código), Alchemy (para compilar código C y C++ dentro de librerías AS), Centaur (la próxima versión de ColdFusion), Bolt (nueva herramienta para desarrolladores ColdFusion, basada en Eclipse), Configurator (para la creación de paneles y paletas para usar en Photoshop), Durango (un framework para Air) y PathPanel (una librería para Flex y un conjunto de servicios que hacen posible que los ficheros SWF trabajen como plugins CS).

¡Qué frenesí!

lunes, 29 de septiembre de 2008

Desarrollando con Flex, flexmdi, PureMVC, BlazeDS, Spring, JPA, Hibernate,... (parte 9)

Comenzaremos, en este artículo, con la creación de las tablas (el script funciona para MySQL pero, es sencillo adaptarlo a otras bases de datos) y de los DAOs (Data Access Object) u objetos Java de acceso a datos, de nuestra aplicación Mocky.

Suponiendo que nuestra MySQL está ya perfectamente instalada, abriremos una consola y escribiremos:
shell> mysql -u root -p
Enter password: *********
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 3
Server version: 5.0.51b-community-nt MySQL Community Edition (GPL)

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> create database mocky;
Query OK, 1 row affected (0.00 sec)

mysql> use mocky;
Database changed
Con esto nuestra base de datos estará ya creada y podremos comenzar a crear las primeras tablas e insertar sus registros:
CREATE TABLE `mk_rol` (
`idrol` decimal(22,0) NOT NULL,
`nombre` varchar(100) NOT NULL,
`activo` decimal(22,0) NOT NULL,
PRIMARY KEY (`idrol`)
);

INSERT INTO `mk_rol` values (1, 'Administrador', 1);
INSERT INTO `mk_rol` values (2, 'Usuario', 1);

CREATE TABLE `mk_rolrol` (
`idrolpadre` decimal(22,0) NOT NULL,
`idrolhijo` decimal(22,0) NOT NULL,
PRIMARY KEY (`idrolpadre`,`idrolhijo`)
);

INSERT INTO `mk_rolrol` values (1, 2);

CREATE TABLE `mk_usuario` (
`idusuario` decimal(22,0) NOT NULL,
`nombreusuario` varchar(50) NOT NULL,
`password` varchar(50) NOT NULL,
`nombrereal` varchar(100) NOT NULL,
`activo` decimal(22,0) NOT NULL,
PRIMARY KEY (`idusuario`)
);

INSERT INTO `mk_usuario` values (1, 'admin', 'cambiala', 'Administrador 1', 1);
INSERT INTO `mk_usuario` values (2, 'user', 'cambiala', 'Usuario 1', 1);

CREATE TABLE `mk_usuariorol` (
`idusuario` decimal(22,0) NOT NULL,
`idrol` decimal(22,0) NOT NULL,
PRIMARY KEY (`idusuario`,`idrol`)
);

INSERT INTO `mk_usuariorol` values (1, 1);
INSERT INTO `mk_usuariorol` values (2, 2);
El modelo de datos es muy sencillo, con el script anterior hemos creado cuatro tablas que guardarán el modelo de datos para la seguridad:
  1. mk_rol: son los distintos roles de usuario de nuestra aplicación.
  2. mk_rolrol: un árbol de roles, para que un rol pueda heredar los permisos de otros.
  3. mk_usuario: son los distintos usuarios de la aplicación.
  4. mk_usuariorol: asigna roles a los usuarios.
Alguna de estas tablas tienen un campo "activo", que indica si el registro es válido o si no debería tenerse en cuenta (1=válido, 0=no válido).

Ahora seguiremos los siguientes pasos para construir los objetos de acceso a datos, utilizando para ello JPA:

  1. Con nuestro Eclipse abierto, seleccionaremos el proyecto mocky que, como recordaremos, tiene las clases Java de nuestra aplicación.
  2. Pinchando con el botón derecho del ratón sobre el proyecto y seleccionando "New-Package" crearemos un nuevo paquete.
  3. En la siguiente ventana, en el campo "Name" introduciremos el valor "org.wika2.mocky.model" y pulsaremos el botón "Finish".
  4. Repetiremos el proceso para los siguientes dos paquetes "org.wika2.mocky.dao.jpa" y "org.wika2.mocky.service.impl".
  5. Crearemos nuestra primera clase de modelo Java, pinchando con el botón derecho del ratón sobre la carpeta de fuentes "src" y seleccionando "New-Class".
  6. En la siguiente ventana, en el campo "Package" introduciremos el valor "org.wika2.mocky.model" y en el nombre de la clase (campo "Name") vamos a poner "MkRol". El resto de los campos los dejaremos "tal cual" y pulsaremos el botón "Finish".
Se nos abrirá el editor de textos, donde pegaremos el siguiente código Java:
package org.wika2.mocky.model;

import javax.persistence.*;

@Entity
@Table(name = "MK_ROL")
public class MkRol implements java.io.Serializable {

private Integer idRol;
private String nombre;
private Integer activo;

public MkRol() {
}

public MkRol(Integer idRol, String nombre, Integer activo) {
this.idRol = idRol;
this.nombre = nombre;
this.activo = activo;
}

@Column(name = "ACTIVO", nullable = false, precision = 22, scale = 0)
public Integer getActivo() {
return this.activo;
}

@Id
@GeneratedValue(strategy = GenerationType.TABLE, generator = "MK_ROL_TG")
@TableGenerator(allocationSize = 1, name = "MK_ROL_TG", table = "MK_SEQUENCETABLE", pkColumnName = "SEQ_NAME", valueColumnName = "SEQ_COUNT", pkColumnValue = "MK_ROL")
@Column(name = "IDROL", unique = true, nullable = false, precision = 22, scale = 0)
public Integer getIdRol() {
return this.idRol;
}

@Column(name = "NOMBRE", nullable = false, length = 100)
public String getNombre() {
return this.nombre;
}

public void setActivo(Integer activo) {
this.activo = activo;
}

public void setIdRol(Integer idRol) {
this.idRol = idRol;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

}
Como podemos observar, hemos declarado, mediante anotaciones JPA, que esta clase es una entidad "@Entity" que corresponde con una tabla de una base de datos "@Table" con tres columnas "@Column", una de las cuales es el identificador "@Id" de la misma.

La columna identificador (corresponde con la PrimaryKey de la tabla MySQL) tiene un generador de valores únicos, controlado por JPA mediante la declaración de las anotaciones @GeneratedValue y @TableGenerator. Este generador de valores únicos utiliza una nueva tabla MySQL que tiene el valor siguiente, mantenido automáticamente, a utilizar por cada entidad de nuestra aplicación.

El delegar la generación de identificadores en una tabla puede ocasionar, quizá, problemas de rendimiento... pero es la manera más cómoda de independizar nuestro desarrollo del gestor de datos.

Debemos crear en nuestra MySQL esta nueva tabla, utilizando el siguiente script:
CREATE TABLE `mk_sequencetable` (
`seq_name` varchar(100) NOT NULL,
`seq_count` decimal(22,0) NOT NULL,
PRIMARY KEY (`seq_name`)
);

INSERT INTO `mk_sequencetable` values ('MK_ROL', 1);
INSERT INTO `mk_sequencetable` values ('MK_ROLROL', 1);
INSERT INTO `mk_sequencetable` values ('MK_USUARIO', 1);
INSERT INTO `mk_sequencetable` values ('MK_USUARIOROL', 1);
La columna "seq_name" contiene un nombre único para la secuencia (que yo hago coincidir con el nombre de la tabla) y el "seq_count" contiene el siguiente valor (comenzando por 1 pero serviría cualquier número) a asignar al identificador de esa tabla.

lunes, 22 de septiembre de 2008

Una buena noticia: Oracle sí elige, finalmente, Flex

Hace unos meses, casi ya un año, os anuncié, en un artículo anterior, el rumor de que Oracle apostaba por Flex para el nuevo desarrollo de Metalink y del Enterprise Manager, entre otros de sus productos.

Se han hecho esperar pero, por fin ha visto la luz -yo lo he descubierto esta misma mañana- el nuevo Metalink. Por supuesto, aunque nadie lo diga explicitamente, se deja notar que Flex ha sido la tecnología -no creo equivocarme- que subyace bajo este nuevo producto.

Una interesante noticia para los desarrolladores de Flex, que ven su apuesta reforzada por compañías como Oracle, y también una buena noticia para los usuarios de Oracle Metalink, su centro de soporte.

jueves, 4 de septiembre de 2008

Aprendiendo idiomas, problemas antiguos, métodos modernos

El otro día comentábamos, en el trabajo, sobre los diferentes (e infructuosos) métodos que todos nosotros hemos probado alguna vez para aprender idiomas: en el colegio, por fascículos, en academias, con aupairs, unos meses en el extranjero, escuchando la radio, etc.

Alguno de estos métodos los volvemos a probar con nuestros hijos, dando así al método una segunda oportunidad (¿para fracasar?).

Pues siendo que los padres de nuestros hijos son tecnólogos y que nuestros hijos son hijos de la tecnología... deberíamos utilizar métodos más modernos.

Hoy lo que está de moda son las redes sociales y también el aprendizaje de idiomas es 2.0

Algunos ejemplos:

http://www.livemocha.com
http://www.soziety.com
http://www.palabea.net

Este último tiene muy buena pinta, aunque yo no los he probado y solo tengo referencias. Se basan en el "intercambio de nativos" ;-) Nosotros somos nativos hispanohablantes y estableceremos contactos con otros nativos de aquellos idiomas que queremos aprender.

Se utiliza, en muchos de ellos, Skype o productos similares y, además de aprender, se puede "ligar" que siempre ha sido el mejor método para aprender idiomas.

Para los críos/adolescentes, ya que el control de edades es más rígido, se ha puesto de moda el "Hotel Habbo" (http://www.habbo.com), aunque la finalidad no es estrictamente el aprendizaje de idiomas.

miércoles, 3 de septiembre de 2008

Google Chrome: un nuevo navegador para la web

Google ha publicado hoy, en fase beta, lo que será su más próxima y "sonada" novedad... un nuevo navegador web llamado "Google Chrome".

Personalmente no entiendo muy bien el sentido de "esto" a día de hoy, aunque puedo intuirlo...

Por una parte, Google dona cantidad de dinero a la organización Mozilla para que ésta, entre otras cosas, mejore el desarrollo de Firefox y lo convierta en un rival, no mejor que ya lo es, que le robe cuota de mercado a IE.

El movimiento, supongo que, quizá tendrá que ver con alguna estrategia de Google para lanzar a Chrome como el navegador ideal para la telefonía móvil y ocupar una posición privilegia en este tipo de dispositivos (dispositivos que se convertirán en los futuros puntos de acceso universales a Internet).

Un movimiento similar a lo que hizo cuando anunció el SDK Android y que solo pretende dar un toque de atención (a veces en beneficio y a veces en perjuicio de los usuarios) a Sun, Microsoft, Apple, ...

La buena noticia: tiene muy buena pinta, es muy sencillo y agradable de usar. Está basado en el motor webkit (http://webkit.org) que es el mismo utilizado por Safari.

La mala noticia: si tiene éxito, otro más para comprobar la compatibilidad de nuestros desarrollos: IE, Firefox, Opera, Konqueror, Safari, ... y ahora Chrome. Tampoco aporta ninguna novedad frente a la competencia.

Más en: http://www.google.com/chrome

De momento solo disponible para Windows, pero se dice que en próximos días verán la luz las versiones Linux y Mac.

martes, 26 de agosto de 2008

Desarrollando con Flex, flexmdi, PureMVC, BlazeDS, Spring, JPA, Hibernate,... (parte 8)

Pasos para crear el fichero de distribución swf, la parte Flex del proyecto Mocky:
  1. Añadiremos al proyecto "flex-mocky" un nuevo fichero de nombre "build.properties", con la siguientes 8 líneas:
    # Propiedades del proyecto
    company.name=Wika2.org
    project.name=flex-mocky
    project.version=1.0.0
    project.refs=wika2-fframework-1.0.0
    project.mxml=Mocky
    project.blazeds.service.config=mocky
    project.blazeds.context.root=mocky
    Las tres primeras propiedades, se entienden fácilmente, son: la primera es el nombre de la empresa -se utiliza para rellenar la metainformación del swf que vamos a generar- y las dos siguientes se utilizan para crear el nombre del fichero ".swf" con la distribución de este proyecto. La propiedad project-refs es una lista (separada por ",") de las librerías "swc" que forman parte de este ".swf" creado, se copiarán en la carpeta "libs" del proyecto antes de compilarse. La propiedad project.mxml indica el nombre del fichero ".mxml" principal de la aplicación. Las dos siguientes propiedades, relacionadas con BlazeDS, las utilizaremos más adelante.
  2. Añadiremos al mismo proyecto un nuevo fichero de nombre "build.xml" con el siguiente contenido:
    <?xml version="1.0"?>

    <project name="flex-mocky" default="dist" basedir=".">

    <!-- Lectura de propiedades externas -->
    <property file="build.properties"/>

    <!-- Propiedades globales para este build -->
    <property environment="env"/>
    <property name="FLEX_HOME" value="${env.FLEX_HOME}"/>
    <property name="dist.dir" value="bin-release"/>
    <property name="doc.dir" value="asdoc"/>
    <property name="src.dir" value="src"/>
    <property name="html.template.dir" value="html-template"/>

    <!-- Declaracion del classpath -->
    <path id="project.classpath">
    <fileset dir="../3rdparty/ant">
    <include name="**/*.jar"/>
    <include name="**/*.zip"/>
    </fileset>
    <fileset dir="../3rdparty/lib">
    <include name="**/*.jar"/>
    <include name="**/*.zip"/>
    </fileset>
    </path>

    <!-- Tareas -->
    <taskdef resource="net/sf/antcontrib/antcontrib.properties"
    classpathref="project.classpath"/>

    <taskdef resource="flexTasks.tasks"
    classpathref="project.classpath"/>

    <!-- Limpieza -->
    <target name="clean">
    <delete dir="${dist.dir}"/>
    <delete dir="${doc.dir}"/>
    </target>

    <!-- Generar la documentacion -->
    <target name="asdoc">
    <delete includeemptydirs="yes" failonerror="false">
    <fileset dir="${doc.dir}" includes="**/*"/>
    </delete>
    <mkdir dir="${doc.dir}"/>
    <exec executable="${env.FLEX_HOME}\bin\asdoc.exe" failonerror="true">
    <arg line="-doc-sources ${src.dir}/com"/>
    <arg line="-external-library-path 'libs'"/>
    <arg line="-main-title '${project.name} API Documentation'"/>
    <arg line="-output ${doc.dir}"/>
    <arg line="-source-path ${src.dir}"/>
    <arg line="-window-title '${project.name}'"/>
    </exec>
    </target>

    <!-- Generar los Flex de la aplicacion -->
    <target name="dist">
    <!-- Copiar los proyectos referenciados -->
    <foreach list="${project.refs}" param="project.ref" target="update.lib"/>
    <!-- Crear el swf -->
    <mxmlc file="${basedir}/${src.dir}/${project.mxml}.mxml"
    debug="false"
    locale="es_ES"
    optimize="true"
    output="${dist.dir}/${project.mxml}.swf">
    <load-config filename="${env.FLEX_HOME}/frameworks/flex-config.xml"/>
    <source-path path-element="${env.FLEX_HOME}/frameworks"/>
    <compiler.source-path path-element="${basedir}/${src.dir}"/>
    <compiler.library-path dir="libs" append="true">
    <include name="*.swc"/>
    </compiler.library-path>
    <metadata description="FLEX ${project.name}">
    <contributor name="${company.name}"/>
    </metadata>
    </mxmlc>
    <!-- Generar la carpeta con la plantilla html -->
    <html-wrapper title="${project.mxml}"
    application="${project.mxml}"
    bgcolor="#869ca7"
    height="100%"
    history="true"
    output="${dist.dir}"
    swf="${project.mxml}"
    template="express-installation"
    version-major="9"
    version-minor="0"
    version-revision="28"
    width="100%"/>
    </target>

    <!-- Tareas auxilares para el mantenimiento correcto del proyecto -->
    <target name="update.lib">
    <copy file="../3rdparty/lib/${project.ref}.swc" todir="libs"/>
    </target>

    </project>
  3. Tengo 3 targets definidos en este fichero de construcción: clean, asdoc y dist. Utilizaremos "dist" que, además de compilar, nos creará un fichero "project.name-project.version.swf" en una nueva carpeta "bin-release" que aparecerá dentro en la carpeta del proyecto.
  4. Pincharemos con el botón derecho del ratón sobre el "build.xml", en el "Project Explorer" de nuestro Eclipse, y seleccionaremos el menú "Rus As-Ant Build" y comenzará el proceso de creación del fichero de distribución, que podremos seguir en la "Console". El target "dist" está definido como target por defecto ;-) en el fichero de contrucción.
  5. Deberíamos obtener "algo" como lo siguiente:
    Buildfile: C:\Desarrollo\Mocky\flex-mocky\build.xml
    dist:
    update.lib:
    [mxmlc] Loading configuration file C:\Desarrollo\Mocky\flex_sdk_3.0.0.477_mpl\frameworks\flex-config.xml
    [mxmlc] C:\Desarrollo\Mocky\flex-mocky\bin-release\Mocky.swf (150640 bytes)
    BUILD SUCCESSFUL
    Total time: 13 seconds
  6. Ahora, podemos refrescar el proyecto el proyecto "flex-mocky", para ver cómo ha quedado.
  7. Como podéis observar, además de compilar el proyecto, lo ha copiado a la carpeta de distribución "bin-release" del proyecto "flex-mocky".
Pasos para crear el fichero de distribución war, del proyecto Mocky, listo para desplegarse en nuestro servidor de aplicaciones:
  1. Añadiremos al proyecto "mocky" un nuevo fichero de nombre "build.properties", con la siguientes 6 líneas:
    # Propiedades del proyecto
    company.name=Wika2.org
    project.name=mocky
    project.version=1.0.0
    project.refs=wika2-jframework-1.0.0
    project.flex.folder=../flex-mocky
    Las tres primeras propiedades, se entienden fácilmente, son: la primera es el nombre de la empresa -se utiliza en la creación de los ficheros "MANIFEST.MF"- y las dos siguientes se utilizan para crear el nombre del fichero ".war" con la distribución de este proyecto. La propiedad project-refs es una lista (separada por ",") de las librerías "jar" que forman parte de este ".war" creado, se copiarán en la carpeta "WEBINF/lib" del proyecto antes de compilarse. La propiedad project.flex.folder indica el path, relativo al proyecto actual, al directorio del proyecto que tiene la parte Flex de la aplicación.
  2. Añadiremos al mismo proyecto un nuevo fichero de nombre "build.xml" con el siguiente contenido:
    <?xml version="1.0"?>

    <project name="mocky" default="dist" basedir=".">

    <!-- Lectura de propiedades externas -->
    <property file="build.properties"/>

    <!-- Propiedades globales para este build -->
    <property environment="env"/>
    <property name="build.dir" value="build/classes"/>
    <property name="dist.dir" value="dist"/>
    <property name="doc.dir" value="javadoc"/>
    <property name="src.dir" value="src"/>

    <!-- Condiciones -->
    <condition property="3rdparty.available">
    <available file="../3rdparty/lib/${project.name}-${project.version}.jar"/>
    </condition>

    <!-- Declaracion del classpath -->
    <path id="project.classpath">
    <fileset dir="../3rdparty/ant">
    <include name="**/*.jar"/>
    <include name="**/*.zip"/>
    </fileset>
    <fileset dir="../3rdparty/lib">
    <include name="**/*.jar"/>
    <include name="**/*.zip"/>
    </fileset>
    <fileset dir="WebContent/WEB-INF/lib">
    <include name="**/*.jar"/>
    <include name="**/*.zip"/>
    </fileset>
    </path>

    <!-- Enlaces utiles -->
    <patternset id="meta.files">
    <include name="**/*.dtd"/>
    <include name="**/*.properties"/>
    <include name="**/*.xml"/>
    </patternset>

    <!-- Tareas -->
    <taskdef resource="net/sf/antcontrib/antcontrib.properties"
    classpathref="project.classpath"/>

    <!-- Limpieza -->
    <target name="clean">
    <delete dir="${build.dir}"/>
    <delete dir="${dist.dir}"/>
    <delete dir="${doc.dir}"/>
    </target>

    <!-- Compilar los fuentes Java -->
    <target name="compile">
    <delete includeemptydirs="yes" failonerror="false">
    <fileset dir="${build.dir}" includes="**/*"/>
    </delete>
    <mkdir dir="${build.dir}"/>
    <javac srcdir="${src.dir}" destdir="${build.dir}" nowarn="on">
    <classpath refid="project.classpath"/>
    </javac>
    <!-- Copiar los metadatos al classpath de este build -->
    <copy todir="${build.dir}">
    <fileset dir="${src.dir}">
    <patternset refid="meta.files"/>
    </fileset>
    </copy>
    </target>

    <!-- Generar la documentacion -->
    <target name="javadoc">
    <delete includeemptydirs="yes" failonerror="false">
    <fileset dir="${doc.dir}" includes="**/*"/>
    </delete>
    <mkdir dir="${doc.dir}"/>
    <javadoc destdir="${doc.dir}" >
    <classpath refid="project.classpath"/>
    <fileset dir="${src.dir}">
    <include name="**/*.java"/>
    </fileset>
    </javadoc>
    </target>

    <!-- Generar el fichero de distribucion -->
    <target name="dist" depends="compile">
    <!-- Borra los ficheros de distribucion antiguos -->
    <delete includeemptydirs="yes" failonerror="false">
    <fileset dir="${dist.dir}" includes="**/*"/>
    </delete>
    <mkdir dir="${dist.dir}"/>
    <!-- Empaqueta en un jar los fuentes compilados del proyecto -->
    <jar destfile="${dist.dir}/${project.name}-${project.version}.jar" basedir="${build.dir}">
    <manifest>
    <attribute name="Built-By" value="${company.name}"/>
    <attribute name="Implementation-Title" value="${project.name}"/>
    <attribute name="Implementation-Version" value="${project.version}"/>
    </manifest>
    </jar>
    <!-- Copiar el fichero de distribucion al proyecto de 3rdparty -->
    <if>
    <available file="../3rdparty/lib/${project.name}-*.jar"/>
    <then>
    <delete>
    <fileset dir="../3rdparty/lib" includes="${project.name}-*.jar"/>
    </delete>
    </then>
    </if>
    <copy file="${dist.dir}/${project.name}-${project.version}.jar" todir="../3rdparty/lib"/>
    <!-- Copiar la carpeta del proyecto flex -->
    <copy todir="WebContent">
    <fileset dir="${project.flex.folder}/bin-release">
    <include name="**/*"/>
    </fileset>
    </copy>
    <delete dir="WebContent/assets"/>
    <if>
    <available file="${project.flex.folder}/src/assets" type="dir"/>
    <then>
    <copy todir="WebContent/assets">
    <fileset dir="${project.flex.folder}/src/assets">
    <include name="**/*"/>
    <exclude name="**/*.xml"/>
    </fileset>
    </copy>
    <copy todir="WebContent/assets">
    <fileset dir="${project.flex.folder}/src/assets">
    <include name="**/*.xml"/>
    </fileset>
    <filterset>
    <filter token="development" value="false"/>
    </filterset>
    </copy>
    </then>
    </if>
    <!-- Copiar los proyectos referenciados -->
    <foreach list="${project.refs}" param="project.ref" target="update.webinflib"/>
    <!-- Crear el war -->
    <war destfile="${dist.dir}/${project.name}-${project.version}.war" webxml="WebContent/WEB-INF/web.xml">
    <manifest>
    <attribute name="Built-By" value="${company.name}"/>
    <attribute name="Implementation-Title" value="${project.name}"/>
    <attribute name="Implementation-Version" value="${project.version}"/>
    </manifest>
    <fileset dir="WebContent">
    <exclude name="**/.*"/>
    <exclude name="META-INF/*.xml"/>
    <exclude name="WEB-INF/web.xml"/>
    </fileset>
    <lib dir="${dist.dir}">
    <include name="${project.name}-${project.version}.jar"/>
    </lib>
    </war>
    <!-- Copiar el fichero de distribucion -->
    <copy file="${dist.dir}/${project.name}-${project.version}.war" todir="../dist"/>
    </target>

    <!-- Tareas auxilares para el mantenimiento correcto del proyecto -->
    <target name="update.webinflib">
    <copy file="../3rdparty/lib/${project.ref}.jar" todir="WebContent/WEB-INF/lib"/>
    </target>

    </project>
  3. Tengo 4 targets definidos en este fichero de construcción: clean, compile, javadoc y dist. Utilizaremos "dist" que, además de compilar, nos creará un fichero "project.name-project.version.war" en una nueva carpeta "dist" que aparecerá dentro en la carpeta del proyecto.
  4. Pincharemos con el botón derecho del ratón sobre el "build.xml", en el "Project Explorer" de nuestro Eclipse, y seleccionaremos el menú "Rus As-Ant Build" y comenzará el proceso de creación del fichero de distribución, que podremos seguir en la "Console". El target "dist" está definido como target por defecto ;-) en el fichero de contrucción.
  5. Deberíamos obtener "algo" como lo siguiente:
    Buildfile: C:\Desarrollo\Mocky\mocky\build.xml
    compile:
    [javac] Compiling 1 source file to C:\Desarrollo\Mocky\mocky\build\classes
    dist:
    [jar] Building jar: C:\Desarrollo\Mocky\mocky\dist\mocky-1.0.0.jar
    [copy] Copying 1 file to C:\Desarrollo\Mocky\3rdparty\lib
    update.webinflib:
    [war] Building war: C:\Desarrollo\Mocky\mocky\dist\mocky-1.0.0.war
    [copy] Copying 1 file to C:\Desarrollo\Mocky\dist
    BUILD SUCCESSFUL
    Total time: 11 seconds
  6. Ahora, podemos refrescar el proyecto el proyecto "mocky", para ver cómo ha quedado.
  7. Como podéis observar, además de compilar el proyecto, lo ha copiado a la carpeta de distribución "dist" del proyecto "mocky".
Vamos a desplegar nuestra aplicación en el servidor de aplicaciones Tomcat que integramos, hace unos artículos, en nuestro IDE y lanzaremos la aplicación, para comprobar que TODO funciona correctamente, de momento:
  1. En las vistas, en la parte inferior del entorno de desarrollo, hay una lengüeta "Servers" con nuestra instalación de Tomcat.
  2. Picharemos con el botón derecho sobre esta instalación de Tomcat y seleccionaremos el menú "Add and Remove Projects...". Añadiremos "Add..." a la lista de proyectos configurados, desde la lista de proyectos disponibles, nuestro proyecto mocky. Pulsaremos el botón "Finish" y nuestro proyecto aparecerá bajo la instalación de Tomcat.
  3. Comprobaremos que, con el botón de "Start" o con el botón derecho del ratón sobre el servidor, podemos arrancar sin errores.
  4. Abriremos un navegador y llamaremos a la url http://127.0.0.1:8080/mocky y... voilà!!!
  5. Deberíamos tener delante de nuestros ojos la fantástica -y vacía- aplicación MOCKY.

miércoles, 20 de agosto de 2008

Flex SDK 3.1 y Flex Builder 3.01 liberados

Me ha resultado extraño que en la página principal del site referencia http://opensource.adobe.com, en su sección de novedades, no aparezca la noticia.

Solo te das cuenta de la actualización si "pinchas" en el primer logotipo Flex SDK y observas la versión que recomiendan descargar para desarrollos en producción.

Tampoco me ha resultado sencillo encontrar la relación de cambios que incorporan estos dos nuevos productos.

Un pequeño sumario:

Flex SDK 3.1
  • Se ha dado solución a numerosos bugs, que la comunidad de usuarios ha ido aportando durante este tiempo. La lista completa de los bugs resueltos la podéis encontrar aquí.

  • Soporte para Flash Player 10, actualmente en beta y, además, no se espera el soporte definitivo hasta versiones posteriores.

  • Soporte definitivo para AIR 1.1
Flex Builder 3.0.1
  • Se ha dado solución a numerosos bugs del IDE, que la comunidad de usuarios ha ido aportando durante este tiempo. La lista completa de los bugs resueltos la podéis encontrar aquí y la de los componentes aquí.

  • Soporte para AIR 1.1

  • Soporte para Eclipse 3.4

jueves, 14 de agosto de 2008

Flex 3 y el premio Open Source 2008

Me complace mucho anunciar que, Flex 3 ha ganado el premio a la mejor herramienta Open Source 2008 para desarrolladores, en la categoría "Rich Internet Applications".

Los competidores de Flex han sido OpenLazlo -y de cerca- Curl y Silverlight (aunque estas dos últimas no sean realmente tecnologías puramente Open Source).

Si quieres ver la noticia completa o ver la relación de ganadores de otras categorías... sigue los enlaces.

lunes, 11 de agosto de 2008

Desarrollando con Flex, flexmdi, PureMVC, BlazeDS, Spring, JPA, Hibernate,... (parte 7)

Pasos para crear el fichero de distribución del core del framework Java:
  1. Añadiremos al proyecto "wika2-jframework" un nuevo fichero (ya deberíamos saber cómo) de nombre "build.properties", con la siguientes 5 líneas (es más fácil trabajar directamente en modo texto, que seleccionaremos con la segunda lengüeta bajo la zona de edición):
    # Propiedades del proyecto
    company.name=Wika2.org
    project.name=wika2-jframework
    project.version=1.0.0
    project.copytos=mocky
    Las tres primeras propiedades, se entienden fácilmente, son: la primera es el nombre de la empresa -se utiliza en la creación del fichero "MANIFEST.MF"- y las dos siguientes se utilizan para crear el nombre del fichero ".jar" con la distribución de este proyecto. La última propiedad es una lista (separada por ",") de los proyectos Java donde utilizaremos este ".jar" creado.
  2. Añadiremos al mismo proyecto un nuevo fichero de nombre "build.xml" con el siguiente contenido:
    <?xml version="1.0"?>

    <project name="wika2-jframework" default="dist" basedir=".">

    <!-- Lectura de propiedades externas -->
    <property file="build.properties"/>

    <!-- Propiedades globales para este build -->
    <property environment="env"/>
    <property name="build.dir" value="bin"/>
    <property name="dist.dir" value="dist"/>
    <property name="doc.dir" value="javadoc"/>
    <property name="src.dir" value="src"/>

    <!-- Condiciones -->
    <condition property="3rdparty.available">
    <available file="../3rdparty/lib/${project.name}-${project.version}.jar"/>
    </condition>

    <!-- Declaracion del classpath -->
    <path id="project.classpath">
    <fileset dir="../3rdparty/ant">
    <include name="**/*.jar"/>
    <include name="**/*.zip"/>
    </fileset>
    <fileset dir="../3rdparty/lib">
    <include name="**/*.jar"/>
    <include name="**/*.zip"/>
    </fileset>
    </path>

    <!-- Enlaces utiles -->
    <patternset id="meta.files">
    <include name="**/*.dtd"/>
    <include name="**/*.properties"/>
    <include name="**/*.xml"/>
    </patternset>

    <!-- Tareas -->
    <taskdef resource="net/sf/antcontrib/antcontrib.properties"
    classpathref="project.classpath"/>

    <!-- Limpieza -->
    <target name="clean">
    <delete dir="${build.dir}"/>
    <delete dir="${dist.dir}"/>
    <delete dir="${doc.dir}"/>
    </target>

    <!-- Compilar los fuentes Java -->
    <target name="compile">
    <delete includeemptydirs="yes" failonerror="false">
    <fileset dir="${build.dir}" includes="**/*"/>
    </delete>
    <mkdir dir="${build.dir}"/>
    <javac srcdir="${src.dir}" destdir="${build.dir}" nowarn="on">
    <classpath refid="project.classpath"/>
    </javac>
    <!-- Copiar los metadatos al classpath de este build -->
    <copy todir="${build.dir}">
    <fileset dir="${src.dir}">
    <patternset refid="meta.files"/>
    </fileset>
    </copy>
    </target>

    <!-- Generar la documentacion -->
    <target name="javadoc">
    <delete includeemptydirs="yes" failonerror="false">
    <fileset dir="${doc.dir}" includes="**/*"/>
    </delete>
    <mkdir dir="${doc.dir}"/>
    <javadoc destdir="${doc.dir}" >
    <classpath refid="project.classpath"/>
    <fileset dir="${src.dir}">
    <include name="**/*.java"/>
    </fileset>
    </javadoc>
    </target>

    <!-- Generar el fichero de distribucion -->
    <target name="dist" depends="compile">
    <delete includeemptydirs="yes" failonerror="false">
    <fileset dir="${dist.dir}" includes="**/*"/>
    </delete>
    <mkdir dir="${dist.dir}"/>
    <jar destfile="${dist.dir}/${project.name}-${project.version}.jar" basedir="${build.dir}">
    <manifest>
    <attribute name="Built-By" value="${company.name}"/>
    <attribute name="Implementation-Title" value="${project.name}"/>
    <attribute name="Implementation-Version" value="${project.version}"/>
    </manifest>
    </jar>
    <!-- Copiar el fichero de distribucion al proyecto de 3rdparty -->
    <if>
    <available file="../3rdparty/lib/${project.name}-*.jar"/>
    <then>
    <delete>
    <fileset dir="../3rdparty/lib" includes="${project.name}-*.jar"/>
    </delete>
    </then>
    </if>
    <copy file="${dist.dir}/${project.name}-${project.version}.jar" todir="../3rdparty/lib"/>
    <!-- Copiar el fichero de distribucion -->
    <copy file="${dist.dir}/${project.name}-${project.version}.jar" todir="../dist"/>
    <!-- Copiar a los proyectos que me utilizan -->
    <foreach list="${project.copytos}" param="project.copyto" target="update.webinflib"/>
    </target>

    <!-- Tareas auxilares para el mantenimiento correcto del proyecto -->
    <target name="update.webinflib">
    <if>
    <available file="../${project.copyto}/WebContent/WEB-INF/lib/${project.name}-*.jar"/>
    <then>
    <delete>
    <fileset dir="../${project.copyto}/WebContent/WEB-INF/lib" includes="${project.name}-*.jar"/>
    </delete>
    </then>
    </if>
    <copy file="${dist.dir}/${project.name}-${project.version}.jar" todir="../${project.copyto}/WebContent/WEB-INF/lib"/>
    </target>

    </project>
    Como podéis observar, estoy utilizando Apache Ant para la construcción de mis proyectos. He preferido utilizar Apache Ant, en lugar de Apache Maven, que parecería más lógico, ya que esto supondría añadir complejidad al proyecto. Además, personalmente, no me gusta demasiado la gestión de dependencias de Apache Maven.
  3. Tengo 4 targets definidos en este fichero de construcción: clean, compile, javadoc y dist. Utilizaremos "dist" que, además de compilar, nos creará un fichero "project.name-project.version.jar" en una nueva carpeta "dist" que aparecerá dentro en la carpeta del proyecto.
  4. Pincharemos con el botón derecho del ratón sobre el "build.xml", en el "Project Explorer" de nuestro Eclipse, y seleccionaremos el menú "Rus As-Ant Build" y comenzará el proceso de creación del fichero de distribución, que podremos seguir en la "Console". El target "dist" está definido como target por defecto ;-) en el fichero de contrucción.
  5. Deberíamos obtener "algo" como lo siguiente:
    Buildfile: C:\Desarrollo\Mocky\jframework\build.xml
    compile:
    [javac] Compiling 1 source file to C:\Desarrollo\Mocky\jframework\bin
    dist:
    [jar] Building jar: C:\Desarrollo\Mocky\jframework\dist\wika2-jframework-1.0.0.jar
    [copy] Copying 1 file to C:\Desarrollo\Mocky\3rdparty\lib
    [copy] Copying 1 file to C:\Desarrollo\Mocky\dist
    update.webinflib:
    [copy] Copying 1 file to C:\Desarrollo\Mocky\mocky\WebContent\WEB-INF\lib
    BUILD SUCCESSFUL
    Total time: 1 second
  6. Ahora, podemos refrescar el proyecto "wika2-jframework" y el proyecto "mocky", para ver cómo han quedado.
  7. Como podéis observar, además de compilar el proyecto y de copiarlo a la carpeta de distribución del mismo... lo ha copiado a la carpeta de librerías "WEB-INF/lib" del proyecto "mocky".
Pasos para crear el fichero de distribución del core del framework Flex:
  1. Añadiremos al proyecto "wika2-fframework" un nuevo fichero de nombre "build.properties", con la siguientes 5 líneas:
    # Propiedades del proyecto
    company.name=Wika2.org
    project.name=wika2-fframework
    project.version=1.0.0
    project.copytos=flex-mocky
    Las tres primeras propiedades, se entienden fácilmente, son: la primera es el nombre de la empresa -no se utiliza de momento- y las dos siguientes se utilizan para crear el nombre del fichero ".swc" con la distribución de este proyecto. La última propiedad es una lista (separada por ",") de los proyectos Flex donde utilizaremos este ".swc" creado.
  2. Añadiremos al mismo proyecto un nuevo fichero de nombre "build.xml" con el siguiente contenido:
    <?xml version="1.0"?>

    <project name="wika2-fframework" default="dist" basedir=".">

    <!-- Lectura de propiedades externas -->
    <property file="build.properties"/>

    <!-- Propiedades globales para este build -->
    <property environment="env"/>
    <property name="FLEX_HOME" value="${env.FLEX_HOME}"/>
    <property name="dist.dir" value="dist"/>
    <property name="doc.dir" value="asdoc"/>
    <property name="src.dir" value="src"/>

    <!-- Declaracion del classpath -->
    <path id="project.classpath">
    <fileset dir="../3rdparty/ant">
    <include name="**/*.jar"/>
    <include name="**/*.zip"/>
    </fileset>
    <fileset dir="../3rdparty/lib">
    <include name="**/*.jar"/>
    <include name="**/*.zip"/>
    </fileset>
    </path>

    <!-- Tareas -->
    <taskdef resource="net/sf/antcontrib/antcontrib.properties"
    classpathref="project.classpath"/>

    <taskdef resource="flexTasks.tasks"
    classpathref="project.classpath"/>

    <!-- Limpieza -->
    <target name="clean">
    <delete dir="${dist.dir}"/>
    <delete dir="${doc.dir}"/>
    </target>

    <!-- Generar la documentacion -->
    <target name="asdoc">
    <delete includeemptydirs="yes" failonerror="false">
    <fileset dir="${doc.dir}" includes="**/*"/>
    </delete>
    <mkdir dir="${doc.dir}"/>
    <exec executable="${env.FLEX_HOME}\bin\asdoc.exe" failonerror="true">
    <arg line="-doc-sources ${src.dir}/com"/>
    <arg line="-main-title '${project.name} API Documentation'"/>
    <arg line="-output ${doc.dir}"/>
    <arg line="-source-path ${src.dir}"/>
    <arg line="-window-title '${project.name}'"/>
    </exec>
    </target>

    <!-- Generar los Flex de la aplicacion -->
    <target name="dist">
    <delete includeemptydirs="yes" failonerror="false">
    <fileset dir="${dist.dir}" includes="**/*"/>
    </delete>
    <mkdir dir="${dist.dir}"/>
    <!-- Descubriendo clases -->
    <fileset id="sources" dir="${src.dir}/org">
    <include name="**/*.as"/>
    </fileset>
    <pathconvert property="classes" pathsep=" " refid="sources">
    <chainedmapper>
    <globmapper from="${basedir}${file.separator}${src.dir}${file.separator}*" to="*"/>
    <mapper type="package" from="*.as" to="*"/>
    </chainedmapper>
    </pathconvert>
    <!-- Crear el swc -->
    <compc output="${dist.dir}/${project.name}-${project.version}.swc" include-classes="${classes}" locale="es_ES" optimize="true" debug="false">
    <source-path path-element="${basedir}/${src.dir}"/>
    </compc>
    <!-- Copiar el fichero de distribucion al proyecto de 3rdparty -->
    <if>
    <available file="../3rdparty/lib/${project.name}-*.swc"/>
    <then>
    <delete failonerror="false">
    <fileset dir="../3rdparty/lib" includes="${project.name}-*.swc"/>
    </delete>
    </then>
    </if>
    <copy file="${dist.dir}/${project.name}-${project.version}.swc" todir="../3rdparty/lib"/>
    <!-- Copiar a los proyectos que me utilizan -->
    <foreach list="${project.copytos}" param="project.copyto" target="update.libs"/>
    </target>

    <!-- Tareas auxilares para el mantenimiento correcto del proyecto -->
    <target name="update.libs">
    <if>
    <available file="../${project.copyto}/libs/${project.name}-*.swc"/>
    <then>
    <delete>
    <fileset dir="../${project.copyto}/libs" includes="${project.name}-*.swc"/>
    </delete>
    </then>
    </if>
    <copy file="${dist.dir}/${project.name}-${project.version}.swc" todir="../${project.copyto}/libs"/>
    </target>

    </project>
  3. Tengo 3 targets definidos en este fichero de construcción: clean, asdoc y dist. Utilizaremos "dist" que, además de compilar, nos creará un fichero "project.name-project.version.swc" en una nueva carpeta "dist" que aparecerá dentro en la carpeta del proyecto.
  4. Pincharemos con el botón derecho del ratón sobre el "build.xml", en el "Project Explorer" de nuestro Eclipse, y seleccionaremos el menú "Rus As-Ant Build" y comenzará el proceso de creación del fichero de distribución, que podremos seguir en la "Console". El target "dist" está definido como target por defecto ;-) en el fichero de contrucción.
  5. Deberíamos obtener "algo" como lo siguiente:
    Buildfile: C:\Desarrollo\Mocky\fframework\build.xml
    dist:
    [mkdir] Created dir: C:\Desarrollo\Mocky\fframework\dist
    [compc] Loading configuration file C:\Desarrollo\Mocky\flex_sdk_3.0.0.477_mpl\frameworks\flex-config.xml
    [compc] C:\Desarrollo\Mocky\fframework\dist\wika2-fframework-1.0.0.swc (1178 bytes)
    [copy] Copying 1 file to C:\Desarrollo\Mocky\3rdparty\lib
    update.libs:
    [copy] Copying 1 file to C:\Desarrollo\Mocky\flex-mocky\libs
    BUILD SUCCESSFUL
    Total time: 3 seconds
  6. Ahora, podemos refrescar el proyecto "wika2-fframework" y el proyecto "flex-mocky", para ver cómo han quedado.
  7. Como podéis observar, además de compilar el proyecto y de copiarlo a la carpeta de distribución del mismo... lo ha copiado a la carpeta de librerías "libs" del proyecto "flex-mocky".

viernes, 8 de agosto de 2008

Blogger me ha duplicado entradas

Blogger me ha duplicado, estos últimos días, dos entradas. Son las siguientes:
  • Desarrollando con Flex, flexmdi, PureMVC, BlazeDS, Spring, JPA, Hibernate,... (parte 5)
  • Desarrollando con Flex, flexmdi, PureMVC, BlazeDS, Spring, JPA, Hibernate,... (parte 4)
Puede dar la falsa sensación de que he escrito más artículos de los que realmente he publicado ;-)

Además Blogger no me deja borrarlas. Realmente sí me deja borrarlas, pero las deja en un estado peor de lo que están ahora.

Las dos entradas tienen la misma URL, con el mismo blogID.

He descubierto que esto mismo les ha pasado a más bloggers por estas fechas, así que espero que pronto nos den una solución -automáticamente- al problema.

ACTUALIZACIÓN (11 de agosto): como veis, el problema de las entradas duplicadas ha sido resuelto, en pocas horas.

miércoles, 6 de agosto de 2008

Desarrollando con Flex, flexmdi, PureMVC, BlazeDS, Spring, JPA, Hibernate,... (parte 6)

Pasos a seguir para construir el cuarto proyecto mocky:

  1. Seleccionaremos el menú "File-New-Dynamic Web Project...".
  2. En la siguiente ventana, como nombre de proyecto (campo "Project name") utilizaré "mocky". Desmarcaremos el checkbox "Use default" y en el campo "Directory" introduciremos el valor "C:\Desarrollo\Mocky\mocky". El resto de los campos los dejaremos "tal cual" y pulsaremos el botón "Next".
  3. En la siguiente ventana, dejaremos todo "tal cual" y terminaremos la creación del proyecto pulsando el botón "Finish".
  4. Ahora tenemos que copiar (lo podemos hacer desde el propio entorno de desarrollo o desde el sistema operativo) todos los ficheros ".jar" que hay en "C:\Desarrollo\Mocky\3rdparty\wika2" al directorio "C:\Desarrollo\Mocky\mocky\WebContent\WEB-INF\lib". Refrescaremos el contenido, desde el entorno de desarrollo, pinchando con el botón derecho del ratón sobre el proyecto "mocky" y seleccionando "Refresh".
  5. Crearemos nuestra primera clase Java, pinchando con el botón derecho del ratón sobre la carpeta de fuentes "src" y seleccionando "New-Class".
  6. En la siguiente ventana, en el campo "Package" introduciremos el valor "org.wika2.mocky.util" y en el nombre de la clase (campo "Name") vamos a poner "DummyUtils". El resto de los campos los dejaremos "tal cual" y pulsaremos el botón "Finish".

Pasos a seguir para construir el quinto (y último) proyecto flex-mocky:

  1. Seleccionaremos el menú "File-New-Project...", pincharemos en la rama "General-Project" y pulsaremos el botón "Next".
  2. En la siguiente ventana, como nombre de proyecto (campo "Project name") utilizaré "flex-mocky". Desmarcaremos el checkbox "Use default location" y en el campo "Location" introduciremos el valor "C:\Desarrollo\Mocky\flex-mocky". El resto de los campos los dejaremos "tal cual" y pulsaremos el botón "Finish".
  3. Crearemos una nueva clase ActionScript, pinchando con el botón derecho del ratón sobre la carpeta del proyecto "flex-mocky" y seleccionando "New-Folder".
  4. En la siguiente ventana, en el campo "Folder name" introduciremos el valor "src/org/wika2/mocky/util" y pulsaremos el botón "Finish".
  5. Pinchando con el botón derecho del ratón sobre la carpeta recién creada "util" y seleccionando "New-File", crearemos nuestra nueva clase ActionScript.
  6. En la siguiente ventana, en el campo "File name" introduciremos el valor "DummyUtils.as" y pulsaremos el botón "Finish".

Se nos abrirá el editor de textos, donde pegaremos el siguiente código ActionScript:


package org.wika2.mocky.util {

public class DummyUtils {
}

}
  1. Antes de crear nuestro primer fichero Flex, tenemos que asociar la extensión ".mxml" al editor de XML por defecto de Eclipse. Seleccionaremos el menú "Windows-Preferences" y la rama "General-Editors-File Associations". Añadiremos (con el botón "Add.." de la zona superior) un nuevo tipo de fichero "*.mxml" y lo asociaremos (con el botón "Add..." de la zona inferior) al editor "XML Editor" de la lista que se nos presenta.
  2. También, tenemos que asociar el tipo de contenido correspondiente. En esta misma ventana, en la rama "General-Content Types", desplegaremos el árbol con los "Content types" y seleccionaremos el "Text-XML (Illformed)". Una vez seleccionado, añadiremos (con el botón "Add..." de la zona inferior) el nuevo tipo de contenido "*.mxml" a la lista.
  3. Saldremos de la ventana de preferencias pulsando el botón "Ok".
  4. Pinchando con el botón derecho del ratón sobre la carpeta recién creada "src" y seleccionando "New-File", crearemos nuestro primer fichero Flex.
  5. En la siguiente ventana, en el campo "File name" introduciremos el valor "Mocky.mxml" y pulsaremos el botón "Finish".

Se nos abrirá el editor de textos, es más cómodo para trabajar seleccionar el modo "Source" de entre las dos lengüetas que hay bajo la zona del editor, donde pegaremos el siguiente código Flex:


<?xml version="1.0" encoding="utf-8"?>

<mx:Application
xmlns:mx="http://www.adobe.com/2006/mxml"
width="100%" height="100%" layout="absolute"
minWidth="760" minHeight="460"
pageTitle="Mocky">

</mx:Application>

Ahora, debemos tener algo similar a lo que aparece en la siguiente figura:

flex-parte6-fig1.png

martes, 5 de agosto de 2008

Desarrollando con Flex, flexmdi, PureMVC, BlazeDS, Spring, JPA, Hibernate,... (parte 5)

Ya es hora de ponernos "manos a la obra" con nuestro proyecto Mocky. Voy a empezar creando cinco (sí habéis leído bien) proyectos Eclipse:
  1. 3rdparty: es un proyecto que solamente contiene APIs Java, librerías ".jar", que suelo utilizar en TODOS mis proyectos. Luego lo añadiré al "Java Build Path" de todos los proyectos Java de mi organización.
  2. jframework: es un proyecto que contiene clases Java (la primera "j" es de java) de lo que será el core de mi framework, común a todos los proyectos construidos por mi organización.
  3. fframework: es un proyecto que contiene clases ActionScript (la primera "f" es de flex) de lo que será el core de mi framework, común a todos los proyectos construidos por mi organización.
  4. mocky: es el proyecto que tiene la parte que "corre" del lado del servidor (J2EE).
  5. flex-mocky: es el proyecto que tiene la parte que "corre" del lado del cliente (Flex).
Pasos a seguir para construir el primer proyecto 3rdparty:
  1. Descargaremos el siguiente zip, que ya he dejado preparado con el proyecto completo. Contiene un conjunto de APIs que, personalmente, he ido seleccionando a lo largo del tiempo y que cubre un espectro bastante amplio de necesidades.
  2. "Deszipearemos" el contenido dentro de la carpeta "C:\Desarrollo\Mocky\3rdparty".
  3. Lo importaremos en nuestro entorno de desarrollo Eclipse. Seleccionaremos el menú "File-Import..." y pincharemos la rama "General-Existing Projects into Workspace".
  4. En la siguiente ventana, rellenaremos el campo "Select root directory" con el directorio donde hemos "deszipeado" el fichero descargado "C:\Desarrollo\Mocky\3rdparty" y pulsaremos el botón "Finish".
  5. Ahora ya tenemos que ver, en el "Project Explorer" de la parte izquierda de nuestro Eclipse, nuestro primer proyecto "wika2-3rdparty", importado y sin errores.
NOTA: wika2 es el término que voy a utilizar como nombre para mi organización ;-) Podéis sustituirlo por el nombre de vuestra organización, si queréis.

Pasos a seguir para construir el segundo proyecto jframework:
  1. Seleccionaremos el menú "File-New-Project...", pincharemos en la rama "Java-Java Project" y pulsaremos el botón "Next".
  2. En la siguiente ventana, como nombre de proyecto (campo "Project name") utilizaré "wika2-jframework". Seleccionaremos "Create project from existing source" y en el campo "Directory" introduciremos el valor "C:\Desarrollo\Mocky\jframework". El resto de los campos los dejaremos "tal cual" y pulsaremos el botón "Next".
  3. En la siguiente ventana, pincharemos en la lengüeta "Projects" (la segunda, tras "Source") y pulsaremos el botón "Add...". Seleccionaremos el proyecto anteriormente creado "wika2-3rdparty" y pulsaremos el botón "Ok".
  4. Finalmente, terminaremos la creación del proyecto pulsando el botón "Finish".
  5. Nos preguntarán si queremos asociar el proyecto a la perspectiva "Java"... yo respondo que "No" y que, además, recuerde mi decisión (trabajaremos siempre desde la perspectiva "Java EE").
  6. Crearemos nuestra primera clase Java, pinchando con el botón derecho del ratón sobre la carpeta de fuentes "src" y seleccionando "New-Class".
  7. En la siguiente ventana, en el campo "Package" introduciremos el valor "org.wika2.jframework.util" y en el nombre de la clase (campo "Name") vamos a poner "DummyUtils". El resto de los campos los dejaremos "tal cual" y pulsaremos el botón "Finish".
Pasos a seguir para construir el tercer proyecto fframework:
  1. Seleccionaremos el menú "File-New-Project...", pincharemos en la rama "General-Project" y pulsaremos el botón "Next".
  2. En la siguiente ventana, como nombre de proyecto (campo "Project name") utilizaré "wika2-fframework". Desmarcaremos el checkbox "Use default location" y en el campo "Location" introduciremos el valor "C:\Desarrollo\Mocky\fframework". El resto de los campos los dejaremos "tal cual" y pulsaremos el botón "Finish".
  3. Crearemos nuestra primera clase ActionScript, pinchando con el botón derecho del ratón sobre la carpeta del proyecto "wika2-fframework" y seleccionando "New-Folder".
  4. En la siguiente ventana, en el campo "Folder name" introduciremos el valor "src/org/wika2/fframework/util" y pulsaremos el botón "Finish".
  5. Antes de crear nuestra clase ActionScript, tenemos que asociar la extensión ".as" al editor de textos por defecto de Eclipse. Seleccionaremos el menú "Windows-Preferences" y la rama "General-Editors-File Associations". Añadiremos (con el botón "Add.." de la zona superior) un nuevo tipo de fichero "*.as" y lo asociaremos (con el botón "Add..." de la zona inferior) al editor "Text Editor" de la lista que se nos presenta. Saldremos de la ventana de preferencias pulsando el botón "Ok".
  6. Pinchando con el botón derecho del ratón sobre la carpeta recién creada "util" y seleccionando "New-File", crearemos nuestra primera clase ActionScript.
  7. En la siguiente ventana, en el campo "File name" introduciremos el valor "DummyUtils.as" y pulsaremos el botón "Finish".
  8. Se nos abrirá el editor de textos, donde pegaremos el siguiente código ActionScript:

package org.wika2.fframework.util {

public class DummyUtils {
}

}
Por ahora, eso es todo. En un próximo artículo continuaré con la creación de los dos proyectos que nos faltan y con la creación de los "build.xml", asociados a cada proyecto, necesarios para poder crear la distribución de nuestra aplicación.

lunes, 4 de agosto de 2008

Desarrollando con Flex, flexmdi, PureMVC, BlazeDS, Spring, JPA, Hibernate,... (parte 4)

Mi proyecto ejemplo se llamará "Mocky". Será el "esqueleto" de una sencilla aplicación que, simplemente, pedirá al usuario que se identifique y le permitirá mantener la información de un par de tablas, de una base de datos, mediante unos sencillos formularios.

Voy a explicar como preparar el entorno de desarrollo:
  1. Crearemos una carpeta, llamada mocky, en nuestro sistema de ficheros. Contendrá todo nuestro proyecto, tanto el entorno de desarrollo como el proyecto en sí mismo. Para los usuarios Linux podría ser "/opt/desarrollo/mocky" y para los usuarios Windows "C:\Desarrollo\Mocky". Os recomiendo no utilizar espacios en blanco para nombrar carpetas, cuando trabajemos con este tipo de desarrollos.
  2. Instalaremos el IDE Eclipse en esta carpeta. Yo he instalado la última versión del paquete "Eclipse IDE for Java EE Developers (Ganymede)" disponible a la fecha del artículo. La instalación es tan sencilla como "deszipear" el fichero descargado.
  3. Instalaremos el contenedor de servlets Tomcat en esta carpeta. Yo he instalado la versión 5.5.26, porque es con la que suelo trabajar, pero serviría cualquier versión superior. La instalación es tan sencilla como "deszipear" el fichero descargado.
  4. Instalaremos la base de datos MySQL en esta carpeta. Yo he instalado la última versión estable y disponible a la fecha del artículo.
  5. Instalaremos el SDK de Flex en esta carpeta. Yo he instalado la última versión del Open Source Flex SDK estable y disponible a la fecha del artículo. La instalación es tan sencilla como "deszipear" el fichero descargado. Instalaremos, también, la localización en Español, tal y como conté en un artículo anterior.
  6. Instalaremos el SDK de Java en esta carpeta. Yo he instalado la versión JVM 5.0 Update 16, porque es con la que suelo trabajar, pero serviría cualquier versión superior.
  7. Ahora, en nuestra carpeta, deberíamos tener "algo" como lo siguiente:

  1. Crearemos 3 variables de entorno:
  • JAVA_HOME apuntando a "C:\Desarrollo\Mocky\jdk1.5.0_16"
  • FLEX_HOME apuntando a "C:\Desarrollo\Mocky\flex_sdk_3.0.0.477_mpl"
  • MOCKY_HOME apuntando a "C:\Desarrollo\Mocky"
  • y añadiremos al PATH el directorio de binarios de nuestra JVM "%JAVA_HOME%/bin"
  1. Ejecutaremos el entorno de desarrollo con "C:\Desarrollo\Mocky\eclipse\eclipse.exe". Al lanzarlo por primera vez, nos solicitará un directorio para guardar nuestro espacio de trabajo. Le indicaremos el siguiente "C:\Desarrollo\Mocky\eclipse\workspace" y marcaremos el "checkbox" para que no nos pregunte más en el futuro.
  2. Cerraremos la primera pantalla de bienvenida o "Welcome" y nos aparecerá la perspectiva por defecto "Java EE".
  3. Comprobaremos que el entorno ha encontrado nuestra JVM recién instalada. Desde el menú "Windows-Preferences" seleccionaremos la rama "Java-Installed JRE" y comprobamos.
  4. Vamos a crear un nuevo servidor en el IDE asociado a nuestra instalación de Tomcat. Desde el menú "Windows-Preferences" seleccionaremos la rama "Server-Runtime Environments". Pulsaremos el botón "Add...", seleccionaremos la rama "Apache-Apache Tomcat 5.5", marcaremos "Create a new local server" y pulsaremos el botón "Next". En la siguiente pantalla, pulsaremos el botón "Browse...", localizaremos el directorio "C:\Desarrollo\Mocky\apache-tomcat-5.5.26", comprobaremos que el JRE asignado es "Workbench default JRE" y terminaremos pulsando "Finish".
  5. Ahora tendremos, en nuestra perspectiva "Java J2EE", un nuevo proyecto denominado "Servers" (que no debemos borrar NUNCA) y en las vistas, en la parte inferior del entorno de desarrollo, una lengüeta "Servers" con nuestra instalación de Tomcat. Comprobaremos que, con los botones de "Start" y "Stop" o con el botón derecho del ratón sobre el servidor, podemos arrancar y parar sin errores.
  6. Ya tenemos nuestro entorno de desarrollo preparado para empezar a crear NUESTROS proyectos.

viernes, 13 de junio de 2008

Desarrollando con Flex, flexmdi, PureMVC, BlazeDS, Spring, JPA, Hibernate,... (parte 3)

Aunque el artículo anterior habrá sonado un poco descorazonador, tengo que confesar que la aplicación está casi terminada. Pronto pasará a estar en producción y podremos comprobar el éxito o el fracaso -espero que sea lo primero- del producto desarrollado y de las decisiones que he ido tomando a lo largo del proyecto.

Algunas cosas que han cambiado con respecto a lo previsto:
  • Estoy utilizando MySQL como base de datos, para la fase de desarrollo. La aplicación en producción funcionará contra un Oracle 10g. El coste de crear una aplicación que permita seleccionar una base de datos u otra ha sido... "cero"!!! (gracias JPA).
  • Estoy utilizando Tomcat 5.5 como "servidor de aplicaciones", para la fase de desarrollo. La aplicación en producción funcionará sobre un Oracle Application Server (realmente un OC4J 10.1.3). En mis pruebas funciona, además, perfectamente sobre un JBoss 4.2. El coste de crear una aplicación que permita seleccionar un servidor de aplicaciones u otro ha sido... "cero"!!! (gracias J2EE).
  • Como entorno de desarrollo utilizo, exclusivamente, Eclipse y aunque tengo montado Flex Builder (la versión Trial) como un plugin de éste... apenas lo utilizo, al menos intento no utilizarlo. Me las apaño con Apache Ant y con las Flex Ant Tasks para compilar mi librería SWC y mi proyecto SWF. No he encontrado ninguna herramienta Open Source y/o gratuita con la que pueda desarrollar con Flex (parece mentira a estas alturas).
  • Del resto de los productos que pretendía utilizar, menos de la librería flexmdi (y creo que me arrepentiré de no haberlo hecho) he hecho uso de TODOS ellos. Esto se llama... puntería ;-)
  • Además he incorporado JasperReports y su diseñador de informes iReport para generar informes, que exporto a PDF y que muestro desde la aplicación Flex (realmente los muestro sobre el navegador web). El tema de los informes en Flex debería estar un poco mejor tratado.... debería estar tratado, al menos.
  • Una ayuda muy especial para depurar nuestro código es ThunderBolt, una extensión para "tracear" aplicaciones Flex sobre la consola de Firebug del "add-on" para Firefox.

Desarrollando con Flex, flexmdi, PureMVC, BlazeDS, Spring, JPA, Hibernate,... (parte 2)

Después de 2 meses sin dar señales de vida he querido, al menos, escribir sobre la marcha de mi primer proyecto Flex. La verdad es que con esta experiencia estoy teniendo sentimientos contradictorios según el día.

Hay días que me digo: "que bueno haber descubierto Flex". Hay otros que me desconsuelo y me digo: "en qué demonios estaba yo pensando cuando me metí en esto de los RIAs".

Creo que el principal problema es que había puesto demasiadas expectativas.

No nos engañemos, el desarrollo de RIAs era ya posible, estaba en nuestra manos, desde el principio de los tiempos.

No nos engañemos el desarrollo de RIAs para la web estaba en nuestras manos desde los primeros días JAVA, mediante la creación de applets que hacían uso del vetusto API AWT. Yo he visto hace más de 10 años aplicaciones, incluso participado en ellas, alucinantes, que no tenían nada que envidiar a las actuales aplicaciones Flex.

Flex ha venido a recordarnos que esto es posible, mejora un poco -faltaría más- las dificultades que nos encontrábamos con el AWT y añade bonitas animaciones y sombras a nuestros componentes.

Respecto a esto, creo que Flex está poniendo mucho más énfasis en que podamos cambiar los estilos y las "pieles" de nuestras aplicaciones y componentes, hasta extremos innecesarios, que el potenciar aquello que realmente nos hace la vida más fácil a los desarrolladores de productos para la web. Creo que deberían buscar un equilibrio...

sábado, 19 de abril de 2008

Desarrollando con Flex, flexmdi, PureMVC, BlazeDS, Spring, JPA, Hibernate,... (parte 1)

Estoy desarrollando mi primera aplicación con Flex y quería ir comentando mis "desavenencias" en este blog, por si os sirve -o me sirve a mi- de algo, en un futuro, mi experiencia.

El "producto" es una sencilla aplicación Flex que, previa autenticación del usuario y una vez comprobados sus privilegios, nos permitirá mantener la información guardada en una base de datos, mediante sencillos formularios.

El primer problema es encontrar el conjunto de herramientas que me van a acompañar en el desarrollo de este producto. Esta es mi lista, creo, definitiva:
  1. Base de datos: aunque trabajo normalmente con Oracle, el producto podrá funcionar con cualquier base de datos del mercado para la que tengamos un driver JDBC disponible. Es decir, casi todas las existentes o conocidas.
  2. Servidor de aplicaciones: casi toda la lógica de negocio de mi aplicación correrá del lado del servidor. He decidido, de momento, por aprovechar al máximo mi conocimiento en este campo, trabajar con la plataforma J2EE. El servidor de aplicaciones que utilizaré es JBoss, pero la aplicación funcionará en cualquier otro servidor, compatible J2EE, sin dificultad. Incluso, lo haré funcionar en un sencillo contenedor Apache Tomcat.
  3. Como herramientas de desarrollo, seleccionaré Eclipse y me aprovecharé, también, de la ventaja que supone poder utilizar el Flex Builder en modo trial durante unos meses.
  4. Para acceder a la base de datos y desarrollar la lógica de negocio más dura, del lado del servidor, he decidido utilizar la siguiente combinación: algunas clases del proyecto AppFuse (más concretamente la appfuse-jpa.jar y la appfuse-service.jar), el framework Spring y finalmente como implementación de JPA (persistencia Java) he seleccionado Hibernate (pero servirían también Toplink u OpenJPA).
  5. Para acceder desde Flex a los POJOs, los POJOs que desarrollaré del lado del servidor de aplicaciones, me he decidido por BlazeDS, por su madurez y potencia accediendo a objetos remotos. Además integraré BlazeDS con Spring de forma muy sencilla, con una factoría especial (llamada SpringFactory)... ya os contaré cómo. Esta factoría está disponible dentro de otro proyecto de integración llamado "RemoteDestination annotation for Spring".
  6. He decidido utilizar para la parte cliente (la desarrollada con Flex) un framework para construir aplicaciones basadas en el modelo MVC (model-view-controller). He seleccionado PureMVC, que tiene un "port" para Flex y que, aunque al principio me ha costado entender su funcionamiento, creo que le sacaré bastante provecho.
  7. Seguramente utilizaré, a futuro, múltiples librerías SWC. de momento me he descargado la flexmdi (no puedo vivir ;-) sin crear ventanas en modo MDI en mis aplicaciones). Quizá la utilicé o quizá no, ya veremos.
  8. Por supuesto, necesitaré el SDK de Java (una versión 5.0 ó superior) y el SDK de Flex (una versión 3 o superior).
Intentaré dejar en algún sitio, próximamente, un esqueleto de aplicación con todo esto en un paquete, para que sea más fácil empezar con el desarrollo.

miércoles, 9 de abril de 2008

Trabajar con ficheros XML, diferentes opciones

Como sabéis, los más potentes validadores XML y transformadores XSLT son los navegadores que tenemos instalados en nuestros equipos: IE, Firefox, Opera, etc.

Arrastrando sobre ellos un XML nos lo validan, nos lo transforman (si hay un XSLT asociado), nos lo muestran en forma de árbol, nos permiten navegar por sus nodos, etc.

No necesitamos instalar nada para ello!!!

Si no es suficiente:

Editores XML:

1. ECLIPSE: de serie incluye un sencillo editor XML, pero podemos "pegarles" otros más potentes mediante plugins, como el XMLBuddy.

Ver: http://www.eclipse.org
Ver: http://xmlbuddy.com/2.0/products.html

2. FOXE: muy sencillo (para instalar con un simple zip), consume muy pocos recursos y más que suficiente, la mayor parte de las veces. Yo lo utilizo mucho.

Ver: http://www.firstobject.com/dn_editor.htm

3. WMHELP XMLPAD: un poco más potente que el anterior.

Ver: http://www.wmhelp.com/download.htm

4. Y de pago tenemos... OXIGEN y ALTOVA XMLSPY: son dos de los productos más maduros, famosos y profesionales del mercado.

Trabajar con XML (fundamentalmente con APIs JAVA) :

1. Java incorpora un API (JAXP) en su JVM para trabajar con ficheros XML.

2. También son muy interesantes los proyectos XALAN y XERCES de Apache, que tienen "ports" en Java y en C++.

3. A mi, personalmente, me gusta mucho DOM4J (http://www.dom4j.org) que es el que yo utilicé, en su día, para los proyectos de la empresa donde trabajo.

4. Uno de los APIs Java más interesantes lo proporciona, también, Apache en su proyecto commons-digester (http://commons.apache.org/digester). Este API te permite mapear ficheros XML a clases Java.

Este proyecto es utilizado internamente por muchos de los productos con los que trabajamos, día a día, y que utilizan XML como ficheros de configuración, por ejemplo.

5. Hay más: JDOM (http://www.jdom.org), Jaxen (http://jaxen.org) que es un motor XPath, etc.

Generar ficheros XML en nuestras aplicaciones:

DOM4J y JDOM (y otros) permiten generar ficheros XML mediante la exportación a texto (por ejemplo) de documentos XML que vamos generando con estos APIs: creando el objeto documento, generando los nodos, enganchándolos al documento (o a otros nodos) y luego "serializando" este objeto documento a un fichero de texto.

A veces resulta tedioso y es más sencillo generar un fichero de texto, como un fichero de texto más de los que genera nuestra aplicación, que cumpla con las reglas de un fichero XML (claro está).

miércoles, 26 de marzo de 2008

Proyectos, gestión, gestores y programadores

Me he encontrado un libro gratuito y en castellano, en:

http://escolaxaviersoto.org/edicions/E3.pdf

Se llama "Dirección de grupos y reuniones. Gestión del tiempo."

Así que, creo que, NO nos interesa mucho ;-) no sea que empecemos ahora a hacerlo bien (lo de dirigir grupos, dirigir reuniones y gestionar el tiempo).

Además os invito a leer este otro pequeño artículo (me ha resultado interesante por expresar una teoría tan "real como la vida misma" de forma tan sencilla):

http://www.navegapolis.net/content/view/761

Según esta teoría, los proyectos que solo necesitan previsión de fechas y costes requieren de metodologías más tradicionales, con gestores que controlen a su equipo y den "palos" y con programadores a los que NO les guste su trabajo (que lo hagan solo por dinero, vamos).

Sin embargo, los proyectos que se preocupan realmente por el VALOR del producto requieren de metodologías más ágiles, con gestores que velen por su equipo y realmente comprometidos y con programadores que trabajen en "esto" por algo más que por dinero (porque realmente les guste su trabajo).

lunes, 24 de marzo de 2008

Traduciendo el framework de Flex a otros idiomas: catalán, francés, etc.

En mi artículo anterior dejé pendiente comentar cómo había conseguido traducir el framework del Adobe Flex SDK 3 al español. En este nuevo artículo os intentaré comentar los pasos, de forma sencilla, que yo realicé, para que podáis hacer vuestras propias traducciones:
  1. Lo más sencillo es tomar como punto de partida una localización de las disponibles (la del inglés que aporta Adobe en su SDK o la del español que os dejé la semana pasada). Están en el directorio <sdk_home>/frameworks/locale. Así que lo mejor es hacer un "copy-paste" de la carpeta que más os guste y renombrarla con el código del nuevo idioma a traducir (por ejemplo "ca_ES" para el catalán, "fr_FR" para el francés, etcétera).
  2. Dentro de la carpeta encontraréis 3 ficheros con extensión ".swc". Debéis cambiarle la extensión por ".zip" y descomprimirlos cada uno en una carpeta diferente.
  3. Cada carpeta tiene 3 elementos diferenciados: una nueva carpeta de nombre "locale", un fichero "catalog.xml" y un fichero "library.swf".
  4. Editaremos el fichero "catalog.xml" cambiando toda referencia a la localización que hemos tomado como base por los códigos de nuestra nueva localización. Están todas al final del fichero dentro de una etiqueta <files>
  5. Después debemos ir a la carpeta "locale" (al mismo nivel que el fichero "catalog.xml" anterior) y renombrar la subcarpeta que hay dentro de ella con el nuevo código del idioma que estoy traduciendo.
  6. Dentro de esta subcarpeta hay varios ficheros, que son los que realmente debo traducir. Son ficheros de textos (recomiendo que el formato usado para estos ficheros sea el UTF-8 o tendremos problemas con acentos y demás caracteres "extraños") no muy extensos y, creo que, sencillos de traducir. Atentos a la configuración de fechas y formatos numéricos, también configurables desde estos ficheros de texto.
  7. Finalmente, cuando tenga todos los textos ya traducidos, debo volver a comprimir la carpeta que descomprimí en el punto 2 y cambiarle la extensión por su extensión original ".swc".
  8. Debo seguir todos estos pasos para los 3 ficheros ".swc" originales.
  9. Y finalmente... ¡ya tenemos el Flex SDK 3 traducido a nuestro nuevo idioma!
Como os decía en el artículo anterior, simplemente añadiendo la siguiente opción al compilador "-locale ca_ES" (por ejemplo) tendréis resuelto el asunto... al menos, el asunto catalán ;-)

Creo que también se pueden especificar varios códigos al compilador separados por comas (o espacios) de la forma "-locale ca-ES, fr_FR" y luego desde código activar uno u otro al vuelo.

También podéis modificar el fichero <sdk_home>/frameworks/flex-config.xml para activar esta localización como la localización por defecto de vuestras compilaciones (es sencillo encontrar el lugar).

viernes, 21 de marzo de 2008

Flex y locale es_ES... por fin, Flex en español!

Nunca entendí el motivo por el que Adobe no incorporaba al SDK de FLEX la localización en múltiples idiomas (solo lo hace para el inglés y creo que también para el japonés).

Pensaba que era por no disponer todavía de versiones definitivas del SDK... pero, no hemos mejorado en nada tras la liberación del SDK 3.

Esto hace que la localización de nuestras aplicaciones Flex se vea dificultada, al no poder traducir los mensajes (de validación y formateo, por ejemplo) convenientemente a nuestro idioma.

¡Pues al final, buceando por la web de Adobe, un poco por Google y con un poco/bastante de esfuerzo por mi parte, he conseguido resolver el problema!

En el siguiente enlace FLEXSDK3-framework-locale-es_ES.zip
os dejo un .zip que podéis descomprimir en el directorio de vuestro SDK (primero creáis un directorio "es_ES" dentro del directorio "frameworks/locale" y luego copiáis allí los tres ficheros .swc que os dejo dentro del .zip) y simplemente añadiendo la siguiente opción al compilador "-locale es_ES" tendréis resuelto el asunto... al menos, el asunto español ;-)

También podéis modificar el fichero <sdk-home>/frameworks/flex-config.xml para activar esta localización como la localización por defecto de vuestras compilaciones (es sencillo encontrar el lugar).

También podemos activar esta localización en el Flex Builder 3, que realmente utiliza un SDK que viene dentro del directorio "sdks" donde esté instalado este impresionante entorno de desarrollo.

En un próximo artículo os cuento como lo he conseguido y como activar múltiples idiomas en vuestras aplicaciones.

viernes, 14 de marzo de 2008

Generación de informes

Ampliando el artículo anterior sobre la generación de charts, voy a recomendar también algunas herramientas o APIs que he utilizado en la generación de informes de mis aplicaciones:

a) Para la generación de códigos de barras:
b) Generación de informes y generación de PDFs:
c) Generación de otros documentos en formato Word, Excel u OpenOffice:
Espero que ambos dos artículos os sean de utilidad,

Generación de gráficos estadísticos o charts

He recopilado, esta mañana, cuatro categorías de posibilidades para cubrir el requisito de la "generación de gráficos estadísticos (o charts)" en nuestras aplicaciones:

a) Generarlos en el cliente (navegador) con Javascript. Ej:
b) Generarlos en el cliente (navegador) en formato SWF (Flash), resultan super-atractivos. Ej:
c) Mediante el uso de APIs JAVA (permite integración con JSF). Ej:
d) Mediante un servlet que podamos invocar directamente desde mis tags <img>. Ej:

lunes, 25 de febrero de 2008

Adobe Flex 3.0 y Adobe AIR 1.0 ya disponibles

El título lo dice todo. ¡Por fin ha llegado el gran día!
Además, no dejes de pasarte por el portal "Adobe Open Source". En él se mostrarán las actividades emprendidas por Adobe para la comunidad: http://opensource.adobe.com

¡Enhorabuena al equipo!

jueves, 31 de enero de 2008

Programa y llora

Desde hace meses estamos, en mi empresa, inmersos en un proceso de valoración de los puestos de trabajo (VPT) que componen el departamento de informática donde trabajo.

Básicamente se trata de adecuar los salarios a las tareas, responsabilidades, habilidades, capacidades, etc. que ponemos a disposición de nuestros usuarios/clientes.

Tengo que comentar, antes que nada, que trabajo como programador para la Administración. Sí, soy funcionario, pero... esto no es óbice para que tenga sentimientos!!!

Siempre me ha gustado el término "programador". Es un término lleno de romanticismo, pero hoy en día... poco valorado. Bill Gates, Paul Allen, Steve Jobs, Larry Ellison, Linus Torvalds, Richard Stallman, etc. seguro que se sienten orgullosos de decir que son, simplemente: programadores.

Pues en mi empresa, tras esta valoración realizada por una empresa consultora en RRHH de prestigio, de la zona donde trabajo, hemos decidido cambiar el término "programador" por el de "Técnico Medio en Informática". Triste, muy triste, pero... nos hemos visto obligados.

El resultado del informe, que esta empresa realizó, nos "dibuja" como profesionales con una iniciativa en la misma línea que el resto de los trabajadores de la "casa", sin un especial interés por estar formándonos continuamente (parece que no lo necesitamos para desarrollar nuestro trabajo), el grado de influencia de nuestros errores es bajo, tampoco realizamos un trabajo que requiera un gran esfuerzo mental y, además, es bastante fácil que cualquier persona con una experiencia similar a la nuestra se adapte al puesto y realice las mismas tareas que yo realizo y de forma adecuada.

Vamos que casi somos un fraude.

Yo, de momento, voy a intentar que me publiquen el libro Programa y llora (de la Editorial O'reilly) y, así, comprobar si puedo ganarme la vida mejor de este modo ;-)

martes, 29 de enero de 2008

Cambiando el estilo visual de una aplicación Flex

El estilo visual, por defecto, de una aplicación Flex es bastante bonito: ventanas con esquinas redondeadas, sombras, degradados, transiciones, etc.

Si bien, al final todas nuestras aplicaciones parecerán iguales. Esto puede ser bueno para los usuarios, que llegan a reconocer, a la primera, una aplicación y por intuición ya saben como manejarla... pero, para los desarrolladores o creadores, esto, hace de su tarea de creación algo aburrido y tedioso.

Para modificar el estilo de los componentes Flex de nuestras aplicaciones podemos hacer uso de CSS (sí, una cosa menos que aprender) y así cambiar la forma y color de nuestros botones, grids, selectores de fechas, etc.

Es tan fácil como poner al principio de nuestro documento mxml la siguiente línea de código:
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml">
<mx:Style source="myStyle.css"></mx:Style>
</mx:Application>
Aún así, nos queda el trabajo de diseña un estilo propio y bonito... pues aquí viene en nuestra ayuda la siguiente aplicación (desarrollada íntegramente en Flex y de la que podemos ver, incluso, su código fuente): Style Creator

Visualmente podéis editar el cómo os gustaría que quedasen vuestros componentes Flex y finalmente pulsar el botón "Download CSS", que os descargará el fichero CSS a utilizar en vuestra aplicación. Espero que disfrutéis de ella,