Servlet 3.0 soutien Jetty embarqué 8.0

Question

Pour mes tests unitaires j'utiliser un simple test-serveur basé sur la jetée:

package eu.kostia.textanalysis.webservices.jetty; 

import java.awt.Desktop; 
import java.net.URI; 

import org.eclipse.jetty.server.Server; 
import org.eclipse.jetty.webapp.WebAppContext; 

public class TestServer { 
static private final String CONTEXT_PATH = "/webservice"; 
static private final String PROJECT_HOME = System.getenv("MY_WORKSPACE_HOME") + "/WebServices"; 
static public final int PORT = 8080; 

private Server server; 
private Exception startException; 

private static class SingletonHolder { 
    private static final TestServer INSTANCE = new TestServer(); 
} 

/** 
    * Returns the singleton instance of the test server. 
    * 
    * @return the singleton instance of the test server. 
    */ 
public static TestServer getInstance() { 
    return SingletonHolder.INSTANCE; 
} 

private TestServer() { 
    server = new Server(PORT); 

    WebAppContext context = new WebAppContext(); 

    context.setDescriptor(PROJECT_HOME + "/web/WEB-INF/web.xml"); 
    context.setResourceBase(PROJECT_HOME + "/web"); 
    context.setContextPath(CONTEXT_PATH); 
    context.setParentLoaderPriority(true); 


    server.setHandler(context); 
} 

/** 
    * Start the test server. This method returns only when the server is 
    * complete started. There is no effect when you invoke this method and the 
    * server is already running. 
    */ 
public void start() { 
    if (!server.isRunning()) { 
    startException = null; 
    new Thread("TestServer") { 
    public void run() { 
    try { 
     server.start(); 
     server.join(); 
    } catch (Exception exc) { 
     startException = exc; 
    } 
    } 
    }.start(); 

    while (true) { 
    if (startException != null) { 
    throw new Error(startException); 
    } 

    // Block this method call until the server is started 
    if (server.isStarted()) { 
    return; 
    } 
    } 
    } 
} 

/** 
    * Stop the test server. 
    */ 
public void stop() { 
    try { 
    if (server.isRunning()) { 
    server.stop(); 
    } 
    } catch (Exception e) { 
    throw new Error(e); 
    } 
} 

/** 
    * Returns {@code true} is the server is running. 
    * 
    * @return {@code true} is the server is running. 
    */ 
public boolean isRunning() { 
    return server.isRunning(); 
} 

public static void main(String[] args) throws Exception { 
    TestServer.getInstance().start(); 
    Desktop.getDesktop().browse(new URI("http://localhost:8080/webservice/")); 
} 

} 

Il fonctionne très bien pour servlet configuré dans web.xml mais je vais maintenant d'utiliser la nouvelle syntaxe d'annotation introduite par la spécification Servlet 3.0, par exemple:

@WebServlet(urlPatterns = {"/hello"}) 
public class HelloServlet extends HttpServlet { 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
       PrintWriter writer = response.getWriter(); 
       writer.print("<h1>HttpServlet using Servlet 3.0</h1>"); 
     } 
} 

Comment shoud-je configurer la jetée dans ma classe TESTSERVER pour traiter les servlets également basées sur les annotations?

Answer 1

Jetty 8 met en œuvre la spécification de servlet 3.0 mais elle est encore expérimentale.

Vous pouvez également utiliser le plugin glassfish 3 intégré pour effectuer vos tests. Voir les liens ci-dessous pour quelques informations: http://wikis.sun.com/display/GlassFish/3.1EmbeddedOnePager http://ocpsoft.com/java/using-embedded-glassfish-with-maven/ http://embedded-glassfish.java.net/

Je me rends compte que j'écris ceci qu'il n'y a aucune ressource faisant autorité pour en utilisant le plugin Glassfish de la manière Jetty est souvent utilisé. Cependant, cela fonctionne de la même manière. J'espère que cela aide au moins un peu.

Answer 2

Ajouter à votre code

context.setConfigurations(new Configuration[] { 
       new AnnotationConfiguration(), new WebXmlConfiguration(), 
       new WebInfConfiguration(), new TagLibConfiguration(), 
       new PlusConfiguration(), new MetaInfConfiguration(), 
       new FragmentConfiguration(), new EnvConfiguration() }); 

Il vous suffit de régler la AnnotationConfiguration pour obtenir l'auto-découverte des classes annotées au travail. Le reste des configurations permet d'activer d'autres aspects du conteneur. Supposément, vous devriez être capable de le faire à partir de la ligne de commande, en utilisant OPTIONS = annotations, jsp, (etc ...), mais je n'ai jamais eu ce travail. Au moins de cette façon, il devrait ramasser vos classes annotées correctement dans l'environnement intégré. En outre, il apparaît que le projet de jetée Eclipse a désactivé les annotations par défaut, alors que le riptide prétend qu'elles sont activées par défaut. Je suppose que c'est une différence dans les fichiers de configuration.

Answer 3

Répondre encore un an plus tard.

Dans la version actuelle de la jetée (8.1) vous pouvez accomplir exactement ce que vous voulez avec la ligne de commande:

java -jar start.jar OPTIONS=annotations,plus etc/jetty-plus.xml 

invoqué à partir du répertoire de la jetée.