Quelles sont les différences entre Servlet 2.5 et 3 ?

Question

Je développe un code J2EE qui respecte la version 2.5 de Servlet et je me demande quelles sont les principales différences entre 2.5 et 3. Je serais heureux de recevoir des indications sur les documents officiels de Sun et sur mes expériences personnelles.

Si je ne dois pas m'occuper de 3 pour l'instant, dites-le. Merci !

Answer 1

UPDATE

À titre de mise à jour et pour être plus explicite, voici les principales différences entre les servlets 2.5 et 3 (je ne cherche pas à être exhaustif, je mentionne simplement les parties les plus intéressantes) :

Annotations pour déclarer les servlets, filtres et listeners (facilité de développement)

Dans les servlets 2.5, pour déclarer une servlet avec un seul paramètre init, vous devez ajouter ceci à la section web.xml :

<servlet>
    <servlet-name>myServlet</servlet-name>
    <servlet-class>my.server.side.stuff.MyAwesomeServlet</servlet-class>
    <init-param>
        <param-name>configFile</param-name>
        <param-value>config.xml</param-value>
    </init-param>
</servlet>

<servlet-mapping>
    <servlet-name>myServlet</servlet-name>
    <url-pattern>/path/to/my/servlet</url-pattern>
</servlet-mapping>

Dans les servlets 3, web.xml est facultative et vous pouvez utiliser des annotations au lieu de XML. Le même exemple :

@WebServlet(name="myServlet",
    urlPatterns={"/path/to/my/servlet"},
    initParams={@InitParam(name="configFile", value="config.xml")})
public class MyAwesomeServlet extends HttpServlet { ... }

Pour les filtres, vous devez ajouter ceci dans web.xml dans les servlets 2.5 :

<filter>
    <filter-name>myFilter</filter-name>
    <filter-class>my.server.side.stuff.MyAwesomeServlet</filter-class>
</filter>
<filter-mapping>
    <filter-name>myFilter</filter-name>
    <url-pattern>/path/to/my/filter</url-pattern>
</filter-mapping>

Equivalent de l'utilisation des annotations dans les servlets 3 :

@ServletFilter(name="myFilter", urlPatterns={"/path/to/my/filter"})
public class MyAwesomeFilter implements Filter { ... }

Pour un écouteur (dans ce cas, un ServletCotnextListener), dans les servlets 2.5 :

<listener>
    <listener-class>my.server.side.stuff.MyAwesomeListener</listener-class>
</listener>

Il en va de même avec les annotations :

@WebServletContextListener
public class MyAwesomeListener implements ServletContextListener { ... }

Modularisation de web.xml (Pluggability)

• Dans les servlets 2.5 il n'y a qu'un seul monolitique web.xml fichier.
• Dans les servlets 3, chaque jar "chargeable" peut avoir un web-fragment.xml dans son META-INF en spécifiant les servlets, les filtres, etc. Ceci afin de permettre aux bibliothèques et aux frameworks de spécifier leurs propres servlets ou autres objets.

Enregistrement dynamique des servlets, filtres et listeners au moment de l'initialisation du contexte (Pluggability)

Dans les servlets 3, une ServletContextListener peut ajouter dynamiquement des servlets, des filtres et des listeners en utilisant les méthodes suivantes ajoutées à SevletContext : addServlet() , addFilter() y addListener()

Support asynchrone

Exemple : supposons qu'un conteneur de servlets dispose de cinq threads dans son pool de threads, et qu'il y a un processus long à exécuter par requête (comme une requête SQL complexe).

• Avec les servlets 2.5, ce conteneur de servlets serait à court de threads disponibles s'il recevait cinq demandes en même temps et que les cinq threads disponibles commençaient à effectuer le processus, car les threads ne reviendraient pas jusqu'à ce que service() (ou doGet() , doPost() ) est exécuté du début à la fin et renvoie une réponse.

• Avec les servlets 3.0, ce processus de longue haleine peut être délégué à un autre thread et se terminer. service() avant d'envoyer la réponse (la réponse sera maintenant envoyée par le dernier thread). De cette façon, le fil est libre de recevoir de nouvelles réponses.

Un exemple de support asynchrone :

Servlets 2.5 :

public class MyAwesomeServlet extends HttpSerlvet {

    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        // ...

        runSlowProcess();
        // no async support, thread will be free when runSlowProcess() and
        // doGet finish

        // ...
    }

}

Servlets 3 :

@WebServlet(name="myServlet",
             urlPatterns={"/mySlowProcess"},
             asyncSupported=true) // asyncSupported MUST be specified for
                                  // servlets that support asynchronous
                                  // processing
public class MyAwesomeServlet extends HttpSerlvet {

    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response) {

        // an AsyncContext is created, now the response will be completed
        // not when doGet finalizes its execution, but when
        // myAsyncContext.complete() is called.
        AsyncContext myAsyncContext = request.startAsync(request, response);

        // ...

        // myAsyncContext is passed to another thread
        delegateExecutionToProcessingThread(myAsyncContext);

        // done, now this thread is free to serve another request
    }

}

// ... and somewhere in another part of the code:

public class MyProcessingObject {

    public void doSlowProcess() {

        // ...

        runSlowProcess();
        myAsyncContext.complete(); // request is now completed.

        // ...

    }

}

L'interface AsyncContext possède également des méthodes pour obtenir l'objet de la demande, l'objet de la réponse et ajouter des écouteurs pour les notifier lorsqu'un processus est terminé.

Connexion et déconnexion programmées (renforcement de la sécurité)

Dans les servlets 3, l'interface HttpServletRequest a été ajouté deux nouvelles méthodes : login(username, password) y logout() .

Pour plus de détails, consultez la page API Java EE 6 .

Answer 2

Servlet 3.0 n'a pas encore été publié, mais il semble qu'il en soit très proche. Les changements les plus importants de la version 3.0 sont : Pluggabilité, facilité de développement, Async Servlet, sécurité. Il m'est impossible de dire si ces éléments sont importants ou non pour vous.

Le plus important d'entre eux est probablement la prise en charge des servlets asynchrones. Voici un article qui décrit cela en détail. La spécification complète peut être téléchargée aquí .

Answer 3

Comme Don l'a mentionné, les principaux domaines d'améliorations et d'ajouts sont les suivants :

• Pluggabilité (modularisation de web.xml)
• Facilité de développement (annotations, génériques, convention sur la configuration)
• Support des servlets asynchrones (pour la programmation de style comète, le proxy web asynchrone, les services web asynchrones)
• Amélioration de la sécurité (connexion/ déconnexion programmée)
• Autres (Cookie HttpOnly, suivi de session, EJB dans un fichier WAR)

Consultez la présentation de la Javaone 2008 " API Java Servlet 3.0 : Quoi de neuf et de passionnant " pour plus de détails.