Što je JSF? Predstavljamo JavaServer Faces

JavaServer Faces (JSF) je Java standardna tehnologija za izgradnju web sučelja temeljenih na komponentama, orijentiranih na događaje. Kao i JavaServer Pages (JSP), JSF omogućuje pristup podacima i logici na strani poslužitelja. Za razliku od JSP-a, koji je u osnovi HTML stranica prožeta mogućnostima na poslužitelju, JSF je XML dokument koji predstavlja formalne komponente u logičkom stablu. JSF komponente podržane su Java objektima, koji su neovisni o HTML-u i imaju čitav niz Java sposobnosti, uključujući pristup udaljenim API-ima i bazama podataka.

Ključna ideja okvira poput JSF-a je inkapsuliranje (ili umotavanje ) tehnologija na strani klijenta poput HTML-a, CSS-a i JavaScript-a, omogućavajući programerima izgradnju web sučelja bez puno interakcije s tim tehnologijama.

Ovaj članak predstavlja kratki snimak JSF-ovog pristupa razvoju korisničkog sučelja temeljenom na komponentama za Java web aplikacije. Jednostavni primjeri uvode JSF-ovu MVC arhitekturu, model događaja i biblioteku komponenata. Primjeri uključuju nove značajke u JSF 2.3, a mi ćemo koristiti PrimeFaces za našu biblioteku komponenata.

Razvoj JSF-a

Dugo popularan, JSF se nedavno suočio s konkurencijom web okvira kompatibilnih s Javom, uključujući JavaScript okvire na strani klijenta. Ipak, JavaServer Faces ostaje Java standard, posebno za velik Java razvoj poduzeća. JSF specifikacija također je iznjedrila bogatstvo okvira i knjižnica, koji su išli u korak s nedavnim poboljšanjima na strani klijenta. Jedan od njih je PrimeFaces, koji istražujemo u ovom vodiču.

Iako je raspored budućeg razvoja nejasan, JSF 2.3 pruža programerima dovoljno posla za rad dok čekamo. Izbačen u ožujku 2017., JSF 2.3 namjerno je dizajniran za modernizaciju JSF-a. Među nekoliko stotina malih popravaka i većih ažuriranja, JSF 2.3 odbacuje upravljane bilješke graha u korist CDI-a, koje ću predstaviti kasnije u ovom vodiču.

JSF 2.3 u Jakarti EE

U rujnu 2017. Oracle je objavio namjeru da prebaci Java EE na Eclipse Foundation. Java EE od tada je preimenovan u Jakarta EE, a JSF 2.3 (Eclipse Mojarra) usvojen je za nastavak. Sljedeće veliko izdanje JSF specifikacije bit će Eclipse Mojarra 3.0.

Izgradnja web sučelja temeljenih na komponentama u JSF-u

Osnovna ideja JSF-a je inkapsulirati funkcionalnost u komponente za višekratnu upotrebu. To je slično oznakama za ponovnu upotrebu koje se koriste u JSP-u, ali JSF komponente su formalnije.

Iako možete koristiti JSF stranice unutar JavaServer Pages, uobičajenije je koristiti Facelets za izradu samostalnih JSF stranica. Faceleti su XHTML stranice dizajnirane za definiranje JSF sučelja. S faceletima koristite XML oznake za stvaranje stabla komponenata koje postaje skela za JSF korisničko sučelje.

Popis 1 predstavlja glavne dijelove jednostavne JSF stranice napisane pomoću Faceleta. U ovom primjeru pristupamo Javinim mogućnostima na poslužitelju putem graha koji je stavljen u opseg putem CDI-a. O CDI-ju ćete vidjeti više kasnije.

Popis 1. JSF ogledna stranica

    Hello JavaWorld!   #{javaBean.content}  

U Popisu 1 vidimo standardnu ​​XHTML stranicu. Pogled Facelets izgrađen je na vrhu XHTML-a. Pored XHTML prostora imena, definiran je i na njega se odnosi sekundarni prostor imena.

hBiblioteka sadrži standardne komponente za uporabu u JSF HTML stranice. //xmlns.jcp.org/jsf/htmlKnjižnica definira zbirku JSF komponenti, u ovom slučaju zbirku zajedničkih HTML elemenata. Jedna od tih komponenata je element.

HTML komponente u JSF-u

Što se tiče sintakse, element Popisa 1 referencuje na jsf/htmlknjižnicu s hprefiksom. Zatim upućuje na određenu komponentu u knjižnici, koja je headkomponenta.

