Come incorporare Tomcat 6?

Attualmente sto eseguendo le mie app Web su Tomcat 6 in produzione e vorrei valutare l’esecuzione di Tomcat in modalità incorporata.

C’è un buon tutorial o altra risorsa oltre a ciò che c’è nella documentazione di api ?

    Il codice parla da solo. Vedi lo snippet pom.xml e la class per eseguire tomcat.

     org.apache.tomcat catalina 6.0.18 test   org.apache.tomcat coyote 6.0.18 test   org.apache.tomcat jasper 6.0.18 test  public class RunWebApplicationTomcat { private String path = null; private Embedded container = null; private Log logger = LogFactory.getLog(getClass()); /** * The directory to create the Tomcat server configuration under. */ private String catalinaHome = "tomcat"; /** * The port to run the Tomcat server on. */ private int port = 8089; /** * The classs directory for the web application being run. */ private String classsDir = "target/classs"; /** * The web resources directory for the web application being run. */ private String webappDir = "mywebapp"; /** * Creates a single-webapp configuration to be run in Tomcat on port 8089. If module name does * not conform to the 'contextname-webapp' convention, use the two-args constructor. * * @param contextName without leading slash, for example, "mywebapp" * @throws IOException */ public RunWebApplicationTomcat(String contextName) { Assert.isTrue(!contextName.startsWith("/")); path = "/" + contextName; } /** * Starts the embedded Tomcat server. * * @throws LifecycleException * @throws MalformsdURLException if the server could not be configured * @throws LifecycleException if the server could not be started * @throws MalformsdURLException */ public void run(int port) throws LifecycleException, MalformsdURLException { this.port = port; // create server container = new Embedded(); container.setCatalinaHome(catalinaHome); container.setRealm(new MemoryRealm()); // create webapp loader WebappLoader loader = new WebappLoader(this.getClass().getClassLoader()); if (classsDir != null) { loader.addRepository(new File(classsDir).toURI().toURL().toString()); } // create context // TODO: Context rootContext = container.createContext(path, webappDir); Context rootContext = container.createContext(path, webappDir); rootContext.setLoader(loader); rootContext.setReloadable(true); // create host // String appBase = new File(catalinaHome, "webapps").getAbsolutePath(); Host localHost = container.createHost("localHost", new File("target").getAbsolutePath()); localHost.addChild(rootContext); // create engine Engine engine = container.createEngine(); engine.setName("localEngine"); engine.addChild(localHost); engine.setDefaultHost(localHost.getName()); container.addEngine(engine); // create http connector Connector httpConnector = container.createConnector((InetAddress) null, port, false); container.addConnector(httpConnector); container.setAwait(true); // start server container.start(); // add shutdown hook to stop server Runtime.getRuntime().addShutdownHook(new Thread() { public void run() { stopContainer(); } }); } /** * Stops the embedded Tomcat server. */ public void stopContainer() { try { if (container != null) { container.stop(); } } catch (LifecycleException exception) { logger.warn("Cannot Stop Tomcat" + exception.getMessage()); } } public String getPath() { return path; } public void setPath(String path) { this.path = path; } public static void main(String[] args) throws Exception { RunWebApplicationTomcat inst = new RunWebApplicationTomcat("mywebapp"); inst.run(8089); } public int getPort() { return port; } } 

    Anche se questo post è qualcosa che invecchia, rispondo alla mia risposta in quanto potrebbe risparmiare un po ‘di tempo

     package com.creativefella; import org.apache.catalina.Engine; import org.apache.catalina.Host; import org.apache.catalina.LifecycleException; import org.apache.catalina.connector.Connector; import org.apache.catalina.core.StandardContext; import org.apache.catalina.startup.Embedded; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class TomcatServer { private Embedded server; private int port; private boolean isRunning; private static final Logger LOG = LoggerFactory.getLogger(TomcatServer.class); private static final boolean isInfo = LOG.isInfoEnabled(); /** * Create a new Tomcat embedded server instance. Setup looks like: * 
     *  *  *  *  *  *  *  *

    * & will be created automcatically. We need to hook the remaining to an {@link Embedded} instnace * @param contextPath Context path for the application * @param port Port number to be used for the embedded Tomcat server * @param appBase Path to the Application files (for Maven based web apps, in general: /src/main/) * @param shutdownHook If true, registers a server' shutdown hook with JVM. This is useful to shutdown the server * in erroneous cases. * @throws Exception */ public TomcatServer(String contextPath, int port, String appBase, boolean shutdownHook) { if(contextPath == null || appBase == null || appBase.length() == 0) { throw new IllegalArgumentException("Context path or appbase should not be null"); } if(!contextPath.startsWith("/")) { contextPath = "/" + contextPath; } this.port = port; server = new Embedded(); server.setName("TomcatEmbeddedServer"); Host localHost = server.createHost("localhost", appBase); localHost.setAutoDeploy(false); StandardContext rootContext = (StandardContext) server.createContext(contextPath, "webapp"); rootContext.setDefaultWebXml("web.xml"); localHost.addChild(rootContext); Engine engine = server.createEngine(); engine.setDefaultHost(localHost.getName()); engine.setName("TomcatEngine"); engine.addChild(localHost); server.addEngine(engine); Connector connector = server.createConnector(localHost.getName(), port, false); server.addConnector(connector); // register shutdown hook if(shutdownHook) { Runtime.getRuntime().addShutdownHook(new Thread() { public void run() { if(isRunning) { if(isInfo) LOG.info("Stopping the Tomcat server, through shutdown hook"); try { if (server != null) { server.stop(); } } catch (LifecycleException e) { LOG.error("Error while stopping the Tomcat server, through shutdown hook", e); } } } }); } } /** * Start the tomcat embedded server */ public void start() throws LifecycleException { if(isRunning) { LOG.warn("Tomcat server is already running @ port={}; ignoring the start", port); return; } if(isInfo) LOG.info("Starting the Tomcat server @ port={}", port); server.setAwait(true); server.start(); isRunning = true; } /** * Stop the tomcat embedded server */ public void stop() throws LifecycleException { if(!isRunning) { LOG.warn("Tomcat server is not running @ port={}", port); return; } if(isInfo) LOG.info("Stopping the Tomcat server"); server.stop(); isRunning = false; } public boolean isRunning() { return isRunning; } }

    Ho anche affrontato l’errore 404 e ho faticato un po ‘di tempo. Vedendo il log ‘ INFO: No default web.xml ‘, lo sospettavo (se questo è un avvertimento, sarebbe stato facile da individuare) . Il trucco sta nell’usare il web.xml ( rootContext.setDefaultWebXml("web.xml") ) fornito con Tomcat ( conf/web.xml ) . Il motivo è che include il DefaultServlet, che serve i file statici come HTML, JS. Utilizzare il web.xml o registrare manualmente il servlet nel codice.

    Uso :

     // start the server at http://localhost:8080/myapp TomcatServer server = new TomcatServer("myapp", 8080, "/src/main/", true); server.start(); // ..... server.stop(); 

    Non dimenticare di posizionare il web.xml predefinito nella stessa directory di questo programma o puntare alla posizione corretta.

    Va notato che il hook di arresto si ispira alla risposta di Antonio .

    Ci sono diversi motivi per cui si potrebbe usare Tomcat su Jetty:

    1. Uno ha già familiarità con Tomcat
    2. Uno sta sviluppando applicazioni web che devono essere facilmente trasportate su un’installazione di Tomcat
    3. La documentazione dello sviluppatore di Jetty è in realtà più spartana di quella di Tomcat (incredibile!)
    4. Ottenere risposte alle domande nella comunità Jetty può a volte richiedere anni, come nel 2007. vedi Embedding Jetty
    5. Importante: dopo Jetty 6.1. *, Ogni applicazione Web si apre nella sua JVM, quindi se stai cercando di ottenere l’accesso programmatico tra il tuo accesso standalone e la tua app web, la tua unica speranza è tramite un’API web.
    6. Se è un problema per te, Tomcat è un progetto open source la cui proprietà intellettuale è di proprietà di Apache Foundation, Jetty è open source ma di proprietà di una piccola società privata (Mortbay Consulting)

    Il punto # 5 è stato importante nel mio lavoro. Ad esempio, posso ottenere l’accesso diretto a un’istanza di JSPWiki tramite Tomcat, ma è completamente inaccessibile quando si utilizza Jetty. Ho chiesto una soluzione a questo nel 2007 e non ho ancora sentito una risposta. Così alla fine ho rinunciato e ho iniziato a utilizzare Tomcat 6. Ho esaminato Glassfish e Grizzly, ma finora Tomcat è (incredibilmente) il contenitore web più stabile e ben documentato (che non sta dicendo molto).

    Questo potrebbe aiutare.

    Se scarichi il pacchetto sorgente per Tomcat6.x, ottieni questa class:

    http://tomcat.apache.org/tomcat-6.0-doc/api/org/apache/catalina/startup/Catalina.html#main (java.lang.String [])

    Quale è un esempio di come usare la class di Embedd: è una shell che interrompe | avvia una specifica installazione di Tomcat. (Voglio dire, puoi impostare CATALINA_BASE per puntare a un’installazione Tomcat esistente).

    Se lo compili puoi farlo così:

    java -D “catalina.base =% CATALINA_BASE%” -D “catalina.home =% CATALINA_HOME%” org.apache.catalina.startup.Catalina start

    Non sono sicuro di come modificare questo codice per arrestare il server, tuttavia!

    Dopo aver letto questa discussione alcuni mesi fa, ho scritto questo progetto: spring-embedded-tomcat . Può essere utilizzato per incorporare tomcat6 in applicazioni basate su Spring.

    Penso che con l’incorporamento di Tomcat 7 o Jetty 9 sia più facile. Qui troverai una bella introduzione: http://www.hascode.com/2013/07/embedding-jetty-or-tomcat-in-your-java-application/