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

Je roule du code J2EE qui adhère au Servlet 2.5 et je me demande quelles sont les principales différences entre 2.5 et 3. Les pointeurs vers les documents officiels Sun et les expériences personnelles sont les plus appréciés.

Si je ne devais pas me préoccuper de 3 pour le moment, dites-le simplement. Merci!

METTRE À JOUR

Juste à 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 ne fais que mentionner les parties les plus intéressantes):

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

Dans les servlets 2.5, pour déclarer un servlet avec un paramètre init, vous devez l'ajouter à 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 facultatif 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>

Équivalent à l'utilisation d'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 ServletContextListener), dans les servlets 2.5:

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

La même chose en utilisant des annotations:

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

Modularisation de web.xml (Pluggability)

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

Enregistrement dynamique des servlets, des filtres et des écouteurs au moment de l'initialisation du contexte (Pluggabilité)

En servlets 3, un ServletContextListenerpeut ajouter dynamiquement des servlets, des filtres et des auditeurs à l' aide des méthodes suivantes ajoutées à SevletContext: addServlet(), addFilter()etaddListener()

Support asynchrone

Exemple: disons que certains conteneurs de servlets ont cinq threads dans leur pool de threads, et qu'il y a un processus long à exécuter par requête (comme une requête SQL complexe).

• Avec servlets 2.5 ce conteneur servlet court de threads disponibles si elle reçoit cinq demandes en même temps et les cinq threads disponibles commencer à faire le processus, parce que les fils ne rentreraient pas avant service()(ou doGet(), doPost()etc.) est exécutée depuis le début pour terminer et renvoie une réponse.

• Avec les servlets 3.0, ce processus de longue date peut être délégué à un autre thread et se terminer service()avant l'envoi de 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 AsyncContextdispose également de méthodes pour obtenir l'objet de requête, l'objet de réponse et ajouter des écouteurs pour les avertir lorsqu'un processus est terminé.

Connexion et déconnexion programmatiques (améliorations de la sécurité)

Dans les servlets 3, l'interface HttpServletRequesta été ajoutée deux nouvelles méthodes: login(username, password)et logout().

Pour plus de détails, jetez un œil à l' API Java EE 6 .

Servlet 3.0 n'est pas encore sorti, mais il semble que ce soit très proche. Les changements les plus importants de la version 3.0 sont: Pluggability, Facilité de développement, Servlet Async, 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 ici .

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

• Pluggability (modularisation de web.xml)
• Facilité de développement (annotations, génériques, convention sur la configuration)
• Prise en charge des servlets asynchrones (pour la programmation de style comète, proxy Web asynchrone, services Web asynchrones)
• Améliorations de la sécurité (connexion / déconnexion par programmation)
• Autres (cookie HttpOnly, suivi de session, EJB dans le fichier WAR)

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

Ce lien donnera suffisamment d'informations sur le Servlet 3

Servlet 3 prend en charge l'annotation pour éliminer web.xml

@WebServlet
@WebServletContextListener
@ServletFilter
@InitParam