Komponenta izlazi element HTML glavu. (Sva ta sintaksa može se činiti pretjeranom zbog tako jednostavne svrhe, ali za to postoji dobar razlog, kao što ćete uskoro vidjeti.)

Komponente za gniježđenje

Unutar glave ugniježđen je standardni HTML element. Ovaj se element pruža komponenti, zajedno s podređenim elementima sadržaja koji su ugniježđeni unutar nje.

U tijelu dokumenta #{}sintaksa sadrži izraz JSF . To je točno analogno JSP izrazu s ${}formatom: omogućuje pristup Java objektima u opsegu i jednostavnim funkcijama.

Osnovni uzorak za JSF jednostavan je: Upotrijebite facelete za izradu XML stabla koje upućuje na biblioteku komponenata ili knjižnice, a zatim upotrijebite komponente unutar knjižnice za prikazivanje Java objekata kao HTML-a.

Korištenje Java objekata u JSF-u

Vraćajući se na popis 1, primijetite da se unutar JSF izraza ( ${javaBean.content) javaBeanobjekt nalazi u opsegu kada se izvrši ovo označavanje. XHTML faceleta pristupa .contentsvojstvu javaBeanobjekta. Konačni izlaz je web sučelje koje spaja strukturu prikaza Facelets s Java-ovim podacima i logičkim mogućnostima na poslužitelju.

Korištenje JSF izraza samo je jedan od načina za pristup podacima Java aplikacije iz JSF korisničkog sučelja. Na kraju ćete htjeti istražiti druge načine na koje JSF komponenta može komunicirati s Java pozadinom - stvari poput popisa podataka i mreža i raznih kontrola unosa. Za sada je dovoljno apsorbirati kako JSF koristi XML oznake (ili bilješke) kako bi stvorio stablo komponenata koje daju HTML na temelju podataka sadržanih u Java objektima.

Bilješke u odnosu na XML

S JSF 2.3 postalo je moguće definirati JSF komponente s napomenama, u potpunosti izbjegavajući XML metapodatke. Potpuno je moguće definirati i primijeniti JSF aplikaciju bez uređivanja XML-a.

Struktura JSF aplikacije

Kao i JavaServer Pages i Servlet API, JavaServer Faces zahtijeva standardnu ​​strukturu direktorija i metapodatke. Oni su raspoređeni kao .war datoteke.

Struktura .war datoteke slična je Servlet ili JSP aplikaciji. Sadrži /web-appdirektorij koji sadrži datoteke oznaka aplikacije (u ovom slučaju HTML, JSP i Facelets), kao i /WEB-INFdirektorij koji predstavlja metapodatke za opis aplikacije.

Posluživanje JSF-a

Iako JSF možete pokrenuti u Java EE spremniku poput Glassfish-a, jednostavni spremnik servleta sve je što vam stvarno treba. Tomcat je popularan spremnik za JSF i druge Java tehnologije na poslužitelju.

JSF 2.3: Specifikacije i implementacije

Jedna od jakih prednosti Jave je ta što se temelji na standardima, a ti se standardi upravljaju postupkom zajednice otvorenog koda. Od svog nastanka, Java Community Process (JCP) nadgleda razvoj Java tehnologije. Jednom kada je specifikacija ili poboljšanje specifikacije razvijena i odobrena od strane JCP-a, dostupna je za provedbu više strana. Donedavno su svi Servleti, JSP i JSF razvijeni pomoću JCP-ovog postupka specifikacije otvorenog koda.

The most recent JSF specification as of this writing is JSF 2.3, released as part of Java EE 8 in 2017. Oracle's (now Eclipse's) Mojarra is the JSF reference implementation, and MyFaces and PrimeFaces are popular third-party implementations.

Each of these frameworks implements the JSF core, which includes some standard components. Vendors may also offer additional component libraries on top of the standard. When evaluating JSF frameworks, it's a good idea to consider the needs of your application and what component libraries are available to help you build it. Ideally, your JSF framework should get you as close as possible to what you need, right out of the box.

MVC in JSF 2.3

JSF is an MVC framework, implementing the model-view-controller pattern. In the MVC pattern, the idea is to separate the three concerns of a UI into discreet parts, so they're easier to manage. In general, the view is responsible for displaying data in the model, and the controller is responsible for setting up the model and routing the user to the correct view.

In a JSF implementation, the view is the Facelets page with its set of XML tags. These define the layout of the user interface. The other half of using JSF is the server-side, where Java classes back those UI components.

Managed beans deprecated in JSF 2.3

