FAQ JSFConsultez toutes les FAQ

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

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>

• <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).
  

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

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>

• <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é.
  

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>

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>

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 :

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

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>

• <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.
  

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>

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.

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; 
	} 
}

<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.

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 :

public String unNomQuelquonque();

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; 
	} 
}

1
2
3
4
<h:outputText value="#{monManagedBean.test}" /> 
<h:form> 
	<h:commandButton action="#{monManagedBean.monAction}" /> 
</h:form>

	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.

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

<f:loadBundle var="msgs" basename="nomDuFichier"/>

<h:outputText value="#{msgs.nomDuneClé}" />

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

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>

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.