JavaServer Faces (JSF) mit Spring

1. Übersicht

In diesem Artikel wird ein Rezept für den Zugriff auf in Spring definierte Beans über eine von JSF verwaltete Bean und eine JSF-Seite beschrieben, um die Ausführung der Geschäftslogik an die Spring Beans zu delegieren.

In diesem Artikel wird davon ausgegangen, dass der Leser JSF und Spring zuvor separat verstanden hat. Der Artikel basiert auf der Mojarra-Implementierung von JSF.

2. Im Frühling

Lassen Sie uns die folgende Bean im Frühjahr definieren. Die UserManagementDAO- Bean fügt einem In-Memory-Speicher einen Benutzernamen hinzu, der über die folgende Schnittstelle definiert wird:

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

Die Implementierung der Bean wird mit der folgenden Java-Konfiguration konfiguriert:

public class SpringCoreConfig { @Bean public UserManagementDAO userManagementDAO() { return new UserManagementDAOImpl(); } }

Oder verwenden Sie die folgende XML-Konfiguration:

Wir definieren die Bean in XML und registrieren CommonAnnotationBeanPostProcessor, um sicherzustellen, dass die Annotation @PostConstruct aufgenommen wird.

3. Konfiguration

In den folgenden Abschnitten werden die Konfigurationselemente erläutert, die die Integration der Spring- und JSF-Kontexte ermöglichen.

3.1. Java-Konfiguration ohne web.xml

Durch die Implementierung des WebApplicationInitializer können wir den ServletContext programmgesteuert konfigurieren . Das Folgende ist die onStartup () -Implementierung in der MainWebAppInitializer- Klasse:

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

Der AnnotationConfigWebApplicationContext bootet den Spring'g-Kontext und fügt die Beans hinzu, indem die SpringCoreConfig- Klasse registriert wird .

Ebenso gibt es in der Mojarra-Implementierung eine FacesInitializer- Klasse, die das FacesServlet konfiguriert . Um diese Konfiguration zu verwenden, reicht es aus, den FacesInitializer zu erweitern . Die vollständige Implementierung des MainWebAppInitializer lautet nun wie folgt:

public class MainWebAppInitializer extends FacesInitializer implements WebApplicationInitializer { public void onStartup(ServletContext sc) throws ServletException { AnnotationConfigWebApplicationContext root = new AnnotationConfigWebApplicationContext(); root.register(SpringCoreConfig.class); sc.addListener(new ContextLoaderListener(root)); } }

3.2. Mit web.xml

Zunächst konfigurieren wir den ContextLoaderListener in der Datei web.xml der Anwendung:

  org.springframework.web.context.ContextLoaderListener  

Dieser Listener ist dafür verantwortlich, den Spring-Anwendungskontext beim Start der Webanwendung zu starten. Dieser Listener sucht standardmäßig nach einer Spring-Konfigurationsdatei mit dem Namen applicationContext.xml .

3.3. Gesichter-config.xml

Wir konfigurieren jetzt den SpringBeanFacesELResolver in der Datei face-config.xml :

org.springframework.web.jsf.el.SpringBeanFacesELResolver

Ein EL-Resolver ist eine steckbare Komponente, die vom JSF-Framework unterstützt wird und die es uns ermöglicht, das Verhalten der JSF-Laufzeit bei der Auswertung von EL-Ausdrücken (Expression Language) anzupassen. Dieser EL-Resolver ermöglicht der JSF-Laufzeit den Zugriff auf Spring-Komponenten über in JSF definierte EL-Ausdrücke.

4. Zugriff auf Spring Beans in JSF

Zu diesem Zeitpunkt ist unsere JSF-Webanwendung darauf vorbereitet, entweder von einer JSF-Backing-Bean oder von einer JSF-Seite aus auf unsere Spring-Bean zuzugreifen.

4.1. Von einer Backing Bean JSF 2.0

Auf die Spring Bean kann jetzt über eine JSF-Backing Bean zugegriffen werden. Abhängig von der Version von JSF, die Sie ausführen, gibt es zwei mögliche Methoden. In JSF 2.0 verwenden Sie die Annotation @ManagedProperty für die von JSF verwaltete Bean.

@ManagedBean(name = "registration") @RequestScoped public class RegistrationBean implements Serializable { @ManagedProperty(value = "#{userManagementDAO}") transient private IUserManagementDAO theUserDao; private String userName;
 // getters and setters }

Beachten Sie, dass der Getter und der Setter bei Verwendung der @ManagedProperty obligatorisch sind .

Um die Zugänglichkeit einer Spring-Bean von einer verwalteten Bean aus zu bestätigen, fügen wir die Methode createNewUser () hinzu :

public void createNewUser() { FacesContext context = FacesContext.getCurrentInstance(); boolean operationStatus = userDao.createUser(userName); context.isValidationFailed(); if (operationStatus) { operationMessage = "User " + userName + " created"; } } 

Der Kern der Methode besteht darin, die userDao Spring-Bean zu verwenden und auf ihre Funktionalität zuzugreifen.

4.2. Von einer Backing Bean in JSF 2.2

Ein anderer Ansatz, der nur in JSF2.2 und höher gültig ist, ist die Verwendung der @ Inject- Annotation von CDI . Dies gilt für JSF-verwaltete Beans (mit der Annotation @ManagedBean ) und CDI-verwaltete Beans (mit der Annotation @Named ).

In der Tat ist dies mit einer CDI-Annotation die einzig gültige Methode zum Injizieren der Bean:

@Named( "registration") @RequestScoped public class RegistrationBean implements Serializable { @Inject UserManagementDAO theUserDao; }

Bei diesem Ansatz sind Getter und Setter nicht erforderlich. Beachten Sie auch, dass der EL-Ausdruck fehlt.

4.3. Aus einer JSF-Ansicht

Die Methode createNewUser () wird von der folgenden JSF-Seite ausgelöst:

Starten Sie zum Rendern der Seite den Server und navigieren Sie zu:

//localhost:8080/jsf/index.jsf

Wir können EL auch in der JSF-Ansicht verwenden, um auf die Spring Bean zuzugreifen. Um es zu testen, reicht es aus, die Zeilennummer 7 von der zuvor eingeführten JSF-Seite in zu ändern:

Here, we call the createUser method directly on the Spring DAO, passing the bind value of the userName to the method from within the JSF page, circumventing the managed bean all together.

5. Conclusion

We examined a basic integration between the Spring and JSF contexts, where we’re able to access a Spring bean in a JSF bean and page.

It’s worth noting that while the JSF runtime provides the pluggable architecture that enables the Spring framework to provide integration components, the annotations from the Spring framework cannot be used in a JSF context and vice versa.

Dies bedeutet, dass Sie in einer von JSF verwalteten Bean keine Annotationen wie @Autowired oder @Component usw. oder in einer von Spring verwalteten Bean die Annotation @ManagedBean verwenden können . Sie können die Annotation @Inject jedoch sowohl in einer von JSF 2.2+ verwalteten Bean als auch in einer Spring-Bean verwenden (da Spring JSR-330 unterstützt).

Der diesem Artikel beiliegende Quellcode ist bei GitHub verfügbar.