Managed bean annotations have been deprecated in JSF 2.3, and replaced by CDI (Contexts and Dependency Injection). With CDI, developers define a context and inject objects to that context. Those familiar with managed beans will find the annotation syntax slightly different, but the semantics remain exactly the same.

Controller beans

In JSF 2.3, controller beans provide the controller part of the MVC equation. Normal Java objects (often called POJOs, or plain old Java objects) provide the model.

In terms of process flow, controller beans:

  1. Decide where to direct user requests
  2. Set up POJOs for the model
  3. Use the model to render the Facelets view

JSF then folds together the component tree and model to render the output HTML.

Popis 2 pokazuje kako biste definirali javaBeanobjekt iz popisa 1 pomoću CDI-a. Ovaj popis pretpostavlja da aplikacija u svojim ovisnostima ima cdi-api-1.2.jar.

Popis 2. JavaBean definiran pomoću CDI-a

 import javax.inject.Named; import javax.enterprise.context.SessionScoped; @Named @ViewScoped public class JavaBean implements Serializable { private String content = ìWelcome to JSF!î // getters/setters } 

JSF 2.3 s PrimeFaces

U sljedećim odjeljcima koristit ću PrimeFaces kako bih vam pokazao kako JSF implementira MVC uzorak, razmjenu poruka na temelju događaja i komponente za ponovnu upotrebu. Za početak otvorite izložbu PrimeFaces Showcase, kliknite vezu Data u lijevom stupcu i odaberite DataList . Ovo će izvući demo kôd DataList za PrimeFaces.

Slika 1 pokazuje gdje možete pronaći ove uzorke.

Matthew Tyson

Slika 2 prikazuje izlaz jednostavne tablice podataka koja je preuzeta iz demonstracijske datoteke PrimeFaces DataList.

Matthew Tyson

PrimeFaces DataList: Pristup podatkovnom modelu

Listing 3 presents the markup for this dataList display. If you scroll to the bottom of the PrimeFaces showcase, you can see the markup in the dataList.xhtml tab.

Listing 3. Facelet for PrimeFaces DataList

   Basic  #{car.brand}, #{car.year}  

In Listing 3, notice the value property of the dataList component. You can see that this references a dataListView object, and accesses the .cars1 property on it. The component is going to use the model object returned by that field. JSF tokens use conventional accessors to reference object properties, so .cars1 will refer to the getCars() getter on the object.

Next, notice the var="car" property. This tells the dataList component what variable to use when it iterates over the list of cars returned by the value field. These properties are specific to the dataList component, but the value property is very common. The var attribute is also conventional for components that iterate over lists.

In the body of the component in Listing 3, you can see the car variable is accessed via JSF expressions like #{car.brand}. Each iteration of the dataListView.cars1 instance will output the car.brand field.

Notice that the tag demonstrates the ability to customize components for how they will display. In this case, the header is defined as Basic.

You can see how the Facelets XML will drive this output by combining the data with the markup. Now let's look at the Java code behind it.

DataList's server-side components

Listing 4 shows DataListView, the Java class that is used by the markup in Listing 3. You'll see shortly how the dataListView instance is associated with the DataListView class.

Listing 4. DataListView class

 package org.primefaces.showcase.view.data; import java.io.Serializable; import java.util.List; import javax.annotation.PostConstruct; import javax.inject.Named; // Pre JSF 2.3, this was: // import javax.faces.bean.ManagedBean; import javax.inject.Inject; import javax.faces.bean.ViewScoped; import org.primefaces.showcase.domain.Car; import org.primefaces.showcase.service.CarService; @Named @ViewScoped public class DataListView implements Serializable { private List cars1; private Car selectedCar; @Inject("#{carService}") private CarService service; @PostConstruct public void init() { cars1 = service.createCars(10); } public List getCars1() { return cars1; } public void setService(CarService service) { this.service = service; } } 

Listing 4 has a few other important elements, which we'll consider piece by piece.

Dependency injection and annotations

First, notice that the DataListView class is annotated with @Named, which you can see from the import import javax.inject.Named; is part of JSF. The @Named annotation tells JSF this bean is part of the app. The @ViewScoped annotation informs JSF that the bean will live for just the life of the view.

Dalje, uočite da CarServicesvojstvo ima @Injectnapomenu (koja se naziva @ManagedPropertypre JSF 2.3). Ovo je još jedna JSF značajka koja omogućuje grah da se "povežu zajedno", tehnika koju su popularizirali Spring Spring i drugi alati za ubrizgavanje ovisnosti. U osnovi, JSF će pronaći carServiceobjekt u opsegu i automatski ga pridružiti servicepolju na DataListViewobjektu.