javaweb——嵌入tomcat

小鱼儿 2022-07-12 05:59 176阅读 0赞

原创文章，转载请注明出处

该嵌入tomcat的实现可以直接运行类来启动tomcat，也可以在任意路径下运行bat文件启动tomcat，先看一下效果

开发过程，只需要运行类即可

![Center][]

发布过程，只需把war放在bin文件加下，配置的mode项改为release，运行bat文件即可

![Center 1][]

嵌入Tomcat有以下好处：

1、增加开发效率，不再需要下载tomcat，不再需要配置环境变量，不需要配置myeclipse。

2、方便售后发布程序，将调用内嵌tomcat的java类调用放在一个bat文件中，只需要双击bat文件即可进行部署。

3、从tomcat7开始，有自身的内嵌版本，大小非常的小。

思路：

1、普通java工程，内嵌一个tomcat，如果是tomcat7，请使用内嵌版本。该java工程负责一个事情，启动tomcat

2、可配置化，可以启动指定的多个工程，可指定各个工程的context名称，域名或ip

3、写一个bat脚本，方便任意路径进行部署

如何实现tomcat的启动，tomcat6和tomcat7略有差异，这里分别来进行介绍

我们先把tomcat需要的文件夹在工程中建立，conf，lib，webapps。conf中可以把tomcat中的context.xml和web.xml拷入，但是需要在代码中加载。

lib中需要拷入的jar包如下：

嵌入tomcat6

1、tomcat lib下的所有jar包

2、bin目录下的tomcat-juli.jar

3、jdk中的tool.jar

嵌入tomcat7

tomcat7-embedded.zip下的所有jar包

最后，需要将这些jar包加入到classpath下

我们再看一下tomcat的结构

![9f0ffe71-00b9-3b9c-842d-c76e0ae685ca.gif][]

也可以打开server.xml，很直观的可以看到其结构

1、tomcat6的启动

按照tomcat的结构我们一步一步的来实现。

a、创建我们的tomcat服务

主要是通过Embedded类来进行启动的，该类表示tomcat结构中的一个Server

Embedded tomcat=new Embedded();

注意设置环境变量

tomcat.setCatalinaHome(TOMCAT\_HOME);

TOMCAT\_HOME为tomcat在磁盘上的根路径

b、创建engine

需要先创建host

创建host需要先创建context

b.1、创建context

一个host可以有多个context

tomcat.createContext(CONTEXT\_PATH, WEB\_APP\_PATH);

CONTEXT\_PATH为访问的名称，可以任意指定，必须以"/"开头

WEB\_APP\_PATH为需要访问的工程路径，如果是源码环境，为WebRoot目录。如果是发布环境，直接为工程目录

其实这里的WEB\_APP\_PATH为docbase,也就是手动指定需要管理的web应用。如果使用appbase的话，会自动把该路径下的web应用进行管理

b.2、创建host

把域名或ip进行绑定

Host host = tomcat.createHost(ip, tomcat.getCatalinaHome());    
                             host.setAutoDeploy(true);

host.setAppBase(WORKSPACE);

和上面的docbase相对，设置appbase则会将该目录下的所有web应用进行管理，并且通过设置自动发布从而会实现自动解压war

把之前创建的context加入host

host.addChild(context);

b.3、创建engine

Engine engine = tomcat.createEngine();  
                             engine.addChild(host);   
                             tomcat.addEngine(engine);  
                  c、创建connector

设置协议等信息

Connector connector = tomcat.createConnector((java.net.InetAddress) null, TOMCAT\_PORT, false);    
                             connector.setURIEncoding(ENCODING);    
                             connector.setUseBodyEncodingForURI(true);    
                             tomcat.addConnector(connector);   
                             TOMCAT\_PORT为端口号

这个时候就可以调用tomcat.start();  进行启动了，需要注意的是，需要保持该线程的运行。不然服务会结束

2、tomcat7的启动

相对于tomcat6，tomcat7基本把所有创建工作放到了tomcat类中

