O que estudar de Java, Spring Boot e DevOps? Um projeto prático

Depois dos primeiros contatos com Java, os nomes de outras tecnologias começam a se acumular: Spring Boot, banco de dados, testes, deploy. Você pode entender a utilidade de cada uma e ainda não saber o que estudar amanhã. Falta enxergar como esses conhecimentos se encontram no trabalho de construir uma aplicação.

Um caminho é avançar a partir do que seu programa precisa fazer. Primeiro, você implementa e confere uma regra. Depois, permite que ela receba uma requisição, guarda os dados necessários e aprende a executar e acompanhar o sistema em outro ambiente.

Essa sequência ajuda a escolher um próximo passo que tenha motivo. Não é preciso concluir uma lista inteira de ferramentas antes de praticar, nem adicionar todas elas ao primeiro projeto. A cada etapa, vale perguntar o que já consegue explicar e qual necessidade ainda não foi atendida.

Java: calcular R$ 55 e recusar quantidades inválidas

Para começar, escolha um cálculo que consiga conferir sem o computador. Nosso pedido terá dois itens de R$ 20 e um de R$ 15, somando R$ 55. O programa inicial vai implementar apenas esse cálculo e a validação dos itens.

Para chegar ao total, ele precisa representar cada item, multiplicar preço por quantidade e somar os subtotais. Antes de pensar em servidor, confira se consegue acompanhar essas operações.

Vamos usar preços em centavos inteiros e exigir quantidade maior que zero. Preço negativo também será recusado. Pagamento, frete, impostos, moedas diferentes e arredondamento de descontos ficam fora deste exercício.

Salve como PedidoDemo.java e execute java PedidoDemo.java com Java 21:

import java.util.List;

public class PedidoDemo {
    record Item(long precoCentavos, int quantidade) {
        Item {
            if (precoCentavos < 0 || quantidade <= 0) {
                throw new IllegalArgumentException("Item invalido");
            }
        }
        long subtotal() {
            return Math.multiplyExact(precoCentavos, quantidade);
        }
    }

    static long total(List<Item> itens) {
        long resultado = 0;
        for (Item item : itens) {
            resultado = Math.addExact(resultado, item.subtotal());
        }
        return resultado;
    }

    static void conferir(boolean condicao) {
        if (!condicao) throw new AssertionError("Resultado inesperado");
    }

    static void conferirRecusa(long preco, int quantidade) {
        boolean recusou = false;
        try { new Item(preco, quantidade); }
        catch (IllegalArgumentException erro) { recusou = true; }
        conferir(recusou);
    }

    public static void main(String[] args) {
        var itens = List.of(new Item(2000, 2), new Item(1500, 1));
        conferir(total(itens) == 5500);
        conferirRecusa(2000, 0);
        conferirRecusa(2000, -1);
        conferirRecusa(-1, 1);
        conferir(total(List.of()) == 0);

        boolean detectouEstouro = false;
        try { new Item(Long.MAX_VALUE, 2).subtotal(); }
        catch (ArithmeticException erro) { detectouEstouro = true; }
        conferir(detectouEstouro);
        System.out.println(total(itens)); // 5500 centavos
    }
}

O record reúne preço e quantidade. Seu construtor confere os valores antes de criar o item. O for percorre a lista e acumula os subtotais. multiplyExact e addExact sinalizam quando o cálculo excede a capacidade do tipo long, evitando um resultado numérico incorreto que passaria silenciosamente.

A saída é 5500, equivalente a R$ 55. O cálculo de lista vazia retorna zero; decidir se uma aplicação aceita um pedido sem itens será uma regra adicional. O programa não salva pedidos nem recebe requisições.

Se ainda não consegue explicar por que cada item contribuiu para o total, volte a objetos, coleções e métodos antes de acrescentar mais partes. O diagnóstico de o que estudar antes de Spring Boot ajuda a localizar essa base.

Spring Boot: receber o mesmo pedido e devolver o resultado

O próximo incremento é oferecer o cálculo por uma API. Uma requisição HTTP informa itens e quantidades; a aplicação converte a entrada, aplica a regra e devolve uma resposta. Um endpoint é o endereço e a operação pelos quais o cliente acessa esse comportamento.

