Skip to content
Architecture and backend16 min

The structure of a project (5): the layer that did nothing

By · co-founder and Chief Executive Officer of Hábil ·

Four layers and a facade that just passes the call on. What goes in each package of a Spring Boot API, when to skip the facade, and a template that checks it.

The structure of a project · installment 5 of 7 · Java with Spring Boot

Scenario: the characters and the story are made up. The technical data and the quotes carry their source at the end.

In 1 minute

  • Spring Boot doesn't require any particular way of arranging the code [1]. Layers are a decision; here is the template's, with its reasons.
  • Each package is a role in a restaurant: api is the waiter, service the cook, repository the pantry. And each role has something it never does.
  • The facade, the head chef, is justified when it coordinates two or more. If its method only calls another one, it's extra.
  • For Java, the cook knowing the waiter isn't an error: it compiles. An architecture test catches it [12].
  • You take away a template that runs on the first try, with a script that proves that boundary by turning red when it should.
  • For Monday: open your facade and count how many methods only call another one.

In this article

  1. What happened on Thursday at 16:40?
  2. What goes in each package?
  3. When do you need the facade, and when not?
  4. What are the three rules?
  5. What are five frequent mistakes?
  6. Exercise: can you make the cook call the waiter?
  7. Key takeaways
  8. What's next?
  9. The template and the course
  10. What does Hábil do?
  11. References

What happened on Thursday at 16:40?

Iván added a field to a response, touched four files and found a layer that did nothing.

Thursday, 16:05. Third floor.

A month after the alias. His first API in Java, with Spring Boot: a store's orders. The assignment fit in one line: "Make an order lookup also say when it was created."

Someone else had left the project. Four folders named after layers:

src/main/java/…/pedidos/
  api/
  facade/
  service/
  repository/

The data was already in the table. To get it into the JSON, Iván touched four files, one per folder. In three he copied the field from one class to another. In the fourth, the facade, he stopped:

public PedidoResponse buscar(UUID id) {
    return service.buscar(id);
}

A method that only called another one. It took the same thing and returned the same thing. He checked the class's other methods: there were six, and five did that.

Thursday, 16:40.

It compiled. The tests passed. Before pushing the change, he wrote to Lucía.

"Four files to move one piece of data. And one layer does nothing: it calls the next one and that's it. Should I remove it?"

"How many does that method call?" she answered.

"One. The service."

"And the one that creates an order?"

Iván opened it. That one was different: first it asked another system for the price, and then it called the service.

"Two."

"Then in one the head chef is extra, and in the other he isn't."

"What head chef?"

"Tomorrow we're having lunch at the diner across the street. Watch who does what."

Iván looked at the four folders. He had thought they were four mandatory steps. They were four trades.

What goes in each package?

Whatever belongs to one role in a restaurant, and nothing else. Spring Boot doesn't ask for layers: they're a decision.

The Spring Boot documentation says it right away: «Spring Boot does not require any specific code layout to work» [1]. Its own example doesn't even arrange things by layer: it puts one folder for customers and another for orders [1]. What it does recommend is where the class that starts everything goes: «in a root package above other classes» [1]. From that package down, Spring looks for the components and the entities.

So where do api, service and repository come from? From a habit Spring carries in its annotations: @Controller, @Service and @Repository exist for the «persistence, service, and presentation» layers [2]. At Hábil it's house practice: one package per role, and dependencies in one direction only. It's not the only correct way. It's one that fits in a lunch.

This installment's template, estructura-java-spring-boot, is a store's orders API. Its root package is mx.habil.pedidos: the domain reversed and the application's name [1].

estructura-java-spring-boot/
├── pom.xml                          bibliotecas y construcción
├── mvnw · .mvn/                     el Maven del proyecto
├── Dockerfile                       la imagen
├── docs/ARCHITECTURE.md             las capas y las decisiones
├── herramientas/probar-frontera.sh
├── src/main/java/mx/habil/pedidos/
│   ├── PedidosApplication.java      aquí arranca todo
│   ├── api/            el mesero
│   ├── facade/         el jefe de cocina
│   ├── service/        el cocinero
│   ├── repository/     la despensa
│   ├── client/         el proveedor de afuera
│   ├── model/          los papeles que pasan de mano en mano
│   │   ├── request/    la comanda
│   │   ├── response/   el ticket
│   │   ├── entity/     la ficha del archivo
│   │   └── vo/         las medidas exactas
│   ├── mapper/         el que pasa en limpio
│   ├── config/         la instalación del local
│   ├── exception/      el libro de quejas
│   ├── observability/  las cámaras y la bitácora
│   └── utils/          el cajón de herramientas
├── src/main/resources/application.yml
└── src/test/java/mx/habil/pedidos/  el mismo árbol

