将Tomcat嵌入到自己的应用中

转自：http://yshjava.iteye.com/blog/1871965

查看原文请移步《http://www.yshjava.cn/post/418.html》

 

Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，由Apache、Sun 和其他一些公司及个人共同开发而成，是目前比较流行的Web 应用服务器。

Tomcat运行时占用的系统资源小，扩展性好，支持负载平衡与邮件服务等开发应用系统常用的功能而广受广大程序员的喜欢。Tomcat不仅有独立运行的版本，而且还提供了可以内嵌到JavaEE应用中的Embedded版本，这一点非常实用！

将Tomcat服务器嵌入到自己的应用中，不仅可以大幅缩短搭建Web服务器所消耗的时间，还可以深度控制Tomcat，从而更好地为应用服务器。
下面就以Tomcat6为例，以具体代码方式展示如何将Tomcat服务器嵌入到自己的应用中。

Java代码  

1. package cn.ysh.studio.tomcat;  
2.   
3. import java.io.File;  
4. import java.net.InetAddress;  
5. import java.net.UnknownHostException;  
6. import org.apache.catalina.*;  
7. import org.apache.catalina.connector.Connector;  
8. import org.apache.catalina.realm.MemoryRealm;  
9. import org.apache.catalina.startup.Embedded;  
10.   
11. /** 
12.  * 以内嵌的方式启动tomcat服务器 
13.  *  
14.  * @author www.yshjava.cn 
15.  *  
16.  */  
17. public class EmbeddedTomcat {  
18.   
19.     private EmbeddedTomcat(Embedded tomcat, String listenIP, int listenPort) {  
20.         this.tomcat = tomcat;  
21.         this.listenIP = listenIP;  
22.         this.listenPort = listenPort;  
23.     }  
24.   
25.     public static EmbeddedTomcat startup(String catalinaHome, String warFileName, int listenPort, boolean enableRemoteAccess) {  
26.         System.setProperty("catalina.home", catalinaHome);  
27.         // 监听IP获取  
28.         String listenIP;  
29.         try {  
30.             listenIP = (enableRemoteAccess ? InetAddress.getLocalHost().getHostAddress() : "127.0.0.1");  
31.         } catch (UnknownHostException e) {  
32.             throw new RuntimeException(e);  
33.         }  
34.         // war 文件检测  
35.         String contextName;  
36.         int tn = warFileName.lastIndexOf("//");  
37.         if (tn < 0) {  
38.             contextName = warFileName;  
39.             warFileName = catalinaHome + "/webapps/" + warFileName;  
40.         } else {  
41.             contextName = warFileName.substring(tn + 1);  
42.         }  
43.         File warFile = new File(warFileName);  
44.         if (!warFile.exists())  
45.             throw new RuntimeException("File '" + warFileName + "' does'nt exist.");  
46.         if (warFileName.endsWith(".war")) {  
47.             contextName = contextName.substring(0, contextName.lastIndexOf('.'));  
48.         } else {  
49.             if (!warFile.isDirectory()){  
50.                 throw new RuntimeException("File '" + warFileName + "' must be a .war file or a folder.");  
51.             }  
52.         }  
53.         //创建一个内嵌的Tomcat服务器  
54.         Embedded tomcat = new Embedded();  
55.         //设置Tomcat的工作目录  
56.         tomcat.setCatalinaHome(catalinaHome);  
57.         // set the memory realm  
58.         MemoryRealm memRealm = new MemoryRealm();  
59.         tomcat.setRealm(memRealm);  
60.         // 创建Tomcat引擎  
61.         Engine engine = tomcat.createEngine();  
62.         //设置默认的虚拟主机  
63.         engine.setDefaultHost("localhost");  
64.         engine.setName("MyEngine");  
65.         //创建虚拟主机  
66.         Host host = tomcat.createHost("localhost", catalinaHome + "/webapps");  
67.         //把Host加入Engine  
68.         engine.addChild(host);  
69.         /* 
70.          * Create the ROOT context Context rootContext = 
71.          * tomcat.createContext("", catalinaHome + "/webapps/ROOT"); 
72.          * rootContext.setReloadable(false); 
73.          * rootContext.addWelcomeFile("index.jsp"); host.addChild(rootContext); 
74.          */  
75.         Context myContext = tomcat.createContext("/" + contextName, warFileName);  
76.         myContext.setPrivileged(true);  
77.         host.addChild(myContext);  
78.         // Install the assembled container hierarchy  
79.         tomcat.addEngine(engine);  
80.         Connector connector = tomcat.createConnector(listenIP, listenPort, false);  
81.         tomcat.addConnector(connector);  
82.         // Start the embedded server  
83.         try {  
84.             tomcat.start();  
85.         } catch (LifecycleException e) {  
86.             throw new RuntimeException(e);  
87.         }  
88.         EmbeddedTomcat srv = new EmbeddedTomcat(tomcat, listenIP, listenPort);  
89.         return srv;  
90.     }  
91.   
92.     private Embedded tomcat;  
93.     private String listenIP;  
94.     private int listenPort;  
95.   
96.     public void stop() {  
97.         try {  
98.             tomcat.stop();  
99.         } catch (LifecycleException e) {  
100.             throw new RuntimeException(e);  
101.         }  
102.     }  
103.   
104.     public String getListenIP() {  
105.         return listenIP;  
106.     }  
107.   
108.     public int getListenPort() {  
109.         return listenPort;  
110.     }  
111.   
112.     public static void main(String[] args) {  
113.         //内嵌Tomcat的工作目录  
114.         String tomcathome = "D://Test//TestEmbedTomcat";  
115.         //启动内嵌的Tomcat  
116.         final EmbeddedTomcat tomcat = EmbeddedTomcat.startup(tomcathome, "examples", 8080, true);  
117.         //打印启动信息  
118.         System.out.println("Tomcat started at " + tomcat.getListenIP() + ":" + tomcat.getListenPort());  
119.         //在JVM中添加一个Hook,这样可以在虚拟机退出时关闭tomcat以释放相关资源  
120.         Runtime.getRuntime().addShutdownHook(new Thread() {  
121.             public void run() {  
122.                 tomcat.stop();  
123.             }  
124.         });  
125.     }  
126. }  

 

从上述代码来看，将Tomcat内嵌到自己的应用中还是比较简单和方便的，如果你了解Tomcat的目录结构或者是工作原理，那么上述代码就更加容易理解了。

 

原创文章，转载请注明出处：http://www.yshjava.cn/post/418.html