Java s'est progressivement réchauffé ces dernières années. Avec le lancement de Java SE 5 et Java SE 6, l'avenir de Java est encore plus brillant. Cependant, JSP basé sur Java n'a pas pu relever la tête avant le lancement de Java SE 5. La raison la plus importante est que bien que JSP soit très puissant, son plus grand avantage est aussi son plus grand inconvénient. il n'y a pas beaucoup d'outils visuels pour concevoir des interfaces frontales, et ils ne sont pas assez puissants. Par conséquent, concevoir des pages JSP devient très compliqué et fastidieux...
Java s'est progressivement réchauffé ces dernières années. Avec le lancement de Java SE 5 et Java SE 6, l'avenir de Java est encore plus brillant. Cependant, JSP basé sur Java n'a pas pu relever la tête avant le lancement de Java SE 5. La raison la plus importante est que bien que JSP soit très puissant, son plus grand avantage est aussi son plus grand inconvénient. il n'y a pas beaucoup d'outils visuels pour concevoir des interfaces frontales, et ils ne sont pas assez puissants. Par conséquent, la conception de pages JSP devient très compliquée et fastidieuse. Cependant, parallèlement au lancement de Java SE 5, Sun a lancé une nouvelle spécification JavaServer Faces (JSF en abrégé) afin de simplifier le développement de JSP. Cela met JSP sur la bonne voie.
1. Qu'est-ce que JSF ?
JSF et JSP forment une nouvelle paire. JSP est une technologie utilisée pour le traitement logique en arrière-plan, tandis que JSF est tout le contraire. Il s'agit d'une technologie qui permet aux développeurs de développer rapidement des applications Web basées sur Java. Actuellement, JSF1.2 a été officiellement ajouté à Java EE 5 en tant que standard.
En tant que technologie hautement composée de composants, les développeurs peuvent implémenter des opérations d'édition par glisser-déposer avec la prise en charge de certains outils de développement. Les utilisateurs n'ont qu'à faire glisser les composants JSF sur la page pour effectuer facilement le développement Web. C'est le plus grand avantage de cette technologie en tant que composants. Les composants que nous pouvons utiliser ne sont pas seulement des zones de saisie relativement simples, mais également des composants plus complexes, tels que des composants de table comme les composants DataTable Tree comme Tree, etc.
En tant que technologie standard, JSF est également pris en charge par de nombreux fournisseurs d'outils. Dans le même temps, nous disposerons également de nombreux bons outils de développement gratuits. Il n'y a pas si longtemps, Sun Java Studio Creator 2 et Oracle JDeveloper 10g ont été publiés en tant qu'outils de développement gratuits prenant en charge JSF, ce qui a apporté beaucoup de vitalité à JSF. En outre, nous disposons également d'excellents outils de développement commerciaux parmi lesquels choisir. Les outils de développement de plug-ins basés sur Eclipse, tels que BEA Workshop (anciennement M7 NitroX), Exadel et MyEclipse, ont apporté une grande commodité à la majorité des utilisateurs actuels d'IBM. Rational Application Developer et JBuilder de Borland sont également de très bons outils de développement commercial prenant en charge le développement visuel JSF.
JSF est fondamentalement différent de la technologie Web traditionnelle. La technologie Web traditionnelle oblige les utilisateurs à capturer les requêtes du navigateur, à enregistrer l'état du client et à contrôler manuellement la redirection des pages, etc. L'émergence de JSF nous a sans aucun doute apporté une grande commodité. JSF fournit un modèle de navigation de page basé sur des événements, qui permet aux développeurs d'applications de concevoir le flux de pages des applications. Semblable à l'approche Struts, toutes les informations de flux de pages sont définies dans le fichier XML de configuration JSF (faces-config.xml) plutôt que codées en dur dans l'application. Cela simplifie grandement la difficulté de développement pour les développeurs et simplifie le développement d'applications.
Dans le même temps, JSF est également un framework qui suit le modèle modèle-vue-contrôleur (MVC). Il réalise la séparation complète du code de vue (View) et de la logique d'application (Model), permettant aux applications utilisant la technologie JSF d'obtenir une bonne séparation des pages et du code. Toutes les demandes de pages JSF seront traitées via un contrôleur frontal (FacesServlet). Le système traite automatiquement la demande de l'utilisateur et renvoie le résultat à l'utilisateur. Ce n'est pas très différent du framework MVC traditionnel.
JSF utilise non seulement la technologie POJO, mais également la technologie Spring-like Inversion of Control (IoC) (ou Dependency Injection-DI). Dans le Backing Bean de JSF, nous pouvons placer les données et les opérations requises par la vue dans un Backing Bean. . Dans le même temps, grâce à la technologie DI utilisée par JSF, nous pouvons initialiser Managed Bean dans le fichier de configuration. En même temps, nous pouvons également utiliser cette technologie pour s'intégrer facilement à Spring, qui utilise une technologie similaire.
2. Comment utiliser JSF dans JSP
JSF ne peut exercer pleinement son effet qu'en le combinant avec JSP. JSF est intégré via des bibliothèques de balises et JSP. La bibliothèque de balises est équivalente au composant côté serveur d'ASP.NET. JSF fournit une bibliothèque de balises très riche, grâce à laquelle divers modèles clients peuvent être générés, tels que HTML, WML, XML et JavaScript. Grâce à ces balises, vous pouvez facilement créer des modèles clients à grande échelle et gérer automatiquement les demandes des clients via ces balises.
Examinons ensuite un exemple de la manière de faire fonctionner JSF et JSP ensemble. Il existe deux bibliothèques dans JSF. La première s'appelle la bibliothèque du noyau, qui contient diverses balises majeures, telles que la configuration des composants, la gestion des événements, la validation des informations d'entrée, etc. La fonction principale de la deuxième bibliothèque est de correspondre à diverses balises HTML et JSF. Chaque balise JSF correspond à un composant HTML. Par exemple, la balise UIInput correspond à la zone de texte ou à la zone de mot de passe en HTML.
La zone de saisie de texte dans la balise JSF s'appelle inputText et la bibliothèque de saisie de mot de passe s'appelle inputSecret. Ce qui suit est un programme d'interface utilisateur simple combinant JSF et JSP.
＜%@ taglib uri=" http://java.sun.com/jsf/html " préfixe="h" %＞
＜%@ taglib uri=" http://java.sun.com/jsf/core " préfixe ="f" %＞
＜html＞
＜head＞
＜meta HTTP-EQUIV="Content-Type" CONTENT="text/html;CHARSET=GB2312"＞
＜title＞Le premier programme JSF ＜/title＞
＜/head ＞
＜body＞
＜f:view＞
＜h:form id="simpleForm"＞
＜h:outputText id="favoriteLabel" value="Veuillez entrer un nombre :"/＞
＜h:inputText id="favoriteValue" value= " #{simple.longValue}"＞
＜f:validateLongrange maximum="30" minimum="0"/＞
＜/h:inputText＞
＜p/＞
＜h:commandButton id="submit" value="Soumettre" action = "#{simple.simpleActionMethod}"/＞
＜/h:form＞
＜/f:view＞
＜/body＞
＜/html＞
Dans le code ci-dessus, nous pouvons comprendre comment JSF est intégré à JSP. On peut d'abord voir un label du noyau : view. Ensuite, il existe plusieurs composants JSF. Tels que form, outputText, inputText et commandButton. Ces composants sont placés dans le formulaire et en font partie intégrante. Au tout début du programme, deux bibliothèques de balises doivent être importées via import. Le code est le suivant.
＜%@ taglib uri=" http://java.sun.com/jsf/html " préfixe="h" %＞
＜%@ taglib uri=" http://java.sun.com/jsf/core " préfixe ="f" %>
Les deux lignes de code ci-dessus déclarent quelle bibliothèque de balises JSF utiliser dans JSP. La bibliothèque du noyau est déclarée avec le préfixe f, tandis que la bibliothèque HTML est déclarée avec le préfixe h. Ces deux préfixes ne sont pas obligatoires, mais ne sont qu'une suggestion. Dans le programme, la bibliothèque du noyau doit être utilisée, car la vue doit être utilisée dans toutes les pages JSF. La balise HTML convertit la balise JSF en composant HTML au moment de l'exécution. Ce préfixe h n'est pas nécessaire, mais recommandé par la spécification JSF. De cette façon, nous rendons notre programme JSF plus lisible.
Après la déclaration se trouvent plusieurs lignes d'instructions HTML standards, qui ne seront pas décrites en détail dans cet article. À partir de <f:view>, il s'agit d'une instruction JSF. Ce code est le suivant :
＜f:view＞
＜h:form id="simpleForm"＞
＜h:outputText id="favoriteLabel" value="Veuillez entrer un nombre :"/＞
＜h:inputText id="favoriteValue " value="#{simple.longValue}">
＜f:validateLongrange maximum="30" minimum="0"/＞
＜/h:inputText＞
＜p/＞
＜h:commandButton id="submit" value=" Soumettre
La balise"
action="#{simple.simpleActionMethod}"/＞
＜/h:form＞
＜/f:view＞
＜/f:view＞ annonce le début de JSF, et sa prochaine forme de balise créera un formulaire HTML. La balise outputText est équivalente au composant label en HTML. La balise inputText est équivalente au composant textField en HTML. La balise commandButton est équivalente au bouton de soumission en HTML. Lorsque vous exécutez ce programme JSP, vous obtiendrez l'effet illustré à la figure 1.
3. Comment JSP répond-il aux requêtes JSF ?
À partir de l'exemple ci-dessus, nous savons déjà comment utiliser JSF dans JSP. Dans cette partie, examinons comment les requêtes sont traitées dans JSF.
Examinons d'abord un exemple de conversion de Fahrenheit en Celsius. Le programme effectuera la transition lorsque l'utilisateur clique sur le bouton de soumission.
＜%@ taglib uri=" http://java.sun.com/jsf/html " préfixe="h" %＞
＜%@ taglib uri=" http://java.sun.com/jsf/core " préfixe ="f" %＞
＜html＞
＜head＞
＜meta HTTP-EQUIV="Content-Type" CONTENT="text/html;CHARSET=GB2312"＞
＜title＞Programme de conversion de température＜/title＞
＜/head＞
＜ body＞
＜f:view＞
＜h:form＞
＜div＞
＜h:outputText id="fahrenheitLabel" value="Veuillez entrer la température Fahrenheit :"/＞
＜span＞
＜h:inputText id="temperature" value= " #{tc.fahrenheitTemp}"＞
＜f:validateDoublerange minimum="-100.0" maximum="100.0"/＞
＜f:valuechangeListener type="tempconv.page.TCChangedListener"/＞
＜/h:inputText＞
＜/span ＞
＜/div＞
＜div＞
＜h:outputText id="celsiusLabel" value="Température Celsius:"/＞
＜span＞
＜h:outputText id="celsiusValue" value="#{tc.celsiusTemp}"＞
＜ f :convertNumber maxFractionDigits="3" type="number"/＞
＜/h:outputText＞
＜/span＞
＜/div＞
＜div＞
＜h:commandButton value="Convert" action="#{tc.convert} " ＞
＜/h:commandButton＞
＜/div＞
＜/h:form＞
＜/f:view＞
＜/body＞
＜/html＞
Dans les deux premières lignes du programme, la bibliothèque principale JSF et la bibliothèque HTML sont importées . Cela a déjà été fait et ne sera pas discuté en détail ici.
Jetons un coup d'œil à la façon dont les balises JSF interagissent avec le backend. Puisque nous utilisons JSF dans JSP, il n'y a aucune différence entre celui-ci et un JSP normal ; JSP est en fait un servlet. Lorsque le JSP est exécuté pour la première fois, le compilateur JSP compile le fichier .JSP dans un servlet et l'appelle ensuite. le Servlet. Le Servlet reçoit ensuite le flux de données du client. Mais contrairement aux programmes JSP ordinaires, les balises JSF sont appelées par l'API JSF (cela permet de séparer la couche logique et la couche de présentation. À part cela, elles ne sont pas différentes des balises JSP ordinaires).
Lorsqu'une balise UIComponent reçoit la méthode doStartTag, JSF utilise ces propriétés pour définir la valeur de la balise. Par exemple, la balise inputText dans cet exemple sera définie en fonction de sa valeur d'attribut. Vous trouverez ci-dessous l'extrait de code de JSF.
＜h:inputText id="temperature" value="#{tc.fahrenheitTemp}"＞
＜f:validateDoublerange minimum="-100.0" maximum="100.0"/＞
＜f:valuechangeListener type="tempconv.page.TCChangedListener" /＞
＜/h:inputText＞
La balise inputText définit les attributs id et value en fonction des valeurs correspondantes. Dans JSF, chaque valeur d'attribut est définie via setAttribute (nom de chaîne, valeur d'objet). Mais ce que nous devons noter, c'est que les balises JSF peuvent spécifier les valeurs par défaut correspondantes. Ceci est quelque peu similaire aux propriétés système en Java. Si vous donnez un nom de propriété, le système renverra la valeur de la propriété. Si vous spécifiez sa valeur par défaut et que la propriété n'existe pas, la valeur par défaut sera renvoyée.
Examinons ensuite la partie la plus importante du programme ci-dessus, à savoir la gestion des événements du composant UIInput.
<f:valuechangeListener type="tempconv.page.TCChangedListener"/>
Dans JSF, le traitement des événements est complété par la balise valuechangeListener. L'événement représenté par cette étiquette déclenche un événement lorsque la valeur de la zone de texte change. Mais ce qui est intéressant, c'est que cet événement n'est pas soumis immédiatement. Au lieu de cela, l'événement et les données correspondantes ne sont soumis au backend que lorsque l'utilisateur clique sur le bouton « Soumettre ». Par conséquent, cette demande d’événement est également appelée pré-commit. Enfin, examinons l'implémentation du code de UICommand.
＜div＞
＜h:commandButton value="Conversion" action="#{tc.convert}"＞
＜/h:commandButton＞
＜/div＞
Le code ci - dessus connecte la méthode convert() et UICommand,C'est - à - dire, après avoir cliqué sur le bouton "Soumettre", la méthode convert() sera exécutée. Après avoir rencontré la balise view, le programme JSF obtient des résultats et JSFAPI appelle finalement la méthode doEnd pour terminer le programme JSF. Après avoir analysé ce programme, le moteur JSF convertit les balises JSF correspondantes en composants HTML.
Enfin, examinons comment JSP répond aux événements JSF. Vous trouverez ci-dessous un morceau de code Java qui répond aux événements JSF.
public class TCChangedListener implémente ValueChangeListener
{
public TCChangedListener()
{
super
();
}
// Gestion des événements
public void processValueChange (ValueChangeEvent event)
throws AbortProcessingException
{
UIComponent comp = event.getComponent()
;
null != valeur)
{
float curVal = ((Number) value).floatValue();
Mapper les valeurs = comp.getAttributes();
if (curVal < 0)
{
values.put("styleClass", "red") ;
}
else
{
values.put("styleClass", "black");
}
}
}
Pour répondre aux événements JSF, vous devez implémenter l'interface ValueChangeListener dans la bibliothèque JSF. Ce qu'il convient de noter dans le programme ci-dessus, c'est que la couleur correspondante est finalement définie en fonction de la valeur d'entrée. Ces valeurs ne dépendent pas de JSP. Bien sûr, vous pouvez également les définir sur null et laisser les balises JSP définir leurs couleurs.