嵌入式 Tomcat (Embedded Tomcat)

嵌入式 Tomcat 作为嵌入 Java 应用程序的库, 你可以在 mvnrepository 下载 发行版Jar 以及源码

https://mvnrepository.com/search?q=embed+tomcat

作为最基本的依赖, 你需要以下几个库

• Tomcat Embed Core
• Tomcat Embed Logging JULI
• Tomcat Annotations API

概念

• Connector: tomcat监听相关的配置对象。

import org.apache.catalina.connector.Connector;

Connector connector = new Connector();
conn.setProperty("address", hostname); // 监听地址
conn.setPort(port); // 监听端口

// 关联到tomcat实例，启动监听
tomcat.setConnector(connector);
tomcat.start();
tomcat.getServer().await();

• 工作目录，绝对路径，该目录下必须有一个"webapps"目录，同时Tomcat还会生成一个work目录，因此建议使用当前目录"."

tomcat.setBaseDir(new File(".").getAbsolutePath());

// 指定任意工作目录，自动创建webapps目录
    private void configDir(String baseDir) {
        File root = new File(baseDir);
        if (!root.isDirectory() && !root.mkdirs()) {
            throw new RuntimeException("请提供Tomcat工作目录");
        }
        String path4root = root.getAbsolutePath();
        tomcat.setBaseDir(path4root);
        File webapps = new File(path4root + "/webapps");
        if (!webapps.isDirectory() && !webapps.mkdirs()) {
            throw new RuntimeException("无法创建webapps目录");
        }
    }

• 上下文、上下文目录
  添加上下文时，Tomcat会在工作目录下生成目录work/Tomcat/{Hostname}/{contextPath}
  相关代码：

tomcat.setHostname("my_tomcat");

tomcat.addContext(contextPath, docBase) // docBase：您可以为此目录或WAR文件指定绝对路径名，或者相对于所属主机的appBase目录的相对路径名，除非在server.xml中定义了Context元素，或者docBase不在主机的appBase下，否则不得设置此字段的值

• 上下文映射

context = tomcat.addContext("", new File(baseDir).getAbsolutePath());
Tomcat.addServlet(context, "default", new HelloServlet()); // HelloServlet : HttpServlet
context.addServletMappingDecoded("/", "default");

现在, 让我们把 tomcat 跑起来

package develon.test;

import java.io.File;
import java.io.IOException;
import java.io.Writer;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.catalina.Context;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.startup.Tomcat;

public final class Main {
	File tmpDir = new File("F:\Game\tomcat");
	Tomcat tomcat = new Tomcat();
	
	public static void main(String[] args) throws Throwable {
		new Main().init();
	}
	
	private void init() throws Throwable {
		Runtime.getRuntime().addShutdownHook(new Thread(() -> {
				try {
					tomcat.destroy();
				} catch (LifecycleException e) {
					e.printStackTrace();
				}
			})
		);
		test();
	}

	private void test() throws Throwable {
		tomcat.setBaseDir(tmpDir.getAbsolutePath()); // 设置工作目录
		tomcat.setHostname("localhost"); // 主机名, 将生成目录: {工作目录}/work/Tomcat/{主机名}/ROOT
		System.out.println("工作目录: " + tomcat.getServer().getCatalinaBase().getAbsolutePath());

		tomcat.setPort(80);
		Connector conn = tomcat.getConnector(); // Tomcat 9.0 必须调用 Tomcat#getConnector() 方法之后才会监听端口
		System.out.println("连接器设置完成: " + conn);
		
		// contextPath要使用的上下文映射，""表示根上下文
		// docBase上下文的基础目录，用于静态文件。相对于服务器主目录必须存在 ({主目录}/webapps/{docBase})
		Context ctx = tomcat.addContext("", /*{webapps}/~*/ "/ROOT");

        Tomcat.addServlet(ctx, "globalServlet", new HttpServlet() {
			private static final long serialVersionUID = 1L;

			@Override
            protected void service(HttpServletRequest request, HttpServletResponse response)
                    throws ServletException, IOException {
                response.setCharacterEncoding("UTF-8");
                response.setContentType("text/plain");
                response.setHeader("Server", "Embedded Tomcat");
                try (Writer writer = response.getWriter()) {
                    writer.write("Hello, Embedded Tomcat!");
                    writer.flush();
                }
            }
        });
        ctx.addServletMappingDecoded("/", "globalServlet");

		tomcat.start();
		System.out.println("tomcat 已启动");
		tomcat.getServer().await();
	}

}

tomcat 嵌入正常, 让我们继续, 如何令 tomcat 加载 Spring Framework ?

嵌入式 tomcat 集成 Spring 框架

package develon.tomc;

import java.util.HashSet;

import org.apache.catalina.Context;
import org.apache.catalina.LifecycleEvent;
import org.apache.catalina.LifecycleListener;
import org.apache.catalina.LifecycleState;
import org.apache.catalina.startup.Tomcat;
import org.springframework.web.SpringServletContainerInitializer;

public class Main {
	Tomcat tomcat;
	
	{
		tomcat = new Tomcat();
//		tomcat.setAddDefaultWebXmlToWebapp(false);
//		tomcat.noDefaultWebXmlPath();
	}

