Aggiungere più di una directory di risorse al molo

Question

Cercare di utilizzare più directory statiche con Jetty. Quando viene eseguito il server:

http://localhost:8282/A 
    http://localhost:8282/B 
    http://localhost:8282/C 

• A è posizionato in X/V/A
• B è situato in Q/Z/B
• C viene posto in P/T/C

quanto segue non è riuscito:

ResourceHandler resource_handler = new ResourceHandler(); 
    resource_handler.setWelcomeFiles(new String[]{"index.html"}); 
    resource_handler.setResourceBase(HTML_SITE); 

    ResourceHandler resource_handler1 = new ResourceHandler(); 
    resource_handler1.setWelcomeFiles(new String[]{"index.html"}); 
    resource_handler1.setResourceBase(HTML_CLIENTZONE_SITE); 

    // deploy engine 
    WebAppContext webapp = new WebAppContext(); 

    String dir = System.getProperty("user.dir"); 
    webapp.setResourceBase(getWebAppPath()); 
    webapp.setContextPath("/"); 


    HandlerList handlers = new HandlerList(); 
    handlers.setHandlers(new Handler[]{resource_handler,resource_handler1 ,webapp, new DefaultHandler()}); 
    server.setHandler(handlers); 

Come posso aggiungere più di un indice delle risorse statica?

Answer 1

Da 6.1.12, questo è supportata utilizzando un ResourceCollection alla risorsa di base del WebAppContext:

Server server = new Server(8282); 
WebAppContext context = new WebAppContext(); 
context.setContextPath("/"); 
ResourceCollection resources = new ResourceCollection(new String[] { 
    "project/webapp/folder", 
    "/root/static/folder/A",  
    "/root/static/folder/B",  
}); 
context.setBaseResource(resources); 
server.setHandler(context); 
server.start(); 

Per aprire successivamente un file, utilizzare ServletContext (ad esempio, WebAppContext), che potrebbe essere parte di un definizione di interfaccia, quali:

/** 
    * Opens a file using the servlet context. 
    */ 
    public default InputStream open(ServletContext context, String filename) { 
    String f = System.getProperty("file.separator") + filename; 
    return context.getResourceAsStream(f); 
    } 

come:

InputStream in = open(context, "filename.txt"); 

Si aprirà filename.txt se esiste in una delle directory specificate. Si noti che getResourceAsStream tornerà null, piuttosto che un'eccezione, quindi è una buona idea per verificare la presenza di esso:

public default InputStream validate(InputStream in, String filename) 
    throws FileNotFoundException { 
    if(in == null) { 
     throw new FileNotFoundException(filename); 
    } 

    return in; 
    } 

Quindi è possibile aggiornare il metodo open come segue:

return validate(context.getResourceAsStream(filename), filename); 

Answer 2

Se si desidera per "montare" le directory di risorse indipendenti in URI arbitrari nello spazio dei nomi del server, utilizzando più istanze dello DefaultServlet con configurazioni indipendenti resourceBase è la scelta migliore.

il seguente frammento servirà URI /A/* da percorso filesystem X/V/A e /B/* dal percorso filesystem Q/Z/B:

Server server = new Server(); 
SelectChannelConnector connector = new SelectChannelConnector(); 
connector.setPort(Integer.parseInt(port)); 
server.addConnector(connector); 

ServletContextHandler servletHandler = new ServletContextHandler(null, "/", true, false); 

// Configuration for serving /A/* from X/V/A 
DefaultServlet aServlet = new DefaultServlet(); 
ServletHolder aHolder = new ServletHolder(aServlet); 
aHolder.setInitParameter("resourceBase", "X/V/A"); 
aHolder.setInitParameter("pathInfoOnly", "true"); 
servletHandler.addServlet(aHolder, "/A/*"); 

// Configuration for serving /B/* from Q/Z/B 
DefaultServlet bServlet = new DefaultServlet(); 
ServletHolder bHolder = new ServletHolder(bServlet); 
bHolder.setInitParameter("resourceBase", "Q/Z/B"); 
bHolder.setInitParameter("pathInfoOnly", "true"); 
servletHandler.addServlet(bHolder, "/B/*"); 

HandlerList handlers = new HandlerList(); 
handlers.setHandlers(new Handler[] { servletHandler }); 
server.setHandler(handlers); 

server.start(); 

Nota: Come si può vedere dal codice di cui sopra, non è necessario che il nome della directory da cui viene fornito /A/* è esattamente A come nell'esempio. Entrambi i nomi - il nome del filesystem della directory da servire e l'URI per mappare il contenuto - sono completamente indipendenti.