src/main and src/test are Maven's standard layout, Maven being the tool that builds the project: it's there so that someone who knows one project can «immediately feel at home in another» [14]. mvnw is the Maven Wrapper: it downloads the Maven version the project declares, and nobody installs it by hand [15].

Let's go role by role. Each one brings its example from the template and one line: what never goes there.

Who serves the customers?

api, the waiter. Takes the order slip, checks that it's filled in correctly and passes it on. Doesn't cook.

@PostMapping
public ResponseEntity<PedidoResponse> crear(@Valid @RequestBody CrearPedidoRequest comanda) {
    PedidoResponse creado = facade.crear(comanda);
    return ResponseEntity.created(URI.create("/v1/pedidos/" + creado.id())).body(creado);
}

Everything HTTP lives here: the route, the verb, the 201. @Valid is the check: if the order slip is filled in wrong, Spring throws MethodArgumentNotValidException [5] and the kitchen never even hears about it. Never goes here: a business rule. An if on a piece of the order's data belongs to the cook.

service, the cook. The rules live here. The template has two: an order isn't accepted if an item is short, and the total is price times quantity.

if (linea.cantidad() > linea.existencias()) {
    throw new PedidosException(CodigoError.SIN_EXISTENCIAS,
            "De %s se pidieron %d y hay %d".formatted(linea.sku(), linea.cantidad(), linea.existencias()));
}
total = total.mas(linea.importe());

Never goes here: HTTP or JSON. The cook doesn't know whether the order came from an app or by phone; that's why its tests run with no server and no database.

repository, the pantry. Stores and fetches.

public interface PedidoRepository extends JpaRepository<PedidoEntity, UUID> {
}

That's the whole interface. Spring Data takes care of «creating Repository implementations directly from interfaces» [7]. Never goes here: a decision. Whether an order can be saved is up to the cook.

client, the outside supplier. Another system, on another machine. In the template it's the inventory: how many items there are and at what price. It's called with two precautions. A timeout: application.yml declares one second to connect and two to read [8]. And a retry, only on a network error of the kind Spring calls ResourceAccessException; a 404 from the supplier is an answer and isn't repeated. Spring Framework 7 already ships retry in its core [9]. Two retries are three calls: «total attempts = 1 initial attempt + maxRetries attempts» [9]. Never goes here: an order rule. Nor a call without a timeout.

facade, the head chef. Coordinates. It's Iván's question, and it gets its own section.

Which papers change hands?

request is the order slip, response the receipt and entity the file card. Three papers, even if they say almost the same thing.

