原文： https://zetcode.com/web/embeddedtomcat/

在本教程中，我们将展示如何与嵌入式 Tomcat 服务器一起使用。 Tomcat 可以在嵌入式模式下运行； 这意味着无需构建 WAR 文件并将其部署在独立的 Tomcat 服务器中。 本教程中的示例是使用 Maven 构建的。

Tomcat

Apache Tomcat 是 Java Servlet，JavaServer Pages，Java Expression Language 和 Java WebSocket 技术的开源实现。

Apache Maven 是一个软件项目管理和理解工具。 该项目在名为pom.xml的 XML 文件中描述。 它包含对其他外部模块和组件的项目依赖关系，构建顺序，目录和所需的插件。

创建一个 servlet

在下面的示例中，我们创建一个带有嵌入式 Tomcat 服务器的命令行 Java 应用。 该应用附加一个简单的 servlet。

嵌入式 Tomcat - 图1

图：项目结构

该图显示了 NetBeans 中的项目结构。 注意，我们使用的是 Java Maven 控制台应用，而不是 Maven Web 应用。

pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.     <groupId>com.zetcode</groupId>
  7.     <artifactId>EmbeddedTomcatEx</artifactId>
  8.     <version>1.0-SNAPSHOT</version>
  9.     <packaging>jar</packaging>
  10.     <properties>
  11.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  12.         <maven.compiler.source>1.8</maven.compiler.source>
  13.         <maven.compiler.target>1.8</maven.compiler.target>
  14.         <tomcat.version>9.0.0.M6</tomcat.version>
  15.     </properties>
  17.     <dependencies>
  19.         <dependency>
  20.             <groupId>javax.servlet</groupId>
  21.             <artifactId>javax.servlet-api</artifactId>
  22.             <version>3.1.0</version>
  23.         </dependency>         
  24.         <dependency>
  25.             <groupId>org.apache.tomcat.embed</groupId>
  26.             <artifactId>tomcat-embed-core</artifactId>
  27.             <version>${tomcat.version}</version>
  28.         </dependency>
  29.         <dependency>
  30.             <groupId>org.apache.tomcat.embed</groupId>
  31.             <artifactId>tomcat-embed-logging-juli</artifactId>
  32.             <version>${tomcat.version}</version>
  33.         </dependency>
  35.     </dependencies>    
  37.     <build>    
  38.         <plugins>
  39.             <plugin>
  40.                 <groupId>org.codehaus.mojo</groupId>
  41.                 <artifactId>appassembler-maven-plugin</artifactId>
  42.                 <version>1.1.1</version>
  43.                 <configuration>
  44.                     <assembleDirectory>target</assembleDirectory>
  45.                     <programs>
  46.                         <program>
  47.                             <mainClass>com.zetcode.embedded.EmbeddedTomcatEx</mainClass>
  48.                             <name>webapp</name>
  49.                         </program>
  50.                     </programs>
  51.                 </configuration>
  52.                 <executions>
  53.                     <execution>
  54.                         <phase>package</phase>
  55.                         <goals>
  56.                             <goal>assemble</goal>
  57.                         </goals>
  58.                     </execution>
  59.                 </executions>
  60.             </plugin>
  61.         </plugins>    
  62.     </build>
  64. </project>

Maven pom.xml包含嵌入式 Tomcat 服务器和用于构建应用的汇编程序插件的依赖项。 由于我们只有 Servlet，因此 JSP 容器的依赖关系未包含在此应用中。

