lunes, 30 de junio de 2008

i18n Internacionalización en jsp con etiquetas

La internacionalización se emplea para realizar traducciones de partes de la web en determinados idiomas, dependiendo de donde sea el usuario que accede a la misma, teniendo una por defecto y otra(s) determinada(s) por el diseño de desarrollo.

Para realizar el proceso de internacionalización necesitamos incluir en el pom.xml (del proyecto que estemos tratando, en mi caso el de ayer: eticom-discografica-servlet-JSTL),
la dependencia 'standar-1.1.2.jar' (en mi caso ya la añadimos ayer).

Los distintos idiomas que vamos a emplear se crean a partir de distintos ficheros con distintas traducciones, teniendo uno por defecto (Nombre.properties), que normalmente es en inglés, y luego los concretos, cuyo nombre es igual pero con el distintivo del idioma: Nombre_en.properties (inglés), Nombre_es.properties (español), etc. Estos archivos van situados en el source folder 'src/main/resources'.

En mi caso he creado 3 files: Discografica.properties (por defecto),
Discografica_es.properties y Discografica_en.properties, en las que he inlcuido las claves y sus correspondientes traducciones.

Ahora realizo la importación de la librería 'fmt' en la página .jsp que quiera, yo lo hago en index.jsp:

<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>

Seguidamente cargo el archivo de traducciones, el cual hay que cargar una vez por cada página .jsp:

<fmt:setBundle basename="Discografica"/>

Para mostrar las traducciones:

<h2><fmt:message key="hola"/></h2>
<h2><fmt:message key="webmaster"/></h2>

Hay que tener muy en cuenta, que para no tener que cargar las traducciones en cada una de las páginas jsp, hay que indicar las traducciones en el archivo 'web.xml' añadiendole este código:

<context-param>
<param-name>javax.servlet.jsp.jstl.fmt.localizationContext</param-name>
<param-value>Discografica</param-value>
</context-param>

El resultado del web.xml.

enlaces: foro.

JSTL y etiquetas personalizadas

JSTL (JavaServer Pages Standard Tag Library): sirve para separar en un JSP, el código java del código de representación.

Partiendo del proyecto del viernes (eticom-discografica-servlet), vamos a modificarlo empleando etiquetas personalizadas, que son etiquetas de uso parecido a las etiquetas HTML para la representación de datos en el archivo jsp (Servlet). Este proyecto es el "
eticom-discografica-servlet-JSTL".
Lo primero que haremos será crear una nueva dependencia (Maven/add dependency):



Ahora hacemos una clase (SimpleTag.java) que extienda de TagSupport.
Implemento los métodos 'doStartTag' y 'doEndTag', a través de la ruta menú Contextual/source/Override/Implements Methods. Esta clase va a servir para representar su contenido con un formato determinado, en este caso vamos a aplicarle color a un texto. La clase queda así: SimpleTag.java. Como se puede ver, se han implementado los getter y setter de los atributos (color y mensaje).

Después creamos el TLD (Tag Library Descriptor), es decir, el archivo librería donde vamos a describir las etiquetas que vamos a usar. Así pues, creamos una carpeta llamada TLD en la carpeta WEB-INF de nuestro proyecto, y dentro de ella el archivo 'simple.tld'. El resultado de este archivo es este: simple.tld.

Ahora tenemos que definir las librerías de etiquetas en el archivo web.xml. Incluimos la creada anteriormente (simple.tld). El archivo queda así: web.xml (solo hemos añadido la etiqueta jsp-config, lo demás estaba ya).

Finalmente importamos la librería en nuestro archivo JSP. Esto es lo que hay que incluir:


...yo lo añado en mi 'index.jsp'. uri="/simple" indica el lugar donde está la librería, y prefix="ex" indica que las etiquetas que comiencen con ex pertenecen a 'simple.tld'. Podíamos haber puesto cualquier otro prefijo. Si en la etiqueta donde he puesto el colo y el mensaje (ex:simpleTag color="red" mensaje="discografia con TLDs") no pongo el atributo mensaje, me sale el mensaje por defecto, que es el que pusimos en la clase SimpleTag.java, en mi caso "Hola bola Tag!!!". Igual ocurre con el color, que en la clase tengo por defecto el color negro, por lo que si omito el atributo color a la etiqueta, en vez del color que pongamos en la etiqueta, aparecerá el color por defecto.

Ahora arrancamos el servidor jetty ejecutamos en la barra de direcciones del navegador la direccion http://localhost:8080/ y vemos que nos sale el texto "discografica con TLDs" en rojo.


-------------------