public record CrearPedidoRequest(
        @NotBlank @Email @Size(max = 254) String correo,
        @NotEmpty @Size(max = 20) List<@Valid @NotNull Linea> lineas) {

The order slip and the receipt are records: classes that only carry data, with final fields [16]. The annotations are from Jakarta Validation [6]. The order slip carries no price: the price is set by the supplier, not the customer. The receipt carries no email: nobody asked for it. The file card, PedidoEntity, has the shape of the table, and it's a regular class because the JPA specification says a record «may not be designated as an entity» [17]. Never: the file card going out the door. The waiter hands over the receipt.

And the other packages?

vo, the exact measure. vo stands for value object: it's recognized by what it's worth, not by an id; two Dinero of 100 cents are the same amount. Dinero isn't a loose long: it's an amount in cents that is never negative. If it exists, it's already valid, and nobody checks it again. The same goes for Correo. Never goes here: anything from Spring or from another layer.

mapper, the one who writes up the clean copy. Copies from the file card to the receipt, field by field. Never goes here: an if that decides something.

config, the restaurant's fittings. The clock, the phone to call the supplier, how many times to retry. It's set up once, at opening. Never goes here: rules or routes.

exception, the complaints book. Everything that can go wrong has a code in a catalog, and a single place builds the response. The shape isn't ours: it's Problem Details, RFC 9457, which exists «to avoid the need to define new error response formats for HTTP APIs» [4], and Spring already ships it [3]. Measured in the template, ordering four mugs when there are three:

{"detail":"De TAZA-01 se pidieron 4 y hay 3","instance":"/v1/pedidos","status":409,
 "title":"No hay existencias suficientes",
 "type":"https://pedidos.example/errors/sin_existencias","error_code":"SIN_EXISTENCIAS"}

Never goes here: an error format of your own.

observability, the cameras and the log. Each request gets a number, which shows up on every line of the log and goes back to the client in X-Request-ID. Never goes here: personal data in the clear. Measured: pedido f6bd398a-… recibido de a***@tienda.mx por $424.00.

utils, the toolbox drawer. Mascara.correo covered that email. Never goes here: anything that knows what an order is. If it knows, it belongs in another package.

What path does an order follow?

Inward, from the door to the pantry; and through the shortcut when there's nothing to coordinate.

POST /v1/pedidos                          GET /v1/pedidos/{id}
       │                                         │
       ▼                                         ▼
  api (mesero)  revisa la comanda           api (mesero)
       │                                         │
       ▼                                         │  el atajo: lo atiende
  facade (jefe de cocina)                        │  un solo servicio
       ├──► client (proveedor)  ¿hay?            │
       ▼                                         ▼
  service (cocinero)  las reglas  ◄──────────────┘
       │
       ▼
  repository (despensa)  guarda la ficha

On the way back, the file card is written up clean and the receipt goes out.

When do you need the facade, and when not?

Yes, when it coordinates two or more services or clients. No, when its method only calls another one.

Friday, 14:10. The diner across the street.

Lucía ordered the set menu. Iván, just a hibiscus water. The waiter left the set menu's order slip on the kitchen counter, and a woman read it out loud: the soup on one side, the stew on the other, to come out together. The water he ordered straight from whoever served it.

"There it is," said Lucía. "For the set menu, two are involved, and someone has to say the order. For the water, no."

In the template, creating an order is the set menu. The supplier and the cook are involved, in that order:

public PedidoResponse crear(CrearPedidoRequest comanda) {
    List<LineaCotizada> cotizadas = new ArrayList<>();
    for (CrearPedidoRequest.Linea linea : comanda.lineas()) {
        InventarioClient.Producto producto = inventario.consultar(linea.sku())
                .orElseThrow(() -> new PedidosException(CodigoError.PRODUCTO_NO_EXISTE,
                        "No hay un producto con el sku " + linea.sku()));
        cotizadas.add(new LineaCotizada(linea.sku(), linea.cantidad(), producto.existencias(),
                new Dinero(producto.precioCentavos())));
    }
    PedidoEntity pedido = pedidos.crear(new Correo(comanda.correo()), cotizadas);
    return mapper.aResponse(pedido);
}

It asks, passes on and delivers. It doesn't calculate or decide: that's the cook's job. Never goes here: a calculation, a business rule, a direct query to the database, or a method that just passes the call to a single service.

Looking up an order is the water. A single service handles it, and the waiter goes straight there:

@GetMapping("/{id}")
public PedidoResponse buscar(@PathVariable UUID id) {
    return mapper.aResponse(service.buscar(id));
}

What does an extra facade cost? One more file in every change: Iván's four. And in the template no test gives it away, because the arrows are fine. It's decided by reading: how many does this method coordinate?

On Monday, Iván deleted five methods. The facade kept one.

What are the three rules?

Everyone does their own job; arrows only point inward; and what comes in, what gets stored and what goes out are different things.

  1. Everyone does their own job. If you don't know where a line goes, ask whose job it is.
  2. Arrows only point inward. api → facade → service → repository or client. The cook never calls the waiter.
  3. What comes in, what gets stored and what goes out are different things. request, entity and response, even if today they look alike.

The third one bit us while testing the template. On macOS, the 71 tests of that moment passed. On Linux, one failed: the freshly created order said "creado_en":"2026-11-17T21:30:32.024605370Z", and the same order, looked up right after, "2026-11-17T21:30:32.024605Z". What went out and what was stored were no longer the same: the database had stored fewer decimals. The fix was a rule for the cook, truncating the time to the millisecond, with its test. That's why there are 72 today.

How do I know the arrows point inward?

Because a test reads the compiled classes and fails when one points outward. And because a script checks that this test knows how to fail.

For Java, classes in the same project can import each other. If the cook imports the waiter, it compiles. The rule is guarded by CapasTest, written with ArchUnit, a library «for checking the architecture of your Java code» that works by «analyzing given Java bytecode» [12]: it checks the compiled output, not the text. It understands Java 25 since its version 1.4.1 [13]; the template uses 1.5.1.

.whereLayer("api").mayNotBeAccessedByAnyLayer()
.whereLayer("facade").mayOnlyBeAccessedByLayers("api")
.whereLayer("service").mayOnlyBeAccessedByLayers("api", "facade")
.whereLayer("repository").mayOnlyBeAccessedByLayers("service")
.whereLayer("client").mayOnlyBeAccessedByLayers("facade", "service")

But a test that always passes proves nothing. herramientas/probar-frontera.sh works on a temporary copy and runs CapasTest twice:

  1. Control, with the project as it is. It has to run and pass. If not, the experiment is set up wrong, or your project already carries an arrow pointing outward, and the script stops in red.
  2. Violation. A method that takes a PedidoController is planted in PedidoService. It has to compile, and CapasTest has to fail, on a single rule and for the exact reason.

This is the real output:

1/2 control: el proyecto tal como está; el cocinero (service) no conoce al mesero (api)
   ✅ compiló y CapasTest pasó: 4 reglas, 0 fallas
2/2 violación: se siembra en PedidoService un método que recibe un PedidoController
   ✅ compiló sin una queja: para Java, que el cocinero conozca al mesero no es un error
     Method <mx.habil.pedidos.service.PedidoService.avisar(mx.habil.pedidos.api.PedidoController)> has parameter of type <mx.habil.pedidos.api.PedidoController>
   ✅ CapasTest falló en una sola regla, lasFlechasSoloVanHaciaAdentro: las flechas solo van hacia adentro
✅ frontera: se sostiene

We broke it seven ways, and all seven came out red. Three say a lot: with the rule deleted from CapasTest, ❌ PASÓ; with a violation that doesn't compile, it says that this «no demuestra la frontera»; with Java 21 instead of 25, it stops at the control.

What are five frequent mistakes?

All five come from the same thing: one role doing another's job.

1. The waiter who cooks

A business rule in the controller.

It works, and it shows later: to test the rule you have to bring up the web part. The template's controller test uses @WebMvcTest, which leaves out the other components: «Regular @Component and @ConfigurationProperties beans are not scanned» [22]. The service's test runs with Java and nothing else.

2. The head chef who only passes the plate

A facade whose method only calls another one.

It's Iván's. The architecture test doesn't flag it: the arrows are fine. What gives it away is the count: how many services or clients does each method coordinate?

3. Handing over the file card

The controller returns the entity.

It compiles, and it answers too much. Measured in the template, changing a single method: of 72 tests, 3 fail. One says it bluntly:

Expected no value at JSON path "$.correo" but found: 'ana@tienda.mx'

The customer's email went out in a response that should never have carried it. One of the three is CapasTest: it asks whether any api class depends on an entity, not what type a method returns. That's why it also turns red if the file card is hidden in a List<PedidoEntity> or in a ResponseEntity<PedidoEntity>; measured with both.

4. Calling the supplier without a timeout

If the supplier hangs, your API hangs with it.

In the template, the timeout is one line of application.yml [8]. Measured: without that line, the test that expects a 504 turns red. And watch what gets retried: a "doesn't exist" from the supplier is an answer. The template only repeats on a network error, and it can because the query is a GET: asking twice how many mugs there are changes nothing. A write, like charging, isn't retried like that: first it has to be made idempotent, so that repeating it gives the same result as doing it once.

5. Copying the imports from an old tutorial

Spring Boot 4 uses Jackson 3 out of the box, and its classes changed package.

Jackson is the library that turns objects into JSON. In Spring Boot 4, version 3 is «the preferred and default library» [10]; version 2 remains temporarily, for migrating, and the template doesn't use it. And the migration guide warns about it: the packages move from com.fasterxml.jackson to tools.jackson, with one exception, the annotations, which stay in com.fasterxml.jackson.annotation [11]. Measured in the template, with an old-style import:

package com.fasterxml.jackson.databind does not exist
5. Copying the imports from an old tutorial
MistakeWhat gives it awaySource
1. The waiter who cooksAn if on a piece of the order's data in api[2][22]
2. The facade that only passes the plateA method that only calls another onethe template's rule
3. Handing over the file cardOne piece of data too many in the JSONmeasurement
4. No timeoutA slow response that does arrive[8][9]
5. import from an old tutorialpackage … does not exist[10][11]

Exercise: can you make the cook call the waiter?

You're going to plant an arrow pointing outward, see that Java accepts it and see how the test and the script warn you.

You need Java 25 (java -version), Git, bash and curl; about 25 minutes. Not Maven: the project brings it.

  • On Linux and macOS, install Java with SDKMAN [23]. On Linux you need curl, zip and unzip first (measured on Ubuntu 24.04, the base of Linux Mint 22 [28]):
  sudo apt install curl zip unzip
  curl -s "https://get.sdkman.io" | bash

Open another terminal, go into the template's folder (the one from step 1) and run sdk env install. Open one more terminal (in the one where it installed, java still isn't found; measured) and, in that folder, run sdk env. Lesson 1 of the Java course walks through it step by step. - On Windows, use WSL.

