
guide
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
Semplici esempi di configurazione per definire navigazione statica e dinamica in JSF
Le impostazioni per gestire la navigazione tra le pagine JSF si basano su principi piuttosto semplici. Tutto viene scritto nel faces-config.xml
e le asserzioni sono decisamente facili da comprendere.
A sfavore di questa tecnica va sottolineato come per siti di certe dimensioni e con esigenze più complesse la stesura e lettura delle direttive potrebbe risultare caotica.
Creare la pagina “home.jsp”
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Navigazione JSF - Homepage</title>
</head>
<body>
HOMEPAGE <br />
<br />
Navigazione:
<f:view>
<h:form>
<h:commandLink action="pagina1" value="Vai alla prima pagina" />
</h:form>
</f:view>
</body>
</html>
Creare la pagina “target.jsp”
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Navigazione JSF - Target</title>
</head>
<body>
Pagina target
<f:view>
<h:form>
<h:commandLink action="HOME" value="torna alla home" />
</h:form>
</f:view>
</body>
</html>
Queste sono le due pagine del progetto.
E’ evidente che ciò che consente all’utente di passare da una pagina all’altra è il tag <h:commandLink>, ma il motore di tutta l’operazione sono le seguenti righe all’interno del faces-config.xml
:
<navigation-rule>
<from-view-id>/home.jsp</from-view-id>
<navigation-case>
<from-outcome>pagina1</from-outcome>
<to-view-id>/target.jsp</to-view-id>
</navigation-case>
</navigation-rule>
<navigation-rule>
<navigation-case>
<from-outcome>HOME</from-outcome>
<to-view-id>/home.jsp</to-view-id>
</navigation-case>
</navigation-rule>
Per definire la navigazione bisogna impostare delle regole, la prima regola che si può vedere (contenuta nel primo tag <navigation-rule>
) dice questo: se si è nella pagina home.jsp
e viene emesso in output una stringa “pagina1” allora va chiamata la pagina target.jsp
.
Questo tipo di regola è la più comune, viene definito un punto di partenza e si definisce un punto di arrivo basandosi su un output. Nel caso della pagina di esempio mostrata sopra, l’output è dato dall’attributo action del commandLink. All’interno della stessa regola è possibile definire anche più tag <navigation-case>
attivati da diversi output.
La seconda regola permette la navigazione da target.jsp
alla home, ed è diversa dalla prima in quanto non c’è nessun punto di partenza. In questo modo da qualunque pagina venga inviato in output la stringa “HOME” il framework reindirizzerà l’utente alla pagina indicata. Da notare invece che se uscisse un output “pagina1” da una pagina diversa da home.jsp
la regola descritta sopra non verrebbe attivata.
Testando questo primo esempio si otterranno le seguenti pagine:
E’ interessante notare come nella barra dell’indirizzo non cambi il riferimento nella pagina target, e se dalla pagina target si torna alla home, nella barra degli indirizzi apparirà l’url della pagina target. Questo è un dettaglio che potrebbe risultare sgradito, dunque per ovviarvi è possibile aggiungere un tag <redirect />
al’interno del faces-config.xml in questo modo:
<navigation-rule>
<from-view-id>/home.jsp</from-view-id>
<navigation-case>
<from-outcome>pagina1</from-outcome>
<to-view-id>/target.jsp</to-view-id>
<redirect />
</navigation-case>
</navigation-rule>
L’effetto collaterale di questa soluzione è che comporta una richiesta in più al server, che, benché abbia un peso minimo, può essere problematica in casi di connessione lenta.
Negli esempi precedenti si è vista una tecnica di navigazione che si può definire “statica”, in quanto ogni commandLink ha un output definito e dunque non può che puntare ad una sola pagina, e vista l’esigenza di mappare ogni pagina ad uno o più output non sarebbe niente di speciale se fosse limitata solo a questo utilizzo.
Dunque la parte saliente della navigazione JSF sta nella navigazione dinamica.
Il meccanismo non è affatto diverso dagli esempi visti prima, la direzione di navigazione è sempre diretta dai tag definiti nel faces-config.xml
, ma il tag action, nel quale viene definito l’output, può contenere, invece di una stringa, una funzione di un bean il cui risultato (della funzione) stabilisce l’output.
Come esempio per questa tecnica si illustrerà il progetto “Dado”.
Questo semplice programma chiederà all’utente di inserire un numero (tra 1 e 6) e poi di tirare il dado. A seconda del risultato verrà mostrata la pagina di vittoria o di sconfitta.
Per cominciare serve una classe Dado con un unica funzione:
package bean;
import java.util.Random;
public class Dado {
public Dado() { //... }
public int tiraDado() {
final Random r = new Random();
return (r.nextInt(6) + 1);
}
}
Questa classe servirà solo a calcolare casualmente il numero tra 1 e 6.
Anche se non verrà registrato come bean nel faces-config.xml per comodità viene messo comunque nel package bean.
Serve poi una classe Tentativo che invece sarà un vero e proprio bean con i relativi setter e getter dei due attributi di cui è fornita, ovvero numero e tentativo (vedere capitoli precedenti o progetto in allegato), l’uno per memorizzare il tiro del dado, l’altro il tentativo dell’utente.
Infine il controller:
package controller;
import bean.Dado;
import bean.Tentativo;
public class DadoController {
private final Dado d = new Dado();
private Tentativo t;
public String tiraDado() {
String risultato = "";
t.setNumero(d.tiraDado());
if (t.getTentativo() == t.getNumero()) {
risultato = "indovinato";
} else {
risultato = "sbagliato";
}
return risultato;
}
// ...
}
I getter
e setter
sono stati omessi per brevità, il cuore di questa classe è il metodo tiraDado() che calcola il risultato della supposizione dell’utente e torna una stringa: questa sarà la chiave che userà il framework per decidere verso quale pagina navigare.
E’ fondamentale ricordarsi sempre di registrare i propri beans nel faces-config.xml
.
In questo caso i bean da registrare sono 2: il bean tentativo e il bean dadoController, quest’ultimo con il bean tentativo registrato come valore dell’attributo t:
<managed-bean>
<managed-bean-name>dadoController</managed-bean-name>
<managed-bean-class>controller.DadoController</managed-bean-class>
<managed-bean-scope>request</managed-bean-scope>
<managed-property>
<property-name>t</property-name>
<property-class>bean.Tentativo</property-class>
<value>#{tentativo}</value>
</managed-property>
</managed-bean>
Per tenere in memoria il risultato del tiro del dado verrà usata la variabile numero della classe Tentativo, per cui il bean tentativo deve avere session come scope.
Per i dettagli relativi alla creazione dei bean rifarsi agli articoli precedenti.
Le pagine .jsp da creare sono 3:
PROGETTO DADO <br />
<br />
Indovina che numero uscirà col dado:
<f:view>
<h:form>
<h:inputText value="#{tentativo.tentativo}" required="true" label="Inserisci il numero" /><br />
<h:commandButton action="#{dadoController.tiraDado()}" value="tira il Dado!" />
</h:form>
</f:view>
</body>
Al click sul command button l’attributo action verrà valorizzato dalla funzione tiraDado()
e questo valore governerà la navigazione in base alla regola (scritta più avanti) sul faces-config.xml
.
Numero indovinato!
<f:view>
<h:outputLabel value="E' uscito il #{tentativo.numero}" /><br />
<h:form>
<h:commandLink action="HOME" value="torna alla home" /> <br />
<h:commandLink action="Dado" value="gioca ancora" />
</h:form>
</f:view>
Numero sbagliato!
<f:view>
<h:outputLabel value="hai puntato sul numero #{tentativo.tentativo} ma è uscito #{tentativo.numero}" /><br />
<h:form>
<h:commandLink action="HOME" value="torna alla home" /> <br />
<h:commandLink action="Dado" value="ritenta" />
</h:form>
</f:view>
Infine bisogna aggiungere al faces-config.xml
le regole di navigazione per l’output del commandButton della pagina dado.jsp
:
<navigation-rule>
<navigation-case>
<from-outcome>indovinato</from-outcome>
<to-view-id>/successo.jsp</to-view-id>
</navigation-case>
</navigation-rule>
<navigation-rule>
<navigation-case>
<from-outcome>sbagliato</from-outcome>
<to-view-id>/sbagliato.jsp</to-view-id>
</navigation-case>
</navigation-rule>
Le due regole sono assolutamente banali: se esce “successo” reindirizza alla pagina di successo, se esce “sbagliato” alla pagina sbagliato.jsp
.
In definitiva: la potenza e flessibilità della navigazione JSF è data dall’unione dell’utilizzo dei bean nella definizione degli attributi e dalle proprietà del faces-config.xml
. I primi permettono di avere attributi il cui valore viene definito dinamicamente dal codice scritto in Java, i secondi permettono di stabilire delle regole che valgono su tutto il sito e che sono di facile lettura e interpretazione.
In questo modo è possibile nonché relativamente semplice ed elegante definire una navigazione che possa essere sia prefissata sia stabilità dalle logiche del progetto.
Se vuoi aggiornamenti su Navigazione statica e dinamica in JSF inserisci la tua email nel box qui sotto:
Compilando il presente form acconsento a ricevere le informazioni relative ai servizi di cui alla presente pagina ai sensi dell'informativa sulla privacy.
La tua iscrizione è andata a buon fine. Se vuoi ricevere informazioni personalizzate compila anche i seguenti campi opzionali:
Compilando il presente form acconsento a ricevere le informazioni relative ai servizi di cui alla presente pagina ai sensi dell'informativa sulla privacy.
La proprietà intellettuale ci urta e ci intriga, ci annoia e ci sorprende. La verità è che è pervasiva, perché […]
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
Come creare applicazioni per il Web con PHP e MySQL per il DBMS.
Tutte le principali tecnologie per diventare uno sviluppatore mobile per iOS.
I fondamentali per lo sviluppo di applicazioni multi piattaforma con Java.
Diventare degli esperti in tema di sicurezza delle applicazioni Java.
Usare Raspberry Pi e Arduino per avvicinarsi al mondo dei Maker e dell’IoT.
Le principali guide di HTML.it per diventare un esperto dei database NoSQL.
Ecco come i professionisti creano applicazioni per il Cloud con PHP.
Lo sviluppo professionale di applicazioni in PHP alla portata di tutti.
Come sviluppare applicazioni Web dinamiche con PHP e JavaScript.
Fare gli e-commerce developer con Magento, Prestashop e WooCommerce.
Realizzare applicazioni per il Web utilizzando i framework PHP.
Creare applicazioni PHP e gestire l’ambiente di sviluppo come un pro.
Percorso base per avvicinarsi al web design con un occhio al mobile.
Realizzare siti Web e Web application con WordPress a livello professionale.
Impariamo ad utilizzare Takamaka, una blockchain Java Full Stack, per scrivere codice Java installabile ed eseguibile su una blockchain
Alcuni consigli su come preparare la migrazione dalla versione 4 alla versione 5 di PHP. Il supporto per la vecchia versione terminerà il 31 dicembre 2007 e gli aggiornamenti saranno garantiti solo fino ad agosto 2008
Le classi Transform e Matrix, utilizzate insieme, permettono di spostare e inclinare un clip. In questo articolo vediamo alcuni esempi di utilizzo di queste classi oltre alle differenze tra ActionScript 2 e ActionScript 3
Guida a Red Hat Quarkus, uno stack Java Kubernetes nativo pensato per applicazioni serverless e per la realizzazione di microservizi rapidi ed ottimizzati. Una piattaforma concepita per accedere in ambiente Cloud mettendo a disposizione un framework orientato ai microservizi, come ad esempio Spring Boot o Micronaut