JavaServer Faces (JSF) met Spring

1. Overzicht

In dit artikel zullen we een recept bekijken voor toegang tot bonen die in Spring zijn gedefinieerd vanuit een door JSF beheerde bean en een JSF-pagina, met als doel de uitvoering van bedrijfslogica te delegeren aan de Spring Beans.

In dit artikel wordt ervan uitgegaan dat de lezer een voorafgaand begrip heeft van zowel JSF als Spring afzonderlijk. Het artikel is gebaseerd op de Mojarra-implementatie van JSF.

2. In het voorjaar

Laten we de volgende boon in het voorjaar definiëren. De GebruikersbeheerDAO bean voegt een gebruikersnaam toe aan een in-memory store, en deze wordt gedefinieerd door de volgende interface:

openbare interface UserManagementDAO {boolean createUser (String newUserData); }

De implementatie van de bean wordt geconfigureerd met behulp van de volgende Java-configuratie:

openbare klasse SpringCoreConfig {@Bean openbare UserManagementDAO userManagementDAO () {retourneer nieuwe UserManagementDAOImpl (); }}

Of gebruik de volgende XML-configuratie:

We definiëren de boon in XML en registreren CommonAnnotationBeanPostProcessor om ervoor te zorgen dat de @PostConstruct annotatie wordt opgehaald.

3. Configuratie

In de volgende secties worden de configuratie-items uitgelegd die de integratie van de Spring- en JSF-contexten mogelijk maken.

3.1. Java-configuratie zonder web.xml

Door het WebApplicationInitializer we zijn in staat om het ServletContext. Het volgende is de onStartup () implementatie binnen de MainWebAppInitializer klasse:

public void onStartup (ServletContext sc) gooit ServletException {AnnotationConfigWebApplicationContext root = new AnnotationConfigWebApplicationContext (); root.register (SpringCoreConfig.class); sc.addListener (nieuwe ContextLoaderListener (root)); }

De AnnotationConfigWebApplicationContext bootstraps de Spring'g-context en voegt de bonen toe door de SpringCoreConfig klasse.

Evenzo is er in de Mojarra-implementatie een FacesInitializer klasse die het FacesServlet. Om deze configuratie te gebruiken is het voldoende om het FacesInitializer. De volledige implementatie van het MainWebAppInitializer, is nu als volgt:

openbare klasse MainWebAppInitializer breidt FacesInitializer implementeert WebApplicationInitializer {public void onStartup (ServletContext sc) gooit ServletException {AnnotationConfigWebApplicationContext root = nieuwe AnnotationConfigWebApplicationContext (); root.register (SpringCoreConfig.class); sc.addListener (nieuwe ContextLoaderListener (root)); }}

3.2. Met web.xml

We beginnen met het configureren van het ContextLoaderListener in web.xml dossier van de aanvraag:

  org.springframework.web.context.ContextLoaderListener 

Deze listener is verantwoordelijk voor het opstarten van de Spring-toepassingscontext bij het opstarten van de webtoepassing. Deze luisteraar zoekt naar een springconfiguratiebestand met de naam applicationContext.xml standaard.

3.3. faces-config.xml

We configureren nu het SpringBeanFacesELResolver in de face-config.xml het dossier:

org.springframework.web.jsf.el.SpringBeanFacesELResolver

Een EL-resolver is een pluggable component die wordt ondersteund door het JSF-framework, waardoor we het gedrag van de JSF-runtime kunnen aanpassen bij het evalueren van Expression Language (EL) -uitdrukkingen. Deze EL-resolver geeft de JSF-runtime toegang tot Spring-componenten via EL-expressies die zijn gedefinieerd in JSF.

4. Toegang tot Spring Beans in JSF

Op dit punt is onze JSF-webapplicatie klaar om toegang te krijgen tot onze Spring Bean via een JSF-steunboon of vanaf een JSF-pagina.

4.1. Van een Backing Bean JSF 2.0

De Spring bean is nu toegankelijk vanaf een JSF-steunboon. Afhankelijk van de versie van JSF die u gebruikt, zijn er twee mogelijke methoden. Met JSF 2.0 gebruikt u de @ManagedProperty annotatie op de door JSF beheerde bean.

@ManagedBean (name = "registration") @RequestScoped openbare klasse RegistrationBean implementeert Serializable {@ManagedProperty (value = "# {userManagementDAO}") tijdelijk privé IUserManagementDAO theUser Dao; private String gebruikersnaam;
 // getters en setters}

Merk op dat de getter en setter verplicht zijn bij gebruik van de @ManagedProperty.

Nu - om de toegankelijkheid van een springboon van een beheerde boon te bevestigen, zullen we de createNewUser () methode:

openbare ongeldige createNewUser () {FacesContext context = FacesContext.getCurrentInstance (); boolean operationStatus = userão.createUser (gebruikersnaam); context.isValidationFailed (); if (operationStatus) {operationMessage = "Gebruiker" + gebruikersnaam + "aangemaakt"; }} 

De kern van de methode is het gebruik van de userbao Spring bean, en toegang tot de functionaliteit ervan.

4.2. Van een Backing Bean in JSF 2.2

Een andere benadering, alleen geldig in JSF2.2 en hoger, is het gebruik van CDI's @Injecteren annotatie. Dit is van toepassing op door JSF beheerde bonen (met de @ManagedBean annotatie) en door CDI beheerde bonen (met de @Genaamd annotatie).

Met een CDI-annotatie is dit inderdaad de enige geldige methode om de boon te injecteren:

@Named ("registration") @RequestScoped openbare klasse RegistrationBean implementeert Serializable {@Inject UserManagementDAO theUser Dao; }

Met deze aanpak zijn de getter en setter niet nodig. Merk ook op dat de EL-uitdrukking afwezig is.

4.3. Vanuit een JSF-weergave

De createNewUser () methode wordt geactiveerd vanaf de volgende JSF-pagina:

Om de pagina weer te geven, start u de server en gaat u naar:

//localhost:8080/jsf/index.jsf

We kunnen EL ook gebruiken in de JSF-weergave om toegang te krijgen tot de Spring bean. Om het te testen is het voldoende om regelnummer 7 van de eerder geïntroduceerde JSF-pagina te veranderen in:

Hier noemen we de createUser methode rechtstreeks op de Spring DAO, waarbij de bindwaarde van de gebruikersnaam naar de methode vanuit de JSF-pagina, waarbij de beheerde bean helemaal wordt omzeild.

5. Conclusie

We hebben een basisintegratie tussen de Spring- en JSF-contexten onderzocht, waarbij we toegang hebben tot een Spring bean in een JSF-bean en -pagina.

Het is vermeldenswaard dat hoewel de JSF-runtime de pluggable architectuur biedt waarmee het Spring-framework integratiecomponenten kan leveren, de annotaties van het Spring-framework niet in een JSF-context kunnen worden gebruikt en vice versa.

Dit betekent dat je geen annotaties zoals @Autowired of @Component etc. in een door JSF beheerde bean, of gebruik de @ManagedBean annotatie op een door Spring beheerde boon. U kunt echter de @Injecteren annotatie in zowel een JSF 2.2+ beheerde bean als een Spring bean (omdat Spring JSR-330 ondersteunt).

De broncode die bij dit artikel hoort, is beschikbaar op GitHub.