Step 1. Clone and check that everything is green.

git clone https://github.com/HabilMX/estructura-java-spring-boot
cd estructura-java-spring-boot
./mvnw verify
bash herramientas/probar-frontera.sh

The first time it takes a while: it downloads Maven and the libraries. You should see Tests run: 72, Failures: 0, Errors: 0, Skipped: 0, then BUILD SUCCESS and, at the end of the script, ✅ frontera: se sostiene.

Use this clone only for practice. That way, every change you see in it comes from the exercise.

Step 2. Predict before touching. You're going to add to the cook, PedidoService, a method that takes the waiter, PedidoController. Write down: does it compile? What does CapasTest say? And the boundary script?

Step 3. Plant the arrow. The first line removes the class's last brace and leaves a .bak copy; the second adds the method and closes the class. They work the same on Linux and macOS.

sed -i.bak '$d' src/main/java/mx/habil/pedidos/service/PedidoService.java
printf '    public void avisar(mx.habil.pedidos.api.PedidoController mesero) {\n    }\n}\n' \
  >> src/main/java/mx/habil/pedidos/service/PedidoService.java
./mvnw -q test-compile
./mvnw -q test -Dtest=CapasTest

test-compile finishes without saying anything: it compiled. The test doesn't. Among many lines, the ones that matter:

Tests run: 4, Failures: 1, Errors: 0, Skipped: 0
Method <mx.habil.pedidos.service.PedidoService.avisar(mx.habil.pedidos.api.PedidoController)> has parameter of type <mx.habil.pedidos.api.PedidoController> in (PedidoService.java:0)

Step 4. Ask the script.

bash herramientas/probar-frontera.sh

It turns red, without reaching the second step:

❌ el control NO pasó: tu proyecto, tal como está, ya rompe una regla de CapasTest:

That's the control at work: it can't prove the test knows how to fail if your project already has it failing.

Step 5. Put back only what you touched. The exercise changed one file. Before putting it back, look at what changed in it:

git diff -- src/main/java/mx/habil/pedidos/service/PedidoService.java

You should see two new lines: the avisar method and its brace. If you see anything else, it's yours: save it before going on. If only the exercise's changes are there, restore that file. git restore only touches the paths you give it [24]:

git restore src/main/java/mx/habil/pedidos/service/PedidoService.java
bash herramientas/probar-frontera.sh
git status --short

The boundary goes back to green, and git status shows what's left: the copy sed made.

?? src/main/java/mx/habil/pedidos/service/PedidoService.java.bak

Keep it until you're sure you don't need it. Then delete it with rm -i, which asks first. Don't use a command that cleans the whole folder: it would also take your notes.