EmbeddedTomcatEx.java

  1. package com.zetcode.embedded;
  3. import javax.servlet.ServletException;
  4. import javax.servlet.http.HttpServlet;
  5. import javax.servlet.http.HttpServletRequest;
  6. import javax.servlet.http.HttpServletResponse;
  7. import java.io.File;
  8. import java.io.IOException;
  9. import java.io.Writer;
  10. import org.apache.catalina.Context;
  11. import org.apache.catalina.LifecycleException;
  12. import org.apache.catalina.startup.Tomcat;
  14. public class EmbeddedTomcatEx {
  16.     public static void main(String[] args) throws LifecycleException,
  17.             InterruptedException, ServletException {
  19.         Tomcat tomcat = new Tomcat();
  20.         tomcat.setPort(8082);
  22.         Context ctx = tomcat.addContext("/", new File(".").getAbsolutePath());
  24.         Tomcat.addServlet(ctx, "Embedded", new HttpServlet() {
  25.             @Override
  26.             protected void service(HttpServletRequest req, HttpServletResponse resp) 
  27.                     throws ServletException, IOException {
  29.                 Writer w = resp.getWriter();
  30.                 w.write("Embedded Tomcat servlet.\n");
  31.                 w.flush();
  32.                 w.close();
  33.             }
  34.         });
  36.         ctx.addServletMapping("/*", "Embedded");
  38.         tomcat.start();
  39.         tomcat.getServer().await();
  40.     }
  41. }

EmbeddedTomcatEx是 Java 控制台应用，其中包括嵌入式 Tomcat 服务器。

  1. Tomcat tomcat = new Tomcat();
  2. tomcat.setPort(8082);

Tomcat 在端口 8082 上启动。默认端口为 8080；默认端口为 8080。 NetBeans 将 8084 用于其内置的 Tomcat 服务器。 我们选择了另一个端口，以免发生冲突。

  1. Context ctx = tomcat.addContext("/", new File(".").getAbsolutePath());

每个应用都映射到上下文。 使用addContext()方法，我们创建了一个不支持 JSP 文件并且没有web.xml文件的应用。 我们使用根上下文路径和当前工作目录作为文档库。

  1. Tomcat.addServlet(ctx, "Embedded", new HttpServlet() {
  2.     @Override
  3.     protected void service(HttpServletRequest req, HttpServletResponse resp) 
  4.             throws ServletException, IOException {
  6.         Writer w = resp.getWriter();
  7.         w.write("Embedded Tomcat servlet.\n");
  8.         w.flush();
  9.         w.close();
  10.     }
  11. });

通过addServlet()方法添加了一个新的 servlet。 该 servlet 仅以一些 ASCII 文本作为响应。

  1. ctx.addServletMapping("/*", "Embedded");

servlet 映射控制如何访问名为 Embedded 的 servlet。 对于我们的示例，所有 URL 最终都会调用我们的 servlet。

  1. tomcat.start();
  2. tomcat.getServer().await();

Tomcat 服务器已启动。

  1. $ curl localhost:8082/
  2. Embedded Tomcat servlet.

我们运行该应用并使用curl工具对其进行测试。

JSP 文件

在第二个示例中，我们使用嵌入式 Tomcat 服务器来提供 JSP 文件。

pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <groupId>com.zetcode</groupId>
  6.     <artifactId>EmbeddedTomcatEx2</artifactId>
  7.     <version>1.0-SNAPSHOT</version>
  8.     <packaging>jar</packaging>
  9.     <properties>
  10.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  11.         <maven.compiler.source>1.8</maven.compiler.source>
  12.         <maven.compiler.target>1.8</maven.compiler.target>
  13.         <tomcat.version>9.0.0.M6</tomcat.version>
  14.     </properties>
  16.     <dependencies>
  18.         <dependency>
  19.             <groupId>javax.servlet</groupId>
  20.             <artifactId>javax.servlet-api</artifactId>
  21.             <version>3.1.0</version>
  22.         </dependency>         
  23.         <dependency>
  24.             <groupId>org.apache.tomcat.embed</groupId>
  25.             <artifactId>tomcat-embed-core</artifactId>
  26.             <version>${tomcat.version}</version>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>org.apache.tomcat.embed</groupId>
  30.             <artifactId>tomcat-embed-logging-juli</artifactId>
  31.             <version>${tomcat.version}</version>
  32.         </dependency>
  34.         <dependency>
  35.             <groupId>org.apache.tomcat</groupId>
  36.             <artifactId>tomcat-jasper</artifactId>
  37.             <version>${tomcat.version}</version>
  38.         </dependency>
  40.         <dependency>
  41.             <groupId>org.apache.tomcat</groupId>
  42.             <artifactId>tomcat-jasper-el</artifactId>
  43.             <version>${tomcat.version}</version>
  44.         </dependency>
  46.         <dependency>
  47.             <groupId>org.apache.tomcat</groupId>
  48.             <artifactId>tomcat-jsp-api</artifactId>
  49.             <version>${tomcat.version}</version>
  50.         </dependency>        
  52.     </dependencies>    
  54.     <build>
  56.         <plugins>
  57.             <plugin>
  58.                 <groupId>org.codehaus.mojo</groupId>
  59.                 <artifactId>appassembler-maven-plugin</artifactId>
  60.                 <version>1.1.1</version>
  61.                 <configuration>
  62.                     <assembleDirectory>target</assembleDirectory>
  63.                     <programs>
  64.                         <program>
  65.                             <mainClass>com.zetcode.embedded.EmbeddedTomcatEx2</mainClass>
  66.                             <name>webapp</name>
  67.                         </program>
  68.                     </programs>
  69.                 </configuration>
  70.                 <executions>
  71.                     <execution>
  72.                         <phase>package</phase>
  73.                         <goals>
  74.                             <goal>assemble</goal>
  75.                         </goals>
  76.                     </execution>
  77.                 </executions>
  78.             </plugin>
  79.         </plugins>    
  80.     </build>
  81.     <name>EmbeddedTomcatEx2</name>
  82. </project>

在此pom.xml文件中，我们还包括嵌入式 Tomcat JSP 容器的依赖项：tomcat-jasper，tomcat-jasper-el和tomcat-jsp-api。

index.jsp

  1. <%@page contentType="text/html" pageEncoding="UTF-8"%>
  2. <!DOCTYPE html>
  3. <html>
  4.     <head>
  5.         <title>JSP file</title>
  6.         <meta charset="UTF-8">
  7.     </head>
  8.     <body>
  9.         <p>
  10.             This is a simple JSP file.            
  11.         </p>
  12.     </body>
  13. </html>

这是嵌入式 Tomcat 服务器提供的简单 JSP 文件。

EmbeddedTomcatEx2.java

  1. package com.zetcode.embedded;
  3. import javax.servlet.ServletException;
  4. import java.io.File;
  5. import org.apache.catalina.LifecycleException;
  6. import org.apache.catalina.startup.Tomcat;
  8. public class EmbeddedTomcatEx2 {
  10.     public static void main(String[] args) throws LifecycleException,
  11.             InterruptedException, ServletException {
  13.         String docBase = "src/main/webapp/";
  15.         Tomcat tomcat = new Tomcat();
  16.         tomcat.setPort(8082);
  18.         tomcat.addWebapp("/", new File(docBase).getAbsolutePath());
  20.         tomcat.start();
  21.         tomcat.getServer().await();
  22.     }
  23. }

该应用提供一个 JSP 文件。 该文件位于src/main/webapp子目录中。

  1. tomcat.addWebapp("/", new File(docBase).getAbsolutePath());

这次我们使用addWebapp()将应用添加到 Tomcat 服务器。

  1. $ curl localhost:8082/
  3. <!DOCTYPE html>
  4. <html>
  5.     <head>
  6.         <title>JSP file</title>
  7.         <meta charset="UTF-8">
  8.     </head>
  9.     <body>
  10.         <p>
  11.             This is a simple JSP file.            
  12.         </p>
  13.     </body>
  14. </html>

当我们访问应用时，我们得到了这个。

这是嵌入式 Tomcat 教程。 使用嵌入式 Tomcat，我们提供了一个 servlet 和一个 JSP 文件。 我们已经使用了 Apache Tomcat，Maven 和 NetBeans。 您可能还需要查看一些相关的教程：嵌入式 Jetty 的 Jersey 应用， Jetty 教程， Java 教程或 SQL 查询标记教程。