Why AppDTE Was Built with Servlets and Embedded Jetty

 One of the questions I am often asked is:

Why did you build AppDTE using Embedded Jetty instead of Spring Boot?

The answer is that the architecture was never driven by the framework. It was driven by the problem that needed to be solved.

The Real Challenge

When I started developing AppDTE, I was still learning Java web development.

At that time, my goal was not to compare frameworks or choose between different Java technologies.

The real challenge was implementing the Chilean Electronic Invoicing (DTE) specification.

That meant solving problems such as:

  • Generating XML documents according to the SII XML Schemas.
  • Building the TED (Electronic Stamp).
  • Applying XML Digital Signatures (XMLDSig).
  • Validating XML documents.
  • Communicating with the Chilean Internal Revenue Service (SII).
  • Processing responses and document status.

Compared to these tasks, the web framework was only a small part of the project.

The Evolution of the Project

The project evolved over time.

The first versions were desktop applications built with Swing.

Later, the application became a traditional Java web application using Servlets and JSP.

Eventually, JSP was replaced with Thymeleaf for the administrative interface.

Throughout all these stages, however, the core problem remained exactly the same:

  • XML generation
  • Electronic stamping
  • Digital signatures
  • Communication with the SII

The presentation layer changed, but the business logic continued to evolve independently.

A Lightweight Architecture

As the core became more mature, the overall architecture naturally evolved into a lightweight design:

REST Client / Browser
          │
          ▼
   Jakarta Servlets
          │
          ▼
     Service Layer
          │
          ▼
          JDBC
          │
          ▼
        MySQL

For the administration interface:

Servlet
   │
   ▼
Thymeleaf
   │
   ▼
HTML

And the application server:

Java Main
   │
   ▼
Embedded Jetty
   │
   ▼
Servlet Container

This architecture proved to be sufficient for the needs of the project while keeping the technology stack relatively small.

Why Embedded Jetty?

Embedded Jetty provided exactly what the project required:

  • A lightweight embedded servlet container.
  • Standard Jakarta Servlet support.
  • Full programmatic configuration.
  • Fast startup.
  • Minimal runtime dependencies.
  • Easy deployment behind a reverse proxy such as Nginx.

The objective was never to use as many technologies as possible, but only those required to solve the problem.

This Is Not About Spring Boot

This article is not intended to compare Jetty with Spring Boot.

Spring Boot is an excellent framework and a great choice for many applications.

However, AppDTE already had a stable architecture centered around standard Jakarta technologies and a business layer that had evolved independently over several years.

Changing frameworks would not simplify the most complex part of the project, because the real complexity was never the web layer—it was the implementation of the electronic invoicing specification itself.

The Importance of Understanding the Fundamentals

One of the biggest advantages of this approach is educational.

Working directly with standard Jakarta technologies makes it easier to understand:

  • HTTP request processing.
  • The Servlet lifecycle.
  • Layered application architecture.
  • JDBC database access.
  • HTML rendering.
  • Embedded server configuration.

These concepts remain the foundation of many modern Java frameworks.

Conclusion

AppDTE was not designed around a particular framework.

Its architecture emerged from the requirements of the problem it needed to solve.

The most difficult part of the project was never building a web application.

It was implementing XML generation, electronic stamping, XML Digital Signatures, and integration with the Chilean Internal Revenue Service (SII).

Once that core became stable, a lightweight architecture based on Java SE, Jakarta Servlets, Embedded Jetty, Thymeleaf, and JDBC proved to be a simple, maintainable, and effective solution.

Related Project

The architecture described in this article is implemented in AppDTE Community, an Open Source REST API developed in Java for Chilean Electronic Invoicing (DTE).

https://www.appdte.cl

Comments

Post a Comment

Popular posts from this blog

Building a Simple Web Form with Jetty and Servlets

In this article, we will learn how to create a small web application using Java, Jetty, Thymeleaf, and Servlets. We will not use frameworks like Spring Boot because our goal is to understand how a web application works. Before beginning, we need the following requirements: Understanding how a web application works Fundamentals of programming Java 11 or higher Knowledge of how Maven works An IDE of your choice In my case, I will use NetBeans. In NetBeans, I will create a Maven Project → Java Application. We need to edit the pom.xml file because it contains the following dependencies: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">     <modelVersion>4.0.0</modelVersion>     <groupId>com.egga</groupId>     ...
Read more

Creating a MySQL Connection Class in Java

Creating a MySQL Connection Class in Java June 19, 2026 When I started learning Java, one of the first tasks was connecting to a MySQL database. To achieve this, it is common practice to create a class responsible for centralizing the connection configuration and providing Connection objects to the rest of the application. Basic Example package com.egga.appvet.includes; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.Connection; public class ConexionBD { private static final String URL = "jdbc:mysql://localhost:3306/AppVet"; private static final String USER = "tuusuario"; private static final String PASS = "tupassword@"; public static Connection getConnection() throws SQLException { return DriverManager.getConnection(URL, USER, PASS); } } In this example, three constants are defined: URL : the MySQL database address. U...
Read more

Replacing Tomcat: Configure Jetty with Spring Boot

 I this article we will learn how to configure Jetty with SpringBoot. I will not use Spring Initializr. Jetty is fast and lightweight, making it ideal for high-performance applications. Being modular, it allows enabling only the necessary components, optimizing resource usage. Jetty efficiently handles high traffic volumes, enabling applications to scale seamlessly. Add Dependencies to pom.xml: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.egga</groupId> <artifactId>examplejetty</artifactId> <version>0.1</version> <packaging>jar</packaging> <properties> <project.build.sourceEncoding>UTF-8</project.build.s...
Read more