TOC

JavaServer Faces (JSF) avec Spring

JavaServer Faces (JSF) avec Spring

1. Vue d'ensemble

Dans cet article, nous examinerons une recette permettant d'accéder aux beans définis dans Spring à partir d'un bean géré par JSF et d'une page JSF, dans le but de déléguer l'exécution de la logique métier aux beans Spring.

Cet article suppose que le lecteur a une compréhension préalable de JSF et de Spring séparément. L'article est basé surthe Mojarra implementation de JSF.

2. Au printemps

Ayons le haricot suivant défini au printemps. Le beanUserManagementDAO ajoute un nom d’utilisateur à un magasin en mémoire, et il est défini par l’interface suivante: 

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

L'implémentation du bean est configurée à l'aide de la configuration Java suivante: 

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

Ou en utilisant la configuration XML suivante:

Nous définissons le bean en XML et enregistronsCommonAnnotationBeanPostProcessor pour nous assurer que l'annotation@PostConstruct est récupérée.

3. Configuration

Les sections suivantes décrivent les éléments de configuration permettant l'intégration des contextes Spring et JSF.

3.1. Configuration Java sansweb.xml

En implémentant lesWebApplicationInitializer, nous pouvons configurer par programme lesServletContext. Voici l'implémentation deonStartup() dans la classeMainWebAppInitializer: 

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

LeAnnotationConfigWebApplicationContext amorce le contexte Spring’g et ajoute les beans en enregistrant la classeSpringCoreConfig.

De même, dans l'implémentation Mojarra il y a une classeFacesInitializer qui configure lesFacesServlet. Pour utiliser cette configuration il suffit d'étendre lesFacesInitializer. L'implémentation complète desMainWebAppInitializer, est maintenant comme suit: 

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. Avecweb.xml

Nous allons commencer par configurer lesContextLoaderListener dans le fichierweb.xml de l'application: 


    
        org.springframework.web.context.ContextLoaderListener

Cet écouteur est responsable du démarrage du contexte de l'application Spring au démarrage de l'application Web. Cet écouteur recherchera un fichier de configuration de ressort nomméapplicationContext.xml par défaut.

3.3. faces-config.xml

Nous configurons maintenant lesSpringBeanFacesELResolver dans le fichierface-config.xml: 

org.springframework.web.jsf.el.SpringBeanFacesELResolver

Un résolveur EL est un composant enfichable pris en charge par le framework JSF, ce qui nous permet de personnaliser le comportement du moteur d'exécution JSF lors de l'évaluation d'expressions de langage Expression Language (EL). Ce résolveur EL autorisera l'accès aux composants Spring du runtime JSF via les expressions EL définies dans JSF.

4. Accéder aux Spring Beans dans JSF

À ce stade, notre application Web JSF est prête à accéder à notre bean Spring à partir d’un bean de support JSF ou d’une page JSF.

4.1. À partir d'un Backing Bean JSF 2.0

Le haricot Spring est maintenant accessible à partir d’un haricot de soutien JSF. Selon la version de JSF que vous utilisez, il existe deux méthodes. Avec JSF 2.0, vous utilisez l'annotation@ManagedProperty sur le bean géré JSF. 

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

    private String userName;
    // getters and setters
}

Notez que le getter et le setter sont obligatoires lors de l'utilisation du@ManagedProperty. Maintenant - pour affirmer l'accessibilité d'un bean Spring à partir d'un bean géré, nous allons ajouter la méthodecreateNewUser(): 

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

L'essentiel de la méthode consiste à utiliser le bean SpringuserDao et à accéder à ses fonctionnalités.

4.2. À partir d'un backing bean dans JSF 2.2

Une autre approche, valable uniquement dans JSF2.2 et au-dessus, consiste à utiliser l'annotation@Inject de CDI. Cela s'applique aux beans gérés JSF (avec l'annotation@ManagedBean) et aux beans gérés par CDI (avec l'annotation@Named).

En effet, avec une annotation CDI, c’est la seule méthode valide d’injection du bean: 

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

Avec cette approche, le getter et le setter ne sont pas nécessaires. Notez également que l'expression EL est absente.

4.3. Depuis une vue JSF

La méthodecreateNewUser() sera déclenchée à partir de la page JSF suivante:

Pour rendre la page, démarrez le serveur et accédez à: 

http://localhost:8080/jsf/index.jsf

Nous pouvons également utiliser EL dans la vue JSF pour accéder au bean Spring. Pour le tester, il suffit de changer le numéro de ligne 7 de la page JSF introduite précédemment pour:

Ici, nous appelons la méthodecreateUser directement sur le Spring DAO, en transmettant la valeur de liaison desuserName à la méthode depuis la page JSF, en contournant le bean géré tous ensemble.

5. Conclusion

Nous avons examiné une intégration de base entre les contextes Spring et JSF, permettant d’accéder à un bean Spring dans un bean et une page JSF.

Il est à noter que, si le moteur d’exécution JSF fournit l’architecture enfichable qui permet au framework Spring de fournir des composants d’intégration, les annotations du framework Spring ne peuvent pas être utilisées dans un contexte JSF et inversement.

Cela signifie que vous ne pourrez pas utiliser d'annotations telles que@Autowired ou@Component, etc. dans un bean géré JSF, ou utilisez l'annotation@ManagedBean sur un bean géré par Spring. Vous pouvez cependant utiliser l'annotation@Inject à la fois dans un bean géré JSF 2.2+ et un bean Spring (car Spring prend en charge JSR-330).

Le code source qui accompagne cet article est disponible àGitHub.

Related