Skip to content

6. Arquiteturas em camadas

6.1. Introdução

Vamos retomar a última versão da aplicação de cálculo de imposto (versão 3, Capítulo 5). Reduzido ao essencial, seu programa principal tinha a seguinte estrutura (diagrama 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;
}
// laço de entrada
while (true) {
    String parameters = IO.readln("Tax calculation parameters in the format: ...").strip();
    ...
    // os parâmetros estão corretos: calculamos o imposto
    IO.println("Tax=" + tax.calculate(married.equals("y"), nbChildren, salary) + " euros");
}

Este programa reúne três tipos de processamento encontrados na maioria das aplicações:

  • a recuperação de dados armazenados em arquivos, bancos de dados etc.: linhas 1–8;
  • a interação com o usuário: linhas 11–12 (entrada) e 14 (saída);
  • o uso de um algoritmo de negócio, o cálculo do imposto: linha 14. Esse cálculo era feito até aqui pela classe abstrata [AbstractTax], a classe-mãe de [FileTax] e [JsonTax]: na versão 3, a leitura dos dados e o cálculo ainda estão reunidos em um único objeto.

A experiência mostrou que isolar esses diferentes processamentos em classes distintas melhora a manutenibilidade da aplicação. A arquitetura de uma aplicação estruturada dessa forma é a seguinte:

Image

Essa arquitetura é chamada de “arquitetura de três camadas” (three-tier). O termo “tier” designa normalmente uma parte da aplicação executada em uma máquina diferente. Quando as partes estão na mesma máquina, usa-se antes o termo “arquitetura em camadas”:

  • A camada [business] contém as regras de negócio da aplicação. No nosso caso, são as regras usadas para calcular o imposto de um contribuinte. Essa camada precisa de dados para funcionar:
    • as faixas de imposto, que mudam todo ano;
    • o número de filhos, o estado civil do contribuinte e a renda anual;
  • a camada de acesso a dados, ou [dao] (DAO = Data Access Object), fornece os dados já armazenados em arquivos ou bancos de dados. Isso inclui as faixas de imposto, como na versão 3 da aplicação;
  • a camada de interface com o usuário, ou [ui] (UI = User Interface), fornece os dados digitados pelo usuário e exibe os resultados a ele. Aqui, isso se aplica ao número de filhos, ao estado civil e à renda anual do contribuinte.

Em geral:

  • a camada [dao] cuida do acesso a dados persistentes (arquivos, bancos de dados) ou não persistentes (rede, sensores etc.);
  • a camada [ui] cuida das interações com o usuário, se houver;
  • as três camadas são tornadas independentes entre si pelo uso de interfaces.

Vamos retomar a aplicação [Tax], que já examinamos várias vezes, para dar a ela uma arquitetura em camadas. Primeiro, precisamos definir as interfaces das diversas camadas da aplicação.

6.2. As interfaces da aplicação [Tax]

Lembre-se de que uma interface define um conjunto de assinaturas de métodos. As classes que implementam a interface fornecem a implementação desses métodos.

Voltemos à arquitetura em camadas da nossa aplicação:

Image

Nesse tipo de arquitetura, o usuário costuma tomar a iniciativa. Ele faz uma requisição em [1] e recebe uma resposta em [8]. É o chamado ciclo requisição-resposta. Tomemos o exemplo do cálculo do imposto de um contribuinte. Isso exigirá várias etapas:

  • a camada [ui] pergunta ao usuário seu estado civil, seu número de filhos e seu salário anual. É a operação [1] descrita acima;
  • feito isso, a camada [ui] pede à camada [business] que calcule o imposto. Para isso, envia a ela os dados recebidos do usuário. É a operação [2];
  • a camada [business] precisa de certas informações para cumprir sua tarefa: as faixas de imposto. Ela as solicita à camada [dao] pelo caminho [3, 4, 5, 6]: [3] é a requisição inicial e [6] é a resposta a essa requisição;
  • com todos os dados de que precisava, a camada [business] calcula o imposto;
  • a camada [business] pode agora responder à requisição feita pela camada [ui] em [2]. É o caminho [7];
  • a camada [ui] formata esse resultado e depois o apresenta ao usuário. É o caminho [8];
  • Poderíamos imaginar que o usuário execute simulações de imposto e queira salvá-las. Ele usaria o mesmo caminho, [1-8], para isso.

Como mostra essa descrição, uma camada usa os recursos da camada à sua direita, nunca os da camada à sua esquerda. Consideremos duas camadas adjacentes:

Image

A camada [A] faz requisições à camada [B]. Nos casos mais simples, uma camada é implementada por uma única classe. Mas uma aplicação evolui com o tempo, e a camada [B] pode ter sucessivamente diferentes classes de implementação: [B1], [B2] e assim por diante. Se a camada [B] for a camada [dao], ela pode ter uma implementação inicial, [B1], que obtém os dados de um arquivo. Alguns anos depois, pode-se querer armazenar esses dados em um banco de dados: nesse caso, cria-se uma segunda classe de implementação, [B2]. Se, na aplicação inicial, a camada [A] trabalhasse diretamente com a classe [B1], seríamos obrigados a reescrever parcialmente o código da camada [A]. Por exemplo, suponha que tivéssemos escrito algo como o seguinte na camada [A]:

1
2
3
B1 b1 = new B1(...);
...
b1.getData(...);
  • linha 1: uma instância da classe [B1] é criada;
  • linha 3: os dados são solicitados a essa instância.

Se a nova classe de implementação [B2] tiver métodos com a mesma assinatura que os da classe [B1], será preciso trocar todas as ocorrências de [B1] por [B2]. Esse é o melhor cenário, e é bastante improvável se você não tiver prestado atenção a essas assinaturas. Na prática, é comum que as classes [B1] e [B2] tenham assinaturas de métodos diferentes, o que significa que uma parte significativa da camada [A] precisa ser reescrita.

Esse problema pode ser atenuado inserindo-se uma interface entre as camadas [A] e [B]. Isso congela, em uma interface, as assinaturas dos métodos que a camada [B] expõe à camada [A]. O diagrama anterior passa a ser o seguinte:

Image

A camada [A] não se comunica mais diretamente com a camada [B], mas com sua interface [IB]. No código da camada [A], a classe de implementação [Bi] da camada [B] agora aparece apenas uma vez, quando o objeto que implementa a interface [IB] é criado. Depois disso, usa-se a interface [IB], e não sua classe de implementação. O código anterior passa a ser:

1
2
3
IB ib = new B1(...);
...
ib.getData(...);
  • linha 1: uma instância de *[ib] que implementa a interface *[IB] é criada instanciando-se a classe *[B1]* ;
  • linha 3: os dados são solicitados à instância [ib].

Agora, se substituirmos a implementação [B1] da camada [B] por uma implementação [B2], e ambas obedecerem à mesma interface [IB], apenas a linha 1 da camada [A] precisará ser modificada. Essa é uma grande vantagem que, por si só, justifica o uso sistemático de interfaces entre duas camadas.

Podemos ir ainda mais longe e tornar a camada [A] completamente independente da camada [B]. No código acima, a linha 1 é um problema porque fixa no código o nome da classe [B1]. O ideal é que a camada [A] receba uma implementação da interface [IB] sem precisar especificar o nome de uma classe. Isso seria coerente com o diagrama acima: a camada [A] se relaciona com a interface [IB], e não há razão para que precise conhecer o nome da classe que implementa essa interface.

É isso que a injeção de dependência (DI) possibilita. A arquitetura anterior evolui da seguinte forma:

Image

Um componente transversal, o contêiner de injeção de dependência, cria os objetos que implementam as camadas e os conecta entre si: ele passa à camada [A] uma referência ao objeto que implementa a camada [B]. O código da camada [A] assume então a seguinte 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(...);
    }
}
  • linhas 5–7: a camada [A] recebe, por meio do construtor, uma instância [ib] que implementa a interface [IB]. Não é a camada [A] que a cria, mas o contêiner;
  • linha 11: os dados são solicitados à instância [ib].

A classe de implementação [B1] não aparece mais em nenhum lugar do código da camada [A]. Quando a implementação [B1] for substituída por uma nova implementação [B2], nada mudará no código da camada [A]: a única coisa que mudará é o ponto único da aplicação em que se informa ao contêiner qual classe implementa [IB]. Esse ponto pode até ler, em um arquivo de configuração, o nome da implementação a usar.

No mundo Java, a injeção de dependência foi popularizada no início dos anos 2000 pelo framework Spring, cuja configuração era então escrita em arquivos XML. O Spring Framework, hoje na versão 7, continua sendo o padrão do mercado; ele é a base do Spring Boot, que usaremos no Capítulo 13, “Web Services .” Usaremos seu contêiner na versão 5 da aplicação (há outros, como o CDI, o padrão Jakarta EE, ou o Google Guice). A combinação “interfaces Java + injeção de dependência” melhora significativamente a manutenibilidade da aplicação, tornando as camadas independentes entre si.

Voltemos à arquitetura em camadas da nossa aplicação. Em casos simples, podemos começar pela camada [business] para descobrir as interfaces da aplicação. Para funcionar, a aplicação precisa de dados:

  • já disponíveis em arquivos, bancos de dados ou pela rede. Esses dados são fornecidos pela camada [dao];
  • ainda não disponíveis. Nesse caso, são fornecidos pela camada [ui], que os obtém do usuário.

Que interface a camada [dao] deve oferecer à camada [business]? A camada [dao] deve fornecer as faixas de imposto à camada [business]. Em nossa aplicação, a camada [dao] usa dados existentes, mas não cria dados novos. Sua interface pode ser a seguinte:

package dao;

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

// a interface da camada [dao]
public interface ITaxDao {

    // as faixas de imposto
    List<TaxBracket> getTaxBrackets();
}
  • linha 1: a interface está no pacote [dao]. O arquivo [ITaxDao.java] deve, portanto, estar em uma pasta chamada [dao], como veremos;
  • linha 10: a interface [ITaxDao] define o método [getTaxBrackets], que fornece as faixas de imposto à camada [business]. O Java não tem propriedades: os dados somente leitura são expostos pelo método [getXxx], de acordo com a convenção JavaBeans. As faixas de imposto são retornadas como uma lista [List<TaxBracket>] e não como um array: veremos que as implementações retornam uma lista imutável, ao passo que os elementos de um array sempre podem ser modificados pelo destinatário;
  • linha 3: importa o tipo [TaxBracket], definido no pacote [entities]:
1
2
3
4
5
6
7
package entities;

import java.math.BigDecimal;

// uma faixa de imposto: um record, portanto uma classe não modificável
public record TaxBracket(BigDecimal limit, BigDecimal coeffR, BigDecimal coeffN) {
}

Uma faixa de imposto é representada por um record (Java 16): uma classe não modificável para a qual o compilador gera o construtor (com base nos componentes declarados entre parênteses após o nome do tipo), os campos [private final], os acessores [limit()], [coeffR()] e [coeffN()], bem como os métodos [equals], [hashCode], e [toString]. Escrevemos [new TaxBracket(limit, coeffR, coeffN)] para criar uma faixa de imposto. Os três componentes são do tipo [BigDecimal], a classe Java para números decimais exatos: um [double] não consegue representar exatamente 0,068 nem 291,09. Como um *[BigDecimal] é, ele próprio, imutável, uma faixa de imposto não pode ser alterada depois de criada. Uma classe JavaBean tradicional, com métodos [setXxx], teria permitido isso; veremos que essa limitação elimina um efeito colateral de uma forma mais antiga de implementar a camada [business]*.

