4.5. Referenciar Recursos

Las aplicaciones web trabajan sobre la web y tienen varios recursos, como imágenes o archivos descargables, que el navegador web tiene que obtener desde el servidor. Estos recursos son utilizados típicamente en los componentes de interfaz de usuario Embedded (imágenes) o Link (archivos descargables). Varios componentes, tales como TabSheet, también pueden incluir iconos, los cuales también son manejados como recursos.

Un servidor web puede manejar muchas de estas peticiones de recursos estáticos sin tener que pedirlas desde la aplicación, o desde el que el objeto Application puede proporcionarnos. Para los recursos dinámicos, la aplicación de usuario debe ser capaz de crearlos dinámicamente. Vaadin proporciona interfaces de petición de recursos para las aplicaciones de modo que puedan devolver los diversos tipos de recursos, tales como archivos o recursos creados dinámicamente. Esto incluye las clases StreamResource y URI y controladores de parámetros descritos en la Sección 12.5.1, "Controlador de URI" y la Sección 12.5.2, "Controlador de Parametros", respectivamente.

Vaadin proporciona también herramientas de bajo nivel para la recuperación del URI y otros parámetros de una petición HTTP. En primer lugar, examinaremos cómo las aplicaciones pueden ofrecer diversos tipos de recursos y luego buscar en interfaces de bajo nivel para el manejo de los URIs y parámetros para proporcionar los recursos y funcionalidades.

Observe que el uso del URI o controladores de parámetro para crear "páginas" no es significativo en Vaadin o en aplicaciones AJAX en general. Por favor, consulte la Sección 12.1, "Caracteristicas Especiales de Aplicaciones AJAX" para una explicación detallada.

4.5.1. Interfaz y Clases Resource

Vaadin tiene dos interfaces para los recursos: una interfaz genérica Resource y una interfaz ApplicationResource más específica para los recursos proporcionados por la aplicación.

Figura 4.4. Diagrama de la Interfaz y Clase Resource

Los recursos de ApplicationResource son manejados por la clase Application. Cuando usted crea tal recurso, le da el objeto application al constructor. El constructor registra el recurso en la aplicación usando el método addResource.

Application maneja peticiones de los recursos y permite acceder a los recursos utilizando un URI. El URI consiste en el nombre de la base de la aplicación y un nombre relativo del recurso. El nombre relativo es "APP/"+iddelrecurso+"/"+nombredelarchivo, por ejemplo "APP/1/miimagen.png". iddelrecurso es un identificador numérico generado para hacer recursos únicos, y nombredelarchivo es el nombre de fichero del recurso proporcionado en el constructor de su clase. Sin embargo, la aplicación que utiliza un recurso no suele tener en cuenta su URI. Sólo tiene que dar el recurso a un Embedded o Link apropiado o a algún otro componente de interfaz de usuario, que maneje el renderizado del URI.

4.5.2. Recursos de Archivos

Los recursos de archivos son archivos almacenados en cualquier parte del sistema de archivos. El uso de los recursos de archivo generalmente, se divide en dos categorías principales: los archivos descargados y las imágenes embebidas.

Un objeto file que puede ser accedido como un recurso de archivo es definido con la clase estándar java.io.File. Puede crear el archivo, ya sea con una ruta absoluta o con una relativa, pero la ruta base de la ruta de acceso relativa depende de la instalación del servidor web. Por ejemplo, en Apache Tomcat, el directorio actual por defecto es la ruta de instalación de Tomcat.

4.5.3. Recursos de Cargador de Clase

ClassResource permite que los recursos sean cargados desde el paquete desplegado de la aplicación utilizando el Cargador de Clase de Java. En el ejemplo de una línea más abajo, se carga un recurso de imagen desde el paquete de la aplicación y es mostrado en un componente Embedded.

ventanaPrincipal.addComponent(new Embedded ("",
        new ClassResource("sonriente.jpg",
                  ventanaPrincipal.getApplication())));

4.5.4. Recursos de Tema (Estilo)

Los recursos de tema de la clase ThemeResource son archivos, generalmente imagenes, incluidas en un tema. Un tema es localizado en la ruta camino VAADIN/themes/nombredeltema en una aplicación web. El nombre de un recurso de tema es proporcionado como parámetro para el constructor, con una ruta relativa a la carpeta themes.

// Un recurso de tema en el actual tema ("book-examples")
// Localizado en: VAADIN/themes/book-examples/img/themeimage.png
ThemeResource recurso = new ThemeResource("img/themeimage.png");
 
