Какво е JSF? Представяме ви JavaServer Faces

JavaServer Faces (JSF) е стандартната технология на Java за изграждане на базирани на компоненти, ориентирани към събития уеб интерфейси. Подобно на JavaServer Pages (JSP), JSF позволява достъп до данни и логика от страна на сървъра. За разлика от JSP, който по същество е HTML страница, пропита с възможности от страна на сървъра, JSF е XML документ, който представлява формални компоненти в логическо дърво. Компонентите на JSF са подкрепени от Java обекти, които са независими от HTML и имат пълния набор от способности на Java, включително достъп до отдалечени API и бази данни.

Ключовата идея на рамка като JSF е да се капсулират (или обвиват ) клиентски технологии като HTML, CSS и JavaScript, позволявайки на разработчиците да изграждат уеб интерфейси без много взаимодействие с тези технологии.

Тази статия представя моментна снимка на подхода на JSF към базираното на компоненти разработване на потребителски интерфейс за уеб приложения на Java. Прости примери представят MVC архитектурата, модела на събитията и библиотеката на компонентите на JSF. Примерите включват нови функции в JSF 2.3 и ще използваме PrimeFaces за нашата библиотека с компоненти.

Развиващ се JSF

Отдавна популярен, JSF наскоро се сблъска с конкуренция от съвместими с Java уеб рамки, включително JavaScript рамки от страна на клиента. И все пак JavaServer Faces остава стандартът на Java, особено за широкомащабно развитие на Java предприятия. Спецификацията JSF също породи богатство от рамки и библиотеки, които са в крак с последните подобрения от страна на клиента. Един от тях е PrimeFaces, който изследваме в този урок.

Въпреки че графикът за бъдещо развитие е неясен, JSF 2.3 дава на разработчиците много работа, докато чакаме. Издаден през март 2017 г., JSF 2.3 е умишлено проектиран да модернизира JSF. Сред няколкостотин малки поправки и по-големи актуализации, JSF 2.3 отменя управляваните анотации на боб в полза на CDI, които ще представя по-късно в този урок.

JSF 2.3 в Джакарта EE

През септември 2017 г. Oracle обяви намерението си да прехвърли Java EE към фондацията Eclipse. Оттогава Java EE е ребрандирана на Jakarta EE и JSF 2.3 (Eclipse Mojarra) е приет за продължаване. Следващата голяма версия на спецификацията JSF ще бъде Eclipse Mojarra 3.0.

Изграждане на базирани на компоненти уеб интерфейси в JSF

Основната идея на JSF е да капсулира функционалността в компоненти за многократна употреба. Това е подобно на етикетите за многократна употреба, използвани в JSP, но JSF компонентите са по-официални.

Въпреки че можете да използвате JSF страници в JavaServer Pages, по-често се използва Facelets за изграждане на самостоятелни JSF страници. Facelets са XHTML страници, предназначени за дефиниране на JSF интерфейси. С Facelets използвате XML тагове, за да създадете дърво на компоненти, което се превръща в скелето за потребителски интерфейс JSF.

Листинг 1 представя основните части на проста JSF страница, написана с помощта на Facelets. В този пример ние имаме достъп до възможностите на Java от страна на сървъра чрез боб, който е поставен в обхвата чрез CDI. По-късно ще видите повече за CDI.

Листинг 1. Примерна страница на JSF

    Hello JavaWorld!   #{javaBean.content}  

В Листинг 1 виждаме стандартна XHTML страница. Изгледът Facelets е изграден върху XHTML. В допълнение към пространството от имена XHTML се дефинира и препраща към вторично пространство от имена.

В hбиблиотеката съдържа стандартни компоненти за използване в JSF HTML страници. В //xmlns.jcp.org/jsf/htmlбиблиотеката определя колекция от JSF компоненти, в този случай колекция от обикновените HTML елементи. Един от тези компоненти е елементът.

HTML компоненти в JSF

По отношение на синтаксиса, елементът на Листинг 1 се позовава на jsf/htmlбиблиотеката с hпрефикса. След това той препраща към конкретния компонент в библиотеката, който е headкомпонентът.

Най- компонентни изхода елемент HTML глава. (Целият този синтаксис може да изглежда прекалено много за толкова проста цел, но има основателна причина за това, както ще видите скоро.)

Компоненти за влагане

Вътре в главата е вложен стандартен HTML елемент. Този елемент се предоставя на компонента, заедно с дъщерните елементи на съдържанието, вложени вътре в него.

В тялото на документа JSF израз се съдържа от #{}синтаксиса. Това е точно аналогично на JSP израз с ${}формата: позволява достъп на Java обекти в обхват и прости функции.

Основният модел за JSF е прост: Използвайте Facelets, за да изградите XML дърво, което препраща към библиотека или библиотеки на компоненти, след което използвайте компоненти в библиотеката, за да изобразите Java обектите като HTML.

Използване на Java обекти в JSF