Que interface a camada [business] deve apresentar à camada [ui]? Vamos rever as interações entre essas duas camadas:

  • a camada [ui] pergunta ao usuário seu estado civil, seu número de filhos e seu salário anual. É a operação [1] do esquema;
  • feito isso, a camada [ui] pede à camada [business] que calcule o imposto. Para isso, envia à camada [business] os dados recebidos do usuário. É a operação [2].

A interface da camada [business] pode ser assim:

1
2
3
4
5
6
7
package business;

// a interface da camada [business]
public interface ITaxBusiness {

    int calculateTax(boolean married, int nbChildren, int salary);
}
  • linha 1: tudo o que se relaciona à camada [business] é colocado no pacote [business];
  • linha 6: a interface [ITaxBusiness] define apenas um método, que calcula o imposto de um contribuinte com base em seu estado civil, número de filhos e salário anual. Os métodos de uma interface são implicitamente públicos e abstratos: não é preciso escrever [public abstract].

Examinaremos agora uma primeira implementação dessa arquitetura em camadas.

6.3. Aplicação de exemplo — versão 4

6.3.1. O projeto

A versão 4 é um programa composto por vários arquivos-fonte que não usa nenhuma biblioteca externa. Vamos executá-lo com o iniciador de código-fonte do Java, sem criar um projeto Maven. Cada camada ocupa uma pasta própria:

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
  • A pasta [entities] contém os tipos transversais às camadas [ui], [business], e [dao]: o record [TaxBracket], a exceção [TaxException], e a enumeração [ErrorCode] com seus códigos de erro;
  • a pasta [dao] contém a interface e as classes da camada [dao]. Usaremos duas implementações da interface [ITaxDao]: a classe [HardwiredTax], cujos dados estão fixos no código (versão 2), e a classe [FileTax], que lê os dados de um arquivo de texto (versão 3). A leitura de um arquivo JSON, a outra opção da versão 3, será tratada na versão 5;
  • a pasta [business] contém a interface e a classe da camada [business];
  • a pasta [ui] contém a classe da camada [ui];
  • o arquivo [Main.java] cria as camadas e as liga entre si;
  • o arquivo [TaxData.txt] contém as faixas de imposto lidas pela implementação [FileTax] da camada [dao].

Ao contrário de outras linguagens, os nomes das pastas importam aqui: em Java, uma classe do pacote [dao] fica em uma pasta chamada [dao], uma classe do pacote [tax.dao] fica em uma pasta [tax/dao], e essas pastas são relativas à raiz do código-fonte. É assim que o compilador e a máquina virtual localizam as classes a partir de seus nomes totalmente qualificados.

O arquivo [Main.java] é um arquivo-fonte compacto: não tem declaração de pacote e, portanto, pertence ao pacote sem nome na raiz do código-fonte. A partir do Java 22 (iniciador de programas com vários arquivos, JEP 458), o comando [java Main.java], digitado na pasta [TaxV4], basta para executar o programa: o iniciador de código-fonte compila [Main.java] em memória e, sempre que encontra uma classe de outro arquivo (por exemplo, [dao.FileTax]), procura o arquivo [dao/FileTax.java] a partir do diretório de [Main.java] e o compila, por sua vez. Nenhum arquivo chamado [.class] é gravado em disco. Uma classe do pacote sem nome pode usar classes de outros pacotes, mas o inverso não é possível: nenhuma classe pode importar [Main]. É por isso que apenas o programa principal é colocado ali.

Uma IDE abre esta pasta como está e executa [Main.java] sem nenhuma configuração especial. Quando o programa exigir bibliotecas externas (Jackson, Spring), na versão 5, passaremos a um projeto Maven.

6.3.2. Componentes da aplicação

Image

Chamamos de entidades os tipos que atravessam várias camadas. Geralmente são as classes que encapsulam os dados da camada [dao]. Essas entidades costumam se estender até a camada [ui]. As entidades da aplicação são o record [TaxBracket], já apresentado, e a exceção [TaxException], com sua enumeração de códigos de erro:

package entities;

import java.util.StringJoiner;

// os códigos de erro da camada [dao]: cada um corresponde a um bit, portanto podem ser combinados
public enum ErrorCode {
    ACCESS, LINE, FIELD1, FIELD2, FIELD3;

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

    // os nomes dos códigos presentes em uma combinação de bits, por exemplo "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();
    }
}
  • linha 6: uma enumeração ([enum]). Em Java, os valores de uma enumeração são objetos (instâncias únicas da classe [ErrorCode]) e uma enumeração pode ter métodos;
  • linha 7: os cinco códigos de erro. O método [ordinal()], herdado da classe [Enum], retorna a posição do valor na lista: 0 para [ACCESS], 4 para [FIELD3];
  • linhas 10–12: cada código é associado a um bit, obtido por um deslocamento à esquerda: [1 << ordinal()] vale 1, 2, 4, 8 e 16. Essas potências de 2 podem ser combinadas com o operador [|]: o código [FIELD2.bit() | FIELD3.bit()] (8 + 16 = 24) significa que os campos 2 e 3 de uma linha estão incorretos. A versão 3 especificava explicitamente o valor de cada código ([ACCESS(1)], [LINE(2)]…) e decodificava uma combinação em um conjunto [EnumSet]; calcular o bit a partir da posição dispensa aqui esses valores. O código de erro da exceção continua sendo um simples inteiro, que todas as implementações da camada [dao] podem usar;
  • linhas 15–23: o método estático [names] retorna os nomes dos códigos presentes em uma combinação de bits: “FIELD2, FIELD3” para 24. O método [values()], gerado pelo compilador, retorna o array dos valores da enumeração; [code & c.bit()] é diferente de zero se o bit correspondente ao código [c] estiver presente em [code]; [name()] retorna o nome do valor. Um [StringJoiner] (Java 8) concatena strings, separando-as pelo separador fornecido ao seu construtor.
package entities;

import java.io.Serial;

// a exceção lançada pela camada [dao]
// ela deriva de RuntimeException: é uma exceção não verificada
public class TaxException extends RuntimeException {

    // versão da classe para serialização (uma exceção é serializável)
    @Serial
    private static final long serialVersionUID = 1L;

    // código de erro (uma combinação de bits de ErrorCode)
    private final int code;

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

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

    // o código de erro
    public int getCode() {
        return code;
    }
}
  • linha 7: uma exceção específica da aplicação deriva da classe [RuntimeException]; é uma exceção não verificada. Os métodos que a lançam não precisam declará-la em uma cláusula [throws], e seus chamadores não são obrigados a capturá-la. Essa é a abordagem padrão para os erros que uma camada comunica a outra;
  • linhas 10–11: uma exceção é serializável (a classe [Throwable] implementa a interface [Serializable]). O campo [serialVersionUID] especifica a versão da classe para a serialização; sem ele, o compilador, ao usar a opção [-Xlint:all], emite um aviso. A anotação [@Serial] (Java 14) permite que o compilador verifique a declaração desse campo;
  • linha 14: o código de erro, um inteiro que combina bits de [ErrorCode]. O campo é [final]: é inicializado no construtor e não pode ser alterado depois;
  • linhas 17–24: dois construtores, um com uma mensagem e um código, o outro com, além disso, a exceção original (a causa), que ficará acessível pelo método [getCause()]. O primeiro chama o segundo ([this(...)]), que chama o construtor da classe-mãe [RuntimeException] ([super(...)]);
  • linhas 27–29: o acessor do código de erro.

Nesta versão, apenas a classe [FileTax] da camada [dao] lança [TaxException].

6.3.3. A camada [dao]

Vamos rever a interface da camada [dao]:

package dao;

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

// a interface da camada [dao]
public interface ITaxDao {

    // as faixas de imposto
    List<TaxBracket> getTaxBrackets();
}

Implementamos essa interface de duas formas diferentes. Primeiro, com a classe [HardwiredTax]:

package dao;

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

// uma camada [dao] cujos dados são "fixos no código"
public class HardwiredTax implements ITaxDao {

    // faixas de imposto (tabela de 2004 sobre a renda de 2003): uma lista não modificável
    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;
    }

    // uma faixa construída a partir de strings: os valores BigDecimal são exatos
    private static TaxBracket bracket(String limit, String coeffR, String coeffN) {
        return new TaxBracket(new BigDecimal(limit), new BigDecimal(coeffR), new BigDecimal(coeffN));
    }
}
  • linha 8: a classe [HardwiredTax] implementa ([implements]) a interface [ITaxDao];
  • linhas 11–18: as faixas de imposto. [List.of] (Java 9) cria uma lista somente leitura: seus métodos [add], [set] ou [remove] lançam [UnsupportedOperationException]. O campo é inicializado em sua declaração;
  • linhas 20–23: a implementação do método da interface. A anotação [@Override] instrui o compilador a verificar se o método implementa corretamente um método da interface: um erro de digitação em seu nome causaria um erro de compilação;
  • linhas 26–28: um método privado que cria uma faixa de imposto a partir de três strings. Um [BigDecimal] construído a partir de uma string é exato: [new BigDecimal("0.068")] vale exatamente 0,068, ao passo que [new BigDecimal(0.068)] seria 0,0680000000000000049…, o [double] mais próximo de 0,068.

A interface [ITaxDao] também é implementada pela classe [FileTax], que lê as faixas de imposto de um arquivo de texto. O arquivo [TaxData.txt] é o seguinte:

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 linha descreve uma faixa de imposto no formato [limit:coeffR:coeffN]. Os números são escritos com ponto decimal, independentemente do idioma do sistema; isso garante que o arquivo seja legível em todas as máquinas. Os valores são os da tabela de imposto de 2004, para a renda de 2003, mantidos como estão: trata-se de um exercício. A classe [FileTax] é a seguinte:

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;

// uma camada [dao] que lê as faixas de imposto de um arquivo de texto
// uma linha por faixa: limit:coeffR:coeffN (ponto decimal)
public class FileTax implements ITaxDao {

    // arquivo de dados, relativo à pasta atual
    private final String fileName;

    // faixas de imposto
    private final List<TaxBracket> taxBrackets;

