1. Overview

1.概述

In this quick article, we’re going to programmatically create, configure and run a Tomcat server.

在这篇快速文章中，我们将以编程方式创建、配置和运行一个Tomcat服务器。

2. Setup

2.设置

Before we get started, we need to setup our Maven project by adding the below dependencies to our pom.xml:

在开始之前，我们需要在pom.xml中添加以下依赖项来设置我们的Maven项目。

<dependencies>
    <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>tomcat-catalina</artifactId>
        <version>${tomcat.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>${apache.httpclient}</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit.version}</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Here is a link to Maven Central with the latest versions of the dependencies used here in the project.

这里有一个链接到Maven中心，在项目中使用最新版本的依赖项。

3. Initializing and Configuring Tomcat

3.初始化和配置Tomcat

Let’s first talk about the steps required for initialization and configuration of a Tomcat server.

让我们先谈谈Tomcat服务器的初始化和配置所需的步骤。

3.1. Creating Tomcat

3.1.创建Tomcat

We can create an instance by simply doing:

我们可以通过简单的操作创建一个实例。

Tomcat tomcat = new Tomcat();

Now that we have the server, let’s configure it.

现在我们有了服务器，让我们来配置它。

3.2. Configuring Tomcat

3.2.配置Tomcat

We’ll focus on how to get the server up and running, adding a servlet and a filter.

我们将专注于如何让服务器启动和运行，添加一个Servlet和一个过滤器。

First off, we need to configure a port, hostname and an appBase (typically web apps). For our purpose we’ll use the current directory:

首先，我们需要配置一个端口、主机名和一个appBase（通常是网络应用）。为了我们的目的，我们将使用当前目录。

tomcat.setPort(8080);
tomcat.setHostname("localhost");
String appBase = ".";
tomcat.getHost().setAppBase(appBase);

Next, we need to set a docBase (the context root directory for this web application):

接下来，我们需要设置一个docBase（这个web应用程序的上下文根目录）。

File docBase = new File(System.getProperty("java.io.tmpdir"));
Context context = tomcat.addContext("", docBase.getAbsolutePath());

At this point, we have an almost functioning Tomcat.

在这一点上，我们有一个几乎可以运作的Tomcat。

Next, we’ll add a servlet and a filter and start the server to see if it’s working.

接下来，我们将添加一个Servlet和一个过滤器，并启动服务器，看看它是否工作。

3.3. Adding a Servlet to Tomcat Context

3.3.在Tomcat上下文中添加一个Servlet

Next, we’ll add a simple text to the HttpServletResponse. This is the text that is going to be displayed when we access the URL mapping for this servlet.

接下来，我们将在HttpServletResponse中添加一个简单的文本。这是我们访问这个Servlet的URL映射时要显示的文本。

Let’s first define our servlet:

让我们首先定义我们的Servlet。

public class MyServlet extends HttpServlet {

    @Override
    protected void doGet(
      HttpServletRequest req, 
      HttpServletResponse resp) throws IOException {
 
        resp.setStatus(HttpServletResponse.SC_OK);
        resp.getWriter().write("test");
        resp.getWriter().flush();
        resp.getWriter().close();
    }
}

Now we add this servlet to the Tomcat server:

现在我们把这个Servlet添加到Tomcat服务器上。

Class servletClass = MyServlet.class;
Tomcat.addServlet(
  context, servletClass.getSimpleName(), servletClass.getName());
context.addServletMappingDecoded(
  "/my-servlet/*", servletClass.getSimpleName());

3.4. Adding a Filter to Tomcat Context

3.4.在Tomcat上下文中添加一个过滤器

Next, we define a filter and add it to Tomcat:

接下来，我们定义一个过滤器并将其添加到Tomcat。

public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) {
        // ...
    }

    @Override
    public void doFilter(
      ServletRequest request, 
      ServletResponse response, 
      FilterChain chain) 
      throws IOException, ServletException {

        HttpServletResponse httpResponse = (HttpServletResponse) response;
        httpResponse.addHeader("myHeader", "myHeaderValue");
        chain.doFilter(request, httpResponse);
    }

    @Override
    public void destroy() {
        // ...
    }
}

Adding the filter to the context requires a bit more work:

将过滤器添加到上下文中需要多做一点工作。

Class filterClass = MyFilter.class;
FilterDef myFilterDef = new FilterDef();
myFilterDef.setFilterClass(filterClass.getName());
myFilterDef.setFilterName(filterClass.getSimpleName());
context.addFilterDef(myFilterDef);

FilterMap myFilterMap = new FilterMap();
myFilterMap.setFilterName(filterClass.getSimpleName());
myFilterMap.addURLPattern("/my-servlet/*");
context.addFilterMap(myFilterMap);

At this point, we should have a servlet and a filter added to the Tomcat.

在这一点上，我们应该有一个Servlet和一个过滤器被添加到Tomcat。

All that is left to do is start it and get the “test” page and check the logs to see if the filter works.

剩下要做的就是启动它，获得 “测试 “页面，并检查日志，看看过滤器是否工作。

4. Starting Tomcat

4.启动Tomcat

This is a pretty simple operation and after that, we should see Tomcat running:

这是一个相当简单的操作，之后，我们应该看到Tomcat正在运行。

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

Once it started, we can go to http://localhost:8080/my-servlet and see the test page:

一旦启动，我们可以到http://localhost:8080/my-servlet，看到测试页面。

And if we look at the logs we’ll see something like this:

如果我们看一下日志，我们会看到像这样的东西。

These logs show that Tomcat started listening on port 8080 and also that our filter is working correctly.

这些日志显示，Tomcat开始监听8080端口，也显示我们的过滤器工作正常。

5. Conclusion

5.结论

In this tutorial, we went through a basic programmatic setup of a Tomcat server.

在本教程中，我们经历了一个Tomcat服务器的基本程序化设置。

We looked at how to create, configure and run the server, but also at how we can add a Servlet and a Filter programmatically to the Tomcat context.

我们研究了如何创建、配置和运行服务器，还研究了如何以编程方式向Tomcat上下文添加Servlet和Filter。

As always, the full implementation can be found over on Github.

一如既往，完整的实现可以在Github上找到，。