LEARN BACKEND JAVA

🚀 Roadmap Backend Java (do zero ao avançado)

1️⃣ Fundamentos de Java (ESSENCIAL)

Antes de backend, você precisa pensar em Java.

📌 O que aprender

 Instalação do JDK (Java 17 ou 21)

 Tipos primitivos (int, double, boolean)

 if / else, switch

 Laços (for, while)

 Métodos e funções

 Classes e objetos

 this, static

 Encapsulamento (private, get/set)

 Herança e polimorfismo

 Interfaces

 List, Set, Map

 Exception e try/catch

🎯 Objetivo

Conseguir criar um programa Java sem copiar, entendendo o que está

2️⃣ Java Orientado a Backend

Aqui começa o mindset backend.

📌 Conceitos

 Pacotes (package)

 Organização de projeto

 Logs (SLF4J / Logback)

 Leitura de arquivos

 Datas (LocalDate, LocalDateTime)

 Boas práticas (SOLID básico)

Backend sem isso não existe.

📦 Maven

 [Link]

 Dependências

 clean, install, package

🌱 Git

 git init, commit, push

 .gitignore

 GitHub

4️⃣ Spring Boot (A VIRADA DE CHAVE 🔥)

📌 Fundamentos Spring

 Inversão de Controle (IoC)

 Injeção de Dependência

 Anotações:

o @RestController

o @GetMapping, @PostMapping

o @RequestBody, @PathVariable

o @Service, @Repository

🎯 Objetivo

Criar uma API REST que responda JSON.

5️⃣ Banco de Dados (CRUD de verdade)

Backend sem banco é só fachada 😅

📌 Aprender

 SQL básico

 PostgreSQL ou MySQL

 Spring Data JPA

 Hibernate

 Entidades (@Entity)

 Repositórios (JpaRepository)
  Relacionamentos:

o @OneToMany

o @ManyToOne

6️⃣ Validação, Erros e Segurança

Agora fica profissional.

 Bean Validation (@NotNull, @Email)

 Tratamento de erros (@ControllerAdvice)

 HTTP Status corretos

 DTOs

 Spring Security

 JWT (login/autenticação)

7️⃣ Testes e Qualidade

Diferencial forte no mercado.

 JUnit

 Mockito

 Testes de controller

 Testes de serviço

8️⃣ Deploy e Mundo Real

Última fase 💪

 Variáveis de ambiente

 Docker

 Deploy (Railway, Render, VPS)

 Logs em produção

Stack recomendada (iniciante)

 Java 17

 Spring Boot

 Maven

 PostgreSQL
  IntelliJ IDEA

 Postman / Insomnia

📚 Como estudar (jeito inteligente)

⚠️Regra de ouro: menos curso, mais projeto

Projetos para treinar:

1. API de usuários

2. Sistema de tarefas (CRUD)

3. Login + JWT

4. Mini e-commerce

5. API para app mobile

🚀 PASSO 1 — Seu primeiro backend Java (Spring Boot)

🎯 Objetivo deste passo

Criar uma API REST rodando localmente que responde:

[Link]

🧱 Conceito novo (bem rápido)

No Spigot você reage a eventos do servidor.

Exemplo:

 Plugin → PlayerJoinEvent

 Backend → GET /users

Criar o projeto Spring Boot

1️⃣ Acesse o Spring Initializr

👉 [Link]

2️⃣ Configure assim:

 Project: Maven

 Language: Java

 Spring Boot: (deixa o padrão)

 Group: [Link]

 Artifact: backend
  Packaging: Jar

 Java: 17 (ou 21 se preferir)

3️⃣ Dependências (marca só essas):

✔ Spring Web

👉 Clique em Generate e extraia o ZIP

📂 Estrutura do projeto (importante)

Você vai ver algo assim:

backend

└─ src

└─ main

└─ java

└─ [Link]

└─ [Link]

Esse arquivo é tipo o onEnable() do Spring.

▶️Rodar o projeto

No IntelliJ:

 Abre o projeto

 Abre [Link]

 Clica em Run

Se aparecer no console:

Tomcat started on port 8080

🎉 Tá vivo.

🌐 Criando seu primeiro Controller (API)

Crie um pacote:

[Link]

Dentro dele, crie a classe:

package [Link];

import [Link];
import [Link];

@RestController

