Trinidad y Tobago

Hay veces que se nos puede dar el caso, que tenemos que realizar una página donde se van a registrar ciertos tipos de datos, en formularios diferentes, y queremos que una vez el usuario a rellenado todos los campos y los ha validado e insertado en la base de datos, mediante la pulsación de un botón, se de la posibilidad de limpiar y refrescar todos los campos de todos los formularios, para que pueda seguir registrando más datos sin necesidad de salir de la página y volver a entrar en ella.

Existe un objeto en ADF de tipo botón llamado Reset pero para este caso no nos serviría pues tendríamos que asociar uno por cada formulario que tengamos. La solución a nuestro problema sería crear un metodo que refresque el objeto ViewRoot. Se haría del siguiente modo:

    public void recargarPagina(FacesContext contexto) {
        String currentView = contexto.getViewRoot().getViewId();
        ViewHandler vh = contexto.getApplication().
            getViewHandler();
        UIViewRoot x = vh.createView(contexto, currentView);
        x.setViewId(currentView);
        contexto.setViewRoot(x);
    }

Si nos fijamos, este metodo recoge la vista actual de la página (viewId) y lo que hace básicamente es crearla de nuevo y crear un nuevo viewRoot. Una vez que hemos creado el nuevo viewRoot se lo asociamos al contexto y el entenderá que tiene que refrescar la página completamente.

ADF, igual que otros muchos frameworks, trae su propio sistema de gestión para procesar la subida de ficheros. En este tutorial vamos a aprender como hacerlo.

Lo primero que necesitamos es configurar en el fichero web.xml ciertos parametros necesarios para gestionar la subida del fichero, vamos a darle valor a las propiedades que se van a encargar de gestionar donde se almacenarán los ficheros temporales, y cual va a ser el tamaño máximo permitido para los ficheros y para el buffer de memoria:

    <context-param>
        <!– Memoria maxima para cada peticion (en bytes) –>
        <param-name>
            oracle.adf.view.faces.UPLOAD_MAX_MEMORY
        </param-name>
        <param-value>992000000</param-value>
    </context-param>
    <context-param>
        <!– Tamano maximo en disco por peticion (en bytes) –>
        <param-name>
            oracle.adf.view.faces.UPLOAD_MAX_DISK_SPACE
        </param-name>
        <param-value>992000000</param-value>
    </context-param>
    <context-param>
        <!– Directorio de los ficheros temporales –>
        <param-name>
            oracle.adf.view.faces.UPLOAD_TEMP_DIR
        </param-name>
        <param-value>/tmp/ADFUploads/</param-value>
    </context-param>

Una vez configurado el fichero web.xml, podríamos comenzar a generar nuestra página. Para poder realizar la subida de ficheros, el componente que vamos a necesitar es <af:inputFile>. Nuestra página además llevará un botón que llevará asociado el evento ActionEvent para procesar la subida de ficheros cuando se pulse el mismo.

    <af:messages />
    <af:inputFile label="Seleccione el archivo"
        value="#{backing_registro.file}" />
    <af:commandButton text="Enviar"
        actionListener="#{backing_registro.procesarUpload}" />

Un dato a tener muy en cuenta, ya que a veces se nos puede olvidar, es que a la etiqueta que define el form, ya sea <h:form> o <afh:form>, debe llevar seteada una propiedad para indicarle que lo que se va a gestionar es una subida de ficheros. Veamos que valor hay que dar dependiendo del tipo de form que hayamos establecido:

    <af:form usesUpload="true">

    <h:form enctype="multipart/form-data">

Solo nos quedaría realizar el código del backing bean, como indicamos antes, el metodo llevará como parametro un ActionEvent para capturar el evento lanzado por el actionListener. En el método lo que vamos a realizar es una comprobación previa que el fichero no nos llega nulo, y si el fichero llega correctamente mostraremos un mensaje por pantalla:

    private UploadedFile file;
   
    public void procesarUpload(ActionEvent evento) {
        UploadedFile file = getFile();
      
        if (file != null)
        {

            FacesContext context =
                FacesContext.getCurrentInstance();
            FacesMessage message = new FacesMessage(
                "Subida del fichero " + file.getFilename() +
                " satisfactoria (" + file.getLength() +
                " bytes)");
            context.addMessage(
                evento.getComponent().
                    getClientId(context),message);

            // Aqui procesariamos el fichero
            // para guardarlo donde queramos
       
        }
       
    }
   
    public UploadedFile getFile() {
        return file;
    }

    public void setFile(UploadedFile file) {
        this.file = file;
    }

