web-dev-qa-db-ja.com

Tomcat 6を埋め込む方法は？

現在、実稼働環境のTomcat 6でwebappを実行していますが、Tomcatの組み込みモードでの実行を評価したいと思います。

api documentation にあるもののほかに、良いチュートリアルや他のリソースがありますか？

javatomcattomcat6
57
otto.poellath

コードはそれ自体を物語っています。 Tomcatを実行するには、pom.xmlスニペットとクラスを参照してください。

    <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;
    }

}
40
Antonio

この投稿は古くなっていますが、他の時間を節約できるため、自分の答えに答えています

_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;
    }

}
_

また、_404_エラーに直面し、しばらく苦労しました。ログ「_INFO: No default web.xml_」を見ることで、私はそれを疑いました（それが警告なら、簡単に見つけられただろう）。 Tomcatで提供される_web.xml_（rootContext.setDefaultWebXml("web.xml")）を使用するトリック（_conf/web.xml_）。その理由は、HTML、JSなどの静的ファイルを提供するDefaultServletが含まれているからです。 _web.xml_を使用するか、コードにサーブレットを手動で登録します。

使用法：

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

このプログラムの同じディレクトリにデフォルトの_web.xml_を配置するか、正しい場所を指すことを忘れないでください。

シャットダウンフックは Antonioの答え からインスパイアされていることに注意してください。

16
manikanta

JettyではなくTomcatを使用する理由はいくつかあります。

  1. 1つは既にTomcatに精通している
  2. 1つは、Tomcatインストールに簡単に転送する必要があるWebアプリケーションの開発です。
  3. Jettyの開発者向けドキュメントは、実際にはTomcatのものよりも優れています（すごい！）
  4. 2007年のように、Jettyコミュニティで質問に回答するには数年かかる場合があります。 Embedding Jetty を参照してください。
  5. 重要：Jetty 6.1。*の後、各Webアプリケーションは独自のJVMで開くため、スタンドアロンアクセスとWebアプリの場合、唯一の希望はWeb APIを介することです。
  6. あなたにとって問題であれば、TomcatはApache Foundationが所有する知的財産を持つオープンソースプロジェクトであり、Jettyはオープンソースですが小さな民間企業が所有しています（Mortbay Consulting）

ポイント＃5は私の仕事において重要でした。たとえば、Tomcatを介してJSPWikiインスタンスに直接アクセスできますが、Jettyを使用する場合は完全にアクセスできません。私は2007年にそれに対する解決策を求めましたが、まだ答えを聞いていません。そこで私はついにgaveめてTomcat 6の使用を開始しました。GlassfishとGrizzlyを調べましたが、これまでのところTomcatは（驚くほど）最も安定した、よく文書化されたWebコンテナーです（あまり言い表せません）。

11
Ichiro Furusato

これが役立つかもしれません。

Tomcat6.xのソースパッケージをダウンロードすると、次のクラスが取得されます。

http://Tomcat.Apache.org/Tomcat-6.0-doc/api/org/Apache/catalina/startup/Catalina.html#main（Java.lang.String []）

これはEmbeddクラスの使用方法の例です。特定のTomcatインストールを停止または開始するためのシェルです。 （つまり、CATALINA_BASE既存のTomcatインストールを指すようにします）。

これをコンパイルすると、次のように実行できます。

Java -D "catalina.base =％CATALINA_BASE％" -D "catalina.home =％CATALINA_HOME％" org.Apache.catalina.startup.Catalina start

ただし、サーバーをシャットダウンするためにこのコードを変更する方法はまだわかりません！

2
John

数ヶ月前にこのスレッドを読んだ後、このプロジェクトを書きました： spring-embedded-Tomcat 。 Tomcat6をSpringベースのアプリケーションに埋め込むために使用できます。

0
alexkasko

Tomcat 7またはJetty 9の埋め込みは簡単だと思います。ここに素敵な紹介があります： http://www.hascode.com/2013/07/embedding-jetty-or-Tomcat-in-your-Java-application/

0
LinuxLuigi