// utilizar el recurso
Embedded imagen = new Embedded("Mi Imagen del Tema", recurso);

El resultado se muestra en la Figura 4.5, "Recursos de Tema", ilustra también la estructura de la carpeta para el archivo de recursos del tema en un proyecto de Eclipse.

Figura 4.5. Recursos de Tema

Para utilizar recursos de tema, debe establecer el tema para la aplicacion. Consulte el Capítulo 8, Temas para mayor informacion sobre los temas.

4.5.5. Recursos de Flujo

Los recursos de flujo son recursos de aplicaciones que permiten la creación de contenido dinámico de recursos. Los gráficos son ejemplos típicos de imágenes dinámicas. Para definir un recurso de flujo, es necesario implementar la interfaz StreamResource.StreamSource y su método getStream. El método debe devolver un InputStream desde el cual el flujo pueda ser leído.

El siguiente ejemplo muestra la creación de una simple imagen en formato de imagen PNG.

import java.awt.image.*;

public class MiFuenteImagen
             implements StreamResource.StreamSource {
    ByteArrayOutputStream bufferImagen = null;
    int recargas = 0;
    
    /* Necesitamos implementar este método que devuelve
     * el recurso como un flujo. */
    public InputStream getStream () {
        /* Crear una imagenn y dibujar algo en ella. */
        BufferedImage imagen = new BufferedImage (200, 200,
                               BufferedImage.TYPE_INT_RGB);
        Graphics dibujable = imagen.getGraphics();
        dibujable.setColor(Color.lightGray);
        dibujable.fillRect(0,0,200,200);
        dibujable.setColor(Color.yellow);
        dibujable.fillOval(25,25,150,150);
        dibujable.setColor(Color.blue);
        dibujable.drawRect(0,0,199,199);
        dibujable.setColor(Color.black);
        dibujable.drawString("Recargas = " + recargas, 75, 100);
        recargas++;

        try {
            /* Escriba la imagen en un búfer. */
            bufferImagen = new ByteArrayOutputStream();
            ImageIO.write(imagen, "png", bufferImagen);
            
            /* Devolver un flujo desde el buffer. */
            return new ByteArrayInputStream(
                         bufferImagen.toByteArray());
        } catch (IOException e) {
            return null;
        }
    }
}

El contenido de la imagen generada es dinámico, ya que actualiza el contador recargas en cada llamada. El método ImageIO escribe la imagen para un flujo de salida, mientras, tuvimos que devolver un flujo de entrada, por lo que almacenamos los contenidos de la imagen en un búfer temporal.

Puede utilizar los recursos de varias maneras. Algunos componentes de interfaz de usuario, como Link y Embedded, toman sus parámetros como un recurso.

A continuación se mostrará la imagen con el componente Embedded. El constructor StreamResource obtiene una referencia de la aplicación y se registra en los recursos de la aplicación. Supongamos que principal es una referencia a la ventana principal y this es el objeto application.

// Crear una instancia de nuestra fuente de flujo.
StreamResource.StreamSource fuenteImagen = new MiFuenteImagen();
 
// Crear un recurso que utiliza el origen de flujo y proporcinarle un nombre.
// El constructor registrará automáticamente el recurso en
// la aplicación.
StreamResource recursoImagen =
        new StreamResource(fuenteImagen, "miImagen.png", this);
 
// Crear un componente integrado que recibe su contenido
// del recurso.
principal.addComponent(new Embedded("Titulo de la imagen", recursoImagen));

La imagen se verá de la siguiente manera:

Figura 4.6. Pantallazo del ejemplo de recurso de flujo con una imagen embebida

Hemos llamado a este recurso como miImagen.png. La aplicación agrega una llave de recurso al nombre de archivo del recurso para hacerlo único. El URI completo será como http://localhost:8080/bancodepruebas/APP/1/miImagen.png. El APP/1/miImagen.png al final es la parte relativa del URI. Puede obtener la parte relativa de los recursos del URI desde la aplicación con Application.getRelativeLocation().

Otra solución para crear contenido dinámico es un controlador del URI, posiblemente junto con un controlador de parámetro. Vea la Sección 12.5.1, "Controlador de URI" y la Sección 12.5.2, "Controlador de Parametros".



Anterior
4.4. Controlar Eventos con Oyentes
Siguiente
4.6. Apagar una Aplicación

No hay comentarios.:

Publicar un comentario