Como criar Jokenpô com Spring Boot:
Aprenda, de forma prática, como construir um jogo de Pedra, Papel e Tesoura (Jokenpô) em Java utilizando Spring Boot, organizando corretamente models, controllers, DTOs e endpoints RESTful.
Por que isso é importante
Como criar Jokenpô com Spring Boot:. Aprenda, de forma prática, como construir um jogo de Pedra, Papel e Tesoura (Jokenpô) em Java utilizando Spring Boot, organizando corretamente models, controllers, DTOs e endpoints RESTful.
Visão Geral: Por que refatorar para Spring Boot?
Pegar um jogo simples tipo Jokenpô e adaptar pro Spring Boot é esperto. Você reaproveita
a lógica que já tem em Java e expõe tudo via REST. Isso te força a separar
responsabilidades direito - Controllers, Models, DTOs - e deixa o backend escalável pra
projetos de estudo ou integrações de verdade.
Atenção
Spring Boot acelera demais, mas você precisa entender a estrutura de pastas e separação
de camadas. Se não, vai jogar tudo no mesmo arquivo e criar uma bagunça.
Reaproveitando o projeto antigo de Jokenpô
Se você já tem um Jokenpô em Java puro, dá pra aproveitar quase tudo - enums de
movimentos, classes de jogador, lógica do jogo. A diferença fica no controller REST, que
vira o ponto de contato da nova arquitetura.
Dica
Reutiliza a lógica que já funciona. Spring Boot é ótimo justamente pra integrar com
componentes que você já tem.
Entendendo as Classes Essenciais
Enum para Jogadas
Cria um enum Jogada com as regras: Pedra ganha de Tesoura, Papel de
Pedra, Tesoura de Papel. Isso centraliza tudo num lugar só e facilita se você quiser
expandir o jogo depois.
Classe Player e Classe Game
Player guarda nome e jogada de cada um. Game concentra toda a lógica: sorteia jogada do computador, decide quem
ganhou, conta vitórias e controla quando o jogo acaba.
Evite Erros Comuns
Nunca bota lógica de jogo no controller. Game.java decide tudo, controller só serve de
interface REST.
Organizando a Estrutura de Pastas
- Passo 1: Crie o pacote controller para os
endpoints REST. - Passo 2: Organize model para classes como
Game, Jogada, Player. - Passo 3: Insira dto para trocar informações
via API (JogadaRequest, ResultadoResponse). - Passo 4: Mantenha a classe principal dentro do pacote root,
pronta para rodar com o servidor Tomcat embarcado.
Boa Prática
Separar DTOs dos models permite modificar a estrutura da API sem mexer na lógica do
jogo, garantindo flexibilidade e manutenção facilitada.
Dependências Essenciais do Projeto
A configuração inicial via Spring Initializer deve incluir:
Spring Web
Responsável pela camada REST da aplicação
Lombok
Ajuda a reduzir o excesso de getters/setters
Spring Boot DevTools
Facilita o live reload do servidor durante desenvolvimento
Atenção
Não adicione dependências desnecessárias! Mantenha o projeto leve para facilitar
upgrades e evitar conflitos de versões.
Implementando os Models: Enum, Player e Game
- Enum Jogada: Defina os valores Pedra, Papel e Tesoura e
encapsule as regras de vitória no métodovenceDe(). - Classe Player: Implemente nome e jogada do usuário, delegando
com getters e setters automáticos via Lombok. - Classe Game: Gerencie toda a lógica: randomização da jogada do
computador, método para atualizar jogada do jogador e avaliação de resultado
(inclusive contadores de vitória e indicador de jogo finalizado).
Atenção
Garanta que variáveis como finalizado e os contadores de vitória estejam
com valores padrão e expostos por getters.
DTOs: Comunicação Limpa entre Front e Back
• JogadaRequest : recebe a jogada do usuário enviada pelo endpoint. • ResultadoResponse : retorna informações completas após cada
rodada (quem venceu, jogadas, contadores e status do jogo). Utilize Lombok para agilizar criação de getters/setters e mantenha cada DTO bem enxuto e
com finalidade única.
Dica de Produtividade
Contrua testes locais ou use ferramentas como Postman/HTTP Request File para validar a
troca de dados dos DTOs com o backend!
Controller: Expondo toda regra como API RESTful
- 1. Anote com
@RestControllere defina rota base
usando@RequestMapping("/api/jokenpo"). - 2. Instancie
Gamecomo atributo, assim o jogo
persiste entre chamadas enquanto a instância do controller existir. - 3. Implemente endpoint POST
/jogarconsumindo o
DTO de request e retornando o de response, tratando lógica de jogo finalizado vs
rodada em andamento. - 4. Garanta existência de getters/setters necessários para
mapping automático pelo framework.
Evite Erros
Falhas comuns: esquecer de anotar getters/setters ou deixar DTOs sem construtor padrão
pode quebrar o binding do JSON na chamada.
Rodando e Testando sua API Jokenpô
Guia de Solução de Problemas
Se encontrar erros como internal server error ou not acceptable , valide se DTOs possuem getters/setters públicos e tipos
corretos. Falhas geralmente estão no mapping dos dados via JSON.
Adicionando Validações e Melhorias
É possível expandir a API para adicionar limites de rodadas, reset de partidas e
mensagens customizadas, tornando o código ainda mais robusto para uso didático ou
integração com frontends. Considere internacionalizar respostas e limitar tentativas para facilitar testes
automatizados.
Refinamento
Use variáveis booleanas, contadores e enums para manter o fluxo do jogo e a clareza do
código. Isso facilita futuras integrações e manutenção.
Principais Cuidados ao Projetar Endpoints de Jogos
• Garanta idempotência das rotas. • Ofereça respostas claras, inclusive quando a partida já está encerrada. • Mantenha o controller sem regras de jogo, delegando tudo para o Model. • Inicialize corretamente jogadores e suas jogadas a cada nova requisição.
Boas Práticas
Por padrão, nunca exponha diretamente Models nas rotas. DTOs isolam o domínio e tornam
a API mais estável!
Comparativo: Java puro vs Spring Boot para APIs de jogos
Java Puro
Execução em terminal/CLI, lógica regionalizada, sem exposição HTTP
+ Prós
- • Mais controle do fluxo de execução
- • Ideal para prototipação inicial
− Contras
- • Sem possibilidade fácil de integração
- • Pouca escalabilidade
Spring Boot
Estrutura já pronta para REST, escalável, integração facilitada com frontend ou automações
+ Prós
- • Endpoints RESTful prontos para qualquer consumidor
- • Manutenção e extensão facilitadas
− Contras
- • Requer conhecimento de arquitetura Spring
- • Curva de aprendizado maior
Checklist de Implementação do Jokenpô com Spring Boot
Transforme sua carreira
E foi EXATAMENTE por isso que eu criei um curso de Node.js e React chamado CrazyStack.
A minha maior necessidade no início da carreira era alguém que me ensinasse um projeto
prático onde eu pudesse não só desenvolver minhas habilidades de dev como também
lançar algo pronto para entrar no ar no dia seguinte.
Sabe qual era minha maior frustração? Aplicar conhecimentos teóricos em projetos
práticos e reais, mas não encontrar ninguém que me ensinasse COMO fazer isso na
prática! Era exatamente a mesma frustração que você deve sentir: acumular informação
sem saber como implementar na prática.
Assim como você precisa de estratégias claras e implementação prática para ter
sucesso, todo desenvolvedor precisa de um projeto estruturado para sair do teórico e
partir para a execução. É como ter todas as peças do quebra-cabeça mas não saber como
montá-las - você pode ter conhecimento técnico, mas sem um projeto completo, fica
difícil transformar esse conhecimento em resultados concretos.
No CrazyStack, você constrói um SaaS completo do zero - backend robusto em Node.js,
frontend moderno em React, autenticação, pagamentos, deploy, tudo funcionando. É o
projeto que eu queria ter quando comecei: algo que você termina e pode colocar no ar
no mesmo dia, começar a validar com usuários reais e até monetizar.
Checklist de Implementação
- Estruturou corretamente os pacotes (controller, model, dto)
- Implementou enum de jogadas e lógica do game na Model
- Criou DTOs para request/response
- Configurou Controller para expor endpoint POST /jogar
- Incluiu dependências Spring Web, Lombok e DevTools
- Validou chamadas API REST via Postman ou arquivo .http
- Tratou e respondeu erros básicos de binding/mapping
- Documentou possíveis pontos de melhoria e expansão