tomcat-programmatic-setup
Programmatically Create, Configure and Run a Tomcat Server
1. Overview
In this quick article, we’re going to programmatically create, configure and run a Tomcat server.
2. Setup
Before we get started, we need to setup our Maven project by adding the below dependencies to our pom.xml:
<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.
3. Initializing and Configuring Tomcat
3.1. Creating Tomcat
Tomcat tomcat = new Tomcat();
Now that we have the server, let’s configure it.
3.2. Configuring Tomcat
First off, we need to configure a port, hostname and an appBase (typically web apps). For our purpose we’ll use the current directory:
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):
File docBase = new File(System.getProperty("java.io.tmpdir"));
Context context = tomcat.addContext("", docBase.getAbsolutePath());
At this point, we have an almost functioning Tomcat.
Next, we’ll add a servlet and a filter and start the server to see if it’s working.
3.3. Adding a Servlet to Tomcat Context
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.
Let’s first define our 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:
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
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.
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
tomcat.start();
tomcat.getServer().await();
Once it started, we can go to http://localhost:8080/my-servlet and see the test page:
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.
5. Conclusion
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.
As always, the full implementation can be found over on Github.