How you know you did it right: you ran six times and saw three outcomes. Green, four times: the two in step 1, test-compile in step 3 and the boundary in step 5. The test's red, once: Failures: 1 in step 3. And the script's red, «el control NO pasó», in step 4. If in step 3 test-compile shows an error, check that PedidoService.java ends in a single brace }.

To go further (optional): make the waiter hand over the file card. In PedidoController, change the buscar method so it returns mx.habil.pedidos.model.entity.PedidoEntity and gives back service.buscar(id) without going through the mapper. First, predict: does it compile? How many tests fail? Answer: it compiles, and ./mvnw -q test ends with Tests run: 72, Failures: 3 (measured). Put it back the same way as in step 5: git diff of that file, and git restore with its path.

Key takeaways

Three questions to ask your repository this week.

  1. How many methods in your facade only call another one? Each one is an extra file in the next change.
  2. Does any controller return an entity? If so, which column of the table is going out without anyone asking for it?
  3. What warns you if tomorrow a service imports a controller? If the answer is "code review", it depends on someone noticing.

What's next?

The restaurant doesn't depend on the brand of the stove.

Two weeks later, Iván was handed another orders API. He opened the project and recognized the folders: api, facade, service, repository. He searched for @RestController to start with the waiter.

There wasn't one.

The class that starts the application wasn't there either. Not a single Spring import. And even so, the layers were the same and the arrows pointed inward. On Sunday, December 6, in installment 6: same restaurant, a faster kitchen. The same layers in Quarkus, what changes in each package and how fast it is, measured.

The template and the course

  • Template: github.com/HabilMX/estructura-java-spring-boot. Use it as a GitHub template or clone it [26]. The README explains each package with its "never", the path of an order, what it doesn't include (authentication, a real database, an OpenAPI contract), when to add each thing and how to remove the example. The code is MIT; the text and explanations are CC BY-SA 4.0.
  • To see it working: the README has the curl commands. The example inventory supplier is a folder with two JSON files, served with jwebserver, a minimal server the JDK already ships [25]. The database is H2, in memory [7]: the simplest thing that runs on the first try; the data is erased on shutdown. Health answers at /actuator/health, and nothing else from Actuator is exposed [21].
  • Versions: Java 25, the current long-term support (LTS) version [20], with Temurin 25.0.5+8. Spring Boot 4.1.2, the current one on November 17 [19], which accepts Java 17 through Java 27 [18]; the template stays on 25 and won't build with another. Maven 3.9.16, through the Wrapper [15]. ArchUnit 1.5.1 [13]. It was tested on macOS arm64 (also with the system /bin/bash) and on Linux arm64 (ubuntu:24.04 container). Linux x86-64 hasn't been tested yet. The CI is written for Ubuntu and macOS with Temurin 25, on every change and every Monday; if the public repository goes 60 days without activity, GitHub turns off the Monday run [27].
  • Hábil's Java course: if records, Maven or testing with JUnit are new to you, start there: Java course · Lesson 3, records · Lesson 6, a Maven project.

I write from what we see every day at Hábil, where we build systems for banking, insurance and companies in Mexico. If at work or at school you run into a repository nobody knows where to touch, let's talk: habil.mx

What does Hábil do?

We teach programming with the same things we use to build: tested, explained and open code.

This series comes from the same place as our courses. The Java course teaches today's Java: types that express the model, tests, concurrency and a finished program, packaged as a JAR, and we publish it openly, under a Creative Commons license; its lesson 3 covers the records and its lesson 6 the Maven project that this article's template uses. And the catalog has more programming courses, free and with code tested and explained step by step.

See the Java course and the Programming courses catalog.

If your team inherits a system nobody knows where to touch, or needs to build one that can keep being maintained, we do that too: see Build your custom system. Request your first conversation, at no cost. In it we review whether it makes sense to configure what you already have, use a product or build, and what you would get in each case. Write to us on WhatsApp.

Sources accessed on November 17, 2026. Quotes in English are reproduced as is.

