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

Veja como Java, Spring Boot e DevOps se conectam em um projeto prático e escolha o próximo passo de estudo a partir de uma tarefa concreta.

Por Bruno Rana

Publicado em: 2026-10-22
Atualizado em: 2026-11-04

Artigo original: https://buildrun.com.br/blog/trilhas-de-estudo/

![Quantidades de itens de R$20 e R$15 formam subtotais de R$40 e R$15, somando R$55.](https://buildrun.com.br/diagrams/study-order-calculation.webp)

Exercício em centavos inteiros: validar cada item, multiplicar e somar.

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:

```java
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](https://buildrun.com.br/blog/o-que-estudar-antes-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](https://spring.io/guides/gs/rest-service/) 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.

<figure class="explainer explainer--sketch">
<img src="https://buildrun.com.br/diagrams/study-order-delivery-flow.webp" srcset="https://buildrun.com.br/diagrams/study-order-delivery-flow-420.webp 420w, https://buildrun.com.br/diagrams/study-order-delivery-flow-840.webp 840w, https://buildrun.com.br/diagrams/study-order-delivery-flow.webp 1254w" sizes="(max-width: 800px) calc(100vw - 32px), 760px" width="1254" height="1254" loading="lazy" decoding="async" alt="A mesma caixa passa por bancadas DEV e TEST; configuração, logs e uma versão publicada ajudam a investigar a falha.">
<figcaption>Preserve o cálculo validado e investigue a falha no ambiente ou na configuração.</figcaption>
</figure>

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](https://dev.java/learn/). Se usar IA durante a implementação, veja [como estudar sem pular fundamentos](https://buildrun.com.br/blog/java-junior-ia-sem-pular-fundamentos/).

Você também pode acessar os [conteúdos gratuitos da Build & Run](https://www.youtube.com/@buildrun-tech) ou conhecer os [cursos da formação](https://buildrun.com.br/blog/formacao-buildrun/). Compare o conteúdo com a dificuldade que encontrou no projeto, mantendo uma tarefa concreta para a próxima sessão.
