Aquí podría ser tu PUBLICIDAD


¿Cómo incrustar Tomcat 6?

votos
56

Actualmente estoy ejecutando mis webapps en Tomcat 6 en producción, y me gustaría evaluar la ejecución de Tomcat en modo incrustado.

¿Hay un buen tutorial u otro recurso además de lo que está en la documentación de la API ?

Publicado el 12/03/2009 a las 20:00
fuente por usuario otto.poellath
En otros idiomas...        العربية       

6 respuestas

votos
39

El código habla por sí mismo. Vea el fragmento pom.xml y la clase para ejecutar tomcat.

    <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>catalina</artifactId>
        <version>6.0.18</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>coyote</artifactId>
        <version>6.0.18</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>jasper</artifactId>
        <version>6.0.18</version>
        <scope>test</scope>
    </dependency>


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 classes directory for the web application being run.
     */
    private String classesDir = "target/classes";

    /**
     * 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 MalformedURLException if the server could not be configured
     * @throws LifecycleException if the server could not be started
     * @throws MalformedURLException
     */
    public void run(int port) throws LifecycleException, MalformedURLException {
        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 (classesDir != null) {
            loader.addRepository(new File(classesDir).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;
    }

}
Respondida el 13/03/2009 a las 01:31
fuente por usuario Antonio


Aquí podría ser tu PUBLICIDAD


votos
16

Aunque este post es lo que algunos años, yo m responder a mi propia respuesta, ya que podría ahorrar algo de otra hora

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:
 * <pre><Server>
 *    <Service>
 *        <Connector />
 *        <Engine&gt
 *            <Host>
 *                <Context />
 *            </Host>
 *        </Engine>
 *    </Service>
 *</Server></pre>
 * <Server> & <Service> 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: <code>/src/main/</code>)
 * @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;
    }

}

También me enfrenté al 404error y ha costado algo de tiempo. Al ver el registro ' INFO: No default web.xml', lo sospechaba (si eso es una advertencia, hubiera sido fácil de detectar) . El truco está usando el web.xml ( rootContext.setDefaultWebXml("web.xml")) suministrado con Tomcat ( conf/web.xml) . La razón de ser, que incluye la DefaultServlet, que sirve a los archivos estáticos gusta HTML, JS. O bien utilizar el web.xmlo registro del servlet manualmente en su código.

uso :

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

No se olvide de poner el valor por defecto web.xmlen el mismo directorio de este programa o punto a la ubicación correcta.

Cabe señalar que el gancho de cierre se inspira de la respuesta de Antonio .

Respondida el 26/09/2011 a las 01:34
fuente por usuario manikanta

votos
10

Hay una serie de razones por las que se podría utilizar Tomcat sobre el embarcadero:

  1. Una de ellas es que ya están familiarizados con Tomcat
  2. Uno es el desarrollo de aplicaciones web que necesitan ser transportados fácilmente a una instalación de Tomcat
  3. La documentación para desarrolladores embarcadero en realidad es más desigual que la de Tomcat (increíble!)
  4. El conseguir preguntas contestadas en la comunidad embarcadero a veces puede tomar años, al igual que en 2007. Véase incrustación embarcadero
  5. Importante: . Después embarcadero 6.1 *, cada aplicación web se abre en su propia JVM, por lo que si usted está tratando de obtener acceso programática entre su acceso independiente y su aplicación web, su única esperanza es a través de una API web.
  6. Si se trata de un problema para usted, Tomcat es un proyecto de código abierto que la propiedad intelectual es propiedad de la Fundación Apache, Espolón es de código abierto, pero propiedad de una pequeña empresa privada (Mortbay Consulting)

Punto # 5 ha sido importante en mi trabajo. Por ejemplo, puedo tener acceso directo a una instancia de JSPWiki a través de Tomcat, pero es totalmente inaccesible al utilizar el embarcadero. Pedí una solución a la de 2007 y aún no he escuchado una respuesta. Así que finalmente di por vencido y comenzó a utilizar Tomcat 6. He mirado en Glassfish y grisáceo, pero hasta ahora Tomcat es (increíblemente) el contenedor web más estable y bien documentada (que no es decir mucho en realidad).

Respondida el 14/12/2009 a las 05:01
fuente por usuario Ichiro Furusato

votos
2

Esto podría ayudar.

Si descarga el paquete fuente para Tomcat6.x, obtiene esta clase:

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

Lo cual es un ejemplo de cómo usar la clase Embedd: es un shell para detener | iniciar una instalación específica de Tomcat. (Quiero decir que puede configurar CATALINA_BASEpara apuntar a una instalación Tomcat existente).

Si compilas esto, puedes ejecutarlo así:

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

¡Sin embargo, todavía no estoy seguro de cómo alterar este código para apagar el servidor!

Respondida el 03/07/2009 a las 05:07
fuente por usuario John

votos
0

Creo que con Tomcat 7 o 9 embarcadero incrustación es más fácil. Aquí encontrará una buena introducción: http://www.hascode.com/2013/07/embedding-jetty-or-tomcat-in-your-java-application/

Respondida el 11/07/2013 a las 09:42
fuente por usuario LinuxLuigi

votos
0

Después de leer este hilo hace unos meses, escribí este proyecto: primavera-embedded-Tomcat . Se puede utilizar para incrustar tomcat6 en las aplicaciones basadas en la primavera.

Respondida el 16/03/2012 a las 04:44
fuente por usuario alexkasko