a、Tomcat tomcat=new Tomcat();不再使用Embedded类

b、tomcat.getHost().setDeployOnStartup(true);自动发布war

c、tomcat.getHost().setAppBase(WORKSPACE);设置appBase，什么是appBase，请看上文tomcat6中的介绍

d、tomcat.setBaseDir(TOMCAT\_HOME);设置环境变量

e、tomcat.setHostname(ip);设置域名或ip

f、tomcat.setPort(TOMCAT\_PORT);设置端口号

g、tomcat.addWebapp(CONTEXT\_PATH, WEB\_APP\_PATH);设置context和docBase，什么是docBase，请看上文tomcat6中的介绍

h、tomcat.getConnector().setURIEncoding(ENCODING);设置connector

这个时候就可以调用tomcat.start();进行启动了，对于服务的保持，也提供了相应的方法，tomcat.getServer().await();

最后写个bat方便发布

@echo off
    
    @echo %cd%
    
    %~d0%
    cd %cd%
    java -Djava.ext.dirs=Embedded\lib com.my.server.EmbeddedTomcat
    
    @pause

由于开发环境和发布环境的差异，配置文件提供一个mode来进行分别处理，可以设置为debug或者release。多个工程之间用逗号隔开

project=TomcatTest
    context=TomcatTest
    host=localhost
    mode=debug

最后来看下代码

tomcat6

public class EmbeddedTomcat6 {
    
    	private static String CONTEXT_PATH = "";  
        private static String PROJECT_PATH = System.getProperty("user.dir");  
        private static String WORKSPACE = PROJECT_PATH;
        private static String WEB_APP_PATH = "";
        private static String TOMCAT_HOME = PROJECT_PATH + File.separatorChar + "bin" + File.separatorChar + "Embedded" + File.separatorChar + "Tomcat6";
        private static String ENCODING = "UTF-8";  
        private static int TOMCAT_PORT = 8888;  
        
        private static String project;
        private static String contextName;
        private static String ip;
        private static String mode;
        
        private static Embedded tomcat;
        private static boolean isRunning;
      
