# Java, Spring Boot e DevOps: temas para organizar seus estudos

Entenda como Java, Spring Boot e cultura DevOps se conectam e escolha um próximo passo de estudo com uma tarefa prática.

Por Bruno Rana

Publicado em: 2026-10-22
Atualizado em: 2026-10-23

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

**Java, Spring Boot e DevOps podem ser estudados a partir da mesma aplicação: você escreve uma regra, oferece essa regra por uma API e aprende a acompanhar o sistema depois de publicá-lo.** Isso ajuda a escolher o próximo assunto sem tratar cada tecnologia como uma lista separada de aulas.

Vamos usar um pedido de compra fictício. Ele tem itens, quantidades e um status. Não vamos construir uma loja completa; a ideia é acompanhar uma tarefa pequena e perceber quais perguntas surgem em cada etapa.

## Java: entender a regra antes de ampliar o projeto

Comece com os dados do pedido em memória. Um item custa R$ 20 e foi pedido duas vezes; outro custa R$ 15 e foi pedido uma vez. O total esperado é R$ 55. Antes de abrir um framework, explique como o programa chega a esse resultado.

Nesse exercício, variáveis guardam valores, uma coleção reúne os itens e um método calcula o total. Objetos ajudam a organizar os dados e os comportamentos envolvidos. Quando esses conceitos aparecem em uma tarefa, fica mais fácil perceber qual deles precisa de revisão.

Agora defina uma regra: a quantidade precisa ser maior que zero. O que acontece se chegar zero? E se chegar um valor negativo? Escreva o resultado esperado e confira que o pedido não foi alterado quando a entrada foi recusada.