Antes de implementar, defina o contrato: formato dos dados recebidos, resposta de sucesso e resposta para item inválido. Depois faça duas verificações:

1. Envie os mesmos itens do programa e confira o total de 5.500 centavos.
2. Envie uma quantidade zero e confira uma resposta de entrada recusada, sem tratar a exceção como erro inesperado do servidor.

A regra de cálculo já existe e deve continuar testável sem HTTP. Se houver divergência, separe as etapas:

O que aconteceu	Onde começar
O programa recebeu quantidade diferente da enviada	Leitura e conversão da requisição.
Os itens chegaram corretamente, mas o total está errado	Cálculo e testes da regra.
O total está certo, mas a resposta mostra outro valor	Montagem e representação da resposta.

O guia REST do Spring apresenta os mecanismos básicos de requisição e resposta. Use os requisitos da versão escolhida e acompanhe o caminho dos dados, em vez de copiar anotações sem observar o efeito.

Persistência: o pedido precisa sobreviver ao reinício

Depois que a entrada e a resposta estiverem claras, acrescente armazenamento. Guarde o pedido de R$ 55, reinicie apenas a aplicação de treino e consulte-o novamente. Esse teste verifica algo que o cálculo isolado não demonstra: os dados continuam disponíveis depois que a memória do processo foi perdida.

Compare itens, quantidades e total. Se a resposta de gravação indicar sucesso, mas o pedido não aparecer na consulta, investigue gravação, leitura e configuração do banco. Evite mudar o cálculo para tentar corrigir um problema de armazenamento.

Preserve os testes anteriores. Adicionar persistência não deve fazer uma quantidade zero passar a ser aceita. O resultado deste incremento é conseguir salvar e recuperar o mesmo pedido, não apenas observar que o endpoint respondeu.

DevOps: executar e investigar o pedido em outro ambiente

Quando o sistema funciona localmente, a próxima pergunta é se outra pessoa consegue executá-lo. Registre a versão de Java, os comandos e a configuração necessária no README, arquivo de instruções do projeto.

O build prepara e verifica a aplicação a partir do código. Um pipeline automatiza etapas como build, testes e publicação. Comece conferindo se os testes do total e da recusa de quantidade inválida rodam antes de publicar uma mudança.

Ao executar em um ambiente de teste, a aplicação pode falhar por não encontrar o endereço do banco. A regra que chega a R$ 55 não mudou. Nesse caso, confira a configuração, a mensagem de erro e as condições do ambiente. Separe configuração do código e não exponha senhas em logs ou no repositório.

Depois da publicação, acompanhe a consulta do mesmo pedido. Se ela falhar, quais registros mostram em que etapa aconteceu? Você sabe qual versão da aplicação está rodando? Consegue verificar se uma correção preservou o cálculo e a gravação?

A expressão “You build it, you run it” resume essa responsabilidade pelo ciclo da aplicação. Para começar a praticá-la, este projeto pequeno basta: não é necessário adicionar Kubernetes ou dividir o sistema em serviços.

Escolha a próxima sessão pela dúvida que ficou

Dificuldade encontrada	Próxima tarefa
Não consigo explicar os R$ 55	Acompanhar cada subtotal e a soma.
Não sei por que quantidade zero foi aceita	Localizar a validação e reproduzir o caso recusado.
O pedido desapareceu após reiniciar	Conferir gravação e consulta no banco.
O projeto só funciona na minha máquina	Revisar versões, comandos e configuração.
A consulta falhou depois da publicação	Identificar a versão e seguir os registros da operação.

Você não precisa resolver todas as etapas no mesmo dia. Termine a sessão sabendo o que verificou e qual pergunta ainda está aberta. Voltar ao mesmo pedido ajuda a perceber o que cada nova camada acrescenta.

Para revisar a linguagem, consulte o material oficial de Java. Se usar IA durante a implementação, veja como estudar sem pular fundamentos.

Você também pode acessar os conteúdos gratuitos da Build & Run ou conhecer os cursos da formação. Compare o conteúdo com a dificuldade que encontrou no projeto, mantendo uma tarefa concreta para a próxima sessão.