Ahora vamos a crear otra etiqueta dentro del simple.tld, para lo cual tenemos que crear otra clase (ImgTag.java). Luego en simple.tld, creamos otra etiqueta 'tag' de nombre 'imgTag'. Ya en el archivo jsp, creamos otra etiqueta, en este caso etiqueta imgTag: --ex:imgTag url="http://www.....jpg"--

-------------------

Para poder utilizar librerías estandars (incluídas en la especificación de JSP) vamos a incluir una nueva dependencia en pom.xml: el 'taglibs standard' version 1.1.2.
Estas librerías estandars son:
  • core: para iteraciones, condicionales, manipulación de URLs y otras funciones generales.
  • xml: para la manipulación de XML y para XML-Transformation.
  • sql: para gestionar conexiones a bases de datos.
  • i18n: para la internacionalización y formateo de las cadenas de caracteres como cifras.
  • fn:
Una vez añadida la dependencia, y dentro del JSP, podemos hacer referencia a las librerías a través de los imports:

<%@taglib uri="http://java.sun.com/jstl/core_rt" prefix="c" %>

<%@taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>

<%@taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>

<%@taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql" %>

<%@taglib uri="http://java.sun.com/jsp/jstl/xml" prefix="x" %>

Para ver ejemplos relacionados con la librería 'core', pincha en el ejemplo index.jsp.

Enlaces de interés: Librerías de etiquetas, JSTL

viernes, 27 de junio de 2008

Instalacion de eclipse jee y plugins

Para instalar el eclipse JEE, lo descargo de algunos de los espejos de la web. Una vez descargado lo descomprimo y lo renombro como 'eclipseJEE' para que no coincida con la versión de eclipse clásico, y lo coloco en Archivos de Programa. Ejecuto el archivo 'eclipse.exe'.

Me pide que seleccione un Workspace. Selecciono el mismo que tengo, esto es, 'C:\Workspace'.


Ahora voy a instalar los plugins siguiendo la ruta
eclipse>Help>software updates...>find and install >search for new fetures for install> new remote site:
  • Subversion
    • name:svn-subclipse
    • url: http://subclipse.tigris.org/update_1.4.x
  • TestNG
    • name:testng
    • url:http://beust.com/eclipse
  • MAVEN
    • name: maven-m2eclipse
    • url:http://m2eclipse.sonatype.org/update/

martes, 17 de junio de 2008

Desarrollo de modulo Maven para hacer 'mailing'

Hoy vamos a crear un módulo Maven para realizar un envío de correo electrónico basándonos en 4 parámetros de datos:
  • String cuentaGmailRemitente
  • String claveGmailRemitente
  • String destinatario
  • String mensaje
Para ello debemos implementar una interfaz (llamada ServicioMail), que contiene un método al que se le pasan los 4 parámetros anteriores. La interfaz la implementamos a través de la clase 'ServicioMailImpl'.

Todos estos pasos están perfectamente explicados aquí (si quieres más información teórica pincha aquí).