Para esta etapa, você tem uma tarefa clara: calcular o total e tratar quantidades inválidas. Pagamento, frete, descontos e representação monetária completa ficam fora desse primeiro exercício. Se ainda não consegue acompanhar objetos, coleções ou erros, use o diagnóstico de [o que estudar antes de Spring Boot](https://dev.buildrun.com.br/blog/o-que-estudar-antes-spring-boot/).

Podemos tornar o cálculo visível em um programa pequeno. Os preços estão em centavos inteiros, e o construtor recusa um item inválido antes de criá-lo. 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) {
        return itens.stream().mapToLong(Item::subtotal)
            .reduce(0L, Math::addExact);
    }

    public static void main(String[] args) {
        var itens = List.of(new Item(2000, 2), new Item(1500, 1));
        if (total(itens) != 5500) throw new AssertionError();
        boolean recusou = false;
        try { new Item(2000, 0); }
        catch (IllegalArgumentException erro) { recusou = true; }
        if (!recusou) throw new AssertionError();
        System.out.println(total(itens)); // 5500 centavos
    }
}
```

A saída é `5500` centavos, ou R$ 55. Executamos o total e a recusa de quantidade zero com OpenJDK 21.0.2. `multiplyExact` e `addExact` também impedem que um estouro numérico passe silenciosamente; esse caso fica como exercício adicional. O exemplo considera valores já convertidos em centavos, sem conversão de moedas, impostos ou arredondamento de descontos.

## Spring Boot: acompanhar o pedido da entrada à resposta

Depois, exponha a operação pela aplicação. Uma requisição informa os itens e as quantidades. Seu código lê a entrada, verifica as regras e devolve o resultado escolhido no contrato da API. O cálculo continua precisando fazer sentido mesmo com o framework ao redor.

Experimente enviar o pedido válido e conferir o total de R$ 55. Em seguida, envie uma quantidade zero. A resposta deve deixar claro que aquela entrada foi recusada. A decisão sobre o formato e o status HTTP faz parte do contrato que você está praticando.

Ao adicionar banco, faça uma pergunta simples: se a aplicação reiniciar, o pedido ainda aparece? Salve um pedido, reinicie apenas o projeto de treino e consulte o registro. Você está verificando persistência, não apenas se o endpoint responde.

| O que aconteceu | Onde começar a investigação |
| --- | --- |
| A quantidade recebida é diferente da enviada | Leitura e conversão da entrada. |
| Os dados estão certos, mas o total está errado | Regra de cálculo e seus testes. |
| A resposta confirma, mas o registro não aparece | Fluxo de gravação e leitura no banco. |

Essa separação evita atribuir qualquer erro ao Spring. Você passa a procurar em qual etapa o comportamento se afastou do esperado.

## DevOps: conseguir construir, publicar e investigar

Depois que funciona na sua máquina, surgem perguntas sobre o ambiente. Outra pessoa consegue executar o projeto seguindo o README? A versão de Java está registrada? A configuração do banco está separada do código? O pipeline roda os testes antes de publicar?

Imagine que o projeto inicia localmente, mas falha no ambiente de teste porque não encontra o endereço do banco. Reescrever o cálculo do pedido não vai resolver essa falha. Você precisa conferir a configuração exigida, a mensagem de erro e as condições daquele ambiente, sem expor senhas em logs ou no repositório.

DevOps também envolve observar o comportamento depois da publicação. Se a consulta de pedidos começar a falhar, quais registros ajudam a localizar a causa? Você sabe qual versão está executando? Como verifica se uma correção preservou o cálculo e a gravação?

“You build it, you run it” expressa essa responsabilidade pelo ciclo da aplicação. Isso não exige começar por Kubernetes ou por uma arquitetura distribuída. Neste roteiro, um projeto pequeno já permite praticar build, configuração, testes e diagnóstico.

## Escolha o próximo estudo pela pergunta que ficou

Ao terminar uma sessão, registre uma dificuldade específica e a tarefa que vai usar para investigá-la:

| Dificuldade | Próxima tarefa pequena |
| --- | --- |
| Não consigo explicar o total | Percorrer os itens e acompanhar cada parcela do cálculo. |
| Não sei tratar uma quantidade inválida | Definir a recusa e conferir que os dados permanecem intactos. |
| O pedido desaparece no reinício | Verificar a gravação e repetir a consulta após reiniciar. |
| Só funciona na minha máquina | Conferir versões, instruções de execução e configuração. |

Escolha um material sobre essa pergunta, pratique e volte ao mesmo projeto. Se usar IA, peça ajuda para entender uma hipótese e confira o resultado; o artigo sobre [estudar com IA sem pular fundamentos](https://dev.buildrun.com.br/blog/java-junior-ia-sem-pular-fundamentos/) detalha esse ciclo.

## Como avaliar se a sessão de estudo ajudou

Antes de encerrar, tente responder:

* Consigo explicar o que entrou, qual regra foi aplicada e o que saiu?
* Testei uma entrada válida e uma recusada?
* Sei onde procurar se o resultado estiver errado?
* Deixei registrada uma próxima alteração que consigo começar?

Você não precisa resolver todo o ciclo no mesmo dia. O avanço pode ser compreender uma condição que antes copiava ou conseguir separar um erro de configuração de um erro de regra.

Para consultar os conceitos, use o [material oficial de Java](https://dev.java/learn/) e o [guia REST do Spring](https://spring.io/guides/gs/rest-service/), respeitando os requisitos da versão escolhida.

Você pode começar pelos [conteúdos gratuitos da Build & Run](https://www.youtube.com/@buildrun-tech) ou consultar os [cursos da formação](https://dev.buildrun.com.br/blog/formacao-buildrun/). A proposta é engenharia de software com IA, com Java na prática. Compare o conteúdo disponível com a pergunta que ficou no seu projeto; os blocos de Harness Engineering continuam em expansão, conforme explicado na página da formação.

## Para levar à prática

Uma aplicação pequena já conecta Java, HTTP, persistência e operação. Escolha a próxima etapa pela dificuldade encontrada: entender o cálculo, tratar uma entrada recusada ou descobrir por que o projeto só funciona em um ambiente.
