Skip to content

6. Arquitecturas en capas

6.1. Introducción

Retomemos la última versión de la aplicación de cálculo del impuesto (versión 3, capítulo 5). Reducido a lo esencial, su programa principal tenía la siguiente estructura (esquema simplificado):

// creation of an ITax object from a text or JSON file
ITax tax;
try {
    tax = fileName.toLowerCase().endsWith(".json") ? new JsonTax(fileName) : new FileTax(fileName);
} catch (TaxException e) {
    IO.println("The following error occurred: [Code=" + e.getCode() + ", Message=" + e.getMessage() + "]");
    return;
}
// bucle de entrada
while (true) {
    String parameters = IO.readln("Tax calculation parameters in the format: ...").strip();
    ...
    // los parámetros son correctos: calculamos el impuesto
    IO.println("Tax=" + tax.calculate(married.equals("y"), nbChildren, salary) + " euros");
}

Este programa combina tres tipos de procesamiento presentes en la mayoría de las aplicaciones:

  • la obtención de datos almacenados en archivos, bases de datos, etc.: líneas 1–8;
  • la interacción con el usuario: líneas 11–12 (entrada) y 14 (salida);
  • el uso de un algoritmo de negocio, el cálculo del impuesto: línea 14. Este cálculo lo realizaba antes la clase abstracta [AbstractTax], la clase padre de [FileTax] y [JsonTax]: en la versión 3, la lectura de datos y el cálculo siguen combinados en un único objeto.

La experiencia ha demostrado que aislar estos procesos en clases separadas mejora la mantenibilidad de la aplicación. La arquitectura de una aplicación estructurada de este modo es la siguiente:

Image

Esta arquitectura se denomina “arquitectura de tres niveles”. El término “nivel” se refiere normalmente a una parte de la aplicación que se ejecuta en una máquina distinta. Cuando las partes están en la misma máquina, se habla más bien de “arquitectura en capas”:

  • La capa [business] contiene las reglas de negocio de la aplicación. Para nuestra aplicación, son las reglas que sirven para calcular el impuesto de un contribuyente. Esta capa necesita datos para funcionar:
    • los tramos impositivos, que cambian cada año;
    • el número de hijos, el estado civil del contribuyente y sus ingresos anuales;
  • la capa de acceso a datos, o [dao] (DAO = Data Access Object), proporciona los datos ya almacenados en archivos o bases de datos. Esto incluye los tramos impositivos, como en la versión 3 de la aplicación;
  • la capa de interfaz de usuario, o [ui] (UI = User Interface), proporciona los datos ingresados por el usuario y le muestra los resultados. Aquí esto se aplica al número de hijos, al estado civil y a los ingresos anuales del contribuyente.

En general:

  • la capa [dao] se encarga del acceso a datos persistentes (archivos, bases de datos) o no persistentes (red, sensores, etc.);
  • la capa [ui] se encarga de las interacciones con el usuario, si lo hay;
  • las tres capas se hacen independientes entre sí mediante el uso de interfaces.

Retomaremos la aplicación [Tax], que ya hemos examinado varias veces, para darle una arquitectura en capas. Primero debemos definir las interfaces de las distintas capas de la aplicación.

6.2. Las interfaces de la aplicación [Tax]

Recordemos que una interfaz define un conjunto de firmas de métodos. Las clases que implementan la interfaz proporcionan la implementación de estos métodos.

Volvamos a la arquitectura en capas de nuestra aplicación:

Image

En este tipo de arquitectura, con frecuencia el usuario toma la iniciativa. El usuario hace una solicitud en [1] y recibe una respuesta en [8]. A esto se le llama ciclo solicitud-respuesta. Tomemos el ejemplo del cálculo del impuesto de un contribuyente. Esto requerirá varios pasos:

  • La capa [ui] pide al usuario su estado civil, el número de hijos y el salario anual. Esta es la operación [1] descrita anteriormente;
  • hecho esto, la capa [ui] pide a la capa [business] que calcule el impuesto. Para ello, le envía los datos que recibió del usuario. Esta es la operación [2];
  • La capa [business] necesita cierta información para cumplir su tarea: los tramos impositivos. Los solicita a la capa [dao] por el camino [3, 4, 5, 6]: [3] es la solicitud inicial y [6] es la respuesta a esa solicitud;
  • con todos los datos que necesitaba, la capa [business] calcula el impuesto;
  • La capa [business] ya puede responder a la solicitud hecha por la capa [ui] en [2]. Este es el camino [7];
  • La capa [ui] da formato a este resultado y luego se lo presenta al usuario. Este es el camino [8];
  • Podría imaginarse que el usuario realiza simulaciones de impuestos y desea guardarlas. Para ello usaría el mismo camino, [1-8].

Como se ve en esta descripción, una capa utiliza los recursos de la capa que está a su derecha, nunca los de la que está a su izquierda. Consideremos dos capas adyacentes:

Image

La capa [A] hace solicitudes a la capa [B]. En los casos más sencillos, una capa se implementa con una sola clase. Pero una aplicación evoluciona con el tiempo, y la capa [B] puede tener sucesivamente distintas clases de implementación: [B1], [B2], y así sucesivamente. Si la capa [B] es la capa [dao], puede tener una implementación inicial, [B1], que obtiene los datos de un archivo. Algunos años después, podría desearse almacenar esos datos en una base de datos: en ese caso, se crea una segunda clase de implementación, [B2]. Si, en la aplicación inicial, la capa [A] trabajaba directamente con la clase [B1], nos veríamos obligados a reescribir parcialmente el código de la capa [A]. Por ejemplo, supongamos que escribimos algo como lo siguiente en la capa [A]:

1
2
3
B1 b1 = new B1(...);
...
b1.getData(...);
  • Línea 1: se crea una instancia de la clase [B1];
  • línea 3: se solicitan datos a esta instancia.

Si la nueva clase de implementación [B2] tiene métodos con la misma firma que la clase [B1], habrá que cambiar todas las instancias de [B1] por [B2]. Este es el mejor de los casos, y es bastante improbable si no se ha prestado atención a estas firmas. En la práctica, es común que las clases [B1] y [B2] tengan firmas de métodos distintas, lo que significa que hay que reescribir una parte considerable de la capa [A].

Este problema puede mitigarse insertando una interfaz entre las capas [A] y [B] . Así se fijan, dentro de una interfaz, las firmas de los métodos que la capa [B] expone a la capa [A]. El diagrama anterior queda de la siguiente manera:

Image

La capa [A] ya no se comunica directamente con la capa [B], sino con su interfaz [IB]. En el código de la capa [A], la clase de implementación [Bi] de la capa [B] aparece ahora una sola vez, cuando se crea el objeto que implementa la interfaz [IB]. Después de eso, se usa la interfaz [IB], y no su clase de implementación. El código anterior queda así:

1
2
3
IB ib = new B1(...);
...
ib.getData(...);
  • Línea 1: se crea una instancia de *[ib] que implementa la interfaz *[IB] mediante la instanciación de la clase *[B1]* ;
  • Línea 3: se solicitan datos a la instancia [ib].

Ahora, si reemplazamos la implementación [B1] de la capa [B] por una implementación [B2], y ambas implementaciones respetan la misma interfaz [IB], solo hay que modificar la línea 1 de la capa [A]. Esta es una ventaja importante que, por sí sola, justifica el uso sistemático de interfaces entre dos capas.

Podemos ir aún más lejos y hacer que la capa [A] sea completamente independiente de la capa [B]. En el código anterior, la línea 1 plantea un problema porque escribe directamente en el código el nombre de la clase [B1]. Lo ideal es que la capa [A] reciba una implementación de la interfaz [IB] sin tener que especificar el nombre de una clase. Esto sería coherente con el diagrama anterior: la capa [A] se comunica con la interfaz [IB], y no hay razón para que necesite conocer el nombre de la clase que implementa esa interfaz.

Esto es lo que permite la inyección de dependencias (DI). La arquitectura anterior evoluciona de la siguiente manera:

Image

Un componente transversal, el contenedor de inyección de dependencias, crea los objetos que implementan las capas y los conecta entre sí: pasa a la capa [A] una referencia al objeto que implementa la capa [B]. El código de la capa [A] adopta entonces la siguiente forma:

// the layer [A] receives the layer [B] through its constructor
public class A {
    private final IB ib;

    public A(IB ib) {
        this.ib = ib;
    }

    public void work() {
        ...
        ib.getData(...);
    }
}
  • Líneas 5–7: la capa [A] recibe, mediante su constructor, una instancia [ib] que implementa la interfaz [IB]. No es la capa [A] la que la crea, sino el contenedor;
  • Línea 11: se solicitan datos a la instancia [ib].

La clase de implementación [B1] ya no aparece en ninguna parte del código de la capa [A]. Cuando la implementación [B1] se reemplaza por una nueva implementación [B2], nada cambiará en el código de la capa [A]: lo único que cambiará es el único lugar de la aplicación donde se le indica al contenedor qué clase implementa [IB]. Ese lugar incluso puede leer el nombre de la implementación que se usará desde un archivo de configuración.

En el mundo Java, la inyección de dependencias se popularizó a principios de la década de 2000 con el framework Spring, cuya configuración se escribía entonces en archivos XML. Spring Framework, ahora en su versión 7, sigue siendo el estándar de la industria; es la base de Spring Boot, que usaremos en el capítulo 13, “Servicios web”. Usaremos su contenedor en la versión 5 de la aplicación (hay otros, como CDI, el estándar Jakarta EE, o Google Guice). La combinación de “interfaces Java + inyección de dependencias” mejora considerablemente la mantenibilidad de las aplicaciones al hacer que las capas sean independientes entre sí.

Volvamos a la arquitectura en capas de nuestra aplicación. En casos sencillos, podemos partir de la capa [business] para descubrir las interfaces de la aplicación. Para funcionar, la aplicación necesita datos:

  • que ya están disponibles en archivos, bases de datos o a través de la red. Estos datos los proporciona la capa [dao];
  • que aún no están disponibles. En ese caso, los proporciona la capa [ui], que los obtiene del usuario.

¿Qué interfaz debe ofrecer la capa [dao] a la capa [business]? La capa [dao] debe proporcionar los tramos impositivos a la capa [business]. En nuestra aplicación, la capa [dao] utiliza datos existentes pero no crea datos nuevos. Su interfaz puede ser la siguiente:

package dao;

import entities.TaxBracket;
import java.util.List;

// la interfaz de la capa [dao]
public interface ITaxDao {

    // los tramos del impuesto
    List<TaxBracket> getTaxBrackets();
}
  • Línea 1: la interfaz se encuentra en el paquete [dao]. Por lo tanto, el archivo [ITaxDao.java] debe estar en una carpeta llamada [dao], como veremos;
  • línea 10: la interfaz [ITaxDao] define el método [getTaxBrackets], que proporciona los tramos impositivos a la capa [business]. Java no tiene propiedades: los datos de solo lectura se exponen mediante el método [getXxx], según la convención JavaBeans. Los tramos impositivos se devuelven como una lista [List<TaxBracket>] en lugar de un arreglo: veremos que las implementaciones devuelven una lista inmutable, mientras que los elementos de un arreglo siempre pueden ser modificados por quien los recibe;
  • línea 3: importa el tipo [TaxBracket], definido en el paquete [entities]:
1
2
3
4
5
6
7
package entities;

import java.math.BigDecimal;

// un tramo del impuesto: un record, por lo tanto una clase no modificable
public record TaxBracket(BigDecimal limit, BigDecimal coeffR, BigDecimal coeffN) {
}

Un tramo impositivo se representa mediante un record (Java 16): una clase no modificable para la cual el compilador genera el constructor (a partir de los componentes declarados entre paréntesis después del nombre del tipo), los campos [private final], los accesores [limit()], [coeffR()] y [coeffN()], así como los métodos [equals], [hashCode], y [toString]. Escribimos [new TaxBracket(limit, coeffR, coeffN)] para crear un tramo impositivo. Los tres componentes son del tipo [BigDecimal], la clase de Java para números decimales exactos: un [double] no puede representar exactamente 0.068 ni 291.09. Dado que un *[BigDecimal] es a su vez inmutable, un tramo impositivo no puede modificarse una vez creado. Una clase JavaBean tradicional, con métodos [setXxx], lo habría permitido; veremos que esta limitación elimina un efecto secundario de una forma más antigua de implementar la capa [business]*.

¿Qué interfaz debe presentar la capa [business] a la capa [ui]? Repasemos las interacciones entre estas dos capas:

  • La capa [ui] pide al usuario su estado civil, el número de hijos y el salario anual. Esta es la operación [1] del esquema;
  • Hecho esto, la capa [ui] pide a la capa [business] que calcule el impuesto. Para ello, envía a la capa [business] los datos que recibió del usuario. Esta es la operación [2].

La interfaz de la capa [business] podría ser la siguiente:

1
2
3
4
5
6
7
package business;

// la interfaz de la capa [business]
public interface ITaxBusiness {

    int calculateTax(boolean married, int nbChildren, int salary);
}
  • Línea 1: todo lo relacionado con la capa [business] se coloca en el paquete [business];
  • línea 6: la interfaz [ITaxBusiness] define un solo método, que calcula el impuesto de un contribuyente a partir de su estado civil, su número de hijos y su salario anual. Los métodos de una interfaz son implícitamente públicos y abstractos: no es necesario escribir [public abstract].

Examinemos ahora una primera implementación de esta arquitectura en capas.

6.3. Aplicación de ejemplo: versión 4

6.3.1. El proyecto

La versión 4 es un programa formado por varios archivos fuente que no utiliza ninguna biblioteca externa. Lo ejecutaremos con el lanzador de código fuente de Java, sin crear un proyecto Maven. Cada capa ocupa una carpeta distinta:

TaxV4/
  Main.java                  integration of the layers
  TaxData.txt                the tax brackets
  TaxDataInvalid.txt         an incorrect brackets file
  entities/
    TaxBracket.java
    ErrorCode.java
    TaxException.java
  dao/
    ITaxDao.java
    HardwiredTax.java
    FileTax.java
  business/
    ITaxBusiness.java
    TaxBusiness.java
  ui/
    Dialog.java
  • La carpeta [entities] contiene los tipos transversales a las capas [ui], [business], y [dao]: el record [TaxBracket], la excepción [TaxException], y la enumeración [ErrorCode] de sus códigos de error;
  • la carpeta [dao] contiene la interfaz y las clases de la capa [dao]. Usaremos dos implementaciones de la interfaz [ITaxDao]: la clase [HardwiredTax], cuyos datos están escritos directamente en el código (versión 2), y la clase [FileTax], que lee los datos de un archivo de texto (versión 3). La lectura de un archivo JSON, la otra opción de la versión 3, se tratará en la versión 5;
  • la carpeta [business] contiene la interfaz y la clase de la capa [business];
  • la carpeta [ui] contiene la clase de la capa [ui];
  • el archivo [Main.java] crea las capas y las enlaza entre sí;
  • el archivo [TaxData.txt] contiene los tramos impositivos que lee la implementación [FileTax] de la capa [dao].

A diferencia de otros lenguajes, aquí los nombres de las carpetas importan: en Java, una clase del paquete [dao] se ubica en una carpeta llamada [dao], una clase del paquete [tax.dao] está en una carpeta [tax/dao], y estas carpetas son relativas a la raíz de las fuentes. Así es como el compilador y la máquina virtual localizan las clases a partir de sus nombres completamente calificados.

El archivo [Main.java] es un archivo fuente compacto: no tiene declaración de paquete y por lo tanto pertenece al paquete sin nombre de la raíz de las fuentes. A partir de Java 22 (lanzador de programas de varios archivos, JEP 458), basta con el comando [java Main.java], ingresado en la carpeta [TaxV4], para ejecutar el programa: el lanzador de código fuente compila [Main.java] en memoria y, cada vez que encuentra una clase de otro archivo (por ejemplo, [dao.FileTax]), busca el archivo [dao/FileTax.java] a partir del directorio de [Main.java] y lo compila a su vez. No se escribe en el disco ningún archivo llamado [.class] . Una clase del paquete sin nombre puede usar clases de otros paquetes, pero lo inverso no es posible: ninguna clase puede importar [Main]. Por eso solo el programa principal se coloca allí.

Un IDE abre esta carpeta tal cual y ejecuta [Main.java] sin ninguna configuración especial. Cuando el programa requiera bibliotecas externas (Jackson, Spring), en la versión 5, pasaremos a un proyecto Maven.

6.3.2. Componentes de la aplicación

Image

Llamamos entidades a los tipos que abarcan varias capas. Generalmente son las clases que encapsulan los datos de la capa [dao]. Estas entidades suelen extenderse hasta la capa [ui]. Las entidades de la aplicación son el record [TaxBracket], ya presentado, y la excepción [TaxException], junto con su enumeración de códigos de error:

package entities;

import java.util.StringJoiner;

// los códigos de error de la capa [dao]: cada uno corresponde a un bit, por lo que pueden combinarse
public enum ErrorCode {
    ACCESS, LINE, FIELD1, FIELD2, FIELD3;

    // el bit del código: 1 para ACCESS, 2 para LINE, 4 para FIELD1, 8 para FIELD2, 16 para FIELD3
    public int bit() {
        return 1 << ordinal();
    }

    // los nombres de los códigos presentes en una combinación de bits, por ejemplo "FIELD2, FIELD3" para 24
    public static String names(int code) {
        StringJoiner names = new StringJoiner(", ");
        for (ErrorCode c : values()) {
            if ((code & c.bit()) != 0) {
                names.add(c.name());
            }
        }
        return names.toString();
    }
}
  • línea 6: una enumeración ([enum]). En Java, los valores de una enumeración son objetos (instancias únicas de la clase [ErrorCode]), y una enumeración puede tener métodos;
  • línea 7: los cinco códigos de error. El método [ordinal()], heredado de la clase [Enum], devuelve la posición del valor en la lista: 0 para [ACCESS], 4 para [FIELD3];
  • líneas 10–12: cada código se asocia a un bit, obtenido mediante un desplazamiento a la izquierda: [1 << ordinal()] es igual a 1, 2, 4, 8 y 16. Estas potencias de 2 pueden combinarse con el operador [|]: el código [FIELD2.bit() | FIELD3.bit()] (8 + 16 = 24) significa que los campos 2 y 3 de una línea son incorrectos. La versión 3 especificaba explícitamente el valor de cada código ([ACCESS(1)], [LINE(2)]…) y decodificaba una combinación en un conjunto [EnumSet]; calcular el bit a partir de la posición elimina aquí la necesidad de esos valores. El código de error de la excepción sigue siendo un simple entero, que pueden usar todas las implementaciones de la capa [dao];
  • líneas 15–23: el método estático [names] devuelve los nombres de los códigos presentes en una combinación de bits: “FIELD2, FIELD3” para 24. El método [values()], generado por el compilador, devuelve el arreglo de los valores de la enumeración; [code & c.bit()] no es nulo si el bit correspondiente al código [c] está presente en [code]; [name()] devuelve el nombre del valor. Un [StringJoiner] (Java 8) concatena cadenas, separándolas con el separador proporcionado a su constructor.
package entities;

import java.io.Serial;

// la excepción lanzada por la capa [dao]
// deriva de RuntimeException: es una excepción no verificada
public class TaxException extends RuntimeException {

    // versión de la clase para la serialización (una excepción es serializable)
    @Serial
    private static final long serialVersionUID = 1L;

    // código de error (una combinación de bits de ErrorCode)
    private final int code;

    // constructores
    public TaxException(String message, int code) {
        this(message, null, code);
    }

    public TaxException(String message, Throwable cause, int code) {
        super(message, cause);
        this.code = code;
    }

    // el código de error
    public int getCode() {
        return code;
    }
}
  • Línea 7: una excepción propia de la aplicación deriva de la clase [RuntimeException]; es una excepción no verificada. Los métodos que la lanzan no necesitan declararla en una cláusula [throws], y sus llamadores no están obligados a capturarla. Este es el enfoque habitual para los errores que una capa comunica a otra;
  • líneas 10–11: una excepción es serializable (la clase [Throwable] implementa la interfaz [Serializable]). El campo [serialVersionUID] especifica la versión de la clase para la serialización; sin él, el compilador, al usar la opción [-Xlint:all], emite una advertencia. La anotación [@Serial] (Java 14) permite que el compilador verifique la declaración de este campo;
  • línea 14: el código de error, un entero que combina bits de [ErrorCode]. El campo es [final]: se inicializa en el constructor y no puede cambiarse después;
  • líneas 17–24: dos constructores, uno con un mensaje y un código, y el otro con, además, la excepción original (la causa), que será accesible mediante el método [getCause()]. El primero llama al segundo ([this(...)]), que llama al constructor de la clase padre [RuntimeException] ([super(...)]);
  • líneas 27–29: el accesor del código de error.

En esta versión, solo la clase [FileTax] de la capa [dao] lanza [TaxException].

6.3.3. La capa [dao]

Repasemos la interfaz de la capa [dao]:

package dao;

import entities.TaxBracket;
import java.util.List;

// la interfaz de la capa [dao]
public interface ITaxDao {

    // los tramos del impuesto
    List<TaxBracket> getTaxBrackets();
}

Implementamos esta interfaz de dos maneras distintas. Primero, con la clase [HardwiredTax]:

package dao;

import entities.TaxBracket;
import java.math.BigDecimal;
import java.util.List;

// una capa [dao] cuyos datos están "fijos en el código"
public class HardwiredTax implements ITaxDao {

    // tramos del impuesto (baremo de 2004 sobre ingresos de 2003): una lista no modificable
    private final List<TaxBracket> taxBrackets = List.of(
            bracket("4962", "0", "0"),
            bracket("8382", "0.068", "291.09"),
            bracket("14753", "0.191", "1322.92"),
            bracket("23888", "0.283", "2668.39"),
            bracket("38868", "0.374", "4846.98"),
            bracket("47932", "0.426", "6883.66"),
            bracket("0", "0.481", "9505.54"));

    @Override
    public List<TaxBracket> getTaxBrackets() {
        return taxBrackets;
    }

    // un tramo construido a partir de cadenas: los valores BigDecimal son exactos
    private static TaxBracket bracket(String limit, String coeffR, String coeffN) {
        return new TaxBracket(new BigDecimal(limit), new BigDecimal(coeffR), new BigDecimal(coeffN));
    }
}
  • línea 8: la clase [HardwiredTax] implementa ([implements]) la interfaz [ITaxDao];
  • líneas 11–18: los tramos impositivos. [List.of] (Java 9) crea una lista de solo lectura: sus métodos [add], [set] o [remove] lanzan [UnsupportedOperationException]. El campo se inicializa en su declaración;
  • líneas 20–23: la implementación del método de la interfaz. La anotación [@Override] indica al compilador que verifique que el método implemente correctamente un método de la interfaz: un error tipográfico en su nombre provocaría un error de compilación;
  • Líneas 26–28: un método privado que crea un tramo impositivo a partir de tres cadenas. Un [BigDecimal] construido a partir de una cadena es exacto: [new BigDecimal("0.068")] es exactamente 0.068, mientras que [new BigDecimal(0.068)] sería 0.0680000000000000049…, que es el [double] más cercano a 0.068.

La interfaz [ITaxDao] también la implementa la clase [FileTax], que lee los tramos impositivos de un archivo de texto. El archivo [TaxData.txt] es el siguiente:

1
2
3
4
5
6
7
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54

Cada línea describe un tramo impositivo con el formato [limit:coeffR:coeffN]. Los números se escriben con punto decimal, sin importar el idioma del sistema; esto garantiza que el archivo sea legible en todas las máquinas. Los valores son los del baremo fiscal de 2004 para los ingresos de 2003, conservados tal cual: se trata de un ejercicio. La clase [FileTax] es la siguiente:

package dao;

import static entities.ErrorCode.ACCESS;
import static entities.ErrorCode.FIELD1;
import static entities.ErrorCode.FIELD2;
import static entities.ErrorCode.FIELD3;
import static entities.ErrorCode.LINE;

import entities.TaxException;
import entities.TaxBracket;
import java.io.IOException;
import java.math.BigDecimal;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;

// una capa [dao] que lee los tramos del impuesto de un archivo de texto
// una línea por tramo: limit:coeffR:coeffN (punto decimal)
public class FileTax implements ITaxDao {

    // archivo de datos, relativo a la carpeta actual
    private final String fileName;

    // tramos del impuesto
    private final List<TaxBracket> taxBrackets;

    // constructor
    public FileTax(String fileName) {
        // almacenamos el nombre del archivo
        this.fileName = fileName;
        // los tramos leídos
        List<TaxBracket> brackets = new ArrayList<>();
        // lectura del archivo línea por línea
        int lineNumber = 0;
        try {
            Path path = Path.of(fileName);
            if (!Files.exists(path)) {
                throw new NoSuchFileException(fileName, null, "The file [" + fileName + "] does not exist");
            }
            for (String lineRead : Files.readAllLines(path)) {
                lineNumber++;
                // las líneas vacías se ignoran
                String line = lineRead.strip();
                if (line.isEmpty()) {
                    continue;
                }
                // línea dividida en tres campos separados por :
                String[] fields = line.split("\\s*:\\s*");
                int code = 0;
                BigDecimal limit = null, coeffR = null, coeffN = null;
                if (fields.length != 3) {
                    code = LINE.bit();
                } else {
                    // conversiones de los 3 campos: cada error agrega su bit al código
                    limit = parse(fields[0]);
                    coeffR = parse(fields[1]);
                    coeffN = parse(fields[2]);
                    if (limit == null) code |= FIELD1.bit();
                    if (coeffR == null) code |= FIELD2.bit();
                    if (coeffN == null) code |= FIELD3.bit();
                }
                // ¿error?
                if (code != 0) {
                    throw new TaxException("Line no. " + lineNumber + " is incorrect: [" + line + "]", code);
                }
                // almacenamos el nuevo tramo del impuesto
                brackets.add(new TaxBracket(limit, coeffR, coeffN));
            }
        } catch (IOException e) {
            // error de acceso al archivo: se envuelve en una TaxException
            throw new TaxException("Error while reading the file " + fileName, e, ACCESS.bit());
        }
        // devolvemos una copia no modificable de la lista
        taxBrackets = List.copyOf(brackets);
    }

    public String getFileName() {
        return fileName;
    }

    @Override
    public List<TaxBracket> getTaxBrackets() {
        return taxBrackets;
    }

    // un número positivo o cero escrito con dígitos y un punto decimal; null si es incorrecto
    private static BigDecimal parse(String field) {
        return field.matches("\\d+(\\.\\d+)?") ? new BigDecimal(field) : null;
    }
}
  • Líneas 3–7: la importación estática ([import static], Java 5) permite usar los miembros estáticos de una clase sin anteponerles el nombre de la clase. Los valores de un enum son miembros estáticos: escribimos [FIELD1] en lugar de [ErrorCode.FIELD1];
  • línea 21: la clase [FileTax] implementa la interfaz [ITaxDao];
  • Líneas 24, 27: el nombre del archivo y los tramos leídos. Estos campos [final] se inicializan una sola vez, en el constructor (líneas 32 y 76). Se devuelven mediante los métodos de las líneas 79–86; [getTaxBrackets] es el método de la interfaz;
  • línea 30: el constructor recibe el nombre del archivo de tramos impositivos;
  • línea 34: los tramos impositivos leídos se acumulan en una lista llamada [ArrayList];
  • línea 38: [Path.of] (Java 11) crea la ruta del archivo. Una ruta relativa es relativa al directorio actual, aquel en el que se ingresó el comando [java];
  • Líneas 39–41: si el archivo no existe, se lanza una [NoSuchFileException] (paquete [java.nio.file]) con un mensaje explícito. Su constructor de tres parámetros recibe el nombre del archivo, el nombre de un posible segundo archivo (aquí, [null]) y el motivo del error. Sin esta comprobación, [Files.readAllLines] lanzaría por sí mismo una [NoSuchFileException] cuyo mensaje consistiría únicamente en el nombre del archivo;
  • Línea 42: [Files.readAllLines] lee todo el archivo en UTF-8 y devuelve una lista de sus líneas. El método abre y cierra el archivo por sí mismo. Para un archivo grande, sería preferible leerlo progresivamente con [Files.lines] o [BufferedReader];
  • línea 45: [strip()] (Java 11) elimina los espacios iniciales y finales;
  • línea 50: la línea se divide con [split], cuyo parámetro es una expresión regular: el separador es un signo de dos puntos, posiblemente rodeado de espacios ([\s*] coincide con cero o más espacios). En una cadena de Java, la barra invertida se duplica;
  • Líneas 53–54: una línea que no tiene tres campos no es válida;
  • líneas 57–62: conversión de los tres campos. Cada campo incorrecto agrega un bit al código de error mediante el operador [|=];
  • líneas 65–67: una línea no válida provoca una [TaxException], cuyo mensaje indica el número y el contenido de la línea. Esta excepción no es una [IOException]: no se captura en la línea 71 y se propaga tal cual a quien realizó la llamada;
  • línea 69: el tramo leído se agrega a la lista;
  • líneas 71–74: todos los errores de E/S derivan de [IOException]: archivo no encontrado ([NoSuchFileException]), permisos insuficientes ([AccessDeniedException]), archivo que no está en UTF-8 ([MalformedInputException]), etc. El error se encapsula en una [TaxException] con el código [ACCESS]; la excepción original se conserva como causa;
  • línea 76: [List.copyOf] (Java 10) devuelve una copia de solo lectura de la lista;
  • Líneas 89–91: conversión de un campo a [BigDecimal]. El método [matches] verifica que toda la cadena se ajuste a la expresión regular [\d+(\.\d+)?]: uno o más dígitos, seguidos opcionalmente de un punto y más dígitos. Así, “0,191” se rechaza, al igual que cualquier número negativo. El constructor [BigDecimal(String)] no depende del idioma del usuario: siempre espera un punto decimal. En caso de error, el método devuelve [null].

6.3.4. La capa [business]

Repasemos la interfaz de esta capa:

1
2
3
4
5
6
7
package business;

// la interfaz de la capa [business]
public interface ITaxBusiness {

    int calculateTax(boolean married, int nbChildren, int salary);
}

Su implementación, [TaxBusiness], es la siguiente:

package business;

import dao.ITaxDao;
import entities.TaxBracket;
import java.math.BigDecimal;
import java.math.MathContext;
import java.util.List;

// la capa [business] recibe la capa [dao] a través de su constructor
public class TaxBusiness implements ITaxBusiness {

    // los tramos del impuesto, solicitados una sola vez a la capa [dao]
    private final List<TaxBracket> brackets;

    // constructor
    public TaxBusiness(ITaxDao dao) {
        brackets = dao.getTaxBrackets();
    }

    // cálculo del impuesto
    @Override
    public int calculateTax(boolean married, int nbChildren, int salary) {
        // verificación de los parámetros
        if (nbChildren < 0) {
            throw new IllegalArgumentException("nbChildren (" + nbChildren + ") must be positive or zero");
        }
        if (salary < 0) {
            throw new IllegalArgumentException("salary (" + salary + ") must be positive or zero");
        }
        // número de partes
        BigDecimal shares = BigDecimal.valueOf(nbChildren).divide(BigDecimal.TWO)
                .add(BigDecimal.valueOf(married ? 2 : 1));
        if (nbChildren >= 3) {
            shares = shares.add(new BigDecimal("0.5"));
        }
        // ingreso gravable y cociente familiar
        BigDecimal income = new BigDecimal("0.72").multiply(BigDecimal.valueOf(salary));
        BigDecimal qf = income.divide(shares, MathContext.DECIMAL128);
        // el tramo: el primero cuyo límite es mayor o igual que QF,
        // el último si ninguno encaja (no se usa su límite)
        TaxBracket bracket = brackets.getLast();
        for (int i = 0; i < brackets.size() - 1; i++) {
            if (qf.compareTo(brackets.get(i).limit()) <= 0) {
                bracket = brackets.get(i);
                break;
            }
        }
        // impuesto (parte entera)
        return income.multiply(bracket.coeffR()).subtract(shares.multiply(bracket.coeffN())).intValue();
    }
}
  • Línea 10: la clase [TaxBusiness] implementa la interfaz [ITaxBusiness]. La capa [business] debe colaborar con la capa [dao]: por ello recibe, mediante su constructor (línea 16), una referencia al objeto que implementa la interfaz [ITaxDao];
  • Líneas 13, 16–18: al construirse el objeto, la capa [business] solicita los tramos impositivos a la capa [dao] de una vez por todas y los almacena en un campo [final]. Observe que la capa [business] conoce la capa [dao] solo a través de su interfaz [ITaxDao]: no sabe si los tramos impositivos provienen del código, de un archivo o, más adelante, de una base de datos;
  • líneas 24–29: la capa [business] no confía en quienes la invocan. Un parámetro incorrecto provoca una [IllegalArgumentException], la excepción no verificada que Java prevé para este caso, con un mensaje que identifica el parámetro;
  • líneas 31–35: el número de partes. Un [BigDecimal] no tiene operadores aritméticos: en su lugar, se usan sus métodos [add], [subtract], [multiply], y [divide] . Como es inmutable, cada operación devuelve un nuevo objeto, de ahí la notación [shares = shares.add(...)]. La división entre [BigDecimal.TWO] (una constante agregada en Java 19) es exacta: 3 hijos dan como resultado 1.5 partes;
  • líneas 37–38: la renta imponible y el cociente familiar. La división entre el número de partes puede producir una cantidad infinita de decimales (la división entre 3, por ejemplo): sin una precisión especificada, [divide] lanzaría entonces una [ArithmeticException]. [MathContext.DECIMAL128] limita el resultado a 34 dígitos significativos;
  • líneas 41–47: buscamos el primer tramo cuyo umbral sea mayor o igual que el cociente familiar. Los valores [BigDecimal] se comparan con [compareTo], que devuelve un número negativo, cero o positivo: [qf.compareTo(limit) <= 0] significa [qf <= limit]. El último tramo, [brackets.getLast()] (Java 21), se usa si ninguno de los demás corresponde: su umbral (0) no se utiliza;
  • línea 49: el impuesto. [intValue()] devuelve la parte entera del resultado.

Un método que antes era común consistía en modificar el límite del último tramo (algo como [brackets[brackets.length - 1].setLimit(qf + 1)]) antes de la búsqueda, para que el bucle de búsqueda siempre se detuviera. Esta instrucción modificaba el arreglo proporcionado por la capa [dao]: un efecto secundario sobre datos compartidos por todas las capas. Ya no podríamos escribirla aquí, porque un [TaxBracket] no es modificable, como tampoco lo es la lista que los contiene. El código moderno simplemente toma el último tramo cuando ningún límite es adecuado, sin modificar los datos que recibe.

6.3.5. La capa [ui]

En las versiones 2 y 3, la interfaz de usuario se escribía en el programa principal, tras la creación del objeto de cálculo. La única diferencia estaba en la forma de crear este objeto. Ahora aislamos esta interacción en una clase dentro de la capa [ui], que conoce la capa [business] solo a través de su interfaz:

package ui;

import business.ITaxBusiness;

// el diálogo por consola con el usuario: solo conoce la interfaz de la capa [business]
public final class Dialog {

    // ayuda mostrada en caso de entrada incorrecta
    private static final String SYNTAX = """
            syntax: Married NbChildren Salary
            Married: y for married, n for not married
            NbChildren: number of children
            Salary: annual salary in euros""";

    // clase de utilidad: sin instancias
    private Dialog() {
    }

    // bucle de diálogo: ingreso de los parámetros, cálculo, visualización
    public static void run(ITaxBusiness business) {
        while (true) {
            // pedimos los parámetros del cálculo del impuesto
            String input = IO.readln("Tax calculation parameters in the format: "
                    + "Married (y/n) NbChildren Salary, or nothing to stop: ");
            String parameters = input == null ? "" : input.strip();
            // ¿algo que hacer?
            if (parameters.isEmpty()) {
                break;
            }
            // verificación del número de parámetros
            String[] fields = parameters.split("\\s+");
            if (fields.length != 3) {
                IO.println(SYNTAX);
                continue;
            }
            // married
            String married = fields[0].toLowerCase();
            if (!married.equals("y") && !married.equals("n")) {
                IO.println(SYNTAX + "\nIncorrect Married argument: type y or n");
                continue;
            }
            // número de hijos
            int nbChildren = integer(fields[1]);
            if (nbChildren < 0) {
                IO.println(SYNTAX + "\nIncorrect NbChildren argument: type a positive or zero integer");
                continue;
            }
            // salary
            int salary = integer(fields[2]);
            if (salary < 0) {
                IO.println(SYNTAX + "\nIncorrect Salary argument: type a positive or zero integer");
                continue;
            }
            // los parámetros son correctos: le pedimos el cálculo a la capa [business]
            IO.println("Tax=" + business.calculateTax(married.equals("y"), nbChildren, salary) + " euros");
        }
    }

    // un entero positivo o cero, -1 si la cadena no lo es
    private static int integer(String field) {
        try {
            return Integer.parseInt(field);
        } catch (NumberFormatException e) {
            return -1;
        }
    }
}
  • Línea 6: la clase [Dialog] no tiene estado propio y contiene únicamente miembros estáticos. Java no tiene clases estáticas de nivel superior: declaramos la clase [final] (de la que no se puede derivar) y le damos un constructor privado (líneas 16–17), que impide la creación de instancias;
  • líneas 9–13: el mensaje de ayuda es un bloque de texto (Java 15), delimitado por tres comillas. Puede abarcar varias líneas; se elimina la sangría estándar de las líneas. Como las comillas de cierre se colocan al final de la última línea, el texto no termina con un salto de línea;
  • línea 20: el método [run] recibe la capa [business] en forma de su interfaz [ITaxBusiness]. No sabe nada de la clase que la implementa ni de la capa [dao];
  • Líneas 23–25: [IO.readln] (Java 25) imprime su parámetro y luego lee una línea del teclado. Devuelve [null] al final del flujo de entrada; la línea 25 reemplaza entonces [null] por la cadena vacía: una señal de fin de flujo termina el diálogo igual que una línea vacía;
  • línea 31: la línea ingresada se divide por espacios; la expresión regular [\s+] (uno o más espacios) ignora los espacios múltiples;
  • líneas 37–38: las cadenas se comparan con [equals], nunca con [==], que compara referencias;
  • líneas 43–53: el número de hijos y el salario deben ser enteros positivos o cero. El método [integer] (líneas 60–66) devuelve -1 si el campo no es un entero: [Integer.parseInt] lanza entonces una [NumberFormatException], que se intercepta. Un número negativo y una entrada incorrecta se rechazan así con la misma verificación;
  • línea 55: los parámetros son correctos: se solicita el cálculo a la capa [business].

6.3.6. Integración de las capas

Solo falta crear las capas y enlazarlas entre sí. Esta es la función del programa principal [Main.java]:

import dao.FileTax;
import dao.HardwiredTax;
import dao.ITaxDao;
import entities.ErrorCode;
import entities.TaxException;
import business.ITaxBusiness;
import business.TaxBusiness;
import ui.Dialog;

// integración de las capas: es el único lugar donde se nombran las clases de implementación
// argumento: "hardwired" para HardwiredTax,
// de lo contrario el nombre del archivo leído por FileTax (TaxData.txt por defecto)
void main(String[] args) {
    String source = args.length > 0 ? args[0] : "TaxData.txt";
    ITaxBusiness business;
    try {
        // creación de la capa [dao]
        ITaxDao dao = source.equals("hardwired") ? new HardwiredTax() : new FileTax(source);
        // creación de la capa [business], que recibe la capa [dao]
        business = new TaxBusiness(dao);
    } catch (TaxException e) {
        // visualización del error y detención del programa con el código de salida 1
        String origin = e.getCause() == null ? "" : ", original exception: " + e.getCause().getMessage();
        IO.println("The following error occurred: [Code=" + ErrorCode.names(e.getCode())
                + ", Message=" + e.getMessage() + origin + "]");
        System.exit(1);
        return;
    }

    // la capa [ui]: el diálogo con el usuario
    Dialog.run(business);
}
  • Líneas 1–8: un archivo fuente compacto (Java 25) no tiene declaración de clase, pero puede contener importaciones. El compilador coloca su contenido en una clase implícita;
  • línea 13: el método [main] recibe los argumentos de la línea de comandos en el arreglo [args]. El argumento selecciona la implementación de la capa [dao]: [hardwired] para la clase [HardwiredTax]; en caso contrario, el nombre del archivo leído por la clase [FileTax], [TaxData.txt] por defecto;
  • línea 18: creación de la capa [dao]. Este es el único lugar del programa donde se nombran las clases [HardwiredTax] y [FileTax] ;
  • línea 20: creación de la capa [business], que recibe la capa [dao];
  • Líneas 21–28: la creación de la capa [dao] puede provocar la creación de una [TaxException]. En ese caso se muestra el error, junto con el mensaje de la excepción original (si la hay), y el programa termina con el código de salida 1 ([System.exit(1)]). El código de error se muestra en texto claro mediante el método [ErrorCode.names]. La instrucción [return] de la línea 27 nunca se ejecuta, pero el compilador no sabe que [System.exit] no devuelve el control: sin ella, el compilador informaría que la variable [business] podría no estar inicializada en la línea 31;
  • Línea 31: las capas están listas: la capa [ui] interactúa con el usuario.

6.3.7. Ejecuciones

En la carpeta [TaxV4], con el archivo [TaxData.txt] (implementación [FileTax]), y al probar la validación de las entradas:

> java Main.java
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 3 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: x 2 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect Married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y -2 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000€
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect Salary argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Con la implementación [HardwiredTax]:

1
2
3
4
5
6
> java Main.java hardwired
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Con un archivo que no existe:

> java Main.java TaxDataMissing.txt
The following error occurred: [Code=ACCESS, Message=Error while reading the file TaxDataMissing.txt, original exception: TaxDataMissing.txt: The file [TaxDataMissing.txt] does not exist]

El código de error es [ACCESS], y se muestra el mensaje de la excepción original, [NoSuchFileException]: consiste en el nombre del archivo, seguido del motivo proporcionado a su constructor.

Con el siguiente archivo, [TaxDataInvalid.txt], donde la línea 3 contiene comas decimales:

1
2
3
4
4962:0:0
8382:0.068:291.09
14753:0,191:1322,92
23888:0.283:2668.39

el resultado es:

> java Main.java TaxDataInvalid.txt
The following error occurred: [Code=FIELD2, FIELD3, Message=Line no. 3 is incorrect: [14753:0,191:1322,92]]

Los campos 2 y 3 de la línea 3 son incorrectos: el código de error combina los bits de [FIELD2] y [FIELD3], y el método [ErrorCode.names] lo muestra como “FIELD2, FIELD3”.

6.3.8. Conclusión

La arquitectura en capas y el uso de interfaces han aportado cierta flexibilidad a nuestra aplicación. Esto se aprecia en la forma en que el programa principal crea las capas [dao] y [business]:

1
2
3
4
        // creación de la capa [dao]
        ITaxDao dao = source.equals("hardwired") ? new HardwiredTax() : new FileTax(source);
        // creación de la capa [business], que recibe la capa [dao]
        business = new TaxBusiness(dao);

Cambiar la implementación de la capa [dao] afecta únicamente a la línea 2. Una vez creadas las capas, el código de la capa [ui] es el mismo en ambos casos: allí se manipula la capa [business] a través de su interfaz [ITaxBusiness], y no de su clase de implementación.

La misma flexibilidad se aprecia en la capa [business]: se construye a partir de una referencia a la interfaz de la capa [dao]. Por lo tanto, cambiar la implementación de esta última no tiene ningún efecto en la capa [business]. Por eso nuestra única clase [TaxBusiness] pudo funcionar sin modificaciones con dos implementaciones distintas de la capa [dao].

6.4. Aplicación de ejemplo: versión 5

Image

Esta nueva versión se basa en la anterior con los siguientes cambios:

  • Las capas [dao] y [business] se colocan cada una en un módulo Maven que genera una biblioteca (un archivo JAR) y se prueban con el framework de pruebas unitarias JUnit;
  • La capa [dao] incluye ahora una tercera implementación, [JsonTax], que lee los tramos impositivos de un archivo JSON con la biblioteca Jackson;
  • La integración de las capas la realiza el contenedor de inyección de dependencias de Spring, y la implementación de la capa [dao] se selecciona desde un archivo de configuración.

En los proyectos grandes, varios desarrolladores trabajan en la misma aplicación. Las arquitecturas en capas facilitan esta forma de trabajar: como las capas se comunican entre sí mediante interfaces bien definidas, un desarrollador que trabaja en una capa no tiene que preocuparse por el trabajo de otros desarrolladores en otras capas. Solo se requiere que todos respeten las interfaces.

Así, para probar la capa [business], el desarrollador necesita una implementación de la capa [dao]. Mientras esa implementación no esté terminada, puede usar una implementación ficticia de la capa [dao], siempre que respete la interfaz [ITaxDao]. Esta es otra ventaja de la arquitectura en capas: un retraso en la capa [dao] no impide probar la capa [business]. La implementación simulada (mock) tiene además la ventaja de ser mucho más sencilla de configurar que la capa [dao] real, que puede requerir un SGBD, conexiones de red, etc.

Una vez que la capa [dao] está terminada y probada, se entrega a los desarrolladores de la capa [business] en forma de biblioteca (un archivo JAR publicado en un repositorio Maven) y no como código fuente que se deba copiar. En definitiva, la aplicación se entrega como un programa principal (el de la capa [ui]) y bibliotecas de clases (las demás capas).

6.4.1. El proyecto Maven TaxV5

La versión 5 es un proyecto Maven de varios módulos: un proyecto padre, que no produce nada por sí mismo, contiene tres módulos, uno por capa. Las pruebas no forman un proyecto aparte: la convención de Maven coloca las pruebas de un módulo en su carpeta [src/test/java]. Maven las compila y las ejecuta, pero no forman parte del archivo JAR del módulo. Esto da como resultado la siguiente estructura de directorios:

TaxV5/
  pom.xml                          parent project
  tax-dao/                         module: entities and [dao] layer (jar)
    pom.xml
    TaxData.txt
    TaxData.json
    TaxDataInvalid.txt             an incorrect brackets file, for the tests
    src/main/java/tax/entities/
      TaxBracket.java
      TaxException.java
    src/main/java/tax/dao/
      ITaxDao.java
      HardwiredTax.java
      FileTax.java
      JsonTax.java
    src/test/java/tax/dao/
      DaoTests.java                JUnit tests
      TrialDao.java                trial program
  tax-business/                    module: [business] layer (jar)
    pom.xml
    src/main/java/tax/business/
      ITaxBusiness.java
      TaxBusiness.java
    src/test/java/tax/business/
      BusinessTests.java           JUnit tests
      TrialBusiness.java           trial program
  tax-ui/                          module: [ui] layer and integration of the layers
    pom.xml
    tax.properties                 configuration files
    tax-json.properties
    tax-hardwired.properties
    tax-error.properties
    TaxData.txt
    TaxData.json
    src/main/java/tax/ui/
      Dialog.java
      Main.java
      TaxConfig.java
      MainConfig.java

Los paquetes ahora tienen el prefijo [tax]: [tax.entities], [tax.dao], [tax.business], [tax.ui]. Los módulos [tax-dao] y [tax-business] de hecho serán reutilizados por otros proyectos (capítulos 10 a 13), y dos bibliotecas utilizadas por el mismo programa no deben definir dos clases con el mismo nombre completamente calificado. En los proyectos profesionales, los paquetes llevan como prefijo el nombre de dominio invertido de la organización ([org.springframework], [tools.jackson]…), lo que garantiza nombres únicos.

El archivo [pom.xml] del proyecto padre es el siguiente:

<?xml version="1.0" encoding="UTF-8"?>
<!-- proyecto padre de la aplicación [Tax], versión 5: un módulo Maven por capa -->
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>examples.tax</groupId>
    <artifactId>tax-v5</artifactId>
    <version>5.0</version>
    <packaging>pom</packaging>

    <!-- los módulos, en el orden de sus dependencias -->
    <modules>
        <module>tax-dao</module>
        <module>tax-business</module>
        <module>tax-ui</module>
    </modules>

    <properties>
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- las versiones de las bibliotecas, comunes a todos los módulos -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>examples.tax</groupId>
                <artifactId>tax-dao</artifactId>
                <version>5.0</version>
            </dependency>
            <dependency>
                <groupId>examples.tax</groupId>
                <artifactId>tax-business</artifactId>
                <version>5.0</version>
            </dependency>
            <dependency>
                <groupId>tools.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>3.1.5</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>7.0.9</version>
            </dependency>
            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter</artifactId>
                <version>6.0.3</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- JUnit para las pruebas de todos los módulos -->
    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.15.0</version>
                    <configuration>
                        <!-- conserva los nombres de los parámetros de los métodos en el código compilado -->
                        <parameters>true</parameters>
                        <compilerArgs>
                            <arg>-Xlint:all</arg>
                        </compilerArgs>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>3.5.6</version>
                </plugin>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>exec-maven-plugin</artifactId>
                    <version>3.5.1</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>
  • Líneas 8–11: los datos del proyecto padre: grupo [examples.tax], nombre [tax-v5], versión [5.0]. El tipo de empaquetado [pom] indica que el proyecto no produce un archivo JAR: simplemente agrupa módulos y les aplica una configuración común;
  • líneas 14–18: los módulos, es decir, las subcarpetas, cada una de las cuales contiene un proyecto Maven. Un comando Maven ingresado en la carpeta [TaxV5] se aplica a todos los módulos, en el orden que dictan sus dependencias: [tax-dao], luego [tax-business], luego [tax-ui];
  • líneas 20–23: las propiedades heredadas por los módulos: Java 25 y archivos fuente en UTF-8;
  • líneas 26–54: la sección [dependencyManagement] especifica las versiones de las dependencias sin agregarlas a los módulos. Un módulo que necesita una dependencia la declara sin versión; así, todas las versiones quedan reunidas en un solo lugar. Incluye los propios módulos de la aplicación (líneas 28–37), Jackson 3 (líneas 38–42), el contenedor Spring (líneas 43–47) y JUnit (líneas 48–52);
  • líneas 57–63: la sección [dependencies] del padre agrega sus dependencias a todos los módulos: en este caso, JUnit, con el alcance [test]. Una dependencia con el alcance [test] se usa solo para compilar y ejecutar las pruebas: no se incluye en las dependencias de la biblioteca producida;
  • líneas 66–91: la sección [pluginManagement] fija de manera similar la versión y la configuración de los plugins de Maven para todos los módulos: el compilador (con la opción [-Xlint:all], líneas 75–77), Surefire, que ejecuta las pruebas ([mvn test]), y exec, que ejecuta un programa ([mvn exec:java]). La línea 74 indica al compilador que conserve los nombres de los parámetros de los métodos en el código compilado: JUnit lo usa para mostrar las pruebas parametrizadas, como veremos.

La aplicación se construye con el siguiente comando, ingresado en la carpeta [TaxV5]:

> mvn install

Para cada módulo, Maven ejecuta las fases de su ciclo de vida en el siguiente orden: compilación ([compile]), compilación y ejecución de las pruebas ([test]), creación del archivo JAR en la carpeta [target] del módulo ([package]) y, por último, instalación ([install]). Si una prueba falla, la construcción se detiene. La fase [install] copia el archivo JAR y el archivo [pom.xml] de cada módulo en el repositorio Maven local del usuario, la carpeta [~/.m2/repository]: allí se encuentra, por ejemplo, el archivo [examples/tax/tax-dao/5.0/tax-dao-5.0.jar]. Maven busca las dependencias en este repositorio local antes de descargarlas de Maven Central. Este repositorio local cumple dos funciones:

  • un comando Maven ingresado en la carpeta de un módulo (por ejemplo, [mvn exec:java] en la carpeta [tax-ui]) encuentra en el repositorio local los módulos de los que depende ese módulo;
  • las aplicaciones de los capítulos 10 a 13 declaran en sus archivos [pom.xml] dependencias de [examples.tax:tax-dao:5.0], [examples.tax:tax-business:5.0] y, para la clase [Dialog], de [examples.tax:tax-ui:5.0]: así reutilizan las capas de la versión 5 sin copiar el código fuente, igual que usarían Jackson o Spring.

Después de hacer cualquier cambio en un módulo, hay que volver a ejecutar [mvn install] para que los demás proyectos vean la nueva versión. La opción [-DskipTests] omite la ejecución de las pruebas, y la opción [-q] (“quiet”) limita la salida de Maven a los errores.

Si abre en el IDE un proyecto que depende de estos módulos antes de instalar la versión 5, Maven los buscará en vano en Maven Central, y el IDE informará dependencias no resueltas, por ejemplo, “Unresolved dependency: 'examples.tax:tax-dao:jar:5.0' ” en IntelliJ IDEA. Maven deja constancia de este fallo: deja archivos llamados [*.lastUpdated] en la carpeta de cada módulo dentro del repositorio local ([%USERPROFILE%\.m2\repository\examples\tax\tax-dao\5.0], etc.), y el error puede persistir después de la construcción con [mvn install]. La solución:

  • Instale la versión 5 ([mvn install] en la carpeta [TaxV5] o, en IntelliJ, el panel “Maven” / [tax-v5] / “Lifecycle ” / [install]);
  • elimine los archivos [*.lastUpdated] de las carpetas [tax-dao/5.0], [tax-business/5.0] y [tax-ui/5.0] del repositorio local, sin tocar los archivos [.jar] y [.pom];
  • vuelva a sincronizar los proyectos (con el botón “Sync All Maven Projects” del panel “Maven”) y, si el error persiste, borre las cachés de IntelliJ (“File / Invalidate Caches… / Invalidate and Restart”).

Para determinar si el problema proviene de Maven o del IDE, escriba [mvn compile] en la carpeta del proyecto que depende de la versión 5: si Maven responde “BUILD SUCCESS”, las dependencias son correctas y solo hay que volver a sincronizar el IDE.

6.4.2. La capa [dao]

El módulo [tax-dao] contiene la capa [dao] y las entidades de la aplicación. Su archivo [pom.xml] es el siguiente:

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- el proyecto padre proporciona las versiones y la configuración comunes -->
    <parent>
        <groupId>examples.tax</groupId>
        <artifactId>tax-v5</artifactId>
        <version>5.0</version>
    </parent>

    <artifactId>tax-dao</artifactId>

    <dependencies>
        <!-- Jackson para leer el archivo JSON -->
        <dependency>
            <groupId>tools.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
    </dependencies>

</project>
  • líneas 8–12: el proyecto padre. El módulo hereda de él el grupo y la versión; solo se especifica su nombre (línea 14). Por lo tanto, sus coordenadas son [examples.tax:tax-dao:5.0];
  • líneas 18–21: la dependencia de Jackson, sin versión: esta la determina el proyecto padre. JUnit se hereda del padre.

Las entidades

El record [TaxBracket] corresponde a la versión 4 (paquete [tax.entities]). Se elimina la enumeración [ErrorCode] : [TaxException] pasa así a ser común a todas las implementaciones de la capa [dao], sin estar ligada a los códigos de ninguna de ellas:

package tax.entities;

import java.io.Serial;

// la excepción de la aplicación [Tax], sea cual sea la capa que la lance
// deriva de RuntimeException: es una excepción no verificada
public class TaxException extends RuntimeException {

    // versión de la clase para la serialización (una excepción es serializable)
    @Serial
    private static final long serialVersionUID = 1L;

    // código de error
    private final int code;

    // constructores
    public TaxException(String message) {
        this(message, null, 0);
    }

    public TaxException(String message, Throwable cause) {
        this(message, cause, 0);
    }

    public TaxException(String message, int code) {
        this(message, null, code);
    }

    public TaxException(String message, Throwable cause, int code) {
        super(message, cause);
        this.code = code;
    }

    // el código de error
    public int getCode() {
        return code;
    }
}
  • línea 14: el código de error sigue siendo un simple entero: cada implementación de la capa [dao] define sus propios códigos;
  • líneas 17–32: cuatro constructores, con o sin causa, con o sin código. Todos llaman al último. Sin código, este es 0.

La implementación [FileTax]

La interfaz [ITaxDao] y la clase [HardwiredTax] son las de la versión 4. La clase [FileTax] solo difiere en la forma de escribir sus códigos de error:

// una capa [dao] que lee los tramos del impuesto de un archivo de texto
// una línea por tramo: limit:coeffR:coeffN (punto decimal)
public class FileTax implements ITaxDao {

    // códigos de error específicos de esta implementación: potencias de 2, que pueden combinarse
    public static final int ACCESS = 1, LINE = 2, FIELD1 = 4, FIELD2 = 8, FIELD3 = 16;

    // archivo de datos, relativo a la carpeta actual
    private final String fileName;

    // tramos del impuesto
    private final List<TaxBracket> taxBrackets;
  • Línea 6: los códigos de error, que antes estaban en la enumeración [ErrorCode] del paquete de entidades, pasan a ser constantes de la clase [FileTax]: en realidad, son códigos propios de esta implementación de la interfaz [ITaxDao] ([JsonTax] tiene los suyos). En Java, una constante es un campo [static final], cuyo nombre se escribe por convención en mayúsculas. Se pueden declarar varios campos del mismo tipo en una misma instrucción. Las constantes se escriben [FIELD1] dentro de la clase y [FileTax.FIELD1] fuera de ella. Las importaciones estáticas de la versión 4 ya no son necesarias.

Más adelante en el constructor:

                String[] fields = line.split("\\s*:\\s*");
                int code = 0;
                BigDecimal limit = null, coeffR = null, coeffN = null;
                if (fields.length != 3) {
                    code = LINE;
                } else {
                    // conversiones de los 3 campos: cada error agrega su código
                    limit = parse(fields[0]);
                    coeffR = parse(fields[1]);
                    coeffN = parse(fields[2]);
                    if (limit == null) code |= FIELD1;
                    if (coeffR == null) code |= FIELD2;
                    if (coeffN == null) code |= FIELD3;
                }
                // ¿error?
                if (code != 0) {
                    throw new TaxException("Line no. " + lineNumber + " is incorrect: [" + line + "]", code);
                }
                // almacenamos el nuevo tramo del impuesto
                brackets.add(new TaxBracket(limit, coeffR, coeffN));
            }
        } catch (IOException e) {
            // error de acceso al archivo: se envuelve en una TaxException
            throw new TaxException("Error while reading the file " + fileName, e, ACCESS);
        }
  • líneas 4–14: los códigos son enteros que se combinan directamente con el operador [|=];
  • Líneas 17, 24: los errores se encapsulan en una [TaxException], junto con sus códigos.

La implementación [JsonTax]

Al igual que la versión 3 del capítulo 5, la tercera implementación de la capa [dao] lee los tramos impositivos de un archivo JSON con la biblioteca Jackson. El archivo [TaxData.json] es el siguiente:

1
2
3
4
5
6
7
8
9
[
  { "limit": 4962, "coeffR": 0, "coeffN": 0 },
  { "limit": 8382, "coeffR": 0.068, "coeffN": 291.09 },
  { "limit": 14753, "coeffR": 0.191, "coeffN": 1322.92 },
  { "limit": 23888, "coeffR": 0.283, "coeffN": 2668.39 },
  { "limit": 38868, "coeffR": 0.374, "coeffN": 4846.98 },
  { "limit": 47932, "coeffR": 0.426, "coeffN": 6883.66 },
  { "limit": 0, "coeffR": 0.481, "coeffN": 9505.54 }
]

La clase [JsonTax] es la siguiente:

package tax.dao;

import tax.entities.TaxException;
import tax.entities.TaxBracket;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.util.List;
import tools.jackson.core.JacksonException;
import tools.jackson.databind.json.JsonMapper;

// una capa [dao] que lee los tramos del impuesto de un archivo JSON
public class JsonTax implements ITaxDao {

    // códigos de error específicos de esta implementación
    public static final int ACCESS = 1, FORMAT = 2;

    // archivo de datos, relativo a la carpeta actual
    private final String fileName;

    // tramos del impuesto
    private final List<TaxBracket> taxBrackets;

    // constructor
    public JsonTax(String fileName) {
        this.fileName = fileName;
        String json;
        try {
            Path path = Path.of(fileName);
            if (!Files.exists(path)) {
                throw new NoSuchFileException(fileName, null, "The file [" + fileName + "] does not exist");
            }
            json = Files.readString(path);
        } catch (IOException e) {
            throw new TaxException("Error while reading the file " + fileName, e, ACCESS);
        }
        try {
            // deserialización del arreglo JSON en un arreglo de records TaxBracket
            TaxBracket[] brackets = JsonMapper.builder().build().readValue(json, TaxBracket[].class);
            if (brackets == null) {
                throw new TaxException("the file does not contain an array");
            }
            taxBrackets = List.of(brackets);
        } catch (JacksonException | TaxException e) {
            throw new TaxException("The file " + fileName
                    + " is not a valid JSON file of tax brackets", e, FORMAT);
        }
    }

    public String getFileName() {
        return fileName;
    }

    @Override
    public List<TaxBracket> getTaxBrackets() {
        return taxBrackets;
    }
}
  • Línea 17: códigos de error de esta implementación: error de acceso al archivo o contenido incorrecto;
  • Líneas 29–37: el archivo se lee completo en una cadena con [Files.readString] (Java 11), con el mismo manejo de errores de E/S que en [FileTax];
  • línea 40: la cadena JSON se convierte en un arreglo [TaxBracket[]]. En Jackson 3, cuyos paquetes comienzan con [tools.jackson], el objeto [JsonMapper] que realiza la conversión es inmutable: se construye mediante un objeto intermedio, el “builder” ([JsonMapper.builder()...build()]). Su método [readValue] recibe el texto JSON y la clase del objeto que se va a crear, en este caso [TaxBracket[].class]. Jackson sabe construir un record: asocia los nombres JSON ([limit], [coeffR], [coeffN]) con los componentes del record y llama a su constructor. Los números se leen directamente como [BigDecimal], el tipo del componente, sin pasar por un [double]: por lo tanto, son exactos;
  • líneas 41–43: [readValue] devuelve [null] si el archivo contiene el literal JSON [null]; en ese caso, se lanza una excepción;
  • línea 44: el arreglo se convierte en una lista inmutable;
  • líneas 45–48: un archivo que no es un arreglo JSON de tramos impositivos provoca una [JacksonException]. En Jackson 3, esta excepción deriva de [RuntimeException]: es una excepción no verificada. El bloque [catch] captura dos tipos de excepciones (“multi-catch”, Java 7) y las encapsula en una [TaxException] de tipo [FORMAT].

Un programa de prueba

Antes de escribir pruebas automatizadas, hagamos una primera prueba visual de la capa [dao]. El programa [TrialDao] muestra los tramos impositivos proporcionados por las tres implementaciones. Lo hemos colocado en las fuentes de prueba del módulo ([src/test/java]): no se incluirá en el archivo JAR de la capa [dao]:

package tax.dao;

import tax.entities.TaxException;
import tax.entities.TaxBracket;
import java.util.List;

// programa de prueba: los tramos del impuesto proporcionados por las tres implementaciones de la capa [dao]
public class TrialDao {

    public static void main(String[] args) {
        try {
            List<ITaxDao> daos = List.of(
                    new HardwiredTax(), new FileTax("TaxData.txt"), new JsonTax("TaxData.json"));
            for (ITaxDao dao : daos) {
                IO.println("--- " + dao.getClass().getSimpleName());
                for (TaxBracket bracket : dao.getTaxBrackets()) {
                    IO.println(bracket);
                }
            }
        } catch (TaxException e) {
            // visualización del error
            String origin = e.getCause() == null ? ""
                    : ", original exception: " + e.getCause().getMessage();
            IO.println("The following error occurred: [Code=" + e.getCode()
                    + ", Message=" + e.getMessage() + origin + "]");
        }
    }
}
  • línea 10: el método [main]. A partir de Java 25, ya no necesitaría ser público ni recibir argumentos del programa; en los proyectos Maven, conservamos su forma clásica [public static void main(String[] args)], que reconocen todas las herramientas (el plugin [exec-maven-plugin], los IDE);
  • líneas 12–13: una lista de las tres implementaciones de la interfaz [ITaxDao];
  • línea 15: [getClass()] devuelve la clase real del objeto, cuyo nombre (sin el paquete) es [getSimpleName()];
  • línea 17: [IO.println] muestra el tramo impositivo mediante su método [toString], que el compilador genera para un record;
  • líneas 20–26: maneja una posible [TaxException].

El programa se ejecuta en la carpeta [tax-dao]. La fase [test-compile] compila el código fuente principal y el código fuente de las pruebas; el parámetro [exec.mainClass] especifica la clase que se ejecutará, y [exec.classpathScope=test] indica al plugin exec que use las clases de prueba y las dependencias de alcance [test]:

> mvn -q test-compile exec:java -Dexec.mainClass=tax.dao.TrialDao -Dexec.classpathScope=test
--- HardwiredTax
TaxBracket[limit=4962, coeffR=0, coeffN=0]
TaxBracket[limit=8382, coeffR=0.068, coeffN=291.09]
TaxBracket[limit=14753, coeffR=0.191, coeffN=1322.92]
TaxBracket[limit=23888, coeffR=0.283, coeffN=2668.39]
TaxBracket[limit=38868, coeffR=0.374, coeffN=4846.98]
TaxBracket[limit=47932, coeffR=0.426, coeffN=6883.66]
TaxBracket[limit=0, coeffR=0.481, coeffN=9505.54]
--- FileTax
TaxBracket[limit=4962, coeffR=0, coeffN=0]
TaxBracket[limit=8382, coeffR=0.068, coeffN=291.09]
TaxBracket[limit=14753, coeffR=0.191, coeffN=1322.92]
TaxBracket[limit=23888, coeffR=0.283, coeffN=2668.39]
TaxBracket[limit=38868, coeffR=0.374, coeffN=4846.98]
TaxBracket[limit=47932, coeffR=0.426, coeffN=6883.66]
TaxBracket[limit=0, coeffR=0.481, coeffN=9505.54]
--- JsonTax
TaxBracket[limit=4962, coeffR=0, coeffN=0]
TaxBracket[limit=8382, coeffR=0.068, coeffN=291.09]
TaxBracket[limit=14753, coeffR=0.191, coeffN=1322.92]
TaxBracket[limit=23888, coeffR=0.283, coeffN=2668.39]
TaxBracket[limit=38868, coeffR=0.374, coeffN=4846.98]
TaxBracket[limit=47932, coeffR=0.426, coeffN=6883.66]
TaxBracket[limit=0, coeffR=0.481, coeffN=9505.54]

Las tres implementaciones devuelven los mismos tramos. El método [toString] de un [BigDecimal] siempre escribe un punto decimal, sin importar el idioma del usuario.

6.4.3. La capa [business]

El archivo [pom.xml] del módulo [tax-business] es el siguiente:

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- el proyecto padre proporciona las versiones y la configuración comunes -->
    <parent>
        <groupId>examples.tax</groupId>
        <artifactId>tax-v5</artifactId>
        <version>5.0</version>
    </parent>

    <artifactId>tax-business</artifactId>

    <dependencies>
        <!-- la capa [business] usa la capa [dao] -->
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-dao</artifactId>
        </dependency>
    </dependencies>

</project>
  • Líneas 18–21: la capa [business] utiliza la capa [dao]. En la carpeta [TaxV5], Maven construye [tax-dao] antes que [tax-business]; en la carpeta [tax-business], encuentra [tax-dao] en el repositorio local, donde lo colocó [mvn install]. Las dependencias son transitivas: el módulo también recibe Jackson, del que depende [tax-dao].

La interfaz [ITaxBusiness] y la clase [TaxBusiness] son las de la versión 4 (paquete [tax.business]). El programa de prueba [TrialBusiness], ubicado en las fuentes de prueba del módulo, realiza algunos cálculos de impuestos:

package tax.business;

import tax.dao.FileTax;
import tax.entities.TaxException;

// programa de prueba: algunos cálculos de impuesto con la capa [dao] FileTax
public class TrialBusiness {

    public static void main(String[] args) {
        try {
            // el archivo de tramos es el del módulo tax-dao (ruta relativa a la carpeta actual)
            ITaxBusiness business = new TaxBusiness(new FileTax("../tax-dao/TaxData.txt"));
            IO.println("Tax(true,2,60000)=" + business.calculateTax(true, 2, 60000) + " euros");
            IO.println("Tax(false,3,60000)=" + business.calculateTax(false, 3, 60000) + " euros");
            IO.println("Tax(false,3,6000)=" + business.calculateTax(false, 3, 6000) + " euros");
            IO.println("Tax(false,3,600000)=" + business.calculateTax(false, 3, 600000) + " euros");
        } catch (TaxException e) {
            // visualización del error
            String origin = e.getCause() == null ? ""
                    : ", original exception: " + e.getCause().getMessage();
            IO.println("The following error occurred: [Code=" + e.getCode()
                    + ", Message=" + e.getMessage() + origin + "]");
        }
    }
}
  • línea 12: creación de las capas [dao] y [business]. La capa [dao] se implementa con la clase [FileTax]. Como el programa se ejecuta en la carpeta [tax-business], la ruta relativa [../tax-dao/TaxData.txt] hace referencia al archivo de datos del módulo [tax-dao];
  • líneas 13–16: llamadas repetidas al único método de la interfaz [ITaxBusiness].

Resultados, en la carpeta [tax-business]:

1
2
3
4
5
> mvn -q test-compile exec:java -Dexec.mainClass=tax.business.TrialBusiness -Dexec.classpathScope=test
Tax(true,2,60000)=4282 euros
Tax(false,3,60000)=4282 euros
Tax(false,3,6000)=0 euros
Tax(false,3,600000)=179275 euros

Una pareja casada con 2 hijos y una persona soltera con 3 hijos tienen el mismo número de partes (3): sus impuestos son iguales.

6.4.4. Pruebas unitarias con JUnit

6.4.4.1. El principio

Las pruebas realizadas hasta ahora se basaban en la verificación visual: comprobábamos que la pantalla mostrara los resultados esperados. Este método es poco práctico cuando hay muchas pruebas que ejecutar: los humanos son propensos a la fatiga, y su capacidad para verificar resultados disminuye a medida que avanza el día. Por lo tanto, las pruebas deben automatizarse y no requerir ninguna intervención humana.

Una aplicación evoluciona con el tiempo. En cada actualización, debemos verificar que no “regrese” a un estado anterior, es decir, que siga superando las pruebas de funcionalidad realizadas durante su desarrollo inicial. Estas pruebas se denominan pruebas de no regresión. Una aplicación de tamaño moderado puede requerir cientos de pruebas: de hecho, se prueba cada método de cada clase de la aplicación. Estas son las llamadas pruebas unitarias.

Se han desarrollado frameworks para automatizar estas pruebas. En Java, el framework principal es JUnit, creado a finales de la década de 1990 por Kent Beck y Erich Gamma. Usamos la versión 6, publicada a finales de 2025 (aquí, la versión 6.0.3); su API, la incluida en el paquete [org.junit.jupiter.api], es la versión 5 de JUnit, también conocida como JUnit Jupiter (TestNG es otro framework basado en el mismo principio). Las pruebas se ejecutan con el comando [mvn test] desde la línea de comandos: esto es lo que permite lanzarlas automáticamente, por ejemplo, cada vez que se envían cambios de código a un servidor de integración continua. Los IDE (IntelliJ IDEA, VS Code con el Extension Pack for Java) también ejecutan estas pruebas y muestran sus resultados en una estructura de árbol.

6.4.4.2. Un primer ejemplo

Examinemos el principio de las pruebas JUnit con un ejemplo. El proyecto Maven [DemoTests] contiene solo pruebas, ubicadas en la carpeta [src/test/java/demotests]. Su archivo [pom.xml] es el siguiente:

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>examples.architectures</groupId>
    <artifactId>demo-tests</artifactId>
    <version>1.0</version>

    <properties>
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- JUnit Jupiter: la API de pruebas y el motor que las ejecuta -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>6.0.3</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.15.0</version>
                <configuration>
                    <parameters>true</parameters>
                    <compilerArgs>
                        <arg>-Xlint:all</arg>
                    </compilerArgs>
                </configuration>
            </plugin>
            <!-- mvn test: el plugin Surefire ejecuta las pruebas -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.5.6</version>
            </plugin>
        </plugins>
    </build>
</project>
  • líneas 18–23: el proyecto utiliza el artefacto [junit-jupiter], que incluye la API de pruebas (las anotaciones y la clase [Assertions]), el soporte para pruebas parametrizadas y el motor que descubre y ejecuta las pruebas. Su alcance es [test];
  • línea 33: el compilador conserva los nombres de los parámetros de los métodos, que JUnit muestra para las pruebas parametrizadas;
  • líneas 40–44: el plugin Surefire, que ejecuta las pruebas durante la fase [test] de Maven.

La clase de prueba [Tests1] es la siguiente:

package demotests;

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

// una clase de prueba
class Tests1 {

    // el método probado
    private static int sum(int a, int b) {
        return a + b;
    }

    // constructor
    Tests1() {
        IO.println("constructor");
    }

    // se ejecuta antes de cada prueba
    @BeforeEach
    void before() {
        IO.println("before");
    }

    // se ejecuta después de cada prueba
    @AfterEach
    void after() {
        IO.println("after");
    }

    // una prueba que tiene éxito
    @Test
    void t1() {
        IO.println("test1");
        assertEquals(4, sum(2, 2));
    }

    // una prueba que falla
    @Test
    void t2() {
        IO.println("test2");
        assertEquals(5, sum(2, 2), "2 + 2 is not equal to 5");
    }
}
  • Línea 3: los métodos de verificación, o aserciones, son métodos estáticos de la clase [Assertions]. Se importan mediante una importación estática para poder escribir [assertEquals(...)] en lugar de [Assertions.assertEquals(...)];
  • línea 10: una clase de prueba es una clase normal, sin anotaciones. No necesita ser pública, ni sus métodos tampoco: la visibilidad de paquete es suficiente;
  • líneas 13–15: el método que se prueba. En un proyecto real, estaría en el código fuente principal del proyecto ([src/main/java]);
  • líneas 18–20: el constructor. Solo sirve para mostrar un mensaje en pantalla: queremos ver cuándo se ejecuta;
  • línea 23: la anotación [@BeforeEach] designa un método que se ejecuta antes de cada prueba;
  • línea 29: la anotación [@AfterEach] designa un método que se ejecuta después de cada prueba;
  • línea 35: la anotación [@Test] designa un método de prueba. Un método de prueba no devuelve nada, no es privado y —con una excepción que veremos— no tiene parámetros;
  • línea 38: el método [assertEquals(expected, actual)] verifica que el valor obtenido sea igual al valor esperado. Si no es así, lanza una excepción [AssertionFailedError] y la prueba falla. Aquí, la aserción debe cumplirse;
  • línea 45: esta aserción debe fallar. El tercer parámetro es el mensaje que se muestra en caso de fallo: en JUnit, el mensaje es siempre el último parámetro de las aserciones.

Ejecutamos las pruebas con el comando [mvn test] en la carpeta del proyecto. A continuación se muestra una captura de pantalla del iniciador de consola de JUnit, que presenta las pruebas en una estructura de árbol; [mvn test] ejecuta las mismas pruebas, y el IDE muestra el mismo árbol. Hemos abreviado la pila de llamadas (líneas [...]):

> mvn test
constructor
before
test1
after
constructor
before
test2
after
╷
└─ JUnit Jupiter ✔
   ├─ Tests2 ✔
   │  ├─ t3() ✔
   │  ├─ t4() ✔
   │  ├─ t5() ✔
   │  ├─ t6() ✔
   │  ├─ t7(int, int, int) ✔
   │  │  ├─ [1] a=1, b=1, sum=2 ✔
   │  │  ├─ [2] a=2, b=3, sum=5 ✔
   │  │  └─ [3] a=-1, b=1, sum=0 ✔
   │  └─ t8(int) ✔
   │     ├─ [1] n=2 ✔
   │     ├─ [2] n=4 ✔
   │     └─ [3] n=6 ✔
   └─ Tests1 ✔
      ├─ t1() ✔
      └─ t2() ✘ 2 + 2 is not equal to 5 ==> expected: <5> but was: <4>

Failures (1):
  JUnit Jupiter:Tests1:t2()
    MethodSource [className = 'demotests.Tests1', methodName = 't2', methodParameterTypes = '']
    => org.opentest4j.AssertionFailedError: 2 + 2 is not equal to 5 ==> expected: <5> but was: <4>
...
       demotests.Tests1.t2(Tests1.java:45)
...
Test run finished after 1350 ms
...
[        12 tests found           ]
[         0 tests skipped         ]
[        12 tests started         ]
[         0 tests aborted         ]
[        11 tests successful      ]
[         1 tests failed          ]
  • Líneas 2–5: la salida de la prueba [t1]: se ejecutó el constructor, seguido del método [before], la prueba y, por último, el método [after]. El iniciador de consola muestra la salida de las pruebas a medida que se ejecutan, antes del árbol de resumen;
  • Líneas 6–9: salida de la prueba [t2]. Observe que el constructor se ejecutó de nuevo: JUnit crea una nueva instancia de la clase de prueba para cada prueba. Por lo tanto, las pruebas son independientes entre sí: una prueba no puede verse afectada por el estado que deja otra (en cambio, la anotación [@TestInstance(Lifecycle.PER_CLASS)] exige una única instancia para todas las pruebas de la clase);
  • líneas 11–27: el árbol de pruebas: el motor JUnit Jupiter, las clases de prueba y luego sus pruebas. El símbolo ✔ indica que la prueba pasó y el símbolo ✘ indica un fallo. Las pruebas de la clase [Tests2], que se muestran a continuación, pasaron todas; JUnit las ejecutó antes que las de [Tests1]. El orden de ejecución de las clases y los métodos es coherente, pero intencionalmente poco evidente: las pruebas no deben depender de su orden de ejecución;
  • línea 27: la prueba [t2] falló. El mensaje de error contiene el mensaje pasado a [assertEquals], el valor esperado y el valor real. Los mensajes de JUnit están en inglés;
  • líneas 29–34: detalles del fallo: la excepción [AssertionFailedError] lanzada por la aserción y la pila de llamadas en el momento del fallo, que señala la línea defectuosa, la línea 45 del archivo [Tests1.java];
  • líneas 38–43: el resumen: 12 pruebas, de las cuales 11 pasaron y 1 falló. El comando [mvn test] termina entonces con un fallo de compilación (“BUILD FAILURE”) y un código de salida distinto de cero, lo que permite que un script detecte el fallo.

Para ejecutar solo un subconjunto de las pruebas, use el parámetro [test] del complemento Surefire: [mvn test -Dtest=Tests2] ejecuta solo las pruebas de la clase [Tests2], mientras que [mvn test -Dtest=Tests1#t1] ejecuta solo la prueba [t1]. Por último, observe las anotaciones [@BeforeAll] y [@AfterAll], que designan métodos estáticos ejecutados una sola vez —antes de la primera prueba y después de la última prueba de la clase— y la anotación [@DisplayName], que da a una prueba un nombre más descriptivo que el de su método. De forma predeterminada, JUnit ejecuta las pruebas una tras otra; se puede solicitar la ejecución en paralelo en un archivo de configuración [junit-platform.properties].

6.4.4.3. Otras aserciones

La clase [Assertions] tiene muchos métodos. La clase [Tests2] presenta algunos de ellos:

package demotests;

import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertIterableEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;

// algunas otras aserciones de JUnit
class Tests2 {

    // booleanos, null, referencias
    @Test
    void t3() {
        boolean isTrue = 1 < 2, isFalse = 1 > 2;
        assertTrue(isTrue);
        assertFalse(isFalse);
        Object obj1 = new Object(), obj2 = null, obj3 = obj1;
        assertNotNull(obj1);
        assertNull(obj2);
        assertSame(obj1, obj3);
        assertNotSame(obj1, new Object());
    }

    // reales: igualdad dentro de un delta
    @Test
    void t4() {
        double d1 = 0.1 + 0.2, d2 = 0.3;
        assertNotEquals(d2, d1);
        assertEquals(d2, d1, 1e-6);
    }

    // cadenas y colecciones: se verifican todas las aserciones, incluso si una falla
    @Test
    void t5() {
        String message = "Line no. 3 is incorrect";
        List<Integer> numbers = List.of(1, 2, 3);
        assertAll(
                () -> assertTrue(message.startsWith("Line")),
                () -> assertTrue(message.contains("incorrect")),
                () -> assertEquals(3, numbers.size()),
                () -> assertTrue(numbers.contains(2)),
                () -> assertIterableEquals(List.of(1, 2, 3), numbers));
    }

    // excepciones: la prueba tiene éxito si se lanza la excepción esperada
    @Test
    void t6() {
        List<Integer> numbers = List.of(1, 2, 3);
        assertThrows(IndexOutOfBoundsException.class, () -> numbers.get(3));
        NumberFormatException e =
                assertThrowsExactly(NumberFormatException.class, () -> Integer.parseInt("x"));
        assertNotNull(e.getMessage());
    }

    // una prueba parametrizada: una ejecución por línea de valores
    @ParameterizedTest
    @CsvSource({"1, 1, 2", "2, 3, 5", "-1, 1, 0"})
    void t7(int a, int b, int sum) {
        assertEquals(sum, a + b);
    }

    // una prueba parametrizada con un solo parámetro: una ejecución por valor
    @ParameterizedTest
    @ValueSource(ints = {2, 4, 6})
    void t8(int n) {
        assertEquals(0, n % 2);
    }
}
  • líneas 29–30: verifican si una expresión booleana es verdadera o falsa;
  • líneas 32–33: verifican si una referencia es no nula o nula;
  • líneas 34–35: verifican si dos referencias se refieren al mismo objeto;
  • líneas 41–43: los cálculos con números reales [double] son aproximados: [0.1 + 0.2] no es exactamente igual a [0.3]. Por eso comparamos dos números reales con cierto margen de error, en este caso una millonésima;
  • líneas 51–56: JUnit no tiene aserciones específicas para cadenas de caracteres: usamos [assertTrue] para verificar el resultado de los métodos [startsWith] o [contains]. [assertIterableEquals] verifica que dos colecciones tengan los mismos elementos, en el mismo orden. Estas aserciones se agrupan con [assertAll], que recibe [() -> ...] expresiones lambda (capítulo 7): todas las aserciones se ejecutan, incluso si alguna falla, y los fallos se informan en conjunto. Sin [assertAll], el primer fallo detiene la prueba. La biblioteca AssertJ, utilizada con frecuencia con JUnit, ofrece aserciones más sofisticadas, escritas en la forma [assertThat(message).startsWith("Line")];
  • líneas 63–65: [assertThrows(Type.class, action)] ejecuta la acción —una expresión lambda— y verifica que lance una excepción de tipo [Type] o de un tipo derivado. Aquí, el método [get] de la lista creada por [List.of] lanza una [ArrayIndexOutOfBoundsException], una clase derivada de [IndexOutOfBoundsException]: la aserción se cumple. [assertThrowsExactly], en cambio, exige una excepción exactamente del tipo [Type]. Ambos métodos devuelven la excepción lanzada, lo que permite verificar posteriormente sus propiedades (línea 66);
  • líneas 70–74: una prueba parametrizada. La anotación [@ParameterizedTest] reemplaza a [@Test]; el método tiene parámetros, y la anotación [@CsvSource] proporciona conjuntos de valores, una cadena por conjunto, con los valores separados por comas. JUnit los convierte al tipo de los parámetros. La prueba se ejecuta una vez por cada conjunto de valores: esto se ve en las líneas 18–20 de los resultados anteriores;
  • líneas 77–81: para una prueba con un solo parámetro, la anotación [@ValueSource] proporciona directamente la lista de valores ([ints], [strings], [doubles]…).

Resumamos los principales métodos de la clase [Assertions]:

Método
Verifica que
[assertEquals(expected, actual)]
los dos valores sean iguales (método [equals])
[assertEquals(real1, real2, delta)]
los dos números reales sean iguales dentro de un margen delta
[assertNotEquals(v1, v2)]
los dos valores sean diferentes
[assertSame(o1, o2)], [assertNotSame(o1, o2)]
las dos referencias se refieran (o no) al mismo objeto
[assertNull(o)], [assertNotNull(o)]
la referencia sea nula (o no)
[assertTrue(b)], [assertFalse(b)]
la expresión booleana sea verdadera (o falsa)
[assertInstanceOf(Type.class, o)]
el objeto sea de tipo [Type] o de un tipo derivado
[assertArrayEquals(t1, t2)]
ambos arreglos tengan los mismos elementos, en el mismo orden
[assertIterableEquals(c1, c2)]
ambas colecciones tengan los mismos elementos, en el mismo orden
[assertAll(action1, action2, ...)]
todas las aserciones de las acciones se cumplan (los fallos se informan en conjunto)
[assertThrows(Type.class, action)]
la acción lance una excepción de tipo [Type] o de un tipo derivado
[assertThrowsExactly(Type.class, action)]
la acción lance una excepción de tipo [Type] exactamente
[fail(message)]
(siempre falla)

Todos estos métodos aceptan un último parámetro opcional: el mensaje que se muestra en caso de fallo.

6.4.4.4. Pruebas de la capa [dao]

Volvamos a la aplicación [Tax]. La clase [DaoTests], que prueba la capa [dao], se encuentra en la carpeta [src/test/java/tax/dao] del módulo [tax-dao]. Pertenece al mismo paquete que las clases que se prueban, lo que le da acceso a sus miembros con visibilidad de paquete. El archivo [pom.xml] del módulo no necesita modificarse: JUnit se hereda del proyecto padre. El archivo de datos incorrecto [TaxDataInvalid.txt] se coloca en la carpeta del módulo: esa es la carpeta actual durante la ejecución de las pruebas.

package tax.dao;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import static org.junit.jupiter.api.Assertions.assertTrue;

import tax.entities.TaxException;
import tax.entities.TaxBracket;
import java.math.BigDecimal;
import java.nio.file.NoSuchFileException;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

// pruebas de la capa [dao]
class DaoTests {

    // fábrica de una capa [dao] a partir del nombre de su clase
    private static ITaxDao createDao(String implementation) {
        return switch (implementation) {
            case "HardwiredTax" -> new HardwiredTax();
            case "FileTax" -> new FileTax("TaxData.txt");
            case "JsonTax" -> new JsonTax("TaxData.json");
            default -> throw new IllegalArgumentException("unknown implementation: " + implementation);
        };
    }

    // la misma prueba para las tres implementaciones
    @ParameterizedTest
    @ValueSource(strings = {"HardwiredTax", "FileTax", "JsonTax"})
    void taxBrackets(String implementation) {
        List<TaxBracket> brackets = createDao(implementation).getTaxBrackets();
        // algunas verificaciones: compareTo ignora la escala de BigDecimal (0.191 y 0.1910 son iguales)
        assertEquals(7, brackets.size());
        assertEquals(0, new BigDecimal("14753").compareTo(brackets.get(2).limit()));
        assertEquals(0, new BigDecimal("0.191").compareTo(brackets.get(2).coeffR()));
        assertEquals(0, new BigDecimal("1322.92").compareTo(brackets.get(2).coeffN()));
    }

    // las tres implementaciones dan los mismos tramos
    @Test
    void sameBrackets() {
        List<TaxBracket> reference = new HardwiredTax().getTaxBrackets();
        assertEquals(reference, new FileTax("TaxData.txt").getTaxBrackets());
        assertEquals(reference, new JsonTax("TaxData.json").getTaxBrackets());
    }

    // archivo ausente
    @Test
    void missingFile() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new FileTax("TaxDataMissing.txt"));
        assertEquals(FileTax.ACCESS, e.getCode());
        assertInstanceOf(NoSuchFileException.class, e.getCause());
    }

    // archivo cuya línea 3 es incorrecta (comas decimales)
    @Test
    void incorrectLine() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new FileTax("TaxDataInvalid.txt"));
        assertEquals(FileTax.FIELD2 | FileTax.FIELD3, e.getCode());
        assertTrue(e.getMessage().startsWith("Line no. 3"));
    }

    // archivo JSON ausente
    @Test
    void missingJsonFile() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new JsonTax("TaxDataMissing.json"));
        assertEquals(JsonTax.ACCESS, e.getCode());
    }
}
  • líneas 21–28: un método que crea una capa llamada [dao] a partir del nombre de su clase, mediante una expresión [switch] (Java 14): cada [case] devuelve, después de la flecha [->], el valor de la expresión;
  • líneas 31–40: la misma prueba se realiza para las tres implementaciones mediante la anotación [@ValueSource]. Verifica que hay 7 tramos impositivos y comprueba el valor del tramo n.º 2 (el tercero). Los valores [BigDecimal] se comparan con [compareTo] en lugar de [equals]: el método [equals] de un [BigDecimal] tiene en cuenta el número de decimales escritos (su escala, “scale”) y trata 0.191 y 0.1910 como diferentes, mientras que [compareTo] compara solo los valores;
  • líneas 44–48: las tres implementaciones producen exactamente los mismos tramos. [assertEquals] compara las listas mediante su propio método [equals], que compara los elementos uno por uno; el método [equals] de un record, generado por el compilador, compara sus componentes. La comparación se cumple porque las tres fuentes escriben los números de la misma manera;
  • líneas 52–57: un archivo inexistente provoca una [TaxException] con código [ACCESS], que encapsula una [NoSuchFileException]. [assertInstanceOf] verifica el tipo de la causa;
  • líneas 61–66: el archivo [TaxDataInvalid.txt] provoca una [TaxException] cuyo código combina los bits de [FIELD2] y [FIELD3], y cuyo mensaje comienza con “Line no. 3”;
  • líneas 70–74: la misma verificación para la implementación [JsonTax].

6.4.4.5. Pruebas de la capa [business]

La clase [BusinessTests] del módulo [tax-business] prueba la capa [business]:

package tax.business;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrowsExactly;

import tax.dao.HardwiredTax;
import tax.dao.ITaxDao;
import tax.entities.TaxBracket;
import java.math.BigDecimal;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

// pruebas de la capa [business]
class BusinessTests {

    // la capa [dao] y la capa [business] probada: JUnit crea una instancia de la clase por prueba
    private final HardwiredTax dao = new HardwiredTax();
    private final ITaxBusiness business = new TaxBusiness(dao);

    // cálculos cuyo resultado se conoce
    @ParameterizedTest
    @CsvSource({
        "true, 2, 60000, 4282",
        "false, 3, 60000, 4282",
        "true, 3, 60000, 2959",
        "false, 0, 60000, 11519",
        "false, 3, 6000, 0",
        "false, 3, 600000, 179275"
    })
    void calculateTax(boolean married, int nbChildren, int salary, int tax) {
        assertEquals(tax, business.calculateTax(married, nbChildren, salary));
    }

    // el cálculo no modifica los tramos proporcionados por la capa [dao]
    @Test
    void unchangedBrackets() {
        List<TaxBracket> before = List.copyOf(dao.getTaxBrackets());
        business.calculateTax(true, 2, 600000);
        assertEquals(before, dao.getTaxBrackets());
    }

    // los parámetros negativos se rechazan
    @Test
    void negativeParameters() {
        assertThrowsExactly(IllegalArgumentException.class, () -> business.calculateTax(true, -1, 60000));
        assertThrowsExactly(IllegalArgumentException.class, () -> business.calculateTax(true, 2, -60000));
    }

    // la capa [business] probada con una capa [dao] simulada: un solo tramo, un impuesto del 10 %
    // ITaxDao tiene un solo método: basta una expresión lambda para implementarlo
    @Test
    void withFakeDao() {
        ITaxDao fakeDao =
                () -> List.of(new TaxBracket(BigDecimal.ZERO, new BigDecimal("0.1"), BigDecimal.ZERO));
        ITaxBusiness fakeBusiness = new TaxBusiness(fakeDao);
        // ingreso gravable = 0.72 x 100000 = 72000; impuesto = 10 % de 72000
        assertEquals(7200, fakeBusiness.calculateTax(false, 0, 100000));
    }
}
  • líneas 19–20: la capa [business] que se prueba se construye sobre la capa [dao] [HardwiredTax], que no depende de ningún archivo. Los campos se inicializan al crear el objeto; como JUnit crea una nueva instancia de la clase para cada prueba, cada prueba tiene capas completamente nuevas;
  • líneas 23–34: cálculos cuyos resultados se conocen, proporcionados por [@CsvSource]. Son los valores de control de la aplicación, ya obtenidos en versiones anteriores: deben seguir siendo exactos en todas las versiones futuras. Las cadenas [true] y [false] se convierten a [boolean];
  • líneas 38–42: el cálculo del impuesto no modifica los tramos impositivos proporcionados por la capa [dao]. Los tramos se almacenan antes de un cálculo que usa el último tramo y luego se hace una comparación. Como la lista ya es de solo lectura, [List.copyOf] devuelve la misma lista, y cualquier intento de modificarla desde la capa [business] provocaría una [UnsupportedOperationException], lo que también haría fallar la prueba. La prueba conserva la memoria del antiguo defecto descrito anteriormente: si alguien lo reintrodujera, esta prueba lo señalaría;
  • líneas 46–49: se rechazan los parámetros negativos;
  • líneas 55–56: una capa [dao] ficticia, como la que usaría el desarrollador de la capa [business] antes de que la capa [dao] real estuviera lista: un solo tramo impositivo, un impuesto del 10 % sobre la renta imponible. Como la interfaz [ITaxDao] tiene un único método abstracto, es una interfaz funcional: una expresión lambda basta para implementarla, sin escribir una clase. Las expresiones lambda se tratarán en el capítulo 7;
  • líneas 57–59: la capa [business] funciona con la capa [dao] ficticia. Así, la capa [business] se prueba de forma aislada, independientemente de las implementaciones reales de la capa [dao].

6.4.4.6. Ejecución de las pruebas

El comando [mvn test], cuando se ejecuta en la carpeta [TaxV5], ejecuta las pruebas de todos los módulos; cuando se ejecuta en la carpeta de un módulo, ejecuta solo las pruebas de ese módulo. Este es el árbol de pruebas del módulo [tax-dao] (hemos incluido solo los resultados de las pruebas):

> mvn -q test
╷
└─ JUnit Jupiter ✔
   └─ DaoTests ✔
      ├─ taxBrackets(String) ✔
      │  ├─ [1] implementation=HardwiredTax ✔
      │  ├─ [2] implementation=FileTax ✔
      │  └─ [3] implementation=JsonTax ✔
      ├─ missingJsonFile() ✔
      ├─ missingFile() ✔
      ├─ sameBrackets() ✔
      └─ incorrectLine() ✔
...
[         7 tests found           ]
[         0 tests skipped         ]
[         7 tests started         ]
[         0 tests aborted         ]
[         7 tests successful      ]
[         0 tests failed          ]

y el árbol de pruebas del módulo [tax-business]:

> mvn -q test
╷
└─ JUnit Jupiter ✔
   └─ BusinessTests ✔
      ├─ withFakeDao() ✔
      ├─ negativeParameters() ✔
      ├─ unchangedBrackets() ✔
      └─ calculateTax(boolean, int, int, int) ✔
         ├─ [1] married=true, nbChildren=2, salary=60000, tax=4282 ✔
         ├─ [2] married=false, nbChildren=3, salary=60000, tax=4282 ✔
         ├─ [3] married=true, nbChildren=3, salary=60000, tax=2959 ✔
         ├─ [4] married=false, nbChildren=0, salary=60000, tax=11519 ✔
         ├─ [5] married=false, nbChildren=3, salary=6000, tax=0 ✔
         └─ [6] married=false, nbChildren=3, salary=600000, tax=179275 ✔
...
[         9 tests found           ]
[         0 tests skipped         ]
[         9 tests started         ]
[         0 tests aborted         ]
[         9 tests successful      ]
[         0 tests failed          ]

Las 16 pruebas pasaron: cada conjunto de valores de una prueba parametrizada cuenta como una prueba, y JUnit los muestra junto con los nombres y valores de sus parámetros (estos nombres están disponibles mediante la opción [parameters] del compilador). Ahora consideramos operativas las capas [dao] y [business] . Los archivos JAR producidos por [mvn package] o [mvn install] contienen solo el código de las capas: las clases de prueba, compiladas en la carpeta [target/test-classes], no se incluyen. Por último, observe que [mvn install] ejecuta las pruebas antes de instalar los módulos: una regresión impide la instalación de una nueva versión de las capas.

6.4.5. La capa [ui]

El archivo [pom.xml] del módulo [tax-ui] es el siguiente:

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- el proyecto padre proporciona las versiones y la configuración comunes -->
    <parent>
        <groupId>examples.tax</groupId>
        <artifactId>tax-v5</artifactId>
        <version>5.0</version>
    </parent>

    <artifactId>tax-ui</artifactId>

    <dependencies>
        <!-- la capa [ui] usa las otras dos capas -->
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-business</artifactId>
        </dependency>
        <!-- el contenedor de inyección de dependencias de Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- mvn exec:java ejecuta la clase principal -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <configuration>
                    <mainClass>tax.ui.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
  • líneas 18–21: la capa [ui] usa la capa [business] y, por transitividad, la capa [dao];
  • líneas 23–26: el contenedor de inyección de dependencias de Spring, el artefacto [spring-context], que incorpora los otros módulos de Spring que necesita ([spring-core], [spring-beans]…);
  • líneas 32–38: el complemento exec, cuya versión determina el proyecto padre. El comando [mvn exec:java] ejecuta la clase [tax.ui.Main].

La clase [Dialog] es la de la versión 4 (paquete [tax.ui]), complementada con un método que muestra una excepción y todas las excepciones que encapsula:

    // visualización de una excepción y de todas las que envuelve
    public static void displayError(Throwable exception) {
        String separator = "-".repeat(40);
        IO.println("Exception chain:\n" + separator);
        for (Throwable e = exception; e != null; e = e.getCause()) {
            IO.println(e.getClass().getName() + ": " + e.getMessage());
            IO.println(separator);
        }
    }
}
  • línea 3: una cadena de 40 guiones, creada por el método [repeat] (Java 11);
  • línea 5: el bucle recorre la cadena de excepciones: cada excepción da acceso, mediante su método [getCause()], a la excepción que encapsula, hasta llegar a la última, cuya causa es [null]. El parámetro es de tipo [Throwable], la superclase de todas las excepciones;
  • línea 6: para cada excepción se muestran el nombre completo de su clase (incluido el paquete) y su mensaje.

La clase [Dialog] es pública: las versiones futuras de la aplicación, que pasarán a la capa [dao], podrán reutilizar la capa [ui] dependiendo del módulo [tax-ui] y llamando a [Dialog.run(business)].

6.4.6. Integración de capas mediante inyección de dependencias

En la versión 4, el programa principal creaba las capas [dao] y [business] nombrando sus clases de implementación:

1
2
3
        ITaxDao dao = source.equals("hardwired") ? new HardwiredTax() : new FileTax(source);
        // creación de la capa [business], que recibe la capa [dao]
        business = new TaxBusiness(dao);

Aparte de estas líneas, no cambia nada en la aplicación cuando cambia la implementación de una capa, ya que cada capa se comunica con la siguiente mediante una interfaz. Podemos llevar la independencia de las capas un paso más allá encomendando su creación a un contenedor de inyección de dependencias y colocando la elección de la implementación de la capa [dao] en un archivo de configuración. Cambiar la implementación de esta capa se reduce entonces a modificar ese archivo, sin recompilar la aplicación.

Image

En el ejemplo anterior, el programa principal de la capa [ui] inicia el contenedor de Spring, [0]. El contenedor de Spring crea las capas [dao] y [1], luego las capas [business] y [2], a las que pasa la capa [dao]. Por último, la capa [ui] solicita al contenedor la capa [business] y recibe una referencia a ella: [3].

6.4.6.1. El archivo de configuración

La elección de la implementación de la capa [dao] se especifica en el archivo [tax.properties] de la carpeta [tax-ui]:

1
2
3
# configuración de la aplicación [Tax]: implementación de la capa [dao]
dao.implementation=FileTax
dao.file=TaxData.txt
  • línea 1: un comentario que comienza con el carácter [#];
  • línea 2: la clase que implementa la capa [dao]: [HardwiredTax], [FileTax], o [JsonTax];
  • línea 3: el archivo de datos, para las implementaciones que leen uno.

Un archivo “properties” es el formato de configuración tradicional de Java: una propiedad por línea, con la forma [key=value], leído por la clase [java.util.Properties]. Las claves suelen llevar un prefijo para formar grupos, como el prefijo [dao.] aquí. El módulo contiene otros tres archivos de configuración, que el programa usa si se pasan sus nombres como argumentos:

1
2
3
tax-json.properties      : dao.implementation=JsonTax, dao.file=TaxData.json
tax-hardwired.properties : dao.implementation=HardwiredTax
tax-error.properties     : dao.implementation=FileTax, dao.file=TaxDataMissing.txt

Los archivos [TaxData.txt] y [TaxData.json] se copiaron en la carpeta [tax-ui]: sus rutas son relativas a la carpeta actual, y [mvn exec:java] ejecuta el programa en la carpeta del módulo.

6.4.6.2. El programa principal

El programa principal [Main] del módulo [tax-ui] es el siguiente:

package tax.ui;

import tax.dao.FileTax;
import tax.dao.HardwiredTax;
import tax.dao.ITaxDao;
import tax.dao.JsonTax;
import tax.entities.TaxException;
import tax.business.ITaxBusiness;
import tax.business.TaxBusiness;
import java.io.IOException;
import java.io.Reader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Properties;
import org.springframework.context.support.GenericApplicationContext;

// integración de las capas por el contenedor Spring GenericApplicationContext
public class Main {

    public static void main(String[] args) {
        // el archivo de configuración: tax.properties por defecto, o el pasado como argumento
        String configFile = args.length > 0 ? args[0] : "tax.properties";

        // integración de las capas
        ITaxBusiness business;
        try {
            // lectura de la configuración, en la carpeta actual
            Properties config = new Properties();
            try (Reader reader = Files.newBufferedReader(Path.of(configFile))) {
                config.load(reader);
            }
            String implementation = config.getProperty("dao.implementation", "HardwiredTax");
            String file = config.getProperty("dao.file", "");

            // el contenedor Spring: las capas se registran en él
            GenericApplicationContext context = new GenericApplicationContext();
            // la capa [dao]: la implementación se elige según la configuración
            context.registerBean(ITaxDao.class, () -> switch (implementation) {
                case "HardwiredTax" -> new HardwiredTax();
                case "FileTax" -> new FileTax(file);
                case "JsonTax" -> new JsonTax(file);
                default -> throw new TaxException(
                        "Unknown implementation [" + implementation + "] of the [dao] layer");
            });
            // la capa [business]: el contenedor le pasará la capa [dao] a su constructor
            context.registerBean(TaxBusiness.class);

            // inicio del contenedor: crea la capa [dao] y luego la capa [business]
            context.refresh();
            business = context.getBean(ITaxBusiness.class);
        } catch (IOException | RuntimeException e) {
            // visualización del error y detención del programa
            Dialog.displayError(e);
            System.exit(1);
            return;
        }

        // el diálogo con el usuario
        Dialog.run(business);
    }
}
  • línea 20: el método [main] de una clase normal, en su forma estándar [public static void main(String[] args)];
  • línea 22: el nombre del archivo de configuración: [tax.properties] de forma predeterminada, o el que se pasa como argumento;
  • líneas 28–31: lectura de la configuración. [Files.newBufferedReader] abre el archivo en UTF-8; la instrucción [try] con un recurso (Java 7) lo cierra al final del bloque, incluso si se produce una excepción. [Properties.load] lee las líneas de la forma [key=value]. Un archivo inexistente provoca una [NoSuchFileException], que se intercepta en la línea 51;
  • líneas 32–33: [getProperty] devuelve el valor de una clave, o el valor predeterminado proporcionado como segundo parámetro si la clave no existe;
  • línea 36: el contenedor de Spring. Spring denomina “bean” a un objeto creado y administrado por el contenedor, y “contexto de aplicación” al contenedor mismo. [GenericApplicationContext] es un contenedor que se configura mediante programación;
  • líneas 38–44: el registro de la capa [dao]. [registerBean(ITaxDao.class, supplier)] indica que el bean de tipo [ITaxDao] será creado por el “supplier”, una expresión lambda sin parámetros que devuelve el objeto. El bean es un singleton, el ámbito predeterminado de Spring: se creará una sola vez y todas las solicitudes devolverán el mismo objeto; solo hay una capa [dao] en la aplicación. El supplier selecciona la clase según la configuración, mediante una expresión [switch]. Una implementación desconocida provoca una [TaxException];
  • línea 46: el registro de la capa [business]: el contenedor creará por sí mismo el objeto [TaxBusiness]. Para ello, examina el constructor de la clase [TaxBusiness], ve que espera un [ITaxDao] y le pasa el bean de ese tipo registrado anteriormente: esto es la inyección de dependencias, en este caso mediante el constructor. La capa [dao] es una dependencia de la capa [business];
  • línea 49: [refresh()] inicia el contenedor. Spring crea entonces todos los beans singleton en el orden en que se registraron: la capa [dao], seguida de la capa [business]. Por lo tanto, un error de creación se produce en esta línea;
  • línea 50: se solicita al contenedor un bean de tipo [ITaxBusiness]. El contenedor encuentra el bean [TaxBusiness], que implementa esta interfaz. [getBean] lanza una excepción si ningún bean tiene este tipo, o si varios lo tienen. Observe que la capa [ui] obtiene la capa [business] sin especificar la clase que la implementa;
  • líneas 51–56: cualquier error al leer la configuración ([IOException]) o al crear las capas ([RuntimeException]: las excepciones de Spring también son no verificadas) se muestra junto con la traza de la pila de la excepción, y el programa termina;
  • línea 59: interacción con el usuario, idéntica a la de la versión 4.

Las primeras versiones de Spring leían de un archivo XML los nombres completos de las clases que debían instanciarse y las creaban mediante reflexión. Nosotros optamos por definir las implementaciones posibles en el proveedor: el archivo de configuración simplemente selecciona entre ellas, y el compilador verifica que las clases existan y tengan los constructores requeridos. En ambos casos, el código de las capas [ui] y [business] nunca especifica la clase que implementa la capa [dao]. También cabe señalar que las clases de las capas no saben nada de Spring: ninguna de ellas importa clases de Spring; solo lo hace el programa principal.

6.4.6.3. Ejecuciones

En la carpeta [tax-ui], tras un [mvn install] en la carpeta [TaxV5], con el archivo [tax.properties] (implementación [FileTax]):

1
2
3
4
5
6
7
8
> mvn -q exec:java
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Con la implementación [JsonTax]:

1
2
3
4
> mvn -q exec:java -Dexec.args="tax-json.properties"
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Con la implementación [HardwiredTax]:

1
2
3
4
> mvn -q exec:java -Dexec.args="tax-hardwired.properties"
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Cambiamos a la implementación [dao] sin modificar una sola línea de código ni recompilar la aplicación.

Con el archivo [tax-error.properties], que hace referencia a un archivo de datos inexistente:

> mvn -q exec:java -Dexec.args="tax-error.properties"
Oct 03, 2026 7:01:28 PM org.springframework.context.support.GenericApplicationContext refresh
WARNING: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.dao.ITaxDao': Instantiation of supplied bean failed
Exception chain:
----------------------------------------
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.dao.ITaxDao': Instantiation of supplied bean failed
----------------------------------------
tax.entities.TaxException: Error while reading the file TaxDataMissing.txt
----------------------------------------
java.nio.file.NoSuchFileException: TaxDataMissing.txt: The file [TaxDataMissing.txt] does not exist
----------------------------------------
  • líneas 2–3: antes de propagar la excepción, Spring escribe una advertencia en su registro. Como no hay ninguna biblioteca de registro en el proyecto, este registro lo gestiona el mecanismo estándar de registro del JDK ([java.util.logging]), que escribe en la salida de error la fecha, la clase que lo emite, el nivel del mensaje y el mensaje mismo;
  • línea 10: la excepción original, de tipo [NoSuchFileException], lanzada por la clase [FileTax];
  • línea 8: la capa [dao] la encapsuló en una [TaxException];
  • línea 6: el propio Spring encapsuló la excepción [TaxException] en una excepción [BeanCreationException], cuyo mensaje identifica el bean que no se pudo crear: el de tipo [ITaxDao]. Esta es la excepción que se propagó hasta el programa principal mediante la llamada a [refresh].

Lo fundamental de esta cadena es que con frecuencia la excepción más profunda —la última que se muestra— es la más significativa.

6.4.6.4. Una variante: configuración mediante una clase anotada

Las aplicaciones Spring suelen describir sus beans en una clase de configuración anotada. El módulo [tax-ui] contiene un ejemplo de esto, la clase [TaxConfig]:

package tax.ui;

import tax.dao.FileTax;
import tax.dao.HardwiredTax;
import tax.dao.ITaxDao;
import tax.dao.JsonTax;
import tax.entities.TaxException;
import tax.business.ITaxBusiness;
import tax.business.TaxBusiness;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

// la configuración del contenedor Spring escrita como una clase Java anotada
@Configuration
// las propiedades del archivo tax.properties de la carpeta actual son accesibles mediante ${...}
@PropertySource("file:tax.properties")
public class TaxConfig {

    // la capa [dao]: la implementación se elige según la configuración
    @Bean
    ITaxDao dao(@Value("${dao.implementation}") String implementation,
            @Value("${dao.file:}") String file) {
        return switch (implementation) {
            case "HardwiredTax" -> new HardwiredTax();
            case "FileTax" -> new FileTax(file);
            case "JsonTax" -> new JsonTax(file);
            default -> throw new TaxException(
                    "Unknown implementation [" + implementation + "] of the [dao] layer");
        };
    }

    // la capa [business]: Spring le pasa al método la capa [dao] creada por el método dao
    @Bean
    ITaxBusiness business(ITaxDao dao) {
        return new TaxBusiness(dao);
    }
}
  • línea 16: la anotación [@Configuration] indica que la clase describe beans;
  • línea 18: la anotación [@PropertySource] indica a Spring que lea por sí mismo el archivo [tax.properties]. El prefijo [file:] se refiere a un archivo del sistema de archivos, relativo al directorio actual; el prefijo [classpath:] se referiría a un recurso ubicado en el archivo JAR;
  • líneas 22–32: un método anotado con [@Bean] crea un bean cuyo nombre es el del método ([dao]) y cuyo tipo es su tipo de retorno. Spring llama al método, proporcionando sus parámetros. La anotación [@Value] solicita el valor de una propiedad: [${dao.implementation}] es el valor de la clave [dao.implementation], y [${dao.file:}] es el valor de la clave [dao.file], con la cadena vacía (colocada después de los dos puntos) como valor predeterminado;
  • líneas 35–38: el bean de la capa [business]. El método espera un [ITaxDao]: Spring le pasa el bean creado por el método [dao]. Esta vez se trata de una inyección mediante un parámetro de método. Para garantizar que un bean singleton se cree una sola vez, Spring deriva en tiempo de ejecución una subclase de la clase de configuración, que redefine sus métodos [@Bean]: por lo tanto, ni la clase ni estos métodos deben declararse [final] ni [private].

El programa principal [MainConfig] usa esta configuración:

package tax.ui;

import tax.business.ITaxBusiness;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

// integración de las capas por el contenedor Spring, configurado por la clase TaxConfig
public class MainConfig {

    public static void main(String[] args) {
        // creación e inicio del contenedor; se cierra al final del bloque try
        try (var context = new AnnotationConfigApplicationContext(TaxConfig.class)) {
            // la capa [business] y el diálogo con el usuario
            ITaxBusiness business = context.getBean(ITaxBusiness.class);
            Dialog.run(business);
        } catch (RuntimeException e) {
            // visualización del error y detención del programa
            Dialog.displayError(e);
            System.exit(1);
        }
    }
}
  • línea 11: [AnnotationConfigApplicationContext] es un contenedor configurado mediante clases anotadas. Su constructor registra los beans descritos por la clase [TaxConfig] e inicia el contenedor. El contenedor implementa la interfaz [AutoCloseable]: el recurso [try] lo cierra al final del bloque, lo que libera los beans. La palabra clave [var] (Java 10) permite que el compilador infiera el tipo de la variable;
  • línea 13: la capa [business] se obtiene como antes;
  • líneas 15–19: manejo de errores.

Resultados:

1
2
3
4
> mvn -q exec:java -Dexec.mainClass=tax.ui.MainConfig
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Con una configuración incorrecta, la cadena de excepciones tiene ahora un nivel adicional: Spring informa del fallo del método [dao] mediante una excepción [BeanInstantiationException], que queda encapsulada dentro de la excepción [BeanCreationException]. Spring también puede descubrir automáticamente las clases que se van a instanciar: con la anotación [@ComponentScan] en la clase de configuración, crea un bean por cada clase de un paquete anotada con [@Component] (o [@Service], [@Repository]). Aquí no lo hicimos, porque habría sido necesario anotar las clases de las capas, haciéndolas así dependientes de Spring. Spring Boot, en el capítulo 13, hace un uso extensivo de este mecanismo.

La inyección de dependencias por sí sola merece un capítulo propio. Solo hemos usado lo esencial: registrar beans ([registerBean], [@Bean]), iniciar el contenedor ([refresh]) y obtener un bean ([getBean]). El contenedor también puede crear un objeto nuevo en cada solicitud (ámbito [prototype]), o un objeto por solicitud (HTTP), o por sesión en una aplicación web (ámbitos [request] y [session]). Puede obtener más información sobre este tema en la documentación de Spring: El contenedor IoC.

6.5. Conclusión

Este capítulo ha dotado a la aplicación [Tax] de la arquitectura que conservará hasta el final del curso:

  • una capa [dao] que proporciona los tramos impositivos a través de la interfaz [ITaxDao];
  • una capa [business] que calcula el impuesto e interactúa con la capa [dao] solo a través de su interfaz;
  • una capa [ui] que interactúa con el usuario y conoce la capa [business] solo a través de su interfaz [ITaxBusiness];
  • un programa principal —el único que conoce las clases de implementación— que crea las capas y las conecta, en este caso mediante el contenedor de inyección de dependencias de Spring y un archivo de configuración;
  • pruebas unitarias automatizadas, que verifican cada capa independientemente de las demás y garantizan la no regresión de la aplicación.

Las ventajas de esta arquitectura se harán plenamente evidentes en los capítulos siguientes, donde los módulos [tax-dao], [tax-business] y [tax-ui] de la versión 5 —instalados en el repositorio local de Maven mediante [mvn install]— se reutilizarán tal cual como dependencias de Maven:

  • Versión 6 (capítulo 10, “Acceso a bases de datos con JDBC”): una nueva implementación de la capa [dao] lee los tramos impositivos de una base de datos MySQL. Las capas [business] y [ui] permanecen sin cambios;
  • Versión 7 (capítulo 11, “Hibernate”): otra implementación de la capa [dao] usa la capa ORM Hibernate para acceder a la misma base de datos;
  • Versión 8 (capítulo 12, “Programación en Internet”): la capa [business] se instala en un servidor TCP, que calcula los impuestos para clientes remotos cuya capa [ui] es la de la versión 5; así, las capas se distribuyen en varias máquinas, lo que devuelve su sentido original al término “tier”;
  • Versión 9 (capítulo 13, “Servicios web”): la capa [business] se expone mediante un servicio web REST/JSON escrito con Spring Boot, cuyo cliente de consola usa la clase [HttpClient] del JDK.

En cada ocasión, el trabajo se limitará a escribir la nueva capa y modificar el programa que integra las capas: ese es todo el sentido de la arquitectura en capas.