Връщайки се към Листинг 1, забележете, че вътре в JSF израза ( ${javaBean.content) javaBeanОбектът е в обхвата, когато се изпълни това маркиране. XHTML на Facelets осъществява достъп до .contentсвойството на javaBeanобекта. Крайният изход е уеб интерфейс, който обединява структурата на изгледите Facelets с данните и логическите възможности на Java от страна на сървъра.

Използването на JSF израз е само един от начините за достъп до данните на Java приложението от потребителския интерфейс на JSF. В крайна сметка ще искате да проучите други начини, по които JSF компонент може да взаимодейства с бекенда на Java - неща като списъци с данни и решетки и разнообразни контроли за въвеждане. Засега е достатъчно да се възприеме как JSF използва XML тагове (или анотации), за да създаде дърво от компоненти, което извежда HTML въз основа на данните, съдържащи се в Java обектите.

Анотации срещу XML

С JSF 2.3 стана възможно да се дефинират JSF компоненти с анотации, избягвайки изцяло XML метаданните. Напълно възможно е да дефинирате и внедрите JSF приложение, без да редактирате XML.

Структура на JSF приложение

Подобно на JavaServer Pages и API на Servlet, JavaServer Faces изисква стандартна структура на директории и метаданни. Те са разположени като .war файлове.

Структурата на .war файл е подобна на Servlet или JSP приложение. Той съдържа /web-appдиректория, която съдържа файловете за маркиране на приложението (в този случай HTML, JSP и Facelets), както и /WEB-INFдиректория, която представя метаданните за описание на приложението.

Обслужване на JSF

Въпреки че можете да стартирате JSF в Java EE контейнер като Glassfish, обикновеният контейнер за сървлети е всичко, от което наистина се нуждаете. Tomcat е популярен контейнер за JSF и други Java технологии от сървъра.

JSF 2.3: Спецификации и изпълнения

Една от силните страни на Java е, че тя се основава на стандарти и тези стандарти се управляват от процес на общност с отворен код. От самото си създаване Java Community Process (JCP) ръководи развитието на Java технологията. След като спецификацията или подобрението на спецификацията е разработена и одобрена от JCP, тя може да бъде приложена от множество страни. Доскоро всички сървлети, JSP и JSF бяха разработени с помощта на процеса на спецификация на JCP с отворен код.

Най-новата JSF спецификация към момента на написването е JSF 2.3, пусната като част от Java EE 8 през 2017 г. Oracle (сега на Eclipse) Mojarra е референтната реализация на JSF, а MyFaces и PrimeFaces са популярни реализации на трети страни.

Всяка от тези рамки изпълнява JSF ядрото, което включва някои стандартни компоненти. Доставчиците могат да предлагат и допълнителни библиотеки на компоненти в допълнение към стандарта. Когато оценявате JSF рамки, е добра идея да вземете предвид нуждите на вашето приложение и какви библиотеки на компоненти са на разположение, за да ви помогнат да го изградите. В идеалния случай вашата JSF рамка трябва да ви доближи възможно най-близо до това, от което се нуждаете, веднага от кутията.

MVC в JSF 2.3

JSF е MVC рамка , прилагаща модела модел-изглед-контролер. В модела на MVC идеята е да се разделят трите проблеми на потребителския интерфейс на дискретни части, така че да се управляват по-лесно. Като цяло изгледът е отговорен за показване на данни в модела, а контролерът е отговорен за настройката на модела и насочването на потребителя към правилния изглед.

В изпълнение на JSF изгледът е страницата Facelets с набора от XML тагове. Те определят оформлението на потребителския интерфейс. Другата половина от използването на JSF е от страна на сървъра, където Java класовете връщат тези компоненти на потребителския интерфейс.

Управляван боб, остарял в JSF 2.3

Управляваните анотации на боб са оттеглени в JSF 2.3 и са заменени от CDI (Контексти и инжектиране на зависимост). С CDI разработчиците дефинират контекст и инжектират обекти към този контекст. Тези, които са запознати с управляваните зърна, ще открият синтаксиса на анотациите малко по-различен, но семантиката остава абсолютно същата.

Контролер боб

В JSF 2.3 зърната на контролера осигуряват контролната част на уравнението MVC. Нормалните Java обекти (често наричани POJO или обикновени стари Java обекти) предоставят модела.

По отношение на потока на процеса, компонентите на контролера:

  1. Решете къде да насочите потребителските заявки
  2. Настройте POJO за модела
  3. Използвайте модела, за да изобразите изгледа Facelets

След това JSF сгъва дървото на компонентите и модела, за да изобрази изходния HTML.

Листинг 2 показва как бихте определили javaBeanобекта от Листинг 1 с помощта на CDI. Този списък предполага, че приложението има cdi-api-1.2.jar в своите зависимости.

Листинг 2. JavaBean, дефиниран с помощта на CDI

 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 с PrimeFaces

В следващите раздели ще използвам PrimeFaces, за да ви покажа как JSF прилага MVC шаблона, управляваните от събития съобщения и компонентите за многократна употреба. За да започнете, отворете PrimeFaces Showcase, щракнете върху връзката Data в лявата колона и изберете DataList . Това ще изведе демо кода на DataList за PrimeFaces.

Фигура 1 ви показва къде да намерите тези проби.

Матю Тайсън

Фигура 2 показва изхода на проста таблица с данни, която е взета от демонстрацията на PrimeFaces DataList.

Матю Тайсън

PrimeFaces DataList: Достъп до модела на данни

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.

След това забележете, че CarServiceсвойството има @Injectанотацията (наречена @ManagedPropertyпреди JSF 2.3). Това е друга функция на JSF, която позволява на зърната да бъдат "свързани заедно", техника, популяризирана от Spring framework и други инструменти за инжектиране на зависимости. По същество JSF ще намери carServiceобекта в обхвата и ще го свърже автоматично с serviceполето на DataListViewобекта.