FAQ JSFConsultez toutes les FAQ

Nombre d'auteurs : 8, nombre de questions : 70, dernière mise à jour : 10 juin 2008  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums de http://www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant rédacteur, lisez ceci.


SommaireLes bases de JSF (9)
précédent sommaire suivant
 

Dans faces-config.xml, on ajoute l'élément suivant :

Code xml : Sélectionner tout
1
2
3
4
5
6
<managed-bean> 
	<managed-bean-class>UnManagedBean</managed-bean-class>	 
	<managed-bean-name>unManagedBean</managed-bean-name>	 
	<managed-bean-scope>session</managed-bean-scope> 
	<description>Ceci est un exemple de managed bean</description> 
</managed-bean>
Avec :

  • <managed-bean-class> pour définir le type du managed bean ;
  • <managed-bean-name> pour définir le nom sous lequel le bean sera exposé aux pages JSF ;
  • <managed-bean-scope> pour définir où sera stocké le managed bean (request, session, application).

Mis à jour le 12 février 2008 djo.mos

En ajoutant un élément <managed-property> dans la déclaration du managed bean dans faces-config.xml :

Code xml : Sélectionner tout
1
2
3
4
5
<managed-property> 
	<property-name>chaîne</property-name> 
	<property-class>java.lang.String</property-class> 
	<value>Une valeur quelquonque</value> 
</managed-property>
Avec :

  • <property-name> est le nom de la propriété (le nom de déclaration) ;
  • <property-class> est le type de la propriété ;
  • <value> la valeur à affecter à la propriété.

Pour les types complexes (collections), voici comment on procède.

Pour une liste (List)/ensemble (Set) :

Code xml : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
<managed-property> 
	<property-name>liste</property-name> 
	<property-class>java.util.List</property-class> 
	<list-entries> 
		<value-class>java.lang.String</value-class> 
		<value>Valeur 1</value> 
		<value>Valeur 2</value> 
		<value>Valeur 3</value> 
	</list-entries> 
</managed-property>
Pour une Map :

Code xml : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<managed-property> 
	<property-name>map</property-name> 
	<property-class>java.util.Map</property-class> 
	<map-entries> 
		<key-class>java.lang.Long</key-class> 
		<value-class>java.lang.String</value-class> 
		<map-entry> 
			<key>1</key> 
			<value>Valeur 1</value> 
		</map-entry> 
		<map-entry> 
			<key>2</key> 
			<value>Valeur 2</value> 
		</map-entry> 
	</map-entries> 
</managed-property>

Mis à jour le 12 février 2008 djo.mos

L'Expression Language (EL) de JSF est un minilangage similaire à l'EL de JSP 2.0 ou de JSTL qui permet de récupérer ou de modifier un attribut.
Dans JSF, un EL est mis dans #{} et peut être utilisé dans la majorité des attributs des composants.
Ils sont en général utilisés pour lier un attribut d'un composant à un champ d'un managed bean, et ce dans les deux sens (à l'inverse de l'EL de JSP 2.0).

Voici une liste non exhaustive des cas d'utilisation des EL :

EL Signification
#{unBean.unChamp} Retourne la valeur du champ unChamp du managed bean unBean
#{unBean['unChamp']} Équivalente à l'écriture précédente
#{unBean.unChamp.unAutreChamp.encoreUnChamp} Les EL n'imposent pas une limite quant à la profondeur
#{uneListe[5]} Retourne le cinquième élément de la liste uneListe
#{unMap['uneClé']} Accède à la valeur enregistrée dans le map unMap sous la clé uneClé
#{unMap.uneClé} Équivalente à l'écriture précédente
#{uneListe[unBean.unIndice]} Accède à l'élément d'indice égal à la valeur du champ unIndice du bean unBean
#{unMap[unBean.uneClé]} Accède à la valeur enregistrée dans le map unMap sous la clé de valeur égale à la valeur du champ uneClé du bean unBean
#{unMap[unBean.uneClé][2]} Accède au second élément de la liste enregistrée dans le map unMap sous la clé unBean.uneClé
#{uneValeur>25} Retourne true si une valeur est < 25. Les opérateurs suivants sont aussi supportés : <, <=, >, >=, ==, !=
#{uneValeur>25 and uneAutreValeur<10} Les EL supportent les opérateurs booléens : and, or et not
#{(unChamp==1?'premier':'autre')} Retourne la chaîne « premier » si unChamp est égal à 1, « autre » sinon
Le nom est #{unBean.nom} et l'age est #{unBean.age} Les EL peuvent être combinés avec un contenu statique
#{10+2/3*(8-1)} Les EL peuvent évaluer des expressions arithmétiques

Ces divers cas d'utilisation peuvent être combinés pour construire des EL de n'importe quelle complexité.

Mis à jour le 12 février 2008 djo.mos

dans faces-config.xml, il faut ajouter un élément <navigation-rule> :

Code xml : Sélectionner tout
1
2
3
4
5
6
7
8
<navigation-rule> 
	<display-name>test</display-name> 
	<from-view-id>/pageSource.jsp</from-view-id> 
	<navigation-case>		 
		<from-outcome>ok</from-outcome> 
		<to-view-id>/pageDestination.jsp</to-view-id> 
	</navigation-case> 
</navigation-rule>
avec :

  • <from-view-id> désigne la page source ;
  • <navigation-case> représente un cas de navigation partant de la page source.
    Il est parfaitement possible d'inclure plusieurs cas de navigation dans une seule règle de navigation ;
  • <from-outcome> représente le résultat d'une action qui active ce cas de navigation ;
  • et enfin, <to-view-id> représente la page destination, i.e. la page où rediriger.

Pour plus de contrôle, il est possible d'affiner encore le outcome en le contraignant à une action particulière :

Code xml : Sélectionner tout
1
2
3
4
5
<navigation-case> 
	<from-action>#{monManagedBean.monAction}</from-action> 
	<from-outcome>ok</from-outcome> 
	<to-view-id>/pageDestination.jsp</to-view-id> 
</navigation-case>
Enfin, il est possible d'utiliser un redirect au lieu de forward (comportement par défaut) en ajoutant l'élément <redirect /> dans le navigation-case.

Mis à jour le 12 février 2008 djo.mos

Il faut auparavant s'assurer que la propriété est déclarée dans le bean en question, qu'elle respecte les conventions de nommage de Java et qu'elle admet au moins un getter.

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
public class MonManagedBean { 
	private String messageAccueil = "Bienvenu"; 
  
	public String getMessageAccueil() { 
		return messageAccueil; 
	} 
  
	public void setMessageAccueil(String messageAccueil) { 
		this.messageAccueil = messageAccueil; 
	} 
}
Si on déclare ensuite cette classe comme étant managed bean, il devient possible alors d'accéder à la propriété messageAccueil via l'EL comme ceci :

Code xml : Sélectionner tout
<h:outputText value="#{monManagedBean.messageAccueil}"/>
JSF n'accède jamais directement à un champ : il passe
toujours par le getter en cas de lecture et le
setter en cas d'écriture.

Mis à jour le 12 février 2008 djo.mos

Il faut d'abord créer une action dans un managed bean. En JSF, une action est une méthode qui admet la signature suivante :

Code java : Sélectionner tout
public String unNomQuelquonque();
i.e. une méthode publique ne prenant aucun paramètre et retournant une chaîne de caractères.

Ensuite, il suffit d'indiquer l'EL de cette méthode comme valeur de l'attribut action d'un commandButton ou commandLink.

Exemple d'action :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
public class MonManagedBean { 
	private int test=0; 
  
	public String monAction() { 
		test++; 
		return null; 
	} 
  
	public int getTest() { 
		return test; 
	} 
}
Et dans la page JSF :

Code xml : Sélectionner tout
1
2
3
4
<h:outputText value="#{monManagedBean.test}" /> 
<h:form> 
	<h:commandButton action="#{monManagedBean.monAction}" /> 
</h:form>
Ainsi, en cliquant sur le bouton, la méthode monAction sera invoquée.

Le type de retour d'une action est une chaîne de caractères. Après avoir invoqué une action, JSF récupère son résultat de retour et l'utilise pour déterminer la page suivante à afficher.
Pour ce faire, il utilise les règles de navigation définies dans faces-config.xml.

Dans JSF, il est possible et très simple de créer
n'importe quel nombre de boutons, chacun invoquant
une action différente dans un seul formulaire.

Mis à jour le 12 février 2008 djo.mos

Après avoir créé le fichier .properties, il faut l'importer dans la page JSF :

Code xml : Sélectionner tout
<f:loadBundle var="msgs" basename="nomDuFichier"/>
Où basename est le nom du fichier .properties (l'extension est optionnelle) et var le nom sous lequel les messages seront accessibles.

Ensuite, pour afficher un message particulier, il suffit de faire :

Code xml : Sélectionner tout
<h:outputText value="#{msgs.nomDuneClé}" />

Mis à jour le 12 février 2008 djo.mos

JSF réalise l'injection de dépendances via l'utilisation de l'EL dans faces-config.xml. exemple :

Code xml : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
<managed-bean> 
	<managed-bean-name>address</managed-bean-name> 
	<managed-bean-class>package.Address</managed-bean-class>	 
</managed-bean> 
<managed-bean> 
	<managed-bean-name>person</managed-bean-name> 
	<managed-bean-class>package.Person</managed-bean-class>	 
	<managed-property> 
		<property-name>address</property-name> 
		<property-class>package.Address</property-class> 
		<value>#{address}</value> 
	</managed-property> 
</managed-bean>

Mis à jour le 12 février 2008 Sniper37

Lorsqu'un attribut immediate=”true” est renseigné sur un composant, cela signifie que la valeur de ce composant va être évaluée durant la phase Apply Request Values et non pendant la phase Process validations.
Cela permet de contourner la validation pour l'action au sein du page.

Par exemple, si vous avez un bouton au sein d'un formulaire permettant d'afficher un nouveau champ en fonction d'une valeur sélectionnée dans un autre, sans pour autant effectuer la validation complète du formulaire (car c'est une opération intermédiaire). Il faut ajouter l'attribut immediate="true" au niveau du bouton et au niveau du champ conditionnant l'affichage du champ tiers.

Cela aura pour effet d'effectuer une action vers le serveur (celle déclarée au niveau du bouton) et de ne pas déclencher la phase de validation.

Seule(s) le(s) valeurs des champs déclarée(s) avec l'attribut immediate seront accessibles dans l'arbre de composants.

Mis à jour le 12 février 2008 fabszn

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsables bénévoles de la rubrique Java Web : Mickael Baron - Robin56 -