मैं वर्तमान में उत्पादन में टॉमकैट 6 पर अपने वेबपैप्स चला रहा हूं, और एम्बेडेड मोड में चल रहे टोमकैट का मूल्यांकन करना चाहता हूं।कैसे टोमकैट 6 एम्बेड करें?
क्या api documentation में क्या है इसके अलावा कोई अच्छा ट्यूटोरियल या अन्य संसाधन है?
कोड खुद के लिए बोलता है। टॉमकैट चलाने के लिए 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;
}
}
इससे मदद मिल सकती है। एक विशिष्ट शुरू | इसकी एक खोल रोकने के लिए:
कौन कैसे embedd वर्ग का उपयोग करने का एक उदाहरण है:
आप Tomcat6.x के लिए स्रोत पैकेज को डाउनलोड, तो आप इस वर्ग मिल टॉमकैट स्थापना। (मेरा मतलब है कि आप मौजूदा टोमकैट स्थापना पर इंगित करने के लिए CATALINA_BASE सेट अप कर सकते हैं)।
आप इस संकलन यदि आप इस तरह चला सकते हैं:
जावा डी "catalina.base =% CATALINA_BASE%" डी "catalina.home =% CATALINA_HOME%" org.apache.catalina.startup.Catalina
मुझे यकीन नहीं है कि सर्वर को बंद करने के लिए इस कोड को कैसे बदला जाए!
कई कारणों से क्यों एक जेट्टी से अधिक बिलाव का उपयोग कर सकते हैं:
प्वाइंट # 5 है मेरे काम में महत्वपूर्ण रहा है। उदाहरण के लिए, मैं टॉमकैट के माध्यम से जेएसपीविकि इंस्टेंस तक सीधे पहुंच प्राप्त कर सकता हूं, लेकिन जेटी का उपयोग करते समय यह पूरी तरह से पहुंच योग्य नहीं है। मैंने 2007 में उस समाधान के लिए कहा और अभी तक कोई जवाब नहीं सुना है। तो मैंने अंत में छोड़ दिया और टॉमकैट 6 का उपयोग शुरू किया। मैंने ग्लासफ़िश और ग्रिज़ली में देखा है, लेकिन अब तक टॉमकैट (आश्चर्यजनक रूप से) सबसे स्थिर और अच्छी तरह से प्रलेखित वेब कंटेनर है (जो वास्तव में बहुत कुछ नहीं कह रहा है)।
"प्रत्येक वेब एप्लिकेशन अपने स्वयं के जेवीएम में खुलता है": आपको यह जानकारी कहां मिली? मुझे संदेह है कि यह सही है। – Bruno
एक क्लासलोडर चीज़ की तरह लगता है। बताना कठिन है। –
मैं बहुत निश्चित वेबपैप्स अपने स्वयं के JVM में _not_ खोलता हूं। वे डिफ़ॉल्ट रूप से अलग क्लासलोडर्स का उपयोग करते हैं। क्लासलोडर व्यवहार प्राप्त करने के लिए आप बस 'webapp.setParentLoaderPriority (true) का उपयोग करना चाहते हैं;' - मुझे लगता है कि यह जेटी दस्तावेज में है। –
मैं भी 404 त्रुटि का सामना करना पड़ा और कुछ समय के लिए संघर्ष किया हालांकि इस पोस्ट कुछ क्या वृद्ध, मैं अपने खुद के जवाब का जवाब दे हूँ इसे किसी और 'समय
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>
* <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;
}
}
बचा सकता है के रूप में है।'INFO: No default web.xml' लॉग देखकर, मुझे संदेह है कि यह (यदि यह एक चेतावनी है, तो स्पॉट करना आसान होगा)। चाल web.xml(rootContext.setDefaultWebXml("web.xml")) बिलाव (conf/web.xml) के साथ आपूर्ति का उपयोग कर किया जा रहा है। इसका कारण यह है कि इसमें डिफॉल्ट सर्विलेट शामिल है, जो स्थिर फ़ाइलों को एचटीएमएल, जेएस पसंद करता है। या तो 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's answer से प्रेरित है।
में मैंने जो कुछ कहा था, उससे काफी सहमत हैं, मैंने आपका उदाहरण आजमाया, मेरा आवेदन बढ़ गया, मुझे लगता है कि वसंत को इंटिलाइज्ड किया गया है, लेकिन जब मैं अपने आवेदन तक पहुंचने का प्रयास करता हूं , मुझे वसंत त्रुटि संदेश मिलते हैं कि मेरे जेएसपीएस के लिए कोई मैपिंग नहीं मिली है। – Thiago
एक मामूली अपडेट: 'org.apache.catalina.startup.Embedded' को बहिष्कृत किया गया है और इसके बजाय' org.apache.catalina.startup.Tomcat' का उपयोग करने की सलाह दी जाती है। इस परिवर्तन को बनाने से कोड को चलाने योग्य बनाने के लिए कई चेन परिवर्तनों का पालन किया जाएगा। – Athafoud
कुछ महीने पहले इस धागे को पढ़ने के बाद, मैंने यह प्रोजेक्ट लिखा: spring-embedded-tomcat। इसका उपयोग स्प्रिंग-आधारित अनुप्रयोगों में tomcat6 को एम्बेड करने के लिए किया जा सकता है।
मुझे लगता है कि टॉमकैट 7 या जेट्टी 9 एम्बेडिंग के साथ आसान है। यहां आपको एक अच्छा परिचय मिलेगा: http://www.hascode.com/2013/07/embedding-jetty-or-tomcat-in-your-java-application/
इसके बजाय जेटी एम्बेड करें। हालांकि, [tomcat-embed] है [http://code.google.com/p/tomcat-embed/)। – stepancheg
सूचक के लिए धन्यवाद। हालांकि, ऐसा लगता है कि यह पूर्ण, सक्रिय रूप से विकसित या बनाए रखा गया है। सभी काम 11 मई, 2008 को दिनांकित हैं, और लॉग संदेशों में से एक इसे "पूर्ण से दूर" कहते हैं। –
इस ब्लॉग पोस्ट में देखने के लायक: [टोमकैट 7 एम्बेड करना] (http://www.copperykeenclaws.com/embedding-tomcat-7/) –