JSF 2-Installation und Konfiguration mit Maven 3

JavaServer-Gesichter (JSF) ist ein serverseitiges Komponenten-Framework zum Erstellen webbasierter Java-Technologieanwendungen. JavaServer Faces (JSF) besteht aus zwei Hauptteilen:

  • Die JavaServer Faces-API zum Darstellen von Komponenten, Verwalten ihrer Zustände, Behandeln von Ereignissen, Behandeln serverseitiger Validierungen und Erreichen der Datenkonvertierung; Definieren der Seitennavigation, Unterstützung der Internationalisierung und Zugänglichkeit sowie Bereitstellung der Erweiterbarkeit für alle diese Funktionen.
  • Tag-Bibliotheken zum Hinzufügen von Komponenten zu den Webseiten und zum Verbinden dieser Komponenten mit ihren entsprechenden serverseitigen Objekten.

In diesem Beitrag soll erläutert werden, wie ein JSF-Framework mithilfe der Eclipse-IDE und Maven installiert und konfiguriert werden kann.

Lesen Sie auch:

  • Einführung in JavaServer Faces
  • Lebenszyklusphasen der Anforderungsverarbeitung in JSF
  • Navigationsmodell in JSF

Benutztes Werkzeug

In diesem Beitrag werden die folgenden Tools verwendet, um die erforderliche Installation und Konfiguration durchzuführen:

Erstellen Sie ein JSF-Projekt mit Maven

Um ein Webprojekt mit Maven zu erstellen, sollten Sie den Maven-Archetyp verwenden. Der Archetype ist ein Vorlagen-Toolkit, das zum Erstellen von Standard-Java-Projekten verwendet wird. Diese Vorlagen werden verwendet, um verschiedene Arten von Java-Projekten zu erstellen, angefangen von einem einfachen Standard-Java bis hin zu sehr komplizierten Unternehmensanwendungen.

Beim Erstellen eines Maven-Webprojekts sollten Sie die folgenden Schritte ausführen:

  • Laden Sie die neuesten Maven-Archetypes-Vorlagen von einer offiziellen „Github“-Site herunter Maven Archetypes Zip-Datei Verwenden Sie dazu den Link „Zip herunterladen“, der im rechten Bereich der Seite angehängt ist.
  • Entpacken Sie die Datei in einen leeren Ordner, navigieren Sie zum Ordner „quickstart-web-app“ und führen Sie die folgenden Maven-Befehle aus, um die Vorlage zu installieren, die zum Erstellen eines einfachen Standard-Webprojekts verwendet wird:
  • Führen Sie mvn clean archetype:create-from-project aus. Das Ergebnis der Ausführung sollte eine neue Vorlage sein, die zur späteren Verwendung in Ihrem lokalen Repository installiert werden muss.
  • Navigieren Sie zu „target/generated-sources/archetype“ und führen Sie „mvn install“ aus, um die erstellte Vorlage in Ihrem lokalen Repository zu installieren.
  • Navigieren Sie in einen leeren Ordner und führen Sie mvn archetype:generate -DarchetypeCatalog=local -DgroupId=net.javabeat.eclipselink –DartifactId=EclipseLink-Installation -Dversion=1.0 aus
  • Wenn Sie unterschiedliche Archetypen erstellt haben, wird eine Liste mit lokalen Archetypen angezeigt.
  • Geben Sie die Nummer neben dem Archetyp mit dem Namen „quickstart-web-app-archetype“ ein.
  • Listen Sie alle Ordner auf, die in Schritt 3 erstellt wurden, indem Sie dir oder ls basierend auf Ihrem Betriebssystem verwenden. Sie sollten das Artefakt JavaBeat-JSF-Installation sehen.
  • Die JavaBeat-JSF-Installation ist ein Standard-Webprojekt, das vom Maven erstellt wurde. Das erstellte Projekt enthält Ihr eigenes benanntes Paket, das in der -DgroupId übergeben wurde.

Sehen Sie sich den folgenden Screenshot an, der Ihnen das erstellte Projekt und seine Struktur zeigt.

JSF Maven-Strukturverzeichnis

Importieren Sie das Maven-Webprojekt in die Eclipse-IDE

Eclipse IDE bietet Entwicklern die Möglichkeit, ein Maven-Projekt über einen von Eclipse gesteuerten Assistenten zu importieren. Führen Sie die folgenden Schritte aus, um das zuvor erstellte Projekt zu importieren.

  • Öffnen Sie EclipseIDE.
  • Klicken Sie mit der rechten Maustaste auf den „Projekt-Explorer“.
  • Wählen Sie die Importoption und klicken Sie im rechten Menü auf Importieren.
  • Erweitern Sie den Maven-Baum.
  • Wählen Sie „Vorhandene Maven-Projekte“. Und klicken Sie auf Weiter.
  • Navigieren Sie mithilfe der Durchsuchen-Funktion zu Ihrem erstellten Projekt und klicken Sie auf „OK“. In unserem Fall lautet der Pfad C:\JavaBeat\archetype.
  • Die Eclipse-IDE sollte die pom.xml lesen und Ihnen den Namen der dort gefundenen Projekte mitteilen.
  • In unserem Fall wird die Eclipse-IDE /JavaBeat-JSF-Installation/pom.xml erwähnen.
  • Wählen Sie das Projekt aus und klicken Sie auf „Fertig stellen“.
  • Das Webprojekt sollte importiert werden.
  • Der folgende Schnappschuss zeigt Ihnen die vollständige Struktur des importierten Verzeichnisses.

    Vollständig von Maven importiertes Projekt für JSF

    Am Ende der vorherigen Schritte haben Sie nun eine Dynamisches Webprojekt Das ist bereit für die nächste Installation und Konfiguration von JavaServer-Gesichter (JSF).

    Fügen Sie JSF-Abhängigkeiten hinzu

    Wenn Sie das Hinzufügen der erforderlichen JavaServer Faces-Bibliothek mithilfe eines Facettenprojekts abschließen möchten, können Sie dem Link zur Installation und Konfiguration von JavaServer Faces mithilfe des Facet Dynamic Web Project mit Eclipse folgen.

    Aber hier sollte das Hinzufügen der erforderlichen Bibliotheken über die Maven-Abhängigkeiten erfolgen. Zuerst müssen wir das konfigurieren pom.xml um die zu unterstützen JavaServer-Gesichter (JSF). Um die zu konfigurieren pom.xml Datei müssen Sie die folgenden Schritte ausführen:

    • Doppelklicken Sie auf pom.xml Datei.
    • Navigieren Sie in die pom.xml Bereich, der sich zuletzt befindet Tab.
    • Maven-Abhängigkeiten für JavaServer-Gesichter werden im Folgenden erwähnt Verknüpfung und verwenden Sie die Referenzimplementierung von Mojarra Sun.

    Fügen Sie die folgenden Abhängigkeiten innerhalb von hinzu Etikett:

    <dependency>
     <groupId>javax.servlet</groupId>
     <artifactId>servlet-api</artifactId>
     <version>${servlet.version}</version>
     <scope>provided</scope>
    </dependency>
    
    <dependency>
     <groupId>com.sun.faces</groupId>
     <artifactId>jsf-api</artifactId>
     <version>2.2.4</version>
    </dependency>
    
    <dependency>
     <groupId>com.sun.faces</groupId>
     <artifactId>mojarra-jsf-api</artifactId>
     <version>2.0.0-b04</version>
    </dependency>
    
    <dependency>
     <groupId>com.sun.faces</groupId>
     <artifactId>jsf-impl</artifactId>
     <version>2.2.4</version>
    </dependency>
    
    <dependency>
     <groupId>com.sun.faces</groupId>
     <artifactId>mojarra-jsf-impl</artifactId>
     <version>2.0.0-b04</version>
    </dependency>
    
    <dependency>
     <groupId>javax.servlet.jsp</groupId>
     <artifactId>javax.servlet.jsp-api</artifactId>
     <version>2.3.1</version>
    </dependency>
    
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.1.2</version>
    </dependency>
    
    

    Installieren der Abhängigkeiten

    Für die Installation der Abhängigkeiten, die Sie im erwähnt haben pom.xml Datei haben Sie zwei Möglichkeiten:

    • Durch Aufrufen der Eclipse-IDE-Build-Projektverknüpfung Strg + B.
    • Durch Aufrufen des Maven-Clean-Install-Befehls.

    Die folgenden Schnappschüsse zeigen Ihnen das Verhalten für jede Installationsart.

    Abhängigkeiten per Eclipse installieren

    Abhängigkeiten von Maven installieren

    Konfigurieren Sie den Bereitstellungsdeskriptor (web.xml)

    Die Datei web.xml sollte so konfiguriert sein, dass die Anwendung in der Lage ist, die Datei aufzurufen JavaServer-Gesichter (JSF) Implementierung. Bei einer solchen Konfiguration sollten die folgenden Punkte berücksichtigt werden:

    • Konfigurieren Sie die JavaServer steht vor dem Servlet das würde von der verwendet werden JavaServer-Gesichter Implementierung und die Zuordnungs-URL, die zum Auslösen dieses Servlets verwendet werden würde.
    • Konfigurieren Sie den Standort des faces-config.xml Datei, die zum Definieren der verwalteten Beans, Navigationsfälle und benutzerdefinierten Komponenten (Validator, Konverter usw.) verwendet wird.
    • Konfigurieren Sie den Speicherort, der zum Speichern des Status der Ansichtskomponenten verwendet wird.
    • Konfigurieren Sie die JavaServer-Gesichter Hörer.

    Die web.xml-Datei sollte wie folgt aussehen

    
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
     id="WebApp_ID" version="2.5" metadata-complete="true">
     <context-param>
     <description>State saving method: 'client' or 'server' (=default). See JSF Specification 2.5.2</description>
     <param-name>javax.faces.STATE_SAVING_METHOD</param-name>
     <param-value>client</param-value>
     </context-param>
     <context-param>
     <param-name>javax.faces.application.CONFIG_FILES</param-name>
     <param-value>/WEB-INF/faces-config.xml</param-value>
     </context-param>
     <servlet>
     <servlet-name>Faces Servlet</servlet-name>
     <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
     <load-on-startup>1</load-on-startup>
     </servlet>
     <servlet-mapping>
     <servlet-name>Faces Servlet</servlet-name>
     <url-pattern>/faces/*</url-pattern>
     </servlet-mapping></pre>
    <servlet-mapping>
     <servlet-name>Faces Servlet</servlet-name>
     <url-pattern>*.xhtml</url-pattern>
     </servlet-mapping>
    <pre>
     <listener>
     <listener-class>com.sun.faces.config.ConfigureListener</listener-class>
     </listener>
    </web-app>
    
    

    Erstellen einer verwalteten Bean

    Die Managed Bean ist der Ort, den Sie zum Verwalten der Daten zwischen der Benutzeroberfläche und dem Server verwendet haben. Im Hello World-Beispiel werden wir eine neue Manged Bean definieren, um ein Hello World zu erstellen! Nachricht serverseitig lesbar, anstatt sie direkt auf der Seite zu erwähnen. Vor JavaServer Faces 2 ist für die Erstellung eines verwalteten Servers eine faces-config.xml erforderlich, um dies zu erwähnen.

    Um eine verwaltete Bean zu erstellen, müssen Sie lediglich Folgendes tun:

    • Klicken Sie mit der rechten Maustaste auf das Paket namens net.javabeat.jsf
    • Wählen Sie Neu -> Klasse.
    • Ändern Sie den Namen der Klasse.
    • Definieren Sie die neue Eigenschaft helloProperty.
    package net.javabeat.jsf;
    
    public class HelloWorldBackingBean {
     private String helloProperty = "Hello World !";
    
    public String getHelloProperty() {
     return helloProperty;
     }
    
    public void setHelloProperty(String helloProperty) {
     this.helloProperty = helloProperty;
     }
    }
    

    Konfigurieren Sie faces-config.xml

    Der faces-config.xml Die Datei sollte auch so konfiguriert werden, dass sie die verwalteten Beans enthält, die in verwendet werden würden JavaServer-Gesichter Seiten. Das folgende Codefragment zeigt Ihnen die vollständige faces-config.xml für die Hello World-Anwendung, falls Sie sich entschieden haben, Ihre Beans in der face-config.xml zu definieren. Seit JavaServer-Gesichter 2 Die Beans werden mithilfe der Annotation of definiert @ManagedBean.

    
    <?xml version="1.0" encoding="UTF-8"?>
    <faces-config xmlns="http://xmlns.jcp.org/xml/ns/javaee"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-facesconfig_2_2.xsd"
     version="2.2">
     <managed-bean>
      <managed-bean-name>helloWorldBackingBean</managed-bean-name>
      <managed-bean-class>net.javabeat.jsf.HelloWorldBackingBean</managed-bean-class>
      <managed-bean-scope>session</managed-bean-scope>
     </managed-bean>
    </faces-config>
    
    

    Das folgende Codefragment zeigt Ihnen übrigens das JavaServer-Gesichter (JSF) Bohnen definiert mit @ManagedBean. Bei der verwalteten Bean, die erstellt wurde, handelt es sich einfach um eine Java-Klassendatei, die mit @ManagedBean annotiert ist. Dadurch durchsucht die JavaServer Faces-Implementierung Ihren Klassenpfad nach den mit @ManagedBean annotierten Klassen.

    
    package net.javabeat.jsf;
    
    import javax.faces.bean.ManagedBean;
    import javax.faces.bean.SessionScoped;
    
    @ManagedBean
    @SessionScoped
    public class HelloWorldBackingBean {
     private String helloProperty = "Hello World !";
    
    public String getHelloProperty() {
     return helloProperty;
     }
    
    public void setHelloProperty(String helloProperty) {
     this.helloProperty = helloProperty;
     }
    }
    
    

    Konfigurieren Sie Apache Tomcat

    Wenn Sie Apache Tomcat jemals für die Ausführung von JSF-Beispielen konfiguriert haben, möchten Sie es für die nächste Verwendung installieren und konfigurieren. Befolgen Sie die folgenden Schritte, um Apache Tomcat für die Verwendung vorzubereiten.

    • Aus dem dynamischen Projekt und unterhalb der Ziellaufzeit -> Wählen Sie „Neue Laufzeit“.

    Neue Laufzeit

  • Wählen Sie Apache Tomcat v7.0 -> Klicken Sie auf Weiter
  • Geben Sie den Namen des Servers ein, den Sie installiert haben.
  • Navigieren Sie zum Zielpfad von Apache Tomcat 7.0 (Laden Sie Apache Tomcat 7.0 herunter).
  • Klicken Sie auf den Serverbereich unter Fenster -> Ansicht anzeigen -> Server oder Andere -> Server.
  • Sie sollten die folgende Meldung finden (Es sind keine Server verfügbar. Klicken Sie auf diesen Link, um einen neuen Server zu erstellen …)
  • Wählen Sie Tomcat 7.0
  • Lassen Sie uns die verbleibende Konfiguration ohne Berührung durchführen.
  • Klicken Sie auf „Weiter“ und beenden Sie den Vorgang.
  • Hinzufügen eines Apache-Servers

    • Der Server ist installiert und betriebsbereit

    Erstellen Sie eine JavaServer Faces-Seite

    Nach dem Erstellen, Konfigurieren und Installieren aller Bibliotheken, die für die Verwendung erforderlich sind JavaServer-Gesichter, Es ist Zeit, das erste Hello World-Beispiel zu erstellen.

    • Klicken Sie mit der rechten Maustaste auf den WebContent des Projekts.
    • Wählen Sie Neu -> HTML-Datei.
    • Benennen Sie Ihre Datei mit index.xhtml -> Klicken Sie auf Weiter
    • Wählen Neue XHTML-Datei (1.0 streng) -> Klicken Sie auf Fertig stellen
    • Schreiben Sie ein JavaServer Faces-Codefragment zur Verwendung der definierten Bean.
    • Die HelloWorldBackingBean enthält ein Attribut mit einem Getter und Setter (Dies ist eine JSF-Einschränkung zum Anzeigen der Eigenschaften der Bean).
    • Eine neue im HelloWorldBackingBean definierte Eigenschaft namens (helloProperty) mit einem Standardwert Hello World!.

    Die Seite, auf der Sie sie erstellen, muss wie folgt aussehen

    
    <html xmlns="http://www.w3.org/1999/xhtml"
     xmlns:h="http://java.sun.com/jsf/html"
     xmlns:f="http://java.sun.com/jsf/core"
     xmlns:ui="http://java.sun.com/jsf/facelets">
     <f:view>
     <h:outputText value="#{helloWorldBackingBean.helloProperty}"></h:outputText>
     </f:view>
    </html>
    
    

    Führen Sie index.xhtml aus

    Um index.xhtml auszuführen, sollten Sie die folgenden Schritte ausführen:

    • Klicken Sie mit der rechten Maustaste auf index.xhtml
    • Wählen Rennen wie
    • Wählen Sie den konfigurierten Apache-Server aus, den Sie zuvor erstellt haben.
    • Klicken Sie auf Fertig stellen.
    • Sie sollten die Nachricht sehen Hallo Welt !

    Laden Sie den Quellcode herunter

    Was kommt als nächstes?

    Nachdem Sie die Installation und Konfiguration von JSF 2 abgeschlossen haben, haben Sie die Möglichkeit, weitere Tutorials durchzugehen, die Ihnen erklären, wie verschiedene Arten von JSF-Komponenten verwendet werden können.

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen