Jetée embarquée avec réponse json/xml

Question

J'ai un serveur jetty intégré Je veux créer un service RESTful GET qui renvoie un pojo au format XML/JSON comme réponse. quelqu'un peut-il me donner un exemple de base comment écrire le gestionnaire pour la jetée? l'exemple donné ne montre que la sortie du type de texte.

Answer 1

Je vous suggère d'utiliser le framework Jersey java REST (http://jersey.java.net/). Le cadre est facile à apprendre. Vous pouvez utiliser un convertisseur Object to Xml comme JAXB pour vous simplifier la vie.

Answer 2

Hmm. J'ai eu le même problème. Je l'ai résolu en ayant un fichier jar utilitaire qui lit un fichier de propriétés pour configurer les contextes pour les Servlets Jersey, les gestionnaires, les fichiers statiques, les webapps explosées etc de telle sorte que le fichier application jar configure les contextes automagiquement et s'exécute depuis la ligne de commande .

Fondamentalement j'ai un HandlerCollection et y ajoute successivement les servlets.

ServletHolder servletHolder = new ServletHolder(ServletContainer.class); 
servletHolder.setInitParameter(
    "com.sun.jersey.config.property.packages", 
    clazz.getPackage().getName() 
); 
ServletContextHandler context = new ServletContextHandler(
    server, 
    "/some_path", 
    ServletContextHandler.SESSIONS 
); 
context.setClassLoader(Thread.currentThread().getContextClassLoader()); 
context.addServlet(servletHolder, "/"); 
context.setHandler(handler); 
handlers.addHandler(context); 

J'ai un exemple servlet Jersey:

@Path("/user1") 
public class JerseyResource1 { 
    public JerseyResource1() { 
    } 
    @GET 
    @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) 
    public ExamplePojo getUser() { 
    log.debug("Inside ExampleJerseyResource1 getUser()"); 
    ExamplePojo pojo = new ExamplePojo(); 
    pojo.setNumber(100); 
    pojo.setWords("hello world 1"); 
    return pojo; 
    } 

}

Les premiers appels obtient une perf frappé comme Jersey choses configure, mais il fonctionne juste Peachy.

Un test JUnit ressemble à ceci:

@BeforeClass 
public static void setUpClass() throws Exception { 
    Thread startupThread = new Thread() { 

     @Override 
     public void run() { 
      try { 
       System.out.println("Starting Jetty..."); 
       JettyMain.main(new String[] {}); 
       // CHECKSTYLE_OFF: Because it does throw Exception! 
      } catch (Exception ex) { 
       // CHECKSTYLE_ON 
       System.err.println("Error Starting Jetty: " + ex); 
      } 
     } 
    }; 
    startupThread.start(); 
    System.out.println("Waiting a few seconds to ensure Jetty is started"); 
    Thread.sleep(2000); 
    System.out.println("Ok. Starting tests"); 
} 

@AfterClass 
public static void tearDownClass() throws Exception { 
    ClientConfig config = new DefaultClientConfig(); 
    Client client = Client.create(config); 
    WebResource service = client.resource(
    UriBuilder.fromUri(
    "http://localhost:8080/admin/stop?secret=YourSecret" 
    ).build()); 
    service.get(String.class); 
    System.out.println("Sent stop command"); 
} 

@Test 
public void testJersey1() { 
    System.out.println("Jersey1 returns correct 200 and body"); 
    ClientResponse response = getService(
     "http://localhost:8080/jersey1/user1/" 
    ).get(ClientResponse.class); 
    assertEquals("Response is 200", 200, response.getStatus()); 
    assertEquals(
     "Valid body", 
     "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" 
     + "<examplePojo><number>100</number><words>hello world 1</words></examplePojo>", 
     response.getEntity(String.class) 
    ); 
    System.out.println("--> WORKED!"); 
} 

appels CURL ressemblent à ceci:

# Show static public files folder: 
curl -v http://localhost:8080/public/x.html 
curl -v http://localhost:8080/public/x.txt 
# Use baseline handlers: 
curl -v http://localhost:8080/handler1/?url=hello 
curl -v http://localhost:8080/handler2/?url=hello 
# Use raw servlets with specific contexts: 
curl -v http://localhost:8080/servlet1?url=hello 
curl -v http://localhost:8080/servlet2?url=hello 
# Call a Jersey servlet using default Accept header (xml): 
curl -v http://localhost:8080/jersey1/user1/ 
curl -v http://localhost:8080/jersey2/user2/ 
# Request Jersey servlet but want JSON: 
curl -v --header "Accept:application/json" http://localhost:8080/jersey1/user1/ 
# Use an exploded webapp: 
curl -v http://localhost:8080/www/x.html 
# Stop the server: 
curl -v http://localhost:8080/admin/stop?secret=MySecret 

Er ... Ce qui suit est pas un bouchon. Sérieusement. Il pourrait être refusée par la société ...

J'ai une solution complète qui 1 fichier jar est ajouté en tant que dépendance et plusieurs petits fichiers (app.properties, classpath.sh, log4j.properties et run.sh) qui configurent complètement une instance de Jetty8 pour de nombreux contextes, Handlers, Servlets, JerseyServlets, StaticFiles et ExplodedWebApps. Le résultat est un fichier exécutable autonome qui redémarre, recharge, s'arrête etc. avec un effort presque nul. Un avantage supplémentaire est qu'il peut agir comme un pseudo-chargeur de classe et évite jar-hell. (Un effet secondaire est que mvn clean test fonctionne aussi contre)

Si quelqu'un est intéressé, envoyez-moi un ping et je peux voir si la compagnie me le permet pour OpenSource et le récupérer sur GitHub. Ou peut-être même le documenter via mon propre site http://www.randomactsofsentience.com

Answer 3

Juste FYI sur la jetée intégrée en général ... J'ai créé un projet de github que je soumets humblement peut couvrir la plupart des problèmes de jetée intégrés qui ne cessent de surgir. Voir https://github.com/ZenGirl/EmbeddedJettyRepository pour plus de détails.