Mit der Einführung von Java SE 5 und Java SE 6 ist Java in den letzten Jahren immer beliebter geworden. Allerdings konnte sich Java-basiertes JSP vor der Einführung von Java SE 5 nicht durchsetzen. Der wichtigste Grund ist, dass JSP zwar sehr leistungsfähig ist, sein größter Vorteil aber auch sein größter Nachteil ist Es gibt nicht viele visuelle Tools zum Entwerfen von Front-End-Schnittstellen und sie sind nicht leistungsstark genug. Daher wird das Entwerfen von JSP-Seiten sehr kompliziert und umständlich ...
Mit der Einführung von Java SE 5 und Java SE 6 ist Java in den letzten Jahren immer beliebter geworden. Allerdings konnte sich Java-basiertes JSP vor der Einführung von Java SE 5 nicht durchsetzen. Der wichtigste Grund ist, dass JSP zwar sehr leistungsfähig ist, sein größter Vorteil aber auch sein größter Nachteil ist Es gibt nicht viele visuelle Tools zum Entwerfen von Front-End-Schnittstellen und sie sind nicht leistungsstark genug. Daher wird das Entwerfen von JSP-Seiten sehr kompliziert und umständlich. Gleichzeitig mit der Einführung von Java SE 5 veröffentlichte Sun jedoch eine neue JavaServer Faces-Spezifikation (kurz JSF), um die Entwicklung von JSP zu vereinfachen. Dies bringt JSP auf einen guten Weg.
1. Was ist JSF?
JSF und JSP sind ein neues Paar. JSP ist eine Technologie für die Hintergrundlogikverarbeitung, während JSF genau das Gegenteil ist. Es handelt sich um eine Technologie, die es Entwicklern ermöglicht, schnell Java-basierte Webanwendungen zu entwickeln. Derzeit wurde JSF1.2 offiziell als Standard zu Java EE 5 hinzugefügt.
Da es sich um eine hochgradig komponentenbasierte Technologie handelt, können Entwickler mit Unterstützung einiger Entwicklungstools Drag-and-Drop-Bearbeitungsvorgänge implementieren. Benutzer müssen lediglich JSF-Komponenten auf die Seite ziehen, um die Webentwicklung einfach durchzuführen. Dies ist der größte Vorteil der komponentenbasierten Technologie. Die Komponenten, die wir verwenden können, sind nicht nur relativ einfache Eingabefelder, sondern auch komplexere Komponenten, wie z. B. Tabellenkomponenten wie DataTable Tree-Komponenten und so weiter.
Als Standardtechnologie wird JSF auch von zahlreichen Tool-Anbietern unterstützt. Gleichzeitig werden uns auch viele gute kostenlose Entwicklungstools zur Verfügung stehen. Vor nicht allzu langer Zeit wurden Sun Java Studio Creator 2 und Oracle JDeveloper 10g als kostenlose Entwicklungstools veröffentlicht, die JSF unterstützen, was JSF viel Lebendigkeit verlieh. Darüber hinaus haben wir auch einige hervorragende kommerzielle Entwicklungstools zur Auswahl, wie BEA Workshop (ehemals M7 NitroX), Exadel und MyEclipse, die den meisten aktuellen Eclipse-Benutzern großen Komfort bieten Rational Application Developer und Borlands JBuilder sind ebenfalls sehr gute kommerzielle Entwicklungstools, die die visuelle JSF-Entwicklung unterstützen.
JSF unterscheidet sich grundlegend von der herkömmlichen Webtechnologie. Bei der herkömmlichen Webtechnologie müssen Benutzer Browseranforderungen erfassen, den Clientstatus speichern und die Seitenumleitung manuell steuern usw. Das Aufkommen von JSF hat uns zweifellos großen Komfort gebracht. JSF bietet ein ereignisgesteuertes Seitennavigationsmodell, das es Anwendungsentwicklern ermöglicht, den Seitenfluss von Anwendungen zu gestalten. Ähnlich wie beim Struts-Ansatz werden alle Seitenflussinformationen in der JSF-Konfigurations-XML-Datei (faces-config.xml) definiert und nicht in der Anwendung fest codiert. Dies vereinfacht die Entwicklungsschwierigkeiten für Entwickler erheblich und vereinfacht die Entwicklung von Anwendungen.
Gleichzeitig ist JSF auch ein Framework, das dem Model-View-Controller (MVC)-Muster folgt. Es erreicht die vollständige Trennung von Ansichtscode (View) und Anwendungslogik (Model), sodass Anwendungen, die die JSF-Technologie verwenden, eine gute Trennung von Seiten und Code erreichen können. Alle Anfragen für JSF-Seiten werden über einen Front-End-Controller (FacesServlet) verarbeitet. Das System verarbeitet die Anfrage des Benutzers automatisch und gibt das Ergebnis an den Benutzer zurück. Dies unterscheidet sich nicht wesentlich vom herkömmlichen MVC-Framework.
JSF verwendet nicht nur die POJO-Technologie, sondern auch die Spring-like Inversion of Control (IoC)-Technologie (oder Dependency Injection-DI). In der Backing Bean von JSF können wir die für die Ansicht erforderlichen Daten und Vorgänge in eine Backing Bean einfügen . Gleichzeitig können wir dank der von JSF verwendeten DI-Technologie Managed Bean in der Konfigurationsdatei initialisieren. Gleichzeitig können wir diese Technologie auch für die einfache Integration mit Spring verwenden, das eine ähnliche Technologie verwendet.
2. Verwendung von JSF in JSP
JSF kann seine Wirkung nur durch die Kombination mit JSP voll entfalten. JSF wird über Tag-Bibliotheken und JSP integriert. Die Tag-Bibliothek entspricht der serverseitigen Komponente von ASP.NET. JSF bietet eine sehr umfangreiche Tag-Bibliothek, mit der verschiedene Client-Modelle wie HTML, WML, XML und JavaScript generiert werden können. Mithilfe dieser Tags können Sie ganz einfach umfangreiche Clientmodelle erstellen und Clientanfragen automatisch über diese Tags bearbeiten.
Schauen wir uns als Nächstes ein Beispiel an, wie man JSF und JSP zusammenarbeiten lässt. Es gibt zwei Bibliotheken in JSF. Die erste wird als Kernel-Bibliothek bezeichnet und enthält verschiedene wichtige Tags, z. B. zum Konfigurieren von Komponenten, zum Verwalten von Ereignissen, zum Überprüfen von Eingabeinformationen usw. Die Hauptfunktion der zweiten Bibliothek besteht darin, verschiedenen Tags von HTML und JSF zu entsprechen. Jedes JSF-Tag entspricht einer HTML-Komponente. Beispielsweise entspricht das UIInput-Tag dem Textfeld oder Passwortfeld in HTML.
Das Texteingabefeld im JSF-Tag heißt inputText und die Passworteingabebibliothek heißt inputSecret. Das Folgende ist ein einfaches Benutzeroberflächenprogramm, das JSF und JSP kombiniert.
＜%@ taglib uri=" http://java.sun.com/jsf/html " Präfix="h" %＞
＜%@ taglib uri=" http://java.sun.com/jsf/core " Präfix ="f" %＞
＜html＞
＜head＞
＜meta HTTP-EQUIV="Content-Type" CONTENT="text/html;CHARSET=GB2312"＞
＜title＞Das erste JSF-Programm ＜/title＞
＜/head ＞
＜body＞
＜f:view＞
＜h:form id="simpleForm"＞
＜h:outputText id="favoriteLabel" value="Bitte geben Sie eine Zahl ein:"/＞
＜h:inputText id="favoriteValue" value= " #{simple.longValue}"＞
＜f:validateLongrange Maximum="30" Minimum="0"/＞
＜/h:inputText＞
＜p/＞
＜h:commandButton id="submit" value="Submit" action = "#{simple.simpleActionMethod}"/＞
＜/h:form＞
＜/f:view＞
＜/body＞
＜/html＞
Im obigen Code können wir verstehen, wie JSF in JSP integriert ist. Wir können zunächst ein Kernel-Label sehen: Ansicht. Dann gibt es mehrere JSF-Komponenten. Wie Formular, Ausgabetext, Eingabetext und Befehlsschaltfläche. Diese Komponenten werden im Formular platziert und werden Teil des Formulars. Ganz am Anfang des Programms müssen zwei Tag-Bibliotheken per Import importiert werden. Der Code lautet wie folgt.
＜%@ taglib uri=" http://java.sun.com/jsf/html " Präfix="h" %＞
＜%@ taglib uri=" http://java.sun.com/jsf/core " Präfix ="f" %>
Die beiden obigen Codezeilen deklarieren, welche JSF-Tag-Bibliothek in JSP verwendet werden soll. Die Kernel-Bibliothek wird mit dem Präfix f deklariert, während die HTML-Bibliothek mit dem Präfix h deklariert wird. Diese beiden Präfixe sind nicht erforderlich, sondern nur ein Vorschlag. Im Programm muss die Kernel-Bibliothek verwendet werden, da die Ansicht in allen JSF-Seiten verwendet werden muss. Das HTML-Tag wandelt das JSF-Tag zur Laufzeit in eine HTML-Komponente um. Dieses h-Präfix wird von der JSF-Spezifikation empfohlen. Auf diese Weise machen wir unser JSF-Programm lesbarer.
Nach der Deklaration folgen mehrere Zeilen mit Standard-HTML-Anweisungen, die in diesem Artikel nicht im Detail beschrieben werden. Ab <f:view> handelt es sich um eine JSF-Anweisung. Dieser Code lautet wie folgt:
＜f:view＞
＜h:form id="simpleForm"＞
＜h:outputText id="favoriteLabel" value="Bitte geben Sie eine Zahl ein:"/＞
＜h:inputText id="favoriteValue " value="#{simple.longValue}">
＜f:validateLongrange Maximum="30" Minimum="0"/＞
＜/h:inputText＞
＜p/＞
＜h:commandButton id="submit" value=" Senden „
action="#{simple.simpleActionMethod}"/＞
＜/h:form＞
＜/f:view＞
＜/f:view＞ Tag kündigt den Beginn von JSF an und sein nächstes Tag form erstellt ein HTML-Formular. Das OutputText-Tag entspricht der Label-Komponente in HTML. Das inputText-Tag entspricht der textField-Komponente in HTML. Das commandButton-Tag entspricht der Senden-Schaltfläche in HTML. Wenn Sie dieses JSP-Programm ausführen, erhalten Sie den in Abbildung 1 gezeigten Effekt.
3. Wie reagiert JSP auf JSF-Anfragen?
Aus dem obigen Beispiel wissen wir bereits, wie JSF in JSP verwendet wird. In diesem Teil werfen wir einen Blick darauf, wie Anfragen in JSF verarbeitet werden.
Schauen wir uns zunächst ein Beispiel für die Umrechnung von Fahrenheit in Celsius an. Das Programm führt den Übergang durch, wenn der Benutzer auf die Schaltfläche „Senden“ klickt.
＜%@ taglib uri=" http://java.sun.com/jsf/html " Präfix="h" %＞
＜%@ taglib uri=" http://java.sun.com/jsf/core " Präfix ="f" %＞
＜html＞
＜head＞
＜meta HTTP-EQUIV="Content-Type" CONTENT="text/html;CHARSET=GB2312"＞
＜title＞Temperaturkonvertierungsprogramm＜/title＞
＜/head＞
＜ body＞
＜f:view＞
＜h:form＞
＜div＞
＜h:outputText id="fahrenheitLabel" value="Bitte geben Sie die Fahrenheit-Temperatur ein:"/＞
＜span＞
＜h:inputText id="temperatur" 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="Celsius-Temperatur:"/＞
＜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＞
In den ersten beiden Zeilen des Programms werden die JSF-Kernbibliothek und die HTML-Bibliothek importiert . Dies wurde bereits besprochen und wird hier nicht im Detail besprochen.
Werfen wir einen Blick darauf, wie JSF-Tags mit dem Backend interagieren. Da wir JSF in JSP verwenden, gibt es keinen Unterschied zwischen dieser und normaler JSP. Wenn die JSP zum ersten Mal ausgeführt wird, kompiliert der JSP-Compiler die .JSP-Datei in ein Servlet und ruft sie dann auf das Servlet. Das Servlet empfängt dann den Datenstrom vom Client. Aber im Gegensatz zu gewöhnlichen JSP-Programmen werden JSF-Tags von der JSF-API aufgerufen (dies ermöglicht die Trennung der Logikschicht und der Präsentationsschicht). Ansonsten unterscheiden sie sich nicht von gewöhnlichen JSP-Tags.
Wenn ein UIComponent-Tag die doStartTag-Methode empfängt, verwendet JSF diese Eigenschaften, um den Wert des Tags festzulegen. Beispielsweise wird das Tag „inputText“ in diesem Beispiel entsprechend seinem Attributwert festgelegt. Unten finden Sie den Codeausschnitt von JSF.
＜h:inputText id="temperature" value="#{tc.fahrenheitTemp}"＞
＜f:validateDoublerange Minimum="-100.0" Maximum="100.0"/＞
＜f:valuechangeListener type="tempconv.page.TCChangedListener" /＞
＜/h:inputText＞
Das Tag inputText legt die Attribute id und value entsprechend den entsprechenden Werten fest. In JSF wird jeder Attributwert über setAttribute(String name, Object value) festgelegt. Wir müssen jedoch beachten, dass JSF-Tags entsprechende Standardwerte angeben können. Dies ähnelt in gewisser Weise den Systemeigenschaften in Java. Wenn Sie einen Eigenschaftsnamen angeben, gibt das System den Wert der Eigenschaft zurück. Wenn Sie den Standardwert angeben und die Eigenschaft nicht vorhanden ist, wird der Standardwert zurückgegeben.
Schauen wir uns als Nächstes den wichtigsten Teil des obigen Programms an, nämlich die Ereignisbehandlung der UIInput-Komponente.
<f:valuechangeListener type="tempconv.page.TCChangedListener"/>
In JSF wird die Ereignisverarbeitung durch das valuechangeListener-Tag abgeschlossen. Das durch diese Bezeichnung dargestellte Ereignis löst ein Ereignis aus, wenn sich der Wert des Textfelds ändert. Interessant ist jedoch, dass dieses Ereignis nicht sofort übermittelt wird, sondern das Ereignis und die entsprechenden Daten erst dann an das Backend übermittelt werden, wenn der Benutzer auf die Schaltfläche „Senden“ klickt. Daher wird diese Ereignisanforderung auch als Pre-Commit bezeichnet. Schauen wir uns abschließend die Code-Implementierung von UICommand an.
＜div＞
＜h:commandButton value="Conversion" action="#{tc.convert}"＞
＜/h:commandButton＞
＜/div＞
Der obige Code verbindet die Methode „convert()“ mit UICommand, d. h. Nach dem Klicken auf die Schaltfläche „Senden“ wird die Methode „convert()“ ausgeführt. Nach dem Auffinden des View-Tags führt das JSF-Programm zu Ergebnissen und JSFAPI ruft schließlich die doEnd-Methode auf, um das JSF-Programm zu beenden. Nach dem Parsen dieses Programms konvertiert die JSF-Engine die entsprechenden JSF-Tags in HTML-Komponenten.
Schauen wir uns abschließend an, wie JSP auf JSF-Ereignisse reagiert. Unten finden Sie einen Java-Code, der auf JSF-Ereignisse reagiert.
öffentliche
Klasse
TCChangedListener
implementiert
ValueChangeListener
{
super
(
)
;
null != value)
{
float curVal = ((Number) value).floatValue();
Map Values = comp.getAttributes();
if (curVal < 0)
{
Values.put("styleClass", "red") ;
}
else
{
Values.put("styleClass", "black");
Um
auf JSF-Ereignisse zu reagieren,müssen
Sie
die ValueChangeListener-Schnittstelle in der JSF-Bibliothek implementieren. Im obigen Programm ist zu beachten, dass die entsprechende Farbe letztendlich entsprechend dem Eingabewert eingestellt wird. Diese Werte sind nicht von JSP abhängig. Natürlich können Sie sie auch auf null setzen und die Farben von den JSP-Tags festlegen lassen.