public class HelloController {

@GetMapping("/hello")

public String hello() {

return "Hello, backend Java!";

🔥 Testando

Abra o navegador ou Postman e vá em:

[Link]

Se aparecer:

Hello, backend Java!

🚀 Você acabou de criar uma API REST em Java.

🧠 Comparando com Spigot (pra fixar)

Spigot Spring Boot

@EventHandler @GetMapping

Listener Controller

application.y
[Link]
ml

onEnable() main()

Serviços Beans do
singleton Spring

⚠️Regra de ouro desde agora

❌ Controller com lógica

🎯 Objetivo

Criar uma rota que:

 Usa Service

 Retorna JSON

 Não deixa lógica no Controller

Exemplo final:

GET /api/hello

→ { "message": "Olá, Gustavo!" }

🧱 Estrutura que vamos usar (padrão profissional)

Crie os pacotes:

[Link]

├─ controller

├─ service

└─ dto

Isso é tipo:

 controller → listener

 service → manager

 dto → objeto de transporte (não é entity)

1️⃣ Criando o DTO

📦 dto/[Link]

package [Link];

public class HelloResponse {

private String message;

public HelloResponse(String message) {

[Link] = message;

}
 public String getMessage() {

return message;

👉 Spring vai converter isso automaticamente em JSON (Jackson).

2️⃣ Criando o Service

📦 service/[Link]

package [Link];

import [Link];

@Service

public class HelloService {

public String getHelloMessage() {

return "Olá, Gustavo! Backend Java ativo 🚀";

🔎 @Service = Bean gerenciado pelo Spring (construtor singleton, igual service no

3️⃣ Atualizando o Controller

📦 controller/[Link]

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

import [Link];
@RestController

@RequestMapping("/api")

public class HelloController {

private final HelloService helloService;

public HelloController(HelloService helloService) {

[Link] = helloService;

@GetMapping("/hello")

public HelloResponse hello() {

String message = [Link]();

return new HelloResponse(message);

💡 Injeção por construtor → padrão profissional (nada de @Autowired no campo).

🔥 Teste

Acesse:

[Link]

Resposta esperada:

"message": "Olá, Gustavo! Backend Java ativo 🚀"

🧠 O que você acabou de aprender (importante)

✔ Arquitetura em camadas
✔ Injeção de dependência
✔ DTO
✔ Retorno JSON
✔ URL versionável (/api)

Isso já é nível backend real.

 ❌ Entity ≠ DTO

 ❌ Controller ≠ lógica

 ✅ Service = regra de negócio

🐘 PostgreSQL vs 🐬 MySQL — quando usar cada um

🐘 PostgreSQL (o “engenheiro”)

Use quando você quer robustez, regras e consistência.

✅ Pontos fortes

 Muito forte em integridade dos dados

 Tipos avançados:

o JSON / JSONB

o UUID

o ARRAY

 Queries complexas (JOIN pesado, subqueries)

 Melhor suporte a transações complexas

 Muito usado em:

o Fintechs

o SaaS

o Sistemas críticos

 Comunidade forte no mundo Java + Spring

❌ Pontos fracos

 Um pouco mais “chato” de configurar

 Pode consumir um pouco mais de recurso

🧠 Quando escolher PostgreSQL

✔ Backend sério
✔ Muitos relacionamentos
✔ Regras de negócio complexas
✔ Crescimento futuro
✔ APIs modernas (inclusive com JSON no banco)

🐬 MySQL (o “rápido e simples”)

Use quando quer simplicidade e velocidade.

✅ Pontos fortes
  Fácil de configurar

 Muito popular (hosting barato)

 Ótimo pra:

o CRUD simples

o Sistemas pequenos/médios

 Bastante usado em:

o Sites

o Sistemas legados

o PHP (mas não só)

❌ Pontos fracos

 Menos recursos avançados

 Menos rigor com integridade (depende da config)

 Queries complexas ficam mais limitadas

🧠 Quando escolher MySQL

✔ Projetos simples
✔ Aprendizado inicial
✔ CRUD clássico
✔ Infra barata

⚔️Comparação direta

Critério PostgreSQL MySQL

Integridade ⭐⭐⭐⭐⭐ ⭐⭐⭐

Queries
⭐⭐⭐⭐⭐ ⭐⭐⭐
complexas

JSON no banco ⭐⭐⭐⭐⭐ ⭐⭐

Facilidade ⭐⭐⭐ ⭐⭐⭐⭐⭐

Spring Boot ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐

Escalabilidade ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐

🎯 Recomendação honesta pra VOCÊ

Considerando que você:

 já programa Java

 quer backend profissional

👉 PostgreSQL é a melhor escolha 💪

Você aprende:

 SQL de verdade

 Tipos modernos

 Padrões usados em empresas

MySQL você pega depois em uma semana se precisar.

🚀 PASSO 3 — Spring Boot + PostgreSQL + JPA

🎯 Objetivo

Criar um CRUD de usuários:

 Entity

 Repository

 Service

 Controller

 Salvar e buscar no PostgreSQL

🐘 1️⃣ Subindo o PostgreSQL (rápido)

Opção A — Docker (recomendado)

Se tiver Docker instalado, roda no PowerShell:

docker run --name postgres-backend ^

-e POSTGRES_DB=backend ^

-e POSTGRES_USER=postgres ^

-e POSTGRES_PASSWORD=123456 ^

-p 5432:5432 ^

-d postgres

Se não tiver Docker, me avisa que te guio pela instalação normal.

📦 2️⃣ Dependências no [Link]

Adicione dentro de <dependencies>:

<dependency>

<groupId>[Link]</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

<dependency>

<groupId>[Link]</groupId>

<artifactId>postgresql</artifactId>

<scope>runtime</scope>

</dependency>

👉 Dá Reload Maven no IntelliJ.

⚙️3️⃣ Configurando o banco

📄 src/main/resources/[Link]

spring:

datasource:

url: jdbc:postgresql://localhost:5432/backend

username: postgres

password: 123456

jpa:

hibernate:

ddl-auto: update

show-sql: true

properties:

hibernate:

format_sql: true

💡 ddl-auto: update cria/atualiza tabelas automaticamente (dev only).

🧱 4️⃣ Criando a Entity (User)

📦 entity/[Link]

package [Link];

import [Link].*;
@Entity

@Table(name = "users")

public class User {

@Id

@GeneratedValue(strategy = [Link])

private Long id;

@Column(nullable = false)

private String name;

@Column(nullable = false, unique = true)

private String email;

protected User() {}

public User(String name, String email) {

[Link] = name;

[Link] = email;

public Long getId() {

return id;

public String getName() {

return name;

public String getEmail() {

return email;

}
}

🔎 Construtor protegido = padrão JPA.

5️⃣ Repository

📦 repository/[Link]

package [Link];

import [Link];

import [Link];

public interface UserRepository extends JpaRepository<User, Long> {

Sem implementação. Spring faz a mágica ✨

🧠 6️⃣ Service (regra de negócio)

📦 service/[Link]

package [Link];

import [Link];

import [Link];

import [Link];

import [Link];

@Service

public class UserService {

private final UserRepository repository;

public UserService(UserRepository repository) {

[Link] = repository;

}
 public User create(String name, String email) {

User user = new User(name, email);

return [Link](user);

public List<User> findAll() {

return [Link]();

🌐 7️⃣ Controller (CRUD)

📦 controller/[Link]

package [Link];

import [Link];

import [Link];

import [Link].*;

import [Link];

import [Link];

@RestController

@RequestMapping("/api/users")

public class UserController {

private final UserService service;

public UserController(UserService service) {

[Link] = service;

@PostMapping
 public User create(@RequestBody Map<String, String> body) {

return [Link]([Link]("name"), [Link]("email"));

@GetMapping

public List<User> list() {

return [Link]();

⚠️DTO vamos refinar no próximo passo — aqui é foco em fluxo.

🧪 8️⃣ Testando no Postman

POST

POST [Link]

Body (JSON):

"name": "Gustavo",

"email": "gustavo@[Link]"

GET

GET [Link]

🧠 O que você acabou de aprender

✔ JPA + Hibernate
✔ Entity
✔ Repository
✔ CRUD
✔ PostgreSQL integrado
✔ Backend profissional real

Você já passou do nível iniciante 👊

⚠️Aviso importante (muito mercado)

❌ Não exponha Entity direto em produção

1️⃣ Instalar Docker Desktop (Windows)

Requisitos

✔ Windows 10/11
✔ Virtualização ativada na BIOS
✔ WSL2 (o Docker instala sozinho)

Passo a passo

1. Baixe:
👉 [Link]

2. Instale normalmente

3. Durante a instalação, marque:

o ✔ Use WSL 2

4. Reinicie o PC

2️⃣ Verificar se está funcionando

Abra PowerShell e rode:

docker --version

Se aparecer algo tipo:

Docker version 26.x.x

✔ OK

Teste rápido:

docker run hello-world

Se aparecer mensagem de sucesso → Docker tá vivo 🐳🔥

3️⃣ Conceitos essenciais (bem rápido)

Conceit
O que é
o

Template (tipo
Image
JAR)

Containe Instância
r rodando

Dockerfil Receita da
e imagem

Volume Dados
Conceit
O que é
o

persistentes

Port Porta exposta

4️⃣ Subindo PostgreSQL com Docker (jeito certo)

Vamos subir Postgres com persistência (dados não somem).

docker run --name postgres-backend ^

-e POSTGRES_DB=backend ^

-e POSTGRES_USER=postgres ^

-e POSTGRES_PASSWORD=123456 ^

-p 5432:5432 ^

-v postgres_data:/var/lib/postgresql/data ^

-d postgres

O que isso faz

 Cria banco backend

 User postgres

 Senha 123456

 Porta 5432

 Volume persistente (postgres_data)

5️⃣ Comandos Docker que você VAI usar sempre

Ver containers rodando

docker ps

Ver todos (inclusive parados)

docker ps -a

Parar container

docker stop postgres-backend

Iniciar novamente

docker start postgres-backend

Apagar container

docker rm postgres-backend

Apagar volume (⚠️perde dados)

6️⃣ Acessar o PostgreSQL

Opção A — Terminal

docker exec -it postgres-backend psql -U postgres -d backend

Opção B — IntelliJ (recomendado)

 Database → PostgreSQL

 Host: localhost

 Port: 5432

 User: postgres

 Password: 123456

 DB: backend

7️⃣ Erros comuns (e solução)

❌ Docker não inicia

✔ Virtualização desativada → ativar na BIOS

❌ Porta 5432 ocupada

netstat -ano | findstr 5432

Ou mude:

-p 5433:5432

E no Spring:

url: jdbc:postgresql://localhost:5433/backend

8️⃣ Próximo nível (spoiler 👀)

No próximo passo vamos:

 Criar Dockerfile do backend Java

 Subir API + Postgres juntos

 Usar docker-compose

👉 Isso é nível backend profissional.