    // construtor
    public FileTax(String fileName) {
        // armazenamos o nome do arquivo
        this.fileName = fileName;
        // as faixas lidas
        List<TaxBracket> brackets = new ArrayList<>();
        // lendo o arquivo linha por linha
        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++;
                // as linhas vazias são ignoradas
                String line = lineRead.strip();
                if (line.isEmpty()) {
                    continue;
                }
                // linha dividida em três 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 {
                    // conversões dos 3 campos: cada erro adiciona seu bit ao 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();
                }
                // erro?
                if (code != 0) {
                    throw new TaxException("Line no. " + lineNumber + " is incorrect: [" + line + "]", code);
                }
                // armazenamos a nova faixa de imposto
                brackets.add(new TaxBracket(limit, coeffR, coeffN));
            }
        } catch (IOException e) {
            // erro de acesso ao arquivo: ele é encapsulado em uma TaxException
            throw new TaxException("Error while reading the file " + fileName, e, ACCESS.bit());
        }
        // retornamos uma cópia não modificável da lista
        taxBrackets = List.copyOf(brackets);
    }

    public String getFileName() {
        return fileName;
    }

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

    // um número positivo ou zero escrito com dígitos e ponto decimal; null se incorreto
    private static BigDecimal parse(String field) {
        return field.matches("\\d+(\\.\\d+)?") ? new BigDecimal(field) : null;
    }
}
  • linhas 3–7: a importação estática ([import static], Java 5) permite usar os membros estáticos de uma classe sem prefixá-los com o nome da classe. Os valores de uma enumeração são membros estáticos: escrevemos [FIELD1] em vez de [ErrorCode.FIELD1];
  • linha 21: a classe [FileTax] implementa a interface [ITaxDao];
  • linhas 24, 27: o nome do arquivo e as faixas lidas. Esses campos [final] são inicializados uma única vez, no construtor (linhas 32 e 76). São retornados pelos métodos das linhas 79–86; [getTaxBrackets] é o método da interface;
  • linha 30: o construtor recebe o nome do arquivo de faixas de imposto;
  • linha 34: as faixas de imposto lidas são acumuladas em uma lista [ArrayList];
  • linha 38: [Path.of] (Java 11) cria o caminho do arquivo. Um caminho relativo é relativo ao diretório atual, aquele em que o comando [java] foi digitado;
  • linhas 39–41: se o arquivo não existir, uma [NoSuchFileException] (do pacote [java.nio.file]) é lançada com uma mensagem explícita. Seu construtor de três parâmetros recebe o nome do arquivo, o nome de um eventual segundo arquivo (aqui, [null]) e o motivo do erro. Sem esse teste, [Files.readAllLines] lançaria ela mesma uma [NoSuchFileException] cuja mensagem seria composta apenas pelo nome do arquivo;
  • linha 42: [Files.readAllLines] lê o arquivo inteiro em UTF-8 e retorna uma lista com suas linhas. O método abre e fecha o arquivo por conta própria. Para um arquivo grande, seria preferível lê-lo aos poucos com [Files.lines] ou [BufferedReader];
  • linha 45: [strip()] (Java 11) remove os espaços no início e no fim;
  • linha 50: a linha é dividida por [split], cujo parâmetro é uma expressão regular: o separador é um dois-pontos, possivelmente cercado de espaços ([\s*] corresponde a zero ou mais espaços). Em uma string Java, a barra invertida é duplicada;
  • linhas 53–54: uma linha que não tem três campos é inválida;
  • linhas 57–62: conversão dos três campos. Cada campo incorreto acrescenta um bit ao código de erro com o operador [|=];
  • linhas 65–67: uma linha inválida provoca uma [TaxException], cuja mensagem informa o número e o conteúdo da linha. Essa exceção não é uma [IOException]: não é capturada na linha 71 e se propaga como está até o chamador;
  • linha 69: a faixa lida é adicionada à lista;
  • linhas 71–74: todos os erros de E/S derivam de [IOException]: arquivo não encontrado ([NoSuchFileException]), permissões insuficientes ([AccessDeniedException]), arquivo que não está em UTF-8 ([MalformedInputException]) etc. O erro é encapsulado em uma [TaxException] com o código [ACCESS]; a exceção original é mantida como causa;
  • linha 76: [List.copyOf] (Java 10) retorna uma cópia somente leitura da lista;
  • linhas 89–91: conversão de um campo em [BigDecimal]. O método [matches] verifica se a string inteira corresponde à expressão regular [\d+(\.\d+)?]: um ou mais dígitos, opcionalmente seguidos de um ponto e mais dígitos. Assim, “0,191” é rejeitado, assim como qualquer número negativo. O construtor [BigDecimal(String)] não depende do idioma do usuário: sempre espera um ponto decimal. Em caso de erro, o método retorna [null].

6.3.4. A camada [business]

Vamos rever a interface dessa camada:

1
2
3
4
5
6
7
package business;

// a interface da camada [business]
public interface ITaxBusiness {

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

Sua implementação, [TaxBusiness], é a seguinte:

package business;

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

// a camada [business] recebe a camada [dao] por meio de seu construtor
public class TaxBusiness implements ITaxBusiness {

    // as faixas de imposto, solicitadas uma vez por todas à camada [dao]
    private final List<TaxBracket> brackets;

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

    // cálculo do imposto
    @Override
    public int calculateTax(boolean married, int nbChildren, int salary) {
        // verificando os 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 cotas
        BigDecimal shares = BigDecimal.valueOf(nbChildren).divide(BigDecimal.TWO)
                .add(BigDecimal.valueOf(married ? 2 : 1));
        if (nbChildren >= 3) {
            shares = shares.add(new BigDecimal("0.5"));
        }
        // renda tributável e quociente familiar
        BigDecimal income = new BigDecimal("0.72").multiply(BigDecimal.valueOf(salary));
        BigDecimal qf = income.divide(shares, MathContext.DECIMAL128);
        // a faixa: a primeira cujo limite é maior ou igual ao QF,
        // a última se nenhuma servir (seu limite não é usado)
        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;
            }
        }
        // imposto (parte inteira)
        return income.multiply(bracket.coeffR()).subtract(shares.multiply(bracket.coeffN())).intValue();
    }
}
  • linha 10: a classe [TaxBusiness] implementa a interface [ITaxBusiness]. A camada [business] precisa colaborar com a camada [dao]: por isso, recebe, por meio de seu construtor (linha 16), uma referência ao objeto que implementa a interface [ITaxDao];
  • linhas 13, 16–18: na construção do objeto, a camada [business] solicita as faixas de imposto à camada [dao] uma única vez e as armazena em um campo [final]. Observe que a camada [business] conhece a camada [dao] apenas por meio de sua interface [ITaxDao]: ela não sabe se as faixas de imposto vêm do código, de um arquivo ou, mais adiante, de um banco de dados;
  • linhas 24–29: a camada [business] não confia em seus chamadores. Um parâmetro incorreto provoca uma [IllegalArgumentException], a exceção não verificada que o Java oferece para esse caso, com uma mensagem que identifica o parâmetro;
  • linhas 31–35: o número de partes. Um [BigDecimal] não tem operadores aritméticos: usam-se, em vez disso, seus métodos [add], [subtract], [multiply], e [divide] . Como é imutável, cada operação retorna um novo objeto, daí a notação [shares = shares.add(...)]. A divisão por [BigDecimal.TWO] (uma constante adicionada no Java 19) é exata: 3 filhos resultam em 1,5 parte;
  • linhas 37–38: a renda tributável e o quociente familiar. A divisão pelo número de partes pode resultar em um número infinito de casas decimais (a divisão por 3, por exemplo): sem uma precisão especificada, [divide] provocaria então uma [ArithmeticException]. [MathContext.DECIMAL128] limita o resultado a 34 dígitos significativos;
  • linhas 41–47: procuramos a primeira faixa cujo limite seja maior ou igual ao quociente familiar. Os valores [BigDecimal] são comparados com [compareTo], que retorna um número negativo, zero ou positivo: [qf.compareTo(limit) <= 0] significa [qf <= limit]. A última faixa, [brackets.getLast()] (Java 21), é usada se nenhuma das outras servir: seu limite (0) não é utilizado;
  • linha 49: o imposto. [intValue()] retorna a parte inteira do resultado.

Um método que já foi comum consistia em modificar o limite da última faixa (algo como [brackets[brackets.length - 1].setLimit(qf + 1)]) antes da busca, para que o laço de busca sempre parasse. Essa instrução modificava o array fornecido pela camada [dao]: um efeito colateral sobre dados compartilhados por todas as camadas. Não poderíamos mais escrevê-la aqui, pois um [TaxBracket] não é modificável, assim como a lista que os contém. O código moderno simplesmente pega a última faixa quando nenhum limite serve, sem modificar os dados que recebe.

6.3.5. A camada [ui]

Nas versões 2 e 3, a interface com o usuário era escrita no programa principal, depois da criação do objeto de cálculo. A única diferença estava na forma de criar esse objeto. Agora isolamos essa interação em uma classe da camada [ui], que conhece a camada [business] apenas por meio de sua interface:

package ui;

import business.ITaxBusiness;

// o diálogo de console com o usuário: ele só conhece a interface da camada [business]
public final class Dialog {

