java - टोमकैट 6 कैसे एम्बेड करें?




tomcat tomcat6 (6)

मैं वर्तमान में उत्पादन में टॉमकैट 6 पर अपने वेबपैप्स चला रहा हूं, और एम्बेडेड मोड में चल रहे टोमकैट का मूल्यांकन करना चाहता हूं।

क्या एपीआई दस्तावेज में क्या है इसके अलावा कोई अच्छा ट्यूटोरियल या अन्य संसाधन है?


Answers

मुझे लगता है कि टॉमकैट 7 या जेट्टी 9 एम्बेडिंग के साथ आसान है। यहां आपको एक अच्छा परिचय मिलेगा: http://www.hascode.com/2013/07/embedding-jetty-or-tomcat-in-your-java-application/


जेटी पर टॉमकैट का उपयोग करने के कई कारण हैं:

  1. एक पहले से ही टोमकैट से परिचित है
  2. एक वेब अनुप्रयोग विकसित कर रहा है जिसे आसानी से टॉमकैट स्थापना में ले जाने की आवश्यकता है
  3. जेटी डेवलपर प्रलेखन वास्तव में टोमकैट की तुलना में स्पॉटियर है (अद्भुत!)
  4. जेटी समुदाय में दिए गए प्रश्नों को प्राप्त करने में कई बार 2007 लग सकते हैं। जेटी एम्बेड करना देखें
  5. महत्वपूर्ण: जेटी 6.1 के बाद। *, प्रत्येक वेब एप्लिकेशन अपने स्वयं के जेवीएम में खुलता है, इसलिए यदि आप अपने स्टैंडअलोन एक्सेस और अपने वेब ऐप के बीच प्रोग्रामेटिक एक्सेस प्राप्त करने का प्रयास कर रहे हैं, तो आपकी एकमात्र आशा वेब एपीआई के माध्यम से होती है।
  6. यदि यह आपके लिए कोई मुद्दा है, तो टोमकैट एक ओपन सोर्स प्रोजेक्ट है जो बौद्धिक संपदा का स्वामित्व अपाचे फाउंडेशन के पास है, जेटी ओपन सोर्स है लेकिन स्वामित्व वाली एक छोटी निजी कंपनी (मॉर्टबे कंसल्टिंग)

प्वाइंट # 5 मेरे काम में महत्वपूर्ण रहा है। उदाहरण के लिए, मैं टॉमकैट के माध्यम से जेएसपीविकि इंस्टेंस तक सीधे पहुंच प्राप्त कर सकता हूं, लेकिन जेटी का उपयोग करते समय यह पूरी तरह से पहुंच योग्य नहीं है। मैंने 2007 में उस समाधान के लिए कहा और अभी तक कोई जवाब नहीं सुना है। तो मैंने अंत में छोड़ दिया और टॉमकैट 6 का उपयोग शुरू किया। मैंने ग्लासफ़िश और ग्रिज़ली में देखा है, लेकिन अब तक टॉमकैट (आश्चर्यजनक रूप से) सबसे स्थिर और अच्छी तरह से प्रलेखित वेब कंटेनर है (जो वास्तव में बहुत कुछ नहीं कह रहा है)।


कोड खुद के लिए बोलता है। टॉमकैट चलाने के लिए 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;
    }

}

कुछ महीने पहले इस धागे को पढ़ने के बाद, मैंने इस परियोजना को लिखा: spring-embedded-tomcat । इसका उपयोग स्प्रिंग-आधारित अनुप्रयोगों में tomcat6 को एम्बेड करने के लिए किया जा सकता है।


यह मदद कर सकता है।

यदि आप Tomcat6.x के लिए स्रोत पैकेज डाउनलोड करते हैं, तो आपको यह कक्षा मिलती है:

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

एंबेड क्लास का उपयोग करने का एक उदाहरण कौन सा है: इसे रोकने के लिए एक खोल | एक विशिष्ट टोमकैट स्थापना शुरू करें। (मेरा मतलब है कि आप मौजूदा टोमकैट स्थापना पर इंगित करने के लिए CATALINA_BASE सेट अप कर सकते हैं)।

यदि आप इसे संकलित करते हैं तो आप इस तरह से चला सकते हैं:

जावा-डी "catalina.base =% CATALINA_BASE%" -D "catalina.home =% CATALINA_HOME%" org.apache.catalina.startup.Catalina प्रारंभ

मुझे यकीन नहीं है कि सर्वर को बंद करने के लिए इस कोड को कैसे बदला जाए!


वेब कंटेनर मैंने एक जार फ़ाइल में एम्बेड करने के लिए सबसे आसान पाया है (और यह अभी भी मान्य युद्ध है) Winstone ( http://winstone.sourceforge.net/ ) है।

जेनकिंस - http://jenkins-ci.org/ - इस कंटेनर का उपयोग करें, इसलिए यह काफी तनाव-परीक्षण किया गया है। ध्यान दें कि यह केवल सर्लेट 2.4 है





java tomcat tomcat6