	public void run() throws Throwable {
		tomcat.setBaseDir("F:\Game\tomcat");
		tomcat.setHostname("localhost");
		tomcat.setPort(80);
//		tomcat.enableNaming();
		
//		tomcat.getHost().setAutoDeploy(false);
//		tomcat.getEngine().setBackgroundProcessorDelay(-1);
		
		Context ctx = tomcat.addContext("", "ROOT");
		
		ctx.addLifecycleListener(new LifecycleListener() {
			public void lifecycleEvent(LifecycleEvent event) {
//				System.out.println(event.getLifecycle().getState().name());
				if (event.getLifecycle().getState() == LifecycleState.STARTING_PREP) {
					try {
						new SpringServletContainerInitializer().onStartup(new HashSet<Class<?>>() {
							private static final long serialVersionUID = 1L;
							{
								add(WebAppInitializer.class);
							}
						}, ctx.getServletContext());
					} catch (Throwable e) {
						e.printStackTrace();
					}
				}
			}
		});
		
//		tomcat.init();
		tomcat.getConnector();
		tomcat.start();
		tomcat.getServer().await();
	}
	
	public static void main(String[] args) throws Throwable {
		new Main().run();
	}
}

其中 WebAppInitializer 是继承 AbstractAnnotationConfigDispatcherServletInitializer 的一个配置类
由于 AbstractAnnotationConfigDispatcherServletInitializer 继承了 SpringServletContainerInitializer, 所以可以简写为

		Context ctx = tomcat.addContext("", "ROOT");
		
		ctx.addLifecycleListener(new LifecycleListener() {
			public void lifecycleEvent(LifecycleEvent event) {
				if (event.getLifecycle().getState() == LifecycleState.STARTING_PREP) {
					try {
						new WebAppInitializer().onStartup(ctx.getServletContext());
					} catch (Throwable e) {
						e.printStackTrace();
					}
				}
			}
		});

这种方式好像会报一个错误, 不过可以忽略它, 但是注意这是一个运行时异常, 我们最好捕获 Throwable, 否则程序直接退出了
(经查, 是由于注射 dispacherServlet 两次造成的, 实际上第一次已经注射完成了)

java.lang.IllegalStateException: Failed to register servlet with name 'dispatcher'. Check if there is another servlet registered under the same name.
	at org.springframework.web.servlet.support.AbstractDispatcherServletInitializer.registerDispatcherServlet(AbstractDispatcherServletInitializer.java:90)
	at org.springframework.web.servlet.support.AbstractDispatcherServletInitializer.onStartup(AbstractDispatcherServletInitializer.java:63)
	at develon.tomc.Main$1.lifecycleEvent(Main.java:37)

然后我们还能用闭包进一步简化程序, 并且把烦人的栈痕迹删除

		ctx.addLifecycleListener((LifecycleEvent event) -> {
			if (event.getLifecycle().getState() == LifecycleState.STARTING_PREP) {
				try {
					new WebAppInitializer().onStartup(ctx.getServletContext());
				} catch (Throwable e) {
//					e.printStackTrace();
				}
			}
		});

我用 kotlin 简单地封装了一个 EmbeddedTomcat 类

import org.apache.catalina.startup.Tomcat
import org.apache.catalina.Context
import org.apache.catalina.LifecycleState

class EmbeddedTomcat {
	var tomcat: Tomcat = Tomcat()
	var ctx: Context? = null
	
	init {
		
	}
	
	/** 初始化嵌入式 tomcat */
	fun init() {
		tomcat.setBaseDir("""F:\Game\tomcat""")
		tomcat.setHostname("localhost")
		tomcat.setPort(80)
		
		ctx = tomcat.addContext("", "ROOT")
	}
	
	/** 开始监听服务 */
	fun run() {
		tomcat.getConnector()
		tomcat.start()
		tomcat.getServer().await()
	}
	
	/** 启动 Spring 框架, 注射 DispatcherServlet */
	fun spring() {
		var tyusya = false
		ctx?.addLifecycleListener {
			if (tyusya == false && it.getLifecycle().getState() == LifecycleState.STARTING_PREP) {
				println("开始注射 -> ${ it.getLifecycle().getState() }")
				val sctx = ctx?.getServletContext()
				try {
					WebAppInitializer().onStartup(sctx)
					println("完成")
					tyusya = true
				} catch(e: Throwable) {
					println("失败: ${ e.message }")
				}
			}
		}
	}

	fun spring2() { // 调用了 removeLifecycleListener 移除 tomcat 生命周期监听器
		ctx?.addLifecycleListener(object : LifecycleListener {
			override fun lifecycleEvent(it: LifecycleEvent) {
				if (it.getLifecycle().getState() == LifecycleState.STARTING_PREP) {
					println("开始注射 DispatcherServlet -> ${ it.getLifecycle().getState() }")
					try {
						WebAppInitializer().onStartup(ctx?.getServletContext())
						println("注射完成")
						ctx?.removeLifecycleListener(this)
					} catch(e: Throwable) {
						println("注射失败: ${ e.message }")
					}
				}
			}
		})
	}
}

fun main() {
	val tomcat = EmbeddedTomcat()
	tomcat.init()
	tomcat.spring()
	tomcat.run()
}

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer
import org.springframework.context.annotation.ComponentScan

@ComponentScan(basePackageClasses = [DefController::class])
class WebAppInitializer : AbstractAnnotationConfigDispatcherServletInitializer() {
	override fun getRootConfigClasses() = null
	override fun getServletMappings() = arrayOf("/")
	override fun getServletConfigClasses() = arrayOf(WebAppInitializer::class.java)
}