4,5. Hacer referencia a los recursos


4,5. Hacer referencia a los recursos

Las App Web trabajan sobre la web i tienen varios recursos, como imagenes, archibos descargables, que los navegadores tienen que recibir del Server. Esos recursos se suelen usar en imagenes incrustadas (Embedded) o links “piezas de interacciones de usuarios” (archibos descargables). Varias piezas, como las “TabSheet - Las pestanyas” pueden tambien incluir iconos, que son manejados tambien como recursos.

Un server Web puede manajar muchas solicitudes para recursos estaticos sin tener que hacer pedidos a la App, o el objeto App tener que estar suministrandolos. Para recursos dinamico, la App del usuario tiene que poder crearlos dinamiacamente. Vaadin lleva “interacciones solicitudes de recursos” para Apps para que puedan devolver varios tipos de recursos, como un archibo o un recurso creado dinamicamente. Esto incluye la classe “StreamResource” una URI i un manejador de codigo que se explica en el Capitulo 12.5.1 “Manejadores URI” i en el capitulo 12.5.2 “Codigos de manejo”.

Vaadin tambiel lleva ayudantes de bajo nivel para recuperar el URI o otros codigos de una solicitud HTTO. Primero miraremos como las Apps pueden llevar distintos tipos de recursos i luego mirar interacciones de bajo nivel para manejar URIs i codigos para llevar recursos i utilidades.

Date cuenta que usando URI o codigos de manejo para crear “paginas” no es muy inteligente en Vaadin o Apps AJAX en general. En el Capitulo 12.1 “Rasgos especiales de las Apps AJAX” para una explicacion mas detallada.

4.5.1. Interacciones con recursos y classes.

Vaadin lleva 2 tipos de interacciones con recursos: Un interaccionador de recursos general, y otro mas especifico (ApplicationResource) que le distribuye la App.

Figura 4.4. Interacciones con recursos y diagrama de classes.

Los recursos “ApplicationResource - AppRecursos” son manejadas por las classes App. Cuando creas algun recurso, le das “el objeto App” al constructor. El constructor registra el recurso en el App usando el codigo “addResource - sumaRecurso”.

La App maneja solicitudes para los recursos i permite el accesso a los recursos usando una URI. La URI consiste en el nombre base de la App i un nombre relativo al recurso. El nombre relativo es “APP/”-resourceid+“/”+filename, por ejemplo “APP/1/myimage.png”. El id del recurso es un numero de identificacion generado para hacer los recursos unicos, i el filename es el nombre del archibo del recurso que se ha dado en el constructor de su classe. La App usando un recurso no quiere decir que tienes que prestar atencion a la URI. Solo tiene que dar al recurso un incrustado apropiado o un link o cualquier otra pieza de interaccion de usuario, que maneje i assista al URI.

4.5.2. Recursos Archibo

Los recursos archibo son archibos guardados en cualquier parte en el sistema de archibos. El uso de los recursos generalmente se agrupa en dos categorias: descargable i imagenes incrustadas.

Un Archibo objeto que puede ser accedido como recurso archibo es definido con el standard “java.io.File.class”. Tu puedes crear el archibo tambien con un camino absoluto o relativo, pero la base del camino en los caminos relativo depende en la instalacion del server web. Por ejemplo, en Apache Tomcat, la carpeta standard por defeco es el camino a la carpeta del Tomcat.

4.5.3. Classe cargadora de recursos.

La “ClassResource” permite a los recursos ser cargados a partir del pakete desplegado de la App usando la Classe Java Loader. El codigo de una linea del exemplo que viene a continuacion carga una imagen recurso desde el pakete App i muestra la imagen en una pieza incrustada.


mainwindow.addComponent(new Embedded ("",
        new ClassResource("smiley.jpg",
                  mainwindow.getApplication())));

ventanaprincipal.sumaPieza(nueva Incrustacion ("",
        nueva ClasseRecurso("smiley.jpg",
                  ventanaprincipal.recibeApp())));

4.5.4. Recursos Tematica

Los recursos de tematica son archibos incluidos en una tematica, normalmente imagenes. Ver Capitulo 8, Tematicas para mas informacion sobre las Tematicas.

4.5.5. Recursos Corrientes

Los recursos corrientes son recursos App que te permiten crear contenidos recursos dinamicos. Graficos, son tipicos ejemplos de imagenes dinamicas. Para definir un recurso corriente, tienes que usar la herramienta de interacciones “StreamResource.StreamSource - Recurso Corriente.CorrienteCodigo” i su codigo “getStream - recibeCorriente”. Este codigo nessesita devolver un “InputStream - IntroductorCorriente” desde el cual la corriente pueda ser leida.

El siguiente ejemplo demuestra la creacion de una imagen simple usando el formato PNG.

The following example demonstrates the creation of a simple image in PNG image format.


import java.awt.image.*;