Ahora vamos a implementar el módulo anterior dentro de un servlet (http://localhost:8080/olvidoClave), para que, a través de un formulario, nos pida la dirección de correo electrónico (textfield) y podamos enviarlo (mediante un boton -enviarClave-). Una vez enviado nos manda a otro servlet (
http://localhost:8080/envioClave).

jueves, 12 de junio de 2008

Seguimos con Maven

En eclipse, nos bajamos del repositorio el proyecto ServletEticom y después, menú contextual sobre el archivo "pom.xml/run as/Maven build...". En 'goals' escribimos "jetty:run". Veremos en consola que se inicia una aplicación web que se descarga Maven a tavés del servidor "jetty". Si abrimos en un navegador la dirección "http://localhost:8080", veremos que se ha creado una página web.
Es definitiva, que con la orden jetty:run, le estamos diciendo que a través del servidor jetty, corra el archivo pom.xml en un navegador.

Como decía ayer,
POM las iniciales de "Project Object Model", es un archivo XML en el que se definen las configuraciones del proyecto, desarrolladores que participaran, los roles de los desarrolladores, la organización, licencias, la URL, las dependencias/librerías. (info oficial de pom.xml).
Si abrimos ese archivo pom.xml, vemos como, en la primera línea, aparece su version y su encoding. Si queremos que eclipse pueda validarnos el documento hay que indicar el Schema dentro de la etiqueta proyect...

xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd"

Este tipo de archivos se puede ser validado por DTD (descripción de estructura y sintaxis de un documento XML, que es en texto plano) o mediante un schema (también XML).

Si queremos crear un proyecto Maven desde eclipse, File/new/project/en wizards buscamos maven y seleccionamos Maven Project. 3 veces siguiente y..
Group Id: eticom
Artifact Id: ejemplo (es el nombre del proyecto, si Maven ve que el proyecto es dependiente de otro, lo añade como dependencia)
Version: 0.0.1-SNAPSHOOT

miércoles, 11 de junio de 2008

MAVEN

En eclipse, ruta: window/preferences/java/Installed JREs añadimos el JRE home directory "C:\Archivos de programa\Java\jdk1.6.0_06" y lo activamos por defecto. Aceptamos

Nos descargamos el archivo apache-maven-2.0.9-bin.zip y extraemos su contenido en archivos de programa/java (se puede poner donde queramos). Creamos una nueva variable de entorno llamado JAVA_HOME cuya ruta es C:\Archivos de programa\Java\jdk1.6.0_06. Y en la variable Path insertamos otra ruta: C:\Archivos de programa\Java\apache-maven-2.0.9\bin. Aceptamos.

En la ruta "C:\Documents and Settings\Administrador\.m2" añadimos el repositorio descargado del foro de eticom. ESTE ES NUESTRO REPOSITORIO LOCAL.

En consola escribimos "mvn --version"para ver que todo ha ido bien y ver nuestra versión.

Para crear un proyecto nos vamos a la consola, nos colocamos en C:\workspace> y escribimos:

mvn archetype:create -DgroupId=eticom -DartifactId=rafa

...y nos crea un proyecto llamado rafa en el workspace, con toda su estructura (src y test), con sus paquetes y clases de prueba. En palabras de Juan.. "una estructura de directorios estandar (incluyendo tests) y un archivo maven de proyecto llamado pom.xml donde se configuran las dependencias y posibles targets para este proyecto
".
archetype:create es el comando de maven que crea el proyecto, -DgroupId=eticom son los paquetes de nuestro proyecto, y -DartifactId es el nombre del proyecto.

Para realizar operaciones con el proyecto, nos metemos en su directorio y ejecutamos los comandos, tales como:

COMPILAR: mediante el comando "mvn compile", que crea un directorio target justo donde está el archivo pom.xml, y un subdirectorio llamado classes, donde se incluirán todos los archivos .class generados por nuestro proyecto.

GENERAR .JAR: ejecutando "mvn package", si es necesario compilará y después pasará las clases de test de JUnit, y si no tiene errores, incluirá en el directorio target, nuestro archivo .jar.

INSTALAR EL .JAR DE NUESTRO PROYECTO EN EL REPOSITORIO: mediante la línea de comando "mvn install"

REPOSITORIOS de ficheros .jar (los oficiales de maven): maven, a medida que los necesita, se los va descargando en el directorio local "C:\Documents and Settings\Administrador\.m2\", y si los vuelve a necesitar, ya tira de aquí.

DEPENDENCIAS: si queremos bajarnos unos .jar por nosotros mismos, hay que editar el archivo "pom.xml"; en la etiqueta 'dependency' por defecto viene groupId="junit", artifactId="junit", version=3.8.1 y scope=test. Si lo que buscamos es descargarnos el 'log4j' iríamos a los.jar oficiales de Maven, y navegamos hasta llegar al archivo .pom del paquete 'log4j' (aquí el de la versión 1.2.9); finalmente añadimos la dependencia, del mismo modo que el 'junit'.
En Eclipse, menú contextual sobre pom.xml/Maven/Add dependecy. En Query escribimos la dependencia que queramos. Si escribimos TestNG aparecerán todas ellas, en sus distintas versiones; nosotros escogeremos la que utilicemos en nuestro proyecto.

JAVADOC: el javadoc o documentación se crea ejecutando la siguiente línea de comando "mvn javadoc:javadoc"

INTEGRACIÓN con Eclipse: para integrar nuestro proyecto con eclipse, ejecutamos el comando "mvn eclipse:eclipse", con lo que la estructura del mismo se amolda a uno de eclipse. Ahora hay que crear una variable interna para acceder a las librerías de Maven:
mvn -Declipse.workspace=<path_al_workspace_de_eclipse> eclipse:add-maven-repo (el path a mi workspace es C:\workspace).

Ahora vamos a abrir el proyecto creado (llamado "rafa") en el eclipse, lo cual se ahce por la ruta File/new Java proyect/from existing source, entonces seleccionamos la ruta donde se encuentre y le damos el mismo nombre (rafa).

Ahora toca instalar el plugin (instrucciones)... En el menú de Eclipse: Windows/Software Updates/Find and Install/Search for new features to install/siguiente/New remote site, y le añadimos Maven como name y la dirección siguiente:
http://m2eclipse.sonatype.org/update/. Le damos a OK y lo instala. Antes de acabar, seleccionamos el Maven, pichamos en el + para que abra el árbol y seleccionamos todos menos el que está en medio, ya que da conflicto. Ahora, para ver la ventana de Maven en Eclipse pinchamos Window/Show view/Other/Maven Indexes. ENHORABUENA! YA TIENES INSTALADO EL PLUGIN DE MAVEN!

links:
primeros pasos

Trabajando con ANT

Ya instalamos y vimos por encima la instalación y funcionamiento de ANT.
Hoy vamos a crear scripts.. para ello, basta con crearse un archivo llamado "build.xml" (se puede hacer por consola o por un proyecto eclipse).

A través de consola:
En mi caso lo crearé en C:\ para facilitar la ruta, esto es: "c:\build.xml". Partiendo del siguiente código, vemos como la creación del archivo va entre las etiquetas project (lineas 3 y 29). Dentro creamos una definición de lo que serán las tareas del archivo ANT.
A continuación las propiedades que utilizaremos en el desarrollo del mismo. Dentro de las etiquetas property (de la línea 10 a la 14) nos encontramos con sus atributos; en el caso de la property de la línea 11, estamos creando una propiedad de nombre "META-INF" en la carpeta "miapp/META-INF", y así con todas.

Finalmente tenemos las etiquetas target, en este caso dos, pero pueden ser las que queramos. Hemos indicado que por defecto se ejecute el target de nombre "construir", por lo que si queremos ejecutar dicho target, nos vamos a la consola, y en c:\ ejecutamos el comando "c:\>ant" y se ejecutaría. En el caso del tarjet de nombre borrar, hay que especificarlo en el comando:
"c:\>ant borrar".
El primero de los targets nos crea los directorios (mkdir dir) y el fichero xml (touch file), mientras que el segundo borra todo (delete dir), ya que borra el directorio que contiene a todo lo demás.

A través de Eclipse
El mismo archivo "build.xml" (se puede llamar como queramos) lo colocamos en la carpeta principal de un proyecto. Abrimos el pluggin ANT que viene instalado por defecto en Eclipse (Window/show view/Ant) y arrastramos el fichero build.xml a la ventana Ant y veremos todos los targets diponibles. Si hacemos doble click en el archivo principal, se ejecuta el target por defecto, aunque podemos clickear uno independiente. Los resultado aparecen por la consola del eclipse.

Otro ejemplo de archivo tipo Ant es este, que crea una distribución de directorios al estilo de un proyecto java, creando un archivo .jar de un proyecto pasado por propiedad, y finalmente creando un archivo tipo .war.

martes, 10 de junio de 2008

XML (Extensible Markup Language)

Es un metalenguaje extensible de etiquetas desarrollado por el World Wide Web Consortium (W3C) no es realmente un lenguaje en particular, sino una manera de definir lenguajes para diferentes necesidades. Se propone como un estándar para el intercambio de información estructurada entre diferentes plataformas (Bases de datos, editores de texto, hojas de cálculo, etc).

Ventajas del XML:
  • Es extensible, lo que quiere decir que una vez diseñado un lenguaje y puesto en producción, igual es posible extenderlo con la adición de nuevas etiquetas.
  • El analizador es un componente estándar, no es necesario crear un analizador específico para cada lenguaje.
  • Mejora la compatibilidad entre aplicaciones.
XML busca dar solución al problema de expresar información estructurada de la manera más abstracta y reutilizable posible (se compone de partes bien definidas). Entonces se tiene un árbol de pedazos de información.
Una etiqueta consiste en una marca hecha en el documento, que señala una porción de éste como un elemento. Un pedazo de información con un sentido claro y definido.

Un documento XML está formado por el prólogo (es opcional) y por el cuerpo del documento (obligatorio y único).

http://es.wikipedia.org/wiki/XML

http://www.w3schools.com/xml/default.asp


lunes, 9 de junio de 2008

Instalando ANT

Del link http://apache.rediris.es/ant/binaries/apache-ant-1.7.0-bin.zip nos bajamos el ANT.

Descomprimimos el archivo en la carpeta java (se puede poner donde queramos). Ahora copiamos la ruta donde está el bin de ANT (C:\Archivos de programa\Java\apache-ant-1.7.0\bin) y la ponemos en el path de windows: menu contextual sobre Mi PC/propiedades/Opciones avanzadas/variables de entorno/variables del sistema/Path. Aceptamos y abrimos una consola MSDOS y ejecutamos "ant -version" para ver que todo ha ido bien.

(Aquí hay un problema en el que hay que sustituir el archivo tools.jar de la carpeta lib de jdk -C:\Archivos de programa\Java\jdk1.6.0_06\lib- y se lo pasamos a C:\Archivos de programa\Java\jre1.6.0_06\lib).

Ahora nos creamos un archivo donde queramos llamado "build.xml" con el siguiente código este..

En la consola, con la ruta donde hayamos creado el archivo, ejecutamos el comando ant y nos aparece por pantalla la parte del código donde "echo message".

Ejemplo:

C:\Workspace\eticom-jdbc>ant
Buildfile: build.xml

help:
[echo]
[echo] -----------------------------------
[echo]
[echo] Posibles tareas en este archivo ant:
[echo]
[echo] populate --> Inserta filas en la tabla links
[echo] clear --> Borra las filas de la tabla links

BUILD SUCCESSFUL
Total time: 0 seconds


En definitiva, esto consiste en construir el archivo build.xml donde se compondran tareas (tasks) a las que llamaremos desde nuestro código, y que se irán definiendo según nos vayan haciendo falta. Hay una tarea por defecto (default = taskx). Estas tareas se procesan por orden, pasando por todas ellas. Ant incluye algunas tareas básicas, como compilacion y eliminación de ficheros temporales, pero pero podemos crear las que nos hagan falta.

Dos tutoriales:
http://www.marioalberto.com.mx/articulos/java_ant_basico.php (Relacionado con la instalación) http://www.javahispano.org/contenidos/es/introduccrion_a_ant/ (Relacionado con la introducción a ANT)

jueves, 5 de junio de 2008

Transformar el ResultSet en Colección Link

A través del Administrador de MySQL, en la base de datos delicious creamos una tabla "personas" con dos campos (id -int- y nombre -varchar(50)-).

En el proyecto "eticom-jdbc", para hacer una consulta:
  1. Cargamos el driver
  2. Creamos la conexión
  3. Creamos el Statement
  4. Obtenemos ResultSet -> statement.executeQuery(sql); (para consulta) statement.executeUpdate(sql); (para actualizar) statement.executeInsert(sql); (para insertar)
  5. Mostrar datos
Ejemplo

¿Qué hacer con un ResultSet?
es obligatorio realizar el bucle siguiente...

    List links = new ArrayList();
    while(rs.next()){
        Link link = new Link();
        link.id = rs.getInt(0);
        link.nombre = rs.getString(1);
        links.add(link);
    }

..
.para guardar los valores del ResultSet (sin forma) en una Colección de List con los datos ya transformados en un modelo de objetos (con sus propiedades) de tipo Link.
Otra forma de hacerlo más rápida y avanzada es mediante el O.R.M. (Object Relational Mapping -> Object se refiere a la POO, Relational a la relación de JAVA y POO, y Mapping a la información del mapeo), que es sinónimo de Hybernate: Ejemplo.

martes, 3 de junio de 2008

Instalando MySQL

Extraemos el archivo .zip "mysql-5.0.45-win32.zip", y lo ejecutamos. Le decimos configuración tipica y siguiente hasta "Data usage" en la que seleccionamos "Multifunctional Database". Después siguiente hasta Windows options, en la que también activamos "Include Bin Directory in Windows PATH".. y siguiente y final.

Ahora ejecutamos el "mysql-gui-tools-5.0-r12-win32.msi".. es todo siguiente..

De MySQL emplearemos "MySQL Administrator" y "MySQL Query Browser". Cuando iniciamos la aplicación (MySQL Administrator) hay que meterle:

Server host: localhost
Username: root
Password: ******

pinchamos en el apartado Catalogs. En Schemata con el menú contextual "Create New Schema". Le damos como nombre "delicious". Creamos una tabla con dos campos "ID" y "nombre", y "Apply changes".
Si le damos a menú contextual "Edit Table Data" se nos abre el "My SQL Query Browser" y ahí le podemos añadir información a la tabla, pinchando en el botón "Edit".
______________

Para acceder a MySQL desde la consola:

mysql --user=root -p
show database

lunes, 2 de junio de 2008

Librería SWING

En swing, los botones y demás componentes no heredan de Component, sino directamente de Container. Su paquete es "javax.swing".
El botón que cierra la ventana est´automáticamente habilitado, y los controles/componentes no se incluyen directamente al objeto container sino al objeto "ContentPane" del container:

JComponent.getContentPane().add(x);