    // ajuda exibida em caso de entrada incorreta
    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""";

    // classe utilitária: sem instância
    private Dialog() {
    }

    // laço de diálogo: entrada dos parâmetros, cálculo, exibição
    public static void run(ITaxBusiness business) {
        while (true) {
            // pedimos os parâmetros do cálculo do imposto
            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 a fazer?
            if (parameters.isEmpty()) {
                break;
            }
            // verificando o 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 filhos
            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;
            }
            // os parâmetros estão corretos: pedimos o cálculo à camada [business]
            IO.println("Tax=" + business.calculateTax(married.equals("y"), nbChildren, salary) + " euros");
        }
    }

    // um inteiro positivo ou zero, -1 se a string não for um
    private static int integer(String field) {
        try {
            return Integer.parseInt(field);
        } catch (NumberFormatException e) {
            return -1;
        }
    }
}
  • linha 6: a classe [Dialog] não tem estado próprio e contém apenas membros estáticos. O Java não tem classes estáticas de nível superior: declaramos a classe [final] (que não pode ser estendida) e damos a ela um construtor privado (linhas 16–17), que impede a criação de instâncias;
  • linhas 9–13: a mensagem de ajuda é um bloco de texto (Java 15), delimitado por três aspas. Ele pode ocupar várias linhas; a indentação comum das linhas é removida. Como as aspas de fechamento ficam no fim da última linha, o texto não termina com uma quebra de linha;
  • linha 20: o método [run] recebe a camada [business] na forma de sua interface [ITaxBusiness]. Ele nada sabe sobre a classe que a implementa nem sobre a camada [dao];
  • linhas 23–25: [IO.readln] (Java 25) exibe seu parâmetro e depois lê uma linha do teclado. Retorna [null] no fim do fluxo de entrada; a linha 25 então substitui [null] pela string vazia: um sinal de fim de fluxo encerra o diálogo da mesma forma que uma linha vazia;
  • linha 31: a linha digitada é dividida por espaços; a expressão regular [\s+] (um ou mais espaços) ignora espaços múltiplos;
  • linhas 37–38: as strings são comparadas com [equals], nunca com [==], que compara referências;
  • linhas 43–53: o número de filhos e o salário devem ser inteiros positivos ou zero. O método [integer] (linhas 60–66) retorna -1 se o campo não for um inteiro: [Integer.parseInt] lança então uma [NumberFormatException], que é interceptada. Um número negativo e uma entrada incorreta são, assim, rejeitados pela mesma verificação;
  • linha 55: os parâmetros estão corretos: o cálculo é solicitado à camada [business].

6.3.6. Integração das camadas

Resta criar as camadas e ligá-las entre si. Essa é a função do 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;

// integração das camadas: este é o único lugar em que as classes de implementação são nomeadas
// argumento: "hardwired" para HardwiredTax,
// caso contrário, o nome do arquivo lido por FileTax (TaxData.txt por padrão)
void main(String[] args) {
    String source = args.length > 0 ? args[0] : "TaxData.txt";
    ITaxBusiness business;
    try {
        // criação da camada [dao]
        ITaxDao dao = source.equals("hardwired") ? new HardwiredTax() : new FileTax(source);
        // criação da camada [business], que recebe a camada [dao]
        business = new TaxBusiness(dao);
    } catch (TaxException e) {
        // exibição do erro e encerramento do programa com código de saída 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;
    }

    // a camada [ui]: o diálogo com o usuário
    Dialog.run(business);
}
  • linhas 1–8: um arquivo-fonte compacto (Java 25) não tem declaração de classe, mas pode conter importações. O compilador coloca seu conteúdo em uma classe implícita;
  • linha 13: o método [main] recebe os argumentos da linha de comando no array [args]. O argumento seleciona a implementação da camada [dao]: [hardwired] para a classe [HardwiredTax]; caso contrário, o nome do arquivo lido pela classe [FileTax], [TaxData.txt] por padrão;
  • linha 18: criação da camada [dao]. É o único lugar do programa em que as classes [HardwiredTax] e [FileTax] são nomeadas;
  • linha 20: criação da camada [business], que recebe a camada [dao];
  • linhas 21–28: a criação da camada [dao] pode provocar o lançamento de uma [TaxException]. O erro é então exibido, junto com a mensagem da exceção original (se houver), e o programa termina com o código de saída 1 ([System.exit(1)]). O código de erro é exibido em texto simples pelo método [ErrorCode.names]. A instrução [return] da linha 27 nunca é executada, mas o compilador não sabe que [System.exit] não devolve o controle: sem ela, o compilador informaria que a variável [business] pode não ter sido inicializada na linha 31;
  • linha 31: as camadas estão prontas: a camada [ui] interage com o usuário.

6.3.7. Execuções

Na pasta [TaxV4], com o arquivo [TaxData.txt] (implementação [FileTax]) e testando a validação das 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: 

Com a implementação [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: 

Com um arquivo inexistente:

> 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]

O código de erro é [ACCESS], e a mensagem da exceção original, [NoSuchFileException], é exibida: ela é composta pelo nome do arquivo, seguido do motivo informado ao seu criador.

Com o seguinte arquivo, [TaxDataInvalid.txt], em que a linha 3 contém vírgulas decimais:

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

o resultado é:

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

Os campos 2 e 3 da linha 3 estão incorretos: o código de erro combina os bits de [FIELD2] e [FIELD3], e o método [ErrorCode.names] o exibe como “FIELD2, FIELD3”.

6.3.8. Conclusão

A arquitetura em camadas e o uso de interfaces trouxeram certa flexibilidade à nossa aplicação. Isso é evidente na maneira como o programa principal cria as camadas [dao] e [business]:

1
2
3
4
        // criação da camada [dao]
        ITaxDao dao = source.equals("hardwired") ? new HardwiredTax() : new FileTax(source);
        // criação da camada [business], que recebe a camada [dao]
        business = new TaxBusiness(dao);

Mudar a implementação da camada [dao] afeta apenas a linha 2. Uma vez criadas as camadas, o código da camada [ui] é o mesmo nos dois casos: a camada [business] é manipulada ali por meio de sua interface [ITaxBusiness], e não de sua classe de implementação.

A mesma flexibilidade é evidente na camada [business]: ela é construída a partir de uma referência à interface da camada [dao]. Mudar a implementação desta, portanto, não tem nenhum impacto sobre a camada [business]. É por isso que nossa única classe [TaxBusiness] pôde funcionar sem modificação com duas implementações diferentes da camada [dao].

6.4. Aplicação de exemplo — versão 5

Image

Esta nova versão parte da anterior com as seguintes mudanças:

  • as camadas [dao] e [business] são colocadas, cada uma, em um módulo Maven que gera uma biblioteca (um arquivo JAR) e testadas com o framework de testes unitários JUnit;
  • a camada [dao] passa a incluir uma terceira implementação, [JsonTax], que lê as faixas de imposto de um arquivo JSON com a biblioteca Jackson;
  • a integração das camadas é feita pelo contêiner de injeção de dependência do Spring, e a implementação da camada [dao] é escolhida a partir de um arquivo de configuração.

Em grandes projetos, vários desenvolvedores trabalham na mesma aplicação. As arquiteturas em camadas facilitam essa forma de trabalho: como as camadas se comunicam por meio de interfaces bem definidas, um desenvolvedor que trabalha em uma camada não precisa se preocupar com o trabalho dos outros desenvolvedores nas demais camadas. Basta que todos respeitem as interfaces.

Assim, para testar a camada [business], o desenvolvedor precisa de uma implementação da camada [dao]. Até que essa implementação esteja pronta, ele pode usar uma implementação fictícia da camada [dao], desde que ela respeite a interface [ITaxDao]. Essa é mais uma vantagem da arquitetura em camadas: um atraso na camada [dao] não impede que a camada [business] seja testada. A implementação fictícia (mock) também tem a vantagem de ser muito mais simples de montar do que a camada [dao] real, que pode exigir um SGBD, conexões de rede etc.

Quando a camada [dao] está concluída e testada, ela é entregue aos desenvolvedores da camada [business] na forma de uma biblioteca (um arquivo JAR publicado em um repositório Maven) e não de código-fonte a ser copiado. No fim, a aplicação é entregue como um programa principal (o da camada [ui]) e bibliotecas de classes (as demais camadas).

6.4.1. O projeto Maven TaxV5

A versão 5 é um projeto Maven de vários módulos: um projeto pai, que não produz nada por si só, contém três módulos, um por camada. Os testes não formam um projeto separado: a convenção do Maven coloca os testes de um módulo em sua pasta [src/test/java]. Eles são compilados e executados pelo Maven, mas não fazem parte do arquivo JAR do módulo. O resultado é a seguinte estrutura de diretórios:

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

Os pacotes agora têm o prefixo [tax]: [tax.entities], [tax.dao], [tax.business], [tax.ui]. Os módulos [tax-dao] e [tax-business] serão, de fato, reutilizados por outros projetos (Capítulos 10 a 13), e duas bibliotecas usadas pelo mesmo programa não podem definir duas classes com o mesmo nome totalmente qualificado. Em projetos profissionais, os pacotes recebem como prefixo o nome de domínio invertido da organização ([org.springframework], [tools.jackson]…), o que garante nomes únicos.

O arquivo [pom.xml] do projeto pai é o seguinte:

<?xml version="1.0" encoding="UTF-8"?>
<!-- projeto pai da aplicação [Tax], versão 5: um módulo Maven por camada -->
<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>

    <!-- os módulos, na ordem de suas dependências -->
    <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>

    <!-- as versões das bibliotecas, comuns a todos os 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 os testes de todos os 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>
                        <!-- mantém os nomes dos parâmetros dos métodos no 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>
  • linhas 8–11: os dados do projeto pai: grupo [examples.tax], nome [tax-v5], versão [5.0]. O tipo de empacotamento [pom] indica que o projeto não produz um arquivo JAR: ele apenas agrupa módulos e aplica a eles uma configuração comum;
  • linhas 14–18: os módulos, isto é, as subpastas, cada uma contendo um projeto Maven. Um comando Maven digitado na pasta [TaxV5] aplica-se a todos os módulos, na ordem ditada por suas dependências: [tax-dao], depois [tax-business], depois [tax-ui];
  • linhas 20–23: as propriedades herdadas pelos módulos: Java 25 e arquivos-fonte em UTF-8;
  • linhas 26–54: a seção [dependencyManagement] especifica as versões das dependências sem adicioná-las aos módulos. Um módulo que precisa de uma dependência a declara sem versão; assim, todas as versões ficam reunidas em um único lugar. Ela inclui os próprios módulos da aplicação (linhas 28–37), o Jackson 3 (linhas 38–42), o contêiner do Spring (linhas 43–47) e o JUnit (linhas 48–52);
  • linhas 57–63: a seção [dependencies] do pai adiciona suas dependências a todos os módulos: neste caso, o JUnit, com o escopo [test]. Uma dependência com o escopo [test] é usada apenas para compilar e executar os testes: não é incluída nas dependências da biblioteca produzida;
  • linhas 66–91: a seção [pluginManagement] define de forma semelhante a versão e a configuração dos plugins do Maven para todos os módulos: o compilador (com a opção [-Xlint:all], linhas 75–77), o Surefire, que executa os testes ([mvn test]), e o exec, que executa um programa ([mvn exec:java]). A linha 74 instrui o compilador a preservar os nomes dos parâmetros dos métodos no código compilado: o JUnit usa isso para exibir os testes parametrizados, como veremos.

A aplicação é construída com o seguinte comando, digitado na pasta [TaxV5]:

> mvn install

Para cada módulo, o Maven executa as fases de seu ciclo de vida na seguinte ordem: compilação ([compile]), compilação e execução dos testes ([test]), criação do arquivo JAR na pasta [target] do módulo ([package]) e, por fim, instalação ([install]). Se um teste falhar, o build é interrompido. A fase [install] copia o arquivo JAR e o arquivo [pom.xml] de cada módulo para o repositório Maven local do usuário, a pasta [~/.m2/repository]: por exemplo, o arquivo [examples/tax/tax-dao/5.0/tax-dao-5.0.jar] fica ali. O Maven procura as dependências nesse repositório local antes de baixá-las do Maven Central. Esse repositório local tem duas finalidades:

  • um comando Maven digitado na pasta de um módulo (por exemplo, [mvn exec:java] na pasta [tax-ui]) encontra no repositório local os módulos dos quais esse módulo depende;
  • as aplicações dos Capítulos 10 a 13 declaram, em seus arquivos [pom.xml], dependências de [examples.tax:tax-dao:5.0], [examples.tax:tax-business:5.0] e, para a classe [Dialog], de [examples.tax:tax-ui:5.0]: assim, reutilizam as camadas da versão 5 sem copiar o código-fonte, exatamente como usariam o Jackson ou o Spring.

Depois de qualquer alteração em um módulo, é preciso, portanto, executar novamente [mvn install] para que os outros projetos enxerguem a nova versão. A opção [-DskipTests] pula a execução dos testes, e a opção [-q] (“quiet”) limita a saída do Maven apenas aos erros.

Se você abrir na IDE um projeto que depende desses módulos antes de instalar a versão 5, o Maven os procurará em vão no Maven Central, e a IDE informará dependências não resolvidas, por exemplo, “Unresolved dependency: 'examples.tax:tax-dao:jar:5.0' ” no IntelliJ IDEA. O Maven registra essa falha: ele deixa arquivos chamados [*.lastUpdated] na pasta de cada módulo dentro do repositório local ([%USERPROFILE%\.m2\repository\examples\tax\tax-dao\5.0] etc.), e o erro pode persistir após o build [mvn install]. A solução:

  • instalar a versão 5 ([mvn install] na pasta [TaxV5] ou, no IntelliJ, o painel “Maven” / [tax-v5] / “Lifecycle ” / [install]);
  • excluir os arquivos [*.lastUpdated] das pastas [tax-dao/5.0], [tax-business/5.0] e [tax-ui/5.0] do repositório local, sem tocar nos arquivos [.jar] e [.pom];
  • ressincronizar os projetos (com o botão “Sync All Maven Projects” do painel “Maven”) e, se o erro persistir, limpar os caches do IntelliJ (“File / Invalidate Caches… / Invalidate and Restart”).

Para determinar se o problema vem do Maven ou da IDE, digite [mvn compile] na pasta do projeto que depende da versão 5: se o Maven responder “BUILD SUCCESS”, as dependências estão corretas e só a IDE precisa ser ressincronizada.

6.4.2. A camada [dao]

O módulo [tax-dao] contém a camada [dao] e as entidades da aplicação. Seu arquivo [pom.xml] é o seguinte:

<?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>

    <!-- o projeto pai fornece as versões e a configuração comuns -->
    <parent>
        <groupId>examples.tax</groupId>
        <artifactId>tax-v5</artifactId>
        <version>5.0</version>
    </parent>

    <artifactId>tax-dao</artifactId>

    <dependencies>
        <!-- Jackson para a leitura do arquivo JSON -->
        <dependency>
            <groupId>tools.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
    </dependencies>

</project>
  • linhas 8–12: o projeto pai. O módulo herda dele o grupo e a versão; apenas seu nome é especificado (linha 14). Suas coordenadas são, portanto, [examples.tax:tax-dao:5.0];
  • linhas 18–21: a dependência do Jackson, sem versão: ela é determinada pelo projeto pai. O JUnit é herdado do pai.

As entidades

O record [TaxBracket] corresponde ao da versão 4 (pacote [tax.entities]). A enumeração [ErrorCode] é removida: [TaxException] passa assim a ser comum a todas as implementações da camada [dao], sem estar vinculada aos códigos de nenhuma delas:

package tax.entities;

import java.io.Serial;

// a exceção da aplicação [Tax], qualquer que seja a camada que a lance
// ela deriva de RuntimeException: é uma exceção não verificada
public class TaxException extends RuntimeException {

    // versão da classe para serialização (uma exceção é serializável)
    @Serial
    private static final long serialVersionUID = 1L;

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

    // construtores
    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;
    }

    // o código de erro
    public int getCode() {
        return code;
    }
}
  • linha 14: o código de erro continua sendo um simples inteiro: cada implementação da camada [dao] define seus próprios códigos;
  • linhas 17–32: quatro construtores, com ou sem causa, com ou sem código. Todos chamam o último. Sem código, este vale 0.

A implementação [FileTax]

A interface [ITaxDao] e a classe [HardwiredTax] são as da versão 4. A classe [FileTax] difere apenas na maneira de escrever seus códigos de erro:

// uma camada [dao] que lê as faixas de imposto de um arquivo de texto
// uma linha por faixa: limit:coeffR:coeffN (ponto decimal)
public class FileTax implements ITaxDao {

    // códigos de erro específicos desta implementação: potências de 2, que podem ser combinadas
    public static final int ACCESS = 1, LINE = 2, FIELD1 = 4, FIELD2 = 8, FIELD3 = 16;

    // arquivo de dados, relativo à pasta atual
    private final String fileName;

    // faixas de imposto
    private final List<TaxBracket> taxBrackets;
  • linha 6: os códigos de erro, que antes estavam na enumeração [ErrorCode] do pacote de entidades, tornaram-se constantes na classe [FileTax]: são, de fato, códigos específicos desta implementação da interface [ITaxDao] ([JsonTax] tem os seus). Em Java, uma constante é um campo [static final], cujo nome é escrito, por convenção, em maiúsculas. Vários campos do mesmo tipo podem ser declarados na mesma instrução. As constantes são escritas como [FIELD1] dentro da classe e como [FileTax.FIELD1] fora dela. As importações estáticas da versão 4 não são mais necessárias.

Mais adiante, no construtor:

                String[] fields = line.split("\\s*:\\s*");
                int code = 0;
                BigDecimal limit = null, coeffR = null, coeffN = null;
                if (fields.length != 3) {
                    code = LINE;
                } else {
                    // conversões dos 3 campos: cada erro adiciona seu 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;
                }
                // erro?
                if (code != 0) {
                    throw new TaxException("Line no. " + lineNumber + " is incorrect: [" + line + "]", code);
                }
                // armazenamos a nova faixa de imposto
                brackets.add(new TaxBracket(limit, coeffR, coeffN));
            }
        } catch (IOException e) {
            // erro de acesso ao arquivo: ele é encapsulado em uma TaxException
            throw new TaxException("Error while reading the file " + fileName, e, ACCESS);
        }
  • linhas 4–14: os códigos são inteiros combinados diretamente com o operador [|=];
  • linhas 17, 24: os erros são encapsulados em uma [TaxException], junto com seus códigos.

A implementação [JsonTax]

Como na versão 3 do Capítulo 5, a terceira implementação da camada [dao] lê as faixas de imposto de um arquivo JSON com a biblioteca Jackson. O arquivo [TaxData.json] é o seguinte:

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 }
]

A classe [JsonTax] é a seguinte:

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;

// uma camada [dao] que lê as faixas de imposto de um arquivo JSON
public class JsonTax implements ITaxDao {

    // códigos de erro específicos desta implementação
    public static final int ACCESS = 1, FORMAT = 2;

    // arquivo de dados, relativo à pasta atual
    private final String fileName;

    // faixas de imposto
    private final List<TaxBracket> taxBrackets;

    // construtor
    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 {
            // desserialização do array JSON em um array 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;
    }
}
  • linha 17: códigos de erro desta implementação: erro de acesso ao arquivo ou conteúdo incorreto;
  • linhas 29–37: o arquivo é lido por inteiro em uma string por [Files.readString] (Java 11), com o mesmo tratamento dos erros de E/S que em [FileTax];
  • linha 40: a string JSON é convertida em um array [TaxBracket[]]. No Jackson 3, cujos pacotes começam por [tools.jackson], o objeto [JsonMapper] que faz a conversão é imutável: ele é construído por meio de um objeto intermediário, o “builder” ([JsonMapper.builder()...build()]). Seu método [readValue] recebe o texto JSON e a classe do objeto a criar, neste caso [TaxBracket[].class]. O Jackson sabe construir um record: ele associa os nomes JSON ([limit], [coeffR], [coeffN]) aos componentes do record e chama seu construtor. Os números são lidos diretamente em [BigDecimal], o tipo do componente, sem passar por um [double]: são, portanto, exatos;
  • linhas 41–43: [readValue] retorna [null] se o arquivo contiver o literal JSON [null]; nesse caso, uma exceção é lançada;
  • linha 44: o array se torna uma lista imutável;
  • linhas 45–48: um arquivo que não seja um array JSON de faixas de imposto provoca uma [JacksonException]. No Jackson 3, essa exceção deriva de [RuntimeException]: é uma exceção não verificada. O bloco [catch] captura dois tipos de exceção (“multi-catch”, Java 7) e as encapsula em uma [TaxException] do tipo [FORMAT].

Um programa de teste

Antes de escrever testes automatizados, façamos um primeiro teste visual da camada [dao]. O programa [TrialDao] exibe as faixas de imposto fornecidas pelas três implementações. Nós o colocamos nas fontes de teste do módulo ([src/test/java]): ele não será incluído no arquivo JAR da camada [dao]:

package tax.dao;

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

// programa de teste: as faixas de imposto fornecidas pelas três implementações da camada [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) {
            // exibição do erro
            String origin = e.getCause() == null ? ""
                    : ", original exception: " + e.getCause().getMessage();
            IO.println("The following error occurred: [Code=" + e.getCode()
                    + ", Message=" + e.getMessage() + origin + "]");
        }
    }
}
  • linha 10: o método [main]. A partir do Java 25, ele não precisaria mais ser público nem receber argumentos de programa; em projetos Maven, mantemos sua forma clássica [public static void main(String[] args)], reconhecida por todas as ferramentas (plugin [exec-maven-plugin], IDE);
  • linhas 12–13: uma lista das três implementações da interface [ITaxDao];
  • linha 15: [getClass()] retorna a classe real do objeto, cujo nome (sem o pacote) é dado por [getSimpleName()];
  • linha 17: [IO.println] exibe a faixa de imposto por meio de seu método [toString], gerado pelo compilador para um record;
  • linhas 20–26: tratamento de uma eventual [TaxException].

O programa é executado na pasta [tax-dao]. A fase [test-compile] compila o código-fonte principal e o código-fonte de teste; o parâmetro [exec.mainClass] especifica a classe a executar, e [exec.classpathScope=test] instrui o plugin exec a usar as classes de teste e as dependências de escopo [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]

As três implementações retornam as mesmas faixas. O método [toString] de um [BigDecimal] sempre escreve um ponto decimal, independentemente do idioma do usuário.

6.4.3. A camada [business]

O arquivo [pom.xml] do módulo [tax-business] é o seguinte:

<?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>

    <!-- o projeto pai fornece as versões e a configuração comuns -->
    <parent>
        <groupId>examples.tax</groupId>
        <artifactId>tax-v5</artifactId>
        <version>5.0</version>
    </parent>

    <artifactId>tax-business</artifactId>

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

</project>
  • linhas 18–21: a camada [business] usa a camada [dao]. Na pasta [TaxV5], o Maven constrói [tax-dao] antes de [tax-business]; na pasta [tax-business], ele encontra [tax-dao] no repositório local, onde [mvn install] o colocou. As dependências são transitivas: o módulo também recebe o Jackson, do qual [tax-dao] depende.

A interface [ITaxBusiness] e a classe [TaxBusiness] são as da versão 4 (pacote [tax.business]). O programa de teste [TrialBusiness], situado nas fontes de teste do módulo, realiza alguns cálculos de imposto:

package tax.business;

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

// programa de teste: alguns cálculos de imposto com a camada [dao] FileTax
public class TrialBusiness {

    public static void main(String[] args) {
        try {
            // o arquivo de faixas é o do módulo tax-dao (caminho relativo à pasta atual)
            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) {
            // exibição do erro
            String origin = e.getCause() == null ? ""
                    : ", original exception: " + e.getCause().getMessage();
            IO.println("The following error occurred: [Code=" + e.getCode()
                    + ", Message=" + e.getMessage() + origin + "]");
        }
    }
}
  • linha 12: criação das camadas [dao] e [business]. A camada [dao] é implementada pela classe [FileTax]. Como o programa é executado na pasta [tax-business], o caminho relativo [../tax-dao/TaxData.txt] refere-se ao arquivo de dados do módulo [tax-dao];
  • linhas 13–16: chamadas repetidas ao único método da interface [ITaxBusiness].

Resultados, na pasta [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

Um casal com 2 filhos e uma pessoa solteira com 3 filhos têm o mesmo número de partes (3): seus impostos são iguais.

6.4.4. Testes unitários com JUnit

6.4.4.1. O princípio

Os testes feitos até agora baseavam-se na verificação visual: conferíamos se a tela exibia os resultados esperados. Esse método é inviável quando há muitos testes a executar: os humanos se cansam, e sua capacidade de verificar resultados diminui ao longo do dia. Os testes devem, portanto, ser automatizados e dispensar qualquer intervenção humana.

Uma aplicação evolui com o tempo. A cada atualização, é preciso verificar se ela não “regride”, isto é, se continua passando nos testes de funcionalidade feitos durante seu desenvolvimento inicial. Esses testes são chamados de testes de não regressão. Uma aplicação de porte médio pode exigir centenas de testes: de fato, todo método de toda classe da aplicação é testado. São os chamados testes unitários.

Foram desenvolvidos frameworks para automatizar esses testes. Em Java, o principal framework é o JUnit, criado no fim dos anos 1990 por Kent Beck e Erich Gamma. Usamos a versão 6, lançada no fim de 2025 (aqui, a versão 6.0.3); sua API, a do pacote [org.junit.jupiter.api], é a versão 5 do JUnit, também conhecida como JUnit Jupiter (o TestNG é outro framework baseado no mesmo princípio). Os testes são executados pelo comando [mvn test] na linha de comando: é isso que permite iniciá-los automaticamente, por exemplo, sempre que alterações de código são enviadas a um servidor de integração contínua. As IDEs (IntelliJ IDEA, VS Code com o Extension Pack for Java) também executam esses testes e exibem seus resultados em uma estrutura em árvore.

6.4.4.2. Um primeiro exemplo

Examinemos o princípio dos testes JUnit com um exemplo. O projeto Maven [DemoTests] contém apenas testes, situados na pasta [src/test/java/demotests]. Seu arquivo [pom.xml] é o seguinte:

<?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: a API de testes e o motor que executa os testes -->
        <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: o plugin Surefire executa os testes -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.5.6</version>
            </plugin>
        </plugins>
    </build>
</project>
  • linhas 18–23: o projeto usa o artefato [junit-jupiter], que inclui a API de teste (as anotações e a classe [Assertions]), o suporte a testes parametrizados e o mecanismo que descobre e executa os testes. Seu escopo é [test];
  • linha 33: o compilador preserva os nomes dos parâmetros dos métodos, que o JUnit exibe nos testes parametrizados;
  • linhas 40–44: o plugin Surefire, que executa os testes durante a fase [test] do Maven.

A classe de teste [Tests1] é a seguinte:

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;

// uma classe de teste
class Tests1 {

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

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

    // executado antes de cada teste
    @BeforeEach
    void before() {
        IO.println("before");
    }

    // executado depois de cada teste
    @AfterEach
    void after() {
        IO.println("after");
    }

    // um teste que passa
    @Test
    void t1() {
        IO.println("test1");
        assertEquals(4, sum(2, 2));
    }

    // um teste que falha
    @Test
    void t2() {
        IO.println("test2");
        assertEquals(5, sum(2, 2), "2 + 2 is not equal to 5");
    }
}
  • linha 3: os métodos de verificação, ou asserções, são métodos estáticos da classe [Assertions]. Eles são importados com uma importação estática para que possamos escrever [assertEquals(...)] em vez de [Assertions.assertEquals(...)];
  • linha 10: uma classe de teste é uma classe comum, sem anotações. Ela não precisa ser pública, nem seus métodos: a visibilidade de pacote é suficiente;
  • linhas 13–15: o método testado. Em um projeto real, ele estaria no código-fonte principal do projeto ([src/main/java]);
  • linhas 18–20: o construtor. Ele serve apenas para exibir uma mensagem na tela: queremos ver quando ele é executado;
  • linha 23: a anotação [@BeforeEach] designa um método executado antes de cada teste;
  • linha 29: a anotação [@AfterEach] designa um método executado após cada teste;
  • linha 35: a anotação [@Test] designa um método de teste. Um método de teste não retorna nada, não é privado e, com uma exceção que veremos, não tem parâmetros;
  • linha 38: o método [assertEquals(expected, actual)] verifica se o valor obtido é igual ao valor esperado. Caso contrário, lança uma exceção [AssertionFailedError] e o teste falha. Aqui, a asserção deve passar;
  • linha 45: esta asserção deve falhar. O terceiro parâmetro é a mensagem exibida em caso de falha: no JUnit, a mensagem é sempre o último parâmetro das asserções.

Executamos os testes com o comando [mvn test] na pasta do projeto. Abaixo está uma captura de tela do console launcher do JUnit, que exibe os testes em estrutura de árvore; [mvn test] executa os mesmos testes, e a IDE exibe a mesma árvore. Abreviamos a pilha de chamadas (linhas [...]):

> 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          ]
  • Linhas 2–5: a saída do teste [t1]: o construtor foi executado, seguido do método [before], do teste e, por fim, do método [after]. O console launcher exibe a saída dos testes à medida que são executados, antes da árvore-resumo;
  • Linhas 6–9: saída do teste [t2]. Observe que o construtor foi executado novamente: o JUnit cria uma nova instância da classe de teste para cada teste. Os testes são, portanto, independentes entre si: um teste não pode ser afetado pelo estado deixado por outro (em contrapartida, a anotação [@TestInstance(Lifecycle.PER_CLASS)] exige uma única instância para todos os testes da classe);
  • linhas 11–27: a árvore de testes: o engine JUnit Jupiter, as classes de teste e, depois, seus testes. O símbolo ✔ indica sucesso e o símbolo ✘ indica falha. Os testes da classe [Tests2], mostrada abaixo, passaram todos; o JUnit os executou antes dos da classe [Tests1]. A ordem de execução das classes e dos métodos é determinística, mas intencionalmente pouco óbvia: os testes não devem depender da ordem de execução;
  • linha 27: o teste [t2] falhou. A mensagem de erro contém a mensagem passada a [assertEquals], o valor esperado e o valor obtido. As mensagens do JUnit estão em inglês;
  • linhas 29–34: detalhes da falha: a exceção [AssertionFailedError] lançada pela asserção e a pilha de chamadas no momento da falha, que aponta para a linha com defeito, a linha 45 do arquivo [Tests1.java];
  • linhas 38–43: o resumo: 12 testes, dos quais 11 passaram e 1 falhou. O comando [mvn test] termina então com uma falha de build (“BUILD FAILURE”) e um código de saída diferente de zero, o que permite a um script detectar a falha.

Para executar apenas um subconjunto dos testes, use o parâmetro [test] do plugin Surefire: [mvn test -Dtest=Tests2] executa apenas os testes da classe [Tests2], enquanto [mvn test -Dtest=Tests1#t1] executa apenas o teste [t1]. Por fim, observe as anotações [@BeforeAll] e [@AfterAll], que designam métodos estáticos executados uma única vez, antes do primeiro teste e depois do último teste da classe, e a anotação [@DisplayName], que dá a um teste um nome mais descritivo que o de seu método. Por padrão, o JUnit executa os testes um após o outro; a execução paralela pode ser solicitada em um arquivo de configuração [junit-platform.properties].

6.4.4.3. Outras asserções

A classe [Assertions] tem muitos métodos. A classe [Tests2] apresenta alguns deles:

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;

// algumas outras asserções do JUnit
class Tests2 {

    // booleanos, null, referências
    @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());
    }

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

    // strings e coleções: todas as asserções são verificadas, mesmo que uma delas falhe
    @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));
    }

    // exceções: o teste passa se a exceção esperada for lançada
    @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());
    }

    // um teste parametrizado: uma execução por linha 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);
    }

    // um teste parametrizado com um único parâmetro: uma execução por valor
    @ParameterizedTest
    @ValueSource(ints = {2, 4, 6})
    void t8(int n) {
        assertEquals(0, n % 2);
    }
}
  • linhas 29–30: verificam se uma expressão booleana é verdadeira ou falsa;
  • linhas 32–33: verificam se uma referência é não nula ou nula;
  • linhas 34–35: verificam se duas referências apontam para o mesmo objeto;
  • linhas 41–43: os cálculos com números reais [double] são aproximados: [0.1 + 0.2] não é exatamente igual a [0.3]. Por isso comparamos dois números reais com certa margem de erro, neste caso de um milionésimo;
  • linhas 51–56: o JUnit não tem asserções específicas para strings: usamos [assertTrue] para verificar o resultado dos métodos [startsWith] ou [contains]. [assertIterableEquals] verifica se duas coleções têm os mesmos elementos, na mesma ordem. Essas asserções são agrupadas por [assertAll], que recebe [() -> ...] expressões lambda (Capítulo 7): todas as asserções são executadas, mesmo que uma delas falhe, e as falhas são relatadas em conjunto. Sem [assertAll], a primeira falha interrompe o teste. A biblioteca AssertJ, frequentemente usada com o JUnit, oferece asserções mais sofisticadas, escritas na forma [assertThat(message).startsWith("Line")];
  • linhas 63–65: [assertThrows(Type.class, action)] executa a ação, uma expressão lambda, e verifica se ela lança uma exceção do tipo [Type] ou de um tipo derivado. Aqui, o método [get] da lista criada por [List.of] lança uma [ArrayIndexOutOfBoundsException], classe derivada de [IndexOutOfBoundsException]: a asserção é bem-sucedida. [assertThrowsExactly], por outro lado, exige uma exceção exatamente do tipo [Type]. Ambos os métodos retornam a exceção lançada, o que permite verificar suas propriedades em seguida (linha 66);
  • linhas 70–74: um teste parametrizado. A anotação [@ParameterizedTest] substitui [@Test]; o método tem parâmetros, e a anotação [@CsvSource] fornece conjuntos de valores, uma string por conjunto, com os valores separados por vírgulas. O JUnit os converte para o tipo dos parâmetros. O teste é executado uma vez por conjunto de valores: isso aparece nas linhas 18–20 dos resultados anteriores;
  • linhas 77–81: para um teste com um único parâmetro, a anotação [@ValueSource] fornece diretamente a lista de valores ([ints], [strings], [doubles]…).

Vamos resumir os principais métodos da classe [Assertions]:

Método
Verifica que
[assertEquals(expected, actual)]
os dois valores são iguais (método [equals])
[assertEquals(real1, real2, delta)]
os dois números reais são iguais dentro de um delta
[assertNotEquals(v1, v2)]
Os dois valores são diferentes
[assertSame(o1, o2)], [assertNotSame(o1, o2)]
As duas referências apontam (ou não) para o mesmo objeto
[assertNull(o)], [assertNotNull(o)]
A referência é nula (ou não)
[assertTrue(b)], [assertFalse(b)]
A expressão booleana é verdadeira (ou falsa)
[assertInstanceOf(Type.class, o)]
o objeto é do tipo [Type] ou de um tipo derivado
[assertArrayEquals(t1, t2)]
os dois arrays têm os mesmos elementos, na mesma ordem
[assertIterableEquals(c1, c2)]
As duas coleções têm os mesmos elementos, na mesma ordem
[assertAll(action1, action2, ...)]
Todas as asserções das ações são bem-sucedidas (as falhas são relatadas em conjunto)
[assertThrows(Type.class, action)]
A ação lança uma exceção do tipo [Type] ou de um tipo derivado
[assertThrowsExactly(Type.class, action)]
A ação lança uma exceção exatamente do tipo [Type]
[fail(message)]
(sempre falha)

Todos esses métodos aceitam um último parâmetro opcional: a mensagem exibida em caso de falha.

6.4.4.4. Testando a camada [dao]

Voltemos à aplicação [Tax]. A classe [DaoTests], que testa a camada [dao], fica na pasta [src/test/java/tax/dao] do módulo [tax-dao]. Ela pertence ao mesmo pacote das classes testadas, o que lhe dá acesso aos membros com visibilidade de pacote. O [pom.xml] do módulo não precisa ser modificado: o JUnit é herdado do projeto pai. O arquivo de dados incorreto [TaxDataInvalid.txt] fica na pasta do módulo: é o diretório atual durante a execução dos testes.

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;

// testes da camada [dao]
class DaoTests {

    // fábrica de uma camada [dao] a partir do nome de sua classe
    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);
        };
    }

    // o mesmo teste para as três implementações
    @ParameterizedTest
    @ValueSource(strings = {"HardwiredTax", "FileTax", "JsonTax"})
    void taxBrackets(String implementation) {
        List<TaxBracket> brackets = createDao(implementation).getTaxBrackets();
        // algumas verificações: compareTo ignora a escala de BigDecimal (0.191 e 0.1910 são iguais)
        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()));
    }

    // as três implementações fornecem as mesmas faixas
    @Test
    void sameBrackets() {
        List<TaxBracket> reference = new HardwiredTax().getTaxBrackets();
        assertEquals(reference, new FileTax("TaxData.txt").getTaxBrackets());
        assertEquals(reference, new JsonTax("TaxData.json").getTaxBrackets());
    }

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

    // arquivo cuja linha 3 está incorreta (vírgulas decimais)
    @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"));
    }

    // arquivo JSON ausente
    @Test
    void missingJsonFile() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new JsonTax("TaxDataMissing.json"));
        assertEquals(JsonTax.ACCESS, e.getCode());
    }
}
  • linhas 21–28: um método que cria uma camada [dao] a partir do nome de sua classe, usando uma expressão [switch] (Java 14): cada [case] retorna, após a seta [->], o valor da expressão;
  • linhas 31–40: o mesmo teste é feito para as três implementações com a anotação [@ValueSource]. Ele verifica que há 7 faixas de imposto e confere o valor da faixa nº 2 (a terceira). Os valores [BigDecimal] são comparados com [compareTo] em vez de [equals]: o método [equals] de um [BigDecimal] leva em conta o número de casas decimais escritas (sua escala, “scale”) e trata 0.191 e 0.1910 como diferentes, enquanto [compareTo] compara apenas os valores;
  • linhas 44–48: as três implementações produzem exatamente as mesmas faixas. [assertEquals] compara as listas usando seu próprio método [equals], que compara os elementos um a um; o método [equals] de um record, gerado pelo compilador, compara seus componentes. A comparação é bem-sucedida porque as três fontes escrevem os números da mesma maneira;
  • linhas 52–57: um arquivo ausente provoca uma [TaxException] com o código [ACCESS], que encapsula uma [NoSuchFileException]. [assertInstanceOf] verifica o tipo da causa;
  • linhas 61–66: o arquivo [TaxDataInvalid.txt] provoca uma [TaxException] cujo código combina os bits de [FIELD2] e [FIELD3], e cuja mensagem começa com “Line no. 3”;
  • linhas 70–74: a mesma verificação para a implementação [JsonTax].

6.4.4.5. Testes da camada [business]

A classe [BusinessTests] do módulo [tax-business] testa a camada [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;

// testes da camada [business]
class BusinessTests {

    // a camada [dao] e a camada [business] testada: o JUnit cria uma instância da classe por teste
    private final HardwiredTax dao = new HardwiredTax();
    private final ITaxBusiness business = new TaxBusiness(dao);

    // cálculos cujo resultado é conhecido
    @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));
    }

    // o cálculo não modifica as faixas fornecidas pela camada [dao]
    @Test
    void unchangedBrackets() {
        List<TaxBracket> before = List.copyOf(dao.getTaxBrackets());
        business.calculateTax(true, 2, 600000);
        assertEquals(before, dao.getTaxBrackets());
    }

    // parâmetros negativos são rejeitados
    @Test
    void negativeParameters() {
        assertThrowsExactly(IllegalArgumentException.class, () -> business.calculateTax(true, -1, 60000));
        assertThrowsExactly(IllegalArgumentException.class, () -> business.calculateTax(true, 2, -60000));
    }

    // a camada [business] testada com uma camada [dao] falsa: uma única faixa, um imposto de 10 %
    // ITaxDao tem apenas um método: uma expressão lambda basta para implementá-lo
    @Test
    void withFakeDao() {
        ITaxDao fakeDao =
                () -> List.of(new TaxBracket(BigDecimal.ZERO, new BigDecimal("0.1"), BigDecimal.ZERO));
        ITaxBusiness fakeBusiness = new TaxBusiness(fakeDao);
        // renda tributável = 0.72 x 100000 = 72000; imposto = 10 % de 72000
        assertEquals(7200, fakeBusiness.calculateTax(false, 0, 100000));
    }
}
  • Linhas 19–20: a camada [business] testada é construída sobre a camada [dao] [HardwiredTax], que não depende de nenhum arquivo. Os campos são inicializados quando o objeto é criado; como o JUnit cria uma nova instância da classe para cada teste, cada teste recebe camadas novas em folha;
  • linhas 23–34: cálculos cujos resultados são conhecidos, fornecidos por [@CsvSource]. São os valores de controle da aplicação, já obtidos por versões anteriores: devem permanecer corretos em todas as versões futuras. As strings [true] e [false] são convertidas para [boolean];
  • linhas 38–42: o cálculo do imposto não modifica as faixas de imposto fornecidas pela camada [dao]. As faixas são guardadas antes de um cálculo que usa a última faixa, e depois é feita uma comparação. Como a lista já é somente leitura, [List.copyOf] retorna a mesma lista, e qualquer tentativa de modificá-la pela camada [business] provocaria uma [UnsupportedOperationException], o que também faria o teste falhar. O teste guarda a memória do antigo defeito descrito acima: se alguém o reintroduzisse, este teste o sinalizaria;
  • linhas 46–49: parâmetros negativos são rejeitados;
  • linhas 55–56: uma camada [dao] fictícia, como a que o desenvolvedor da camada [business] usaria antes que a camada [dao] real estivesse pronta: uma única faixa de imposto, um imposto de 10% sobre a renda tributável. Como a interface [ITaxDao] tem apenas um método abstrato, ela é uma interface funcional: uma expressão lambda basta para implementá-la, sem escrever uma classe. As expressões lambda serão tratadas no Capítulo 7;
  • linhas 57–59: a camada [business] funciona com a camada [dao] fictícia. A camada [business] é assim testada isoladamente, independentemente das implementações reais da camada [dao].

6.4.4.6. Executando os testes

O comando [mvn test], quando digitado na pasta [TaxV5], executa os testes de todos os módulos; quando digitado na pasta de um módulo, executa apenas os testes desse módulo. Aqui está a árvore de testes do módulo [tax-dao] (incluímos apenas os resultados dos testes):

> 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          ]

e a árvore de testes do 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          ]

Todos os 16 testes passaram: cada conjunto de valores de um teste parametrizado conta como um teste, e o JUnit os exibe junto com os nomes e valores de seus parâmetros (esses nomes estão disponíveis graças à opção [parameters] do compilador). Consideramos agora as camadas [dao] e [business] operacionais. Os arquivos JAR produzidos por [mvn package] ou [mvn install] contêm apenas o código das camadas: as classes de teste, compiladas na pasta [target/test-classes], não são incluídas. Por fim, observe que [mvn install] executa os testes antes de instalar os módulos: uma regressão impede a instalação de uma nova versão das camadas.

6.4.5. A camada [ui]

O arquivo [pom.xml] do módulo [tax-ui] é o seguinte:

<?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>

    <!-- o projeto pai fornece as versões e a configuração comuns -->
    <parent>
        <groupId>examples.tax</groupId>
        <artifactId>tax-v5</artifactId>
        <version>5.0</version>
    </parent>

    <artifactId>tax-ui</artifactId>

    <dependencies>
        <!-- a camada [ui] usa as outras duas camadas -->
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-business</artifactId>
        </dependency>
        <!-- o contêiner de injeção de dependência Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- mvn exec:java executa a classe principal -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <configuration>
                    <mainClass>tax.ui.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
  • linhas 18–21: a camada [ui] usa a camada [business] e, por transitividade, a camada [dao];
  • linhas 23–26: o contêiner de injeção de dependência do Spring, o artefato [spring-context], que traz consigo os outros módulos do Spring de que precisa ([spring-core], [spring-beans]…);
  • linhas 32–38: o plugin exec, cuja versão é determinada pelo pai. O comando [mvn exec:java] executa a classe [tax.ui.Main].

A classe [Dialog] é a da versão 4 (pacote [tax.ui]), complementada com um método que exibe uma exceção e todas as exceções que ela encapsula:

    // exibição de uma exceção e de todas as que ela encapsula
    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);
        }
    }
}
  • linha 3: uma string de 40 traços, criada pelo método [repeat] (Java 11);
  • linha 5: o laço percorre a cadeia de exceções: cada exceção dá acesso, por meio de seu método [getCause()], à exceção que ela encapsula, até a última, cuja causa é [null]. O parâmetro é do tipo [Throwable], a superclasse de todas as exceções;
  • Linha 6: para cada exceção, são exibidos o nome completo de sua classe (incluindo o pacote) e sua mensagem.

A classe [Dialog] é pública: as versões futuras da aplicação, que passarão a usar a camada [dao], poderão reutilizar a camada [ui] dependendo do módulo [tax-ui] e chamando [Dialog.run(business)].

6.4.6. Integrando as camadas por injeção de dependência

Na versão 4, o programa principal criava as camadas [dao] e [business] nomeando suas classes de implementação:

1
2
3
        ITaxDao dao = source.equals("hardwired") ? new HardwiredTax() : new FileTax(source);
        // criação da camada [business], que recebe a camada [dao]
        business = new TaxBusiness(dao);

Além dessas linhas, nada muda na aplicação quando a implementação de uma camada muda, já que cada camada se comunica com a seguinte por meio de uma interface. Podemos levar a independência das camadas um passo adiante confiando sua criação a um contêiner de injeção de dependência e colocando a escolha da implementação da camada [dao] em um arquivo de configuração. Mudar a implementação dessa camada passa então a significar apenas modificar esse arquivo, sem recompilar a aplicação.

Image

No exemplo acima, o programa principal da camada [ui] inicia o contêiner Spring, [0]. O contêiner Spring cria as camadas [dao] e [1], depois as camadas [business] e [2], às quais passa a camada [dao]. Por fim, a camada [ui] solicita ao contêiner a camada [business] e recebe uma referência a ela: [3].

6.4.6.1. O arquivo de configuração

A escolha da implementação da camada [dao] é especificada no arquivo [tax.properties] da pasta [tax-ui]:

1
2
3
# configuração da aplicação [Tax]: implementação da camada [dao]
dao.implementation=FileTax
dao.file=TaxData.txt
  • linha 1: um comentário que começa com o caractere [#];
  • linha 2: a classe que implementa a camada [dao]: [HardwiredTax], [FileTax], ou [JsonTax];
  • linha 3: o arquivo de dados, para as implementações que leem um.

Um arquivo “properties” é o formato tradicional de configuração em Java: uma propriedade por linha, na forma [key=value], lido pela classe [java.util.Properties]. As chaves costumam receber prefixos para formar grupos, como o prefixo [dao.] aqui. O módulo contém três outros arquivos de configuração, que o programa usa se seus nomes forem passados 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

Os arquivos [TaxData.txt] e [TaxData.json] foram copiados para a pasta [tax-ui]: seus caminhos são relativos à pasta atual, e [mvn exec:java] executa o programa na pasta do módulo.

6.4.6.2. O programa principal

O programa principal [Main] do módulo [tax-ui] é o seguinte:

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;

// integração das camadas pelo contêiner Spring GenericApplicationContext
public class Main {

    public static void main(String[] args) {
        // o arquivo de configuração: tax.properties por padrão, ou o passado como argumento
        String configFile = args.length > 0 ? args[0] : "tax.properties";

        // integração das camadas
        ITaxBusiness business;
        try {
            // lendo a configuração, na pasta atual
            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", "");

            // o contêiner Spring: as camadas são registradas nele
            GenericApplicationContext context = new GenericApplicationContext();
            // a camada [dao]: a implementação é escolhida pela configuração
            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");
            });
            // a camada [business]: o contêiner passará a camada [dao] ao seu construtor
            context.registerBean(TaxBusiness.class);

            // iniciando o contêiner: ele cria a camada [dao], depois a camada [business]
            context.refresh();
            business = context.getBean(ITaxBusiness.class);
        } catch (IOException | RuntimeException e) {
            // exibição do erro e encerramento do programa
            Dialog.displayError(e);
            System.exit(1);
            return;
        }

        // o diálogo com o usuário
        Dialog.run(business);
    }
}
  • linha 20: o método [main] de uma classe comum, em sua forma padrão [public static void main(String[] args)];
  • linha 22: o nome do arquivo de configuração: [tax.properties] por padrão, ou o passado como argumento;
  • linhas 28–31: leitura da configuração. [Files.newBufferedReader] abre o arquivo em UTF-8; a instrução [try] com recurso (Java 7) o fecha ao final do bloco, mesmo que ocorra uma exceção. [Properties.load] lê as linhas [key=value]. Um arquivo ausente provoca uma [NoSuchFileException], que é interceptada na linha 51;
  • linhas 32–33: [getProperty] retorna o valor de uma chave, ou o valor padrão fornecido como segundo parâmetro se a chave não existir;
  • linha 36: o contêiner Spring. O Spring chama de “bean” um objeto criado e gerenciado pelo contêiner, e de “contexto de aplicação” (“application context”) o próprio contêiner. [GenericApplicationContext] é um contêiner configurado programaticamente;
  • linhas 38–44: o registro da camada [dao]. [registerBean(ITaxDao.class, supplier)] indica que o bean do tipo [ITaxDao] será criado pelo “supplier”, uma expressão lambda sem parâmetros que retorna o objeto. O bean é um singleton, o escopo padrão do Spring: ele será criado uma única vez, e todas as solicitações retornarão o mesmo objeto; há apenas uma camada [dao] na aplicação. O supplier seleciona a classe de acordo com a configuração, usando uma expressão [switch]. Uma implementação desconhecida provoca uma [TaxException];
  • Linha 46: o registro da camada [business]: o contêiner criará ele mesmo o objeto [TaxBusiness]. Para isso, examina o construtor da classe [TaxBusiness], vê que ela espera um [ITaxDao] e lhe passa o bean desse tipo registrado acima: isso é a injeção de dependência, neste caso via construtor. A camada [dao] é uma dependência da camada [business];
  • linha 49: [refresh()] inicia o contêiner. O Spring cria então todos os beans singleton na ordem em que foram registrados: a camada [dao], seguida da camada [business]. Um erro de criação ocorre, portanto, nesta linha;
  • Linha 50: pede-se ao contêiner um bean do tipo [ITaxBusiness]. O contêiner encontra o bean [TaxBusiness], que implementa essa interface. [getBean] lança uma exceção se nenhum bean tiver esse tipo, ou se vários tiverem. Observe que a camada [ui] obtém a camada [business] sem especificar a classe que a implementa;
  • linhas 51–56: qualquer erro de leitura da configuração ([IOException]) ou de criação das camadas ([RuntimeException]: as exceções do Spring também são não verificadas) é exibido junto com a pilha da exceção, e o programa termina;
  • linha 59: a interação com o usuário, idêntica à da versão 4.

As primeiras versões do Spring liam os nomes completos das classes a instanciar em um arquivo XML e as criavam por reflexão. Optamos por definir as implementações possíveis no provider: o arquivo de configuração apenas seleciona entre elas, e o compilador verifica se as classes existem e têm os construtores exigidos. Nos dois casos, o código das camadas [ui] e [business] nunca especifica a classe que implementa a camada [dao]. Vale notar também que as classes das camadas não sabem nada sobre o Spring: nenhuma delas importa classes do Spring; apenas o programa principal o faz.

6.4.6.3. Execuções

Na pasta [tax-ui], após um [mvn install] na pasta [TaxV5], com o arquivo [tax.properties] (implementação [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: 

Com a implementação [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: 

Com a implementação [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: 

Mudamos para a implementação da camada [dao] sem alterar uma única linha de código nem recompilar a aplicação.

Com o arquivo [tax-error.properties], que se refere a um arquivo de dados 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
----------------------------------------
  • Linhas 2–3: antes de propagar a exceção, o Spring escreve um aviso em seu log. Como não há biblioteca de logging no projeto, esse log é tratado pelo mecanismo de logging padrão do JDK ([java.util.logging]), que escreve na saída de erro a data, a classe emissora, o nível da mensagem e a própria mensagem;
  • linha 10: a exceção original, do tipo [NoSuchFileException], lançada pela classe [FileTax];
  • linha 8: a camada [dao] a encapsulou em uma [TaxException];
  • linha 6: o próprio Spring encapsulou a exceção [TaxException] em uma exceção [BeanCreationException], cuja mensagem identifica o bean que não pôde ser criado: o do tipo [ITaxDao]. É essa exceção que foi propagada até o programa principal pela chamada a [refresh].

O ponto principal dessa cadeia é que muitas vezes a exceção mais profunda, a última exibida, é a mais significativa.

6.4.6.4. Uma variação: configuração por meio de uma classe anotada

As aplicações Spring costumam descrever seus beans em uma classe de configuração anotada. O módulo [tax-ui] contém um exemplo disso, a classe [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;

// a configuração do contêiner Spring escrita como uma classe Java anotada
@Configuration
// as propriedades do arquivo tax.properties da pasta atual são acessíveis por ${...}
@PropertySource("file:tax.properties")
public class TaxConfig {

    // a camada [dao]: a implementação é escolhida pela configuração
    @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");
        };
    }

    // a camada [business]: o Spring passa ao método a camada [dao] criada pelo método dao
    @Bean
    ITaxBusiness business(ITaxDao dao) {
        return new TaxBusiness(dao);
    }
}
  • Linha 16: a anotação [@Configuration] indica que a classe descreve beans;
  • Linha 18: a anotação [@PropertySource] instrui o Spring a ler ele mesmo o arquivo [tax.properties]. O prefixo [file:] designa um arquivo do sistema de arquivos, relativo ao diretório atual; o prefixo [classpath:] designaria um recurso localizado no arquivo JAR;
  • Linhas 22–32: um método anotado com [@Bean] cria um bean cujo nome é o do método ([dao]) e cujo tipo é o seu tipo de retorno. O Spring chama o método, fornecendo seus parâmetros. A anotação [@Value] solicita o valor de uma propriedade: [${dao.implementation}] é o valor da chave [dao.implementation], e [${dao.file:}] é o valor da chave [dao.file], com a string vazia (colocada após os dois-pontos) como valor padrão;
  • Linhas 35–38: o bean da camada [business]. O método espera um [ITaxDao]: o Spring lhe passa o bean criado pelo método [dao]. Desta vez, trata-se de injeção por parâmetro de método. Para garantir que um bean singleton seja criado uma única vez, o Spring deriva em tempo de execução uma subclasse da classe de configuração, que sobrescreve seus métodos [@Bean]: por isso, nem a classe nem esses métodos devem ser declarados [final] ou [private].

O programa principal [MainConfig] usa essa configuração:

package tax.ui;

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

// integração das camadas pelo contêiner Spring, configurado pela classe TaxConfig
public class MainConfig {

    public static void main(String[] args) {
        // criação e início do contêiner; ele é fechado no fim do bloco try
        try (var context = new AnnotationConfigApplicationContext(TaxConfig.class)) {
            // a camada [business] e o diálogo com o usuário
            ITaxBusiness business = context.getBean(ITaxBusiness.class);
            Dialog.run(business);
        } catch (RuntimeException e) {
            // exibição do erro e encerramento do programa
            Dialog.displayError(e);
            System.exit(1);
        }
    }
}
  • Linha 11: [AnnotationConfigApplicationContext] é um contêiner configurado por classes anotadas. Seu construtor registra os beans descritos pela classe [TaxConfig] e inicia o contêiner. O contêiner implementa a interface [AutoCloseable]: o recurso do [try] o fecha ao final do bloco, o que libera os beans. A palavra-chave [var] (Java 10) permite que o compilador infira o tipo da variável;
  • linha 13: a camada [business] é obtida como antes;
  • linhas 15–19: tratamento de erros.

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: 

Com uma configuração incorreta, a cadeia de exceções tem agora um nível a mais: o Spring relata a falha do método [dao] por meio de uma exceção [BeanInstantiationException], que é encapsulada na exceção [BeanCreationException]. O Spring também pode descobrir automaticamente as classes a instanciar: com a anotação [@ComponentScan] na classe de configuração, ele cria um bean para cada classe de um pacote anotada com [@Component] (ou [@Service], [@Repository]). Não fizemos isso aqui, porque teria sido necessário anotar as classes das camadas, tornando-as dependentes do Spring. O Spring Boot, no Capítulo 13, faz amplo uso desse mecanismo.

A injeção de dependência merece, por si só, um capítulo. Usamos apenas o essencial: registrar beans ([registerBean], [@Bean]), iniciar o contêiner ([refresh]) e obter um bean ([getBean]). O contêiner também pode criar um novo objeto a cada solicitação (escopo [prototype]), ou um objeto por requisição (HTTP) ou por sessão em uma aplicação web (escopos [request] e [session]). Você pode saber mais sobre o assunto na documentação do Spring: The IoC Container.

6.5. Conclusão

Este capítulo deu à aplicação [Tax] a arquitetura que ela manterá até o final do curso:

  • uma camada [dao] que fornece as faixas de imposto por meio da interface [ITaxDao];
  • uma camada [business] que calcula o imposto e interage com a camada [dao] apenas por meio de sua interface;
  • uma camada [ui] que interage com o usuário e conhece a camada [business] apenas por meio de sua interface [ITaxBusiness];
  • um programa principal, o único que conhece as classes de implementação, que cria as camadas e as conecta, neste caso por meio do contêiner de injeção de dependência do Spring e de um arquivo de configuração;
  • testes unitários automatizados, que verificam cada camada independentemente das demais e garantem a não regressão da aplicação.

As vantagens dessa arquitetura ficarão plenamente evidentes nos próximos capítulos, em que os módulos [tax-dao], [tax-business] e [tax-ui] da versão 5, instalados no repositório Maven local por [mvn install], serão reutilizados sem alteração como dependências Maven:

  • Versão 6 (Capítulo 10, “Acessando bancos de dados com JDBC”): uma nova implementação da camada [dao] lê as faixas de imposto de um banco de dados MySQL. As camadas [business] e [ui] permanecem inalteradas;
  • Versão 7 (Capítulo 11, “Hibernate”): outra implementação da camada [dao] usa o ORM Hibernate para acessar o mesmo banco de dados;
  • Versão 8 (Capítulo 12, “Programação para Internet”): a camada [business] é instalada em um servidor TCP, que calcula impostos para clientes remotos cuja camada [ui] é a da versão 5; as camadas ficam assim distribuídas por várias máquinas, restaurando o sentido original do termo “tier”;
  • Versão 9 (Capítulo 13, “Web services”): a camada [business] é exposta por um web service REST/JSON escrito com Spring Boot, cujo cliente de console usa a classe [HttpClient] do JDK.

Em cada caso, o trabalho se limitará a escrever a nova camada e a modificar o programa que integra as camadas: esse é todo o objetivo da arquitetura em camadas.