Aún no habríamos guardado el fichero en nuestro servidor, ya es cuestión del programador realizarlo de una manera u otra, y para ello ya no es necesario ningún framework, con las librerías de Java debería bastar. De todos modos, si alguien tuviera dudas de como realizarlo, hacédnoslo saber y ampliaríamos el tutorial.

Si hemos realizado todo correctamente, la página nos quedaría del siguiente modo:

Pulsa la imagen para verla en más detalle.

Cuando tenemos aplicaciones web, que pueden ser visitadas por muchos tipos de clientes, es conveniente internacionalizar la misma. En Java, el método para ello, suele ser siempre el mismo, se crea un fichero properties por cada idioma, y las cadenas de texto que aparecen en nuestra página se cargan desde ese fichero.

En JSF o  ADF el proceso es similar, a continuación vamos a explicar paso a paso, como internacionalizar nuestra propia aplicación web.

Lo primero que debemos hacer será crear nuestro fichero properties, el nombre que debemos darle a este fichero, variará dependiendo de los idiomas que queramos que soporte nuestra página. Por ejemplo, si queremos que la aplicación soporte los idiomas inglés y español, deberemos crear dos properties con el siguiente formato :

• mensajes_ES.properties
• mensajes_EN.properties

Donde el código que va siguiendo al caracter _, será el correspondiente al idioma que se usa en el mismo.

El contenido de estos ficheros siempre será el mismo:

    KEY = CADENA

Por ejemplo si queremos mostrar el mensaje Bienvenido debemos rellenar en nuestros ficheros properties lo siguiente:

• mensajes_ES :

                SALUDO = Bienvenido

• mensajes_EN :

                SALUDO = Welcome

Debemos de tener en cuenta que las cadenas que insertamos en estos ficheros no llevan la doble comilla.

Vamos a ver ahora, como cargar estos ficheros en nuestras páginas. Estos ficheros se cargan justamente debajo de la declaración de directivas del fichero .jsf, y para ello hacemos uso del componente de JSF llamado <f:loadBundle>. A este componente debemos setearle dos propiedades:

• basename : nombre del fichero properties sin incluir el código del idioma.
• var : nombre por el que vamos a referenciar al fichero.

    …    <f:view>
       <f:loadBundle basename="mensajes"
          var="msg">
    …

Ya sólo queda asociarle dichos mensajes, a los distintos componentes que tengamos en nuestra ventana, esto se hace mediante el etiquetado EL:

    <af:panelBox text="#{msg['SALUDO']}">

Si queremos asociar varias cadenas diferentes dentro de una misma propiedad, el formato sería el siguiente:

    <af:panelBox text="#{msg['SALUDO']} #{msg['USUARIO']}">

Para terminar, sólo quedaría definir los lenguajes que soporta nuestra aplicación, en el fichero de configuración faces-config.xml, así como el bundle que vamos a utilizar:

    <application>
       
        <default-render-kit-id>
            oracle.adf.core
        </default-render-kit-id>
       
        <locale-config>
            <default-locale>es</default-locale>
            <supported-locale>en</supported-locale>
        </locale-config>

        <message-bundle id="mensajes">mensajes</message-bundle>
       
    </application>

Desde los ficheros .java, muchas veces, también mostramos mensajes por pantalla al usuario, estos mensajes también se pueden internacionalizar. La manera de realizarlo es creandonos un objeto de tipo ResourceBundle:

    …        
    ResourceBundle bundle = ResourceBundle.getBundle("mensajes");
    …

Y a través de este nuevo objeto, podemos acceder a las cadenas contenidad en el fichero properties que le hemos pasado como parámetro:

    //String mensajeSaludo = bundle.getString(key);
    String mensajeSaludo = bundle.getString("SALUDO");    

Es importate recordar, que las diferentes key que definamos, tienen que estar soportadas en todos los archivos properties que tengamos asociados a la aplicación, ya que sino, corremos el riesgo que a los usuarios, le aparezcan mensajes de error en la lectura del fichero, si no está soportado dicho mensaje en su idioma. Por tanto, es recomendable, si no sabemos traducir una palabra en otro idioma, dejar esa key sin traducir, al menos así, no le apareceran mensajes de error a los usuarios.

El idioma se configura automaticamente, es el navegador del cliente de nuestra aplicación, el que va a detectar, que fichero properties debe usar en cada momento. Por tanto, no debemos nosotros crear ninguna regla ni condición en nuestro código para ello.