        // 开始嵌入式Tomcat服务器  
        public static void startTomcat() throws Exception {  
            try {  
                
            	initConfig();
            	initWorkSpace();
            	initTomcatHome();
            	createTomcat();  
            	Host host=createHost();  
                createContext(host);
                createEngine(host); 
                createConnector();
                createCreateListener();
                tomcat.start();  
                //System.err.println("Tomcat started in " + (System.currentTimeMillis() - startTime) + " ms.");  
                //停住一个小时(3600秒)  
                Thread.sleep(3600000);    
                //tomcat.stop();  
                
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
        
        private static void initConfig() throws IOException{
        	InputStream input;
        	try{
    	    	input=new BufferedInputStream((new FileInputStream(new File("config.propertites"))));
    	        
        	}catch(FileNotFoundException e){
        		input=new BufferedInputStream((new FileInputStream(new File("bin/config.propertites"))));
        	} 
        	Properties config=new Properties();
            config.load(input);
    		project=(String) config.get("project");
    		contextName=(String) config.get("context");
    		ip=(String) config.get("host");
    		mode=(String) config.get("mode");
        }
        
        private static void initWorkSpace(){
        	if(mode.equals("release")){
                if(PROJECT_PATH.contains("\\EmbeddedTomcat\\bin")){
                	WORKSPACE=PROJECT_PATH.substring(0,PROJECT_PATH.lastIndexOf("\\EmbeddedTomcat\\bin"));
                }
    		}else{
    			WORKSPACE=PROJECT_PATH.substring(0,PROJECT_PATH.lastIndexOf("\\EmbeddedTomcat"));
    		}  
            System.err.println("PROJECT_PATH:" + PROJECT_PATH);  
            System.err.println("WORKSPACE:" + WORKSPACE);  
        }
        
        private static void initTomcatHome(){
        	Embedded tomcat = new Embedded();  
            // 设置Tomcat的工作目录:工程根目录/Embedded/Tomcat
            if(mode.equals("release")){ 
            	TOMCAT_HOME=PROJECT_PATH+File.separatorChar+"Embedded"+File.separatorChar+"Tomcat6";
            }
            System.err.println("TOMCAT_HOME:" + TOMCAT_HOME);  
        }
        
        private static void createTomcat(){
        	tomcat=new Embedded();
            tomcat.setCatalinaHome(TOMCAT_HOME);   
        }
          
        private static Host createHost(){
            Host host = tomcat.createHost(ip, tomcat.getCatalinaHome());  
            host.setAutoDeploy(true);
            host.setAppBase(WORKSPACE);
            return host;
        }
        
        private static void createContext(Host host){
        	//创建Context，并加入Host中  
            String[] ps=project.split(",");
            String[] cns=contextName.split(",");
    		for(int i=0;i<ps.length;i++){
    			WEB_APP_PATH=WORKSPACE+ File.separatorChar + ps[i];  
    			CONTEXT_PATH="/"+cns[i]; 
    			
                System.out.println("CONTEXT_PATH:" + CONTEXT_PATH);
                if(mode.equals("release")){
                	if (!new File(WEB_APP_PATH).exists()) {  
    	                System.err.println("请检查应用的目录以及相关资源是否存在.");  
    	            } 
                	System.out.println("WEB_APP_PATH:"+WEB_APP_PATH);	
                }else{
    	            if (!new File(WEB_APP_PATH + File.separatorChar + "WebRoot").exists()) {  
    	                System.err.println("请检查应用的目录以及相关资源是否存在.");  
    	            } 
    	            WEB_APP_PATH=WEB_APP_PATH + File.separatorChar + "WebRoot";
                	System.out.println("WEB_APP_PATH:" + WEB_APP_PATH);
                }
                
    			Context context = null;  
                context = tomcat.createContext(CONTEXT_PATH, WEB_APP_PATH);  
                
                host.addChild(context);  
    		}
            host.addChild(tomcat.createContext("", ""));  
        }
        
        private static void createEngine(Host host){
        	// 产生Tomcat引擎  
            Engine engine = tomcat.createEngine();  
            //"localhost"对应的是work下的"Catalina"  
            engine.setName("Catalina");  
    
            //把Host加入Engine  
            engine.addChild(host);  
            engine.setDefaultHost(host.getName());  
            
            tomcat.addEngine(engine); 
        }
        
        private static void createConnector(){
        	Connector connector = tomcat.createConnector((java.net.InetAddress) null, TOMCAT_PORT, false);  
            connector.setURIEncoding(ENCODING);  
            connector.setUseBodyEncodingForURI(true);  
            tomcat.addConnector(connector);  
        }
        
        private static void createCreateListener(){
        	tomcat.addLifecycleListener(new LifecycleListener() {  
                public void lifecycleEvent(LifecycleEvent le) {  
                    String lc = le.getType();  
                    if(lc.equals(Lifecycle.START_EVENT)){  
                        System.out.println("start!");  
                        isRunning = true;  
                    }else if (lc.equals(Lifecycle.STOP_EVENT)){  
                        System.out.println("stop!");  
                        isRunning = false;  
                    }else if (lc.equals(Lifecycle.DESTROY_EVENT)){  
                        try {  
                            EmbeddedTomcat6.tomcat.stop();  
                            isRunning = false;  
                        } catch (LifecycleException e) {  
                            e.printStackTrace();  
                        }  
                    }  
                }  
            });  
        }
        
        public static void main(String[] args) {  
            try {  
                EmbeddedTomcat6.startTomcat();  
            } catch (Exception e) {  
                e.printStackTrace();  
            }   
        }  
    	
    }

tomcat7

public static void startTomcat() throws Exception {  
            try {  
            	
            	initConfig();
            	initWorkSpace();
            	initTomcatHome();
            	createTomcat();
            	tomcat.start();
            	tomcat.getServer().await();
            	
            }catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
        
        private static void initConfig() throws IOException{
        	InputStream input;
        	try{
    	    	input=new BufferedInputStream((new FileInputStream(new File("config.propertites"))));
    	        
        	}catch(FileNotFoundException e){
        		input=new BufferedInputStream((new FileInputStream(new File("bin/config.propertites"))));
        	} 
        	Properties config=new Properties();
            config.load(input);
    		project=(String) config.get("project");
    		contextName=(String) config.get("context");
    		ip=(String) config.get("host");
    		mode=(String) config.get("mode");
        }
        
        private static void initWorkSpace(){
        	if(mode.equals("release")){
                if(PROJECT_PATH.contains("\\EmbeddedTomcat\\bin")){
                	WORKSPACE=PROJECT_PATH.substring(0,PROJECT_PATH.lastIndexOf("\\EmbeddedTomcat\\bin"));
                }
    		}else{
    			WORKSPACE=PROJECT_PATH.substring(0,PROJECT_PATH.lastIndexOf("\\EmbeddedTomcat"));
    		}  
            System.err.println("PROJECT_PATH:" + PROJECT_PATH);  
            System.err.println("WORKSPACE:" + WORKSPACE);  
        }
        
        private static void initTomcatHome(){
        	Embedded tomcat = new Embedded();  
            // 设置Tomcat的工作目录:工程根目录/Embedded/Tomcat
            if(mode.equals("release")){ 
            	TOMCAT_HOME=PROJECT_PATH+File.separatorChar+"Embedded"+File.separatorChar+"Tomcat6";
            }
            System.err.println("TOMCAT_HOME:" + TOMCAT_HOME);  
        }
        
        private static void createTomcat() throws ServletException{
        	tomcat=new Tomcat();
        	tomcat.getHost().setDeployOnStartup(true);
        	tomcat.getHost().setAppBase(WORKSPACE);
            tomcat.setBaseDir(TOMCAT_HOME);
            tomcat.setHostname(ip);
            tomcat.setPort(TOMCAT_PORT);
            addWebapp();
            tomcat.enableNaming();
            tomcat.getConnector().setURIEncoding(ENCODING);
        }
        
        private static void addWebapp() throws ServletException{
    
        	String[] ps=project.split(",");
            String[] cns=contextName.split(",");
     		for(int i=0;i<ps.length;i++){
     			WEB_APP_PATH=WORKSPACE+ File.separatorChar + ps[i];  
     			CONTEXT_PATH="/"+cns[i]; 
     			
                 System.out.println("CONTEXT_PATH:" + CONTEXT_PATH);
                 if(mode.equals("release")){
                 	if (!new File(WEB_APP_PATH).exists()) {  
     	                System.err.println("请检查应用的目录以及相关资源是否存在.");  
     	            } 
                 	System.out.println("WEB_APP_PATH:"+WEB_APP_PATH);	
                 }else{
     	            if (!new File(WEB_APP_PATH + File.separatorChar + "WebRoot").exists()) {  
     	                System.err.println("请检查应用的目录以及相关资源是否存在.");  
     	            } 
     	            WEB_APP_PATH=WEB_APP_PATH + File.separatorChar + "WebRoot";
                 	System.out.println("WEB_APP_PATH:" + WEB_APP_PATH);
                 }
                
     			tomcat.addWebapp(CONTEXT_PATH, WEB_APP_PATH);
     		}
        	
        }
        
        public static void main(String[] args) {
    		try {
    			EmbeddedTomcat.startTomcat();
    		} catch (Exception e) {
    			e.printStackTrace();
    		} 
    	}
    	
    }

[Center]: /images/20220711/84ade48213414280af4d41865ad121d7.png
[Center 1]: /images/20220711/3aef0dc0aac44ac79fbf24d3cd416c70.png
[9f0ffe71-00b9-3b9c-842d-c76e0ae685ca.gif]: /images/20220711/31a3aa1e96214e9ea7fac040867afd64.png