public class MyImageSource
             implements StreamResource.StreamSource {
    ByteArrayOutputStream imagebuffer = null;
    int reloads = 0;
    
    /* We need to implement this method that returns
     * the resource as a stream. */
    public InputStream getStream () {
        /* Create an image and draw something on it. */
        BufferedImage image = new BufferedImage (200, 200,
                               BufferedImage.TYPE_INT_RGB);
        Graphics drawable = image.getGraphics();
        drawable.setColor(Color.lightGray);
        drawable.fillRect(0,0,200,200);
        drawable.setColor(Color.yellow);
        drawable.fillOval(25,25,150,150);
        drawable.setColor(Color.blue);
        drawable.drawRect(0,0,199,199);
        drawable.setColor(Color.black);
        drawable.drawString("Reloads="+reloads, 75, 100);
        reloads++;

        try {
            /* Write the image to a buffer. */
            imagebuffer = new ByteArrayOutputStream();
            ImageIO.write(image, "png", imagebuffer);
            
            /* Return a stream from the buffer. */
            return new ByteArrayInputStream(
                         imagebuffer.toByteArray());
        } catch (IOException e) {
            return null;
        }
    }
}

llevate java.awt.image.*;

collectivo classe MiImagenCodigo
             herramientas CorricenteRecursos.CorrienteCodigo {
    ByteSandboxSalidaCorriente imagebuffer = nulo;
    int regargas = 0;
    
    /* Nessesitamo herramientizar este rercurso para que devuelva
     * el recurso como una corriente.. */
    collectivo IntroductorCorriente recibeCorriente () {
        /* Crea una imagen i dibuja algo encima de ella. */
        BufferedImagen imagen = nueva BufferedImagen (200, 200,
                               BufferedImagen.TIPO_INT_RGB);
        Graficos pintables = imagen.recibeGraficos();
        pintables.colocaColor(Color.luzGris);
        pintables.rellenaRecta(0,0,200,200);
        pintables.colocaColor(Color.Amarillo);
        pintables.rellenaOvalo(25,25,150,150);
        pintables.colocaColor(Color.azul);
        pintables.pintaRecta(0,0,199,199);
        pintables.colocaColor(Color.negro);
        pintables.pintaCadena("Recargas="+recargas, 75, 100);
        recargas++;

        intenta {
            /* Dibujar imagen al buffer. */
            imagenbuffer = nuevo ByteSandboxSalidaCorriente();
            ImagenIO.write(imagen, "png", imagenbuffer);
            
            /* Devuelve corriente del buffer. */
            devuelve nuevo ByteSandboxSalidaCorriente(
                         imagenbuffer.alByteSandBox());
        } captura (IOException e) {
            devuelve nullo;
        }
    }
}

El contenido de la imagen generada és dinamico, porque se recarga el contador de recargas por cada llamada. El codigo “ImageIO.write() - ImagenIO.escribe()” escribe la imagen a una corriente de salida, como tenemos que devolver un introductor de corriente, asi que hemos archibado los contenidos de la imagen en un buffer temporal.

Puedes usar recursos en varios caminos. Algunas “piezas de interacciones de usuario”, como es un link i un incrustado, cogen sus transformables como recursos.

A continuación ensenyamos la imagen con la pieza incrustada. El constructor “StreamResource - Recurso Corriente” recibe una referencia hacia la App i se registra en los recursos de la App. Assume que principal es una referencia de la ventana principal i estos es el objeto App.


// Create an instance of our stream source.
StreamResource.StreamSource imagesource = new MyImageSource ();
	
// Create a resource that uses the stream source and give it a name.
// The constructor will automatically register the resource in
// the application.
StreamResource imageresource =
        new StreamResource(imagesource, "myimage.png", this);
 
// Create an embedded component that gets its contents
// from the resource.
main.addComponent(new Embedded("Image title", imageresource));

// Crea una fotografia de nuestra corriente de codigo.
CorrienteRecurso.CorrienteCodigo imagencodigo = nuewva MiImagenCodigo ();
	
// Crea un recurso que usa la corriente codigo i dale un nombre.
// El constructor automaticamente registrara el recurso en la App
CorrienteRecurso imagenrecurso =
        nueva CorrienteRecurso(imagencodigo, "miimagen.png", esta);
 
// Crea una pieza incrustada que reciba sus contenidos
// del recurso.
principal.sumaPieza(nuevo Incrusto("Imagen Titulo", imagenrecurso));

La imagen se va a ver como a continuación:

Figura 4.5. Impr paint de la corriete recurso del ejemplo con una imagen incrustada.

Hemos nombrado el recurso como miimagen.png. La App suma una clave recurso al nombre del archibo del recurso para hacerlo unico. La URI completa va parecer como http://localhost:8080/testbench/APP/1/myimage.png. El final APP/1/myimage.png es la parte relativa del URI. Puedes recibir la parte relativa de los recursos URI a partir de la App con “Application.getRelativeLocation() - App.recibeRelativaLocalizacion()”.

Otra solucion para crear contenidos dinamicos es un manejador de URI, possiblemente conjunto con un manejador de transformable. Mira el capitulo 12.5.1, “Manejadores URI” i el capitulo 12.5.2, “Manejo de transformables”