References

  1. Spring Boot 4.1.2, «Structuring Your Code». https://docs.spring.io/spring-boot/reference/using/structuring-your-code.html
  2. Spring Framework, «Classpath Scanning and Managed Components»: @Component and the stereotype annotations. https://docs.spring.io/spring-framework/reference/core/beans/classpath-scanning.html
  3. Spring Framework, «Error Responses». https://docs.spring.io/spring-framework/reference/web/webmvc/mvc-ann-rest-exceptions.html
  4. M. Nottingham, E. Wilde and S. Dalal, «RFC 9457: Problem Details for HTTP APIs», IETF, July 2023. https://www.rfc-editor.org/rfc/rfc9457.html
  5. Spring Framework, «Validation» (Spring MVC, controller methods). https://docs.spring.io/spring-framework/reference/web/webmvc/mvc-controller/ann-validation.html
  6. Eclipse Foundation, «Jakarta Validation 3.1». https://jakarta.ee/specifications/bean-validation/3.1/
  7. Spring Boot 4.1.2, «SQL Databases»: «Embedded Database Support» and the Spring Data repositories. https://docs.spring.io/spring-boot/reference/data/sql.html
  8. Spring Boot 4.1.2, «REST Clients»: spring.http.clients.connect-timeout and read-timeout. https://docs.spring.io/spring-boot/reference/io/rest-client.html
  9. Spring Framework, «Resilience Features». https://docs.spring.io/spring-framework/reference/core/resilience.html
  10. Spring Boot 4.1.2, «JSON» («Jackson 3 is the preferred and default library»). https://docs.spring.io/spring-boot/reference/features/json.html
  11. Spring Boot, «Spring Boot 4.0 Migration Guide»: «Upgrading Jackson». https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-4.0-Migration-Guide
  12. ArchUnit, «ArchUnit User Guide»: «Introduction» and «Layer Checks». https://www.archunit.org/userguide/html/000_Index.html
  13. TNG, «ArchUnit», releases 1.4.1 («Support Java 25») and 1.5.1, GitHub. https://github.com/TNG/ArchUnit/releases
  14. Apache Maven, «Introduction to the Standard Directory Layout». https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html
  15. Apache Maven, «Maven Wrapper». https://maven.apache.org/tools/wrapper/
  16. Oracle, «Record Classes», Java Language Updates, Java SE 25. https://docs.oracle.com/en/java/javase/25/language/records.html
  17. Eclipse Foundation, «Jakarta Persistence 3.2», section «The Entity Class». https://jakarta.ee/specifications/persistence/3.2/jakarta-persistence-spec-3.2
  18. Spring Boot 4.1.2, «System Requirements». https://docs.spring.io/spring-boot/system-requirements.html
  19. Spring, Spring Boot releases (spring.io API): 4.1.2, the current one. https://api.spring.io/projects/spring-boot/releases
  20. Eclipse Adoptium, «Support» («Java 25 (LTS)»). https://adoptium.net/support/
  21. Spring Boot 4.1.2, «Endpoints» (Actuator). https://docs.spring.io/spring-boot/reference/actuator/endpoints.html
  22. Spring Boot 4.1.2, «Testing Spring Boot Applications»: @WebMvcTest. https://docs.spring.io/spring-boot/reference/testing/spring-boot-applications.html
  23. SDKMAN, «Usage»: sdk env. https://sdkman.io/usage/
  24. Git, «git-restore» («Restore specified paths in the working tree»). https://git-scm.com/docs/git-restore
  25. Oracle, «The jwebserver Command», Java SE 25. https://docs.oracle.com/en/java/javase/25/docs/specs/man/jwebserver.html
  26. GitHub Docs, «Creating a template repository». https://docs.github.com/en/repositories/creating-and-managing-repositories/creating-a-template-repository
  27. GitHub Docs, «Disabling and enabling a workflow». https://docs.github.com/en/actions/how-tos/manage-workflow-runs/disable-and-enable-workflows
  28. Linux Mint, «Linux Mint 22 Release Notes» («Linux Mint 22.x is based on Ubuntu 24.04»), linuxmint.com. https://www.linuxmint.com/rel_wilma.php

Does your operation face these challenges?

Let's talk about your case

Prefer email? Write to us at hola@habil.mx