• 10 heures
  • Facile

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 03/09/2019

Faites vos premiers pas avec Struts

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Faire connaissance avec Apache Struts

Apache Struts est un framework MVC (Modèle Vue Contrôleur) permettant de développer des applications web. Mais quelle est la place de Struts dans ces applications ?

Struts va vous permettre d'implémenter facilement les parties Vue et Contrôleur. Il est donc utilisé uniquement dans la couche de présentation.

Voici un schéma du fonctionnement global de Struts. Celui-ci n'est pas complet, mais vous présente de manière générale l'organisation d'une application web avec Struts. Si vous voulez avoir une vision plus précise, la documentation officielle contient un schéma plus complet.

Schéma général
Fonctionnement général de Struts

J'aborderai les différents éléments présents sur ce schéma au fur et à mesure de l'avancée dans le cours. Le plus important à retenir pour le moment, c'est que toute la « tuyauterie » est gérée par Struts et le développeur n'a plus qu'à se concentrer sur les parties spécifiques à l'application : les actions et la vue (JSP).

Hello world

Je vous propose d'entrer tout de suite dans le vif du sujet et de créer une application web avec Apache Struts. Le projet sera géré avec Apache Maven.

Initialiser le projet

L'initialisation d'un projet Maven est abordé dans le chapitre Créez votre premier projet Maven du cours Organisez et packagez une application Java avec Apache Maven.

Afin de gagner du temps et de ne pas me répéter, je vous propose de partir du projet déja initialisé disponible sur GitHub. Il vous suffit de le télécharger et de l'importer dans votre EDI.

Ce projet contient déjà certains éléments, comme vous pourrez le voir. Sans entrer dans le détail, ce projet a déjà les dépendances pour une application web de base comme celle vers la Servlet API par exemple. Ce projet utilise également Spring, mais nous verrons cela plus en détail dans la deuxième partie de ce cours.

Comment le projet est-il organisé ?

Pour vous repérer, voici le diagramme de classes du domaine fonctionnel du projet. Tous les éléments du domaine fonctionnel ne sont pas codés.

Diagramme de classes
Ticket - Diagramme de classes du domaine fonctionnel

Le projet est un projet Maven multi-modules, organisé suivant une architecture multi-tiers où chaque couche fait l'objet d'un module Maven.

Modules Maven
Modules Maven du projet « Ticket »

Voici le contenu du projet :

  • Le module ticket-webapp contient l'application web.

  • Le module ticket-business contient la logique métier de l'application avec notamment les classes Manager.

  • Le module ticket-consumer contient les éléments d'interaction avec les services extérieurs (base de données, webservices...). S'y trouvent notamment les DAO.

  • Le module ticket-model contient les objets métiers (les beans).

  • Le module ticket-technical contient les éléments et dépendances techniques de l'application (gestion des logs...). Tous les autres modules dépendent de ce module technique.

Ajout des dépendances Struts

La première chose à faire pour utiliser Struts, c'est d'ajouter les dépendances à ce framework dans le projet Maven.

  1. Dans la section dependencyManagement du projet racine (fichier ticket/pom.xml), j'importe la « Bill Of Material » (cf cours Organisez et packagez une application Java avec Apache Maven) d'Apache Struts.

    <project>
        <properties>
            ...
            <struts.version>2.5.14.1</struts.version>
        </properties>
        ...
        <dependencyManagement>
            <dependencies>
                ...
                <!-- Framework Apache Struts -->
                <dependency>
                    <groupId>org.apache.struts</groupId>
                    <artifactId>struts2-bom</artifactId>
                    <version>${struts.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                <!-- Gestion des logs avec Log4j -->
                <dependency>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                    <version>1.2</version>
                </dependency>
                <dependency>
                    <groupId>org.apache.logging.log4j</groupId>
                    <artifactId>log4j-core</artifactId>
                    <version>2.9.1</version>
                    <scope>runtime</scope>
                </dependency>
                <dependency>
                    <groupId>org.apache.logging.log4j</groupId>
                    <artifactId>log4j-jcl</artifactId>
                    <version>2.9.1</version>
                    <scope>runtime</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    </project>
  2. Dans le module ticket-webapp, j'ajoute la dépendance vers struts2-core :

    <project>
        ...
        <dependencies>
            ...
            <!-- Framework Apache Struts -->
            <dependency>
                <groupId>org.apache.struts</groupId>
                <artifactId>struts2-core</artifactId>
            </dependency>
        </dependencies>
        ...
    </project>

Configuration de l'application web

Je configure maintenant l'application web. Comme pour toute webapp JEE, je vais utiliser le fichier src/main/webapp/WEB-INF/web.xml.

J'y ajoute le Filter de base fourni par Struts (StrutsPrepareAndExecuteFilter) permettant la prise en charge des requêtes HTTP par ce dernier. Je mappe ce filter sur toutes les URL (filter-mapping à /*).

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

    <!-- ... -->

    <!-- Filter Struts -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

Configuration de Struts

La configuration de Struts comporte deux grandes parties :

  • la configuration globale du framework (moteur de template, thème, cache...) ;

  • la configuration du mapping requêtes / actions / resultats (vue).

Pour ce faire, vous avez plusieurs solutions : fichier properties, fichier XML, annotations... Voici celle que je vais adopter :

  • la configuration globale se fera avec un fichier properties (par défaut src/main/resources/struts.properties) ;

  • la configuration du mapping se fera avec un fichier XML (par défaut src/main/resources/struts.xml).

Fichier struts.properties

Je crée le fichier src/main/resources/struts.properties et y ajoute pour le moment une seule propriété struts.devMode permettant d'activer le mode développement (utile pour les changements à chaud et les logs).

# Activer le mode développement
struts.devMode=true
Fichier struts.xml

Je crée le fichier src/main/resources/struts.xml et y ajoute une configuration de base très simple :

  • Je crée un package default basé sur le package struts-default. Je reviendrai sur cela dans le prochain chapitre.

  • J'ajoute dans ce package une action nommée index.

  • J'ajoute un résultat par défaut dans cette action indiquant d'utiliser la JSP jsp/index.jsp comme vue.

  • Je définis cette action index comme action par défaut.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
        "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
    <package name="default" extends="struts-default">
        <!-- Action par défaut -->
        <default-action-ref name="index" />

        <!-- Action "index" -->
        <action name="index">
            <result>/jsp/index.jsp</result>
        </action>
    </package>
</struts>

Définition de la vue

Il reste encore un élément à définir, il s'agit de la vue. Ici rien de bien compliqué, étant donné que l'on a indiqué à Struts d'utiliser une JSP (en l'occurrence /jsp/index.jsp).

Je crée donc un fichier src/main/webapp/jsp/index.jsp :

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Ticket</title>
</head>

<body>
    <h2>Bienvenue sur l'application Ticket utilisant Apache Struts !</h2>
</body>
</html>

Il ne vous reste plus qu'à déployer l'application web sur un serveur d'application comme Apache Tomcat...

Et TADA, vous avez mis en place votre première webapp basée sur Struts !

Bon, je vous l'accorde, cette application est très minimaliste mais le squelette est maintenant posé. Dans le prochain chapitre je vais commencer à vous faire découvrir la puissance et l'intérêt d'un framework tel que Struts.

Exemple de certificat de réussite
Exemple de certificat de réussite