A Jornada de Juninho, o "BackEnzo" no Mundo do Backend: Construindo uma Aplicação de Cadastro e Consulta de Vagas de Emprego com Spring Boot

Sempre me questionei: qual seria o melhor passo a passo para criar uma aplicação web do zero? Pensando nisso, resolvi criar pequenos tutoriais para que eu e outros iniciantes pudéssemos consultar sempre que necessário. Então, hoje trago a vocês a saga do Juninho, o "BackEnzo", e sua missão de desenvolver uma aplicação de cadastro e consulta de vagas de emprego usando Spring Boot!

Atenção: este projeto é perfeito para iniciantes e cobre conceitos básicos de backend, como Controllers, Services, Repositories e até um pouco de configuração com Servlets.

1. Estrutura da Aplicação: Missão do Juninho

Juninho precisava de um plano. Ele sabia que a aplicação de vagas deveria permitir que usuários:

Cadastrassem uma vaga de emprego.
Consultassem as vagas de emprego já cadastradas.

Para organizar isso, ele decidiu seguir uma estrutura dividida em camadas:

Controller: Para receber as requisições HTTP.
Service: Para aplicar a lógica de negócio.
Repository: Para armazenar e buscar as vagas (simularemos um banco de dados com uma lista para facilitar).

Vejamos o passo a passo de como o Juninho montou essa estrutura e, no final, colocaremos tudo em funcionamento!

2. Criando o Projeto Spring Boot

Juninho começou acessando o Spring Initializr (start.spring.io) para configurar o projeto. Ele definiu as seguintes opções:

Group: com.exemplo
Artifact: sistema-vagas
Dependencies: Spring Web e Spring Data JPA (mesmo sem um banco real, ele achou útil).

Estrutura Inicial do Projeto

Após gerar e abrir o projeto na IDE, ele ficou com esta estrutura:

src
├── main
│   ├── java
│   │   └── com
│   │       └── exemplo
│   │           └── sistemavagas
│   │               ├── SistemaVagasApplication.java
│   │               ├── controller
│   │               ├── model
│   │               ├── repository
│   │               └── service
│   └── resources
│       └── application.properties

Com tudo preparado, era hora de começar a programar!

3. Modelando a Vaga de Emprego

No pacote model, Juninho criou uma classe Vaga para definir como seriam os dados das vagas de emprego.

package com.exemplo.sistemavagas.model;

public class Vaga {
  private Long id;
  private String titulo;
  private String descricao;
  private String localizacao;
  private double salario;

  public Vaga() {}

  public Vaga(Long id, String titulo, String descricao, String localizacao, double salario) {
      this.id = id;
      this.titulo = titulo;
      this.descricao = descricao;
      this.localizacao = localizacao;
      this.salario = salario;
  }

  // Getters e Setters
  public Long getId() { return id; }
  public void setId(Long id) { this.id = id; }
  public String getTitulo() { return titulo; }
  public void setTitulo(String titulo) { this.titulo = titulo; }
  public String getDescricao() { return descricao; }
  public void setDescricao(String descricao) { this.descricao = descricao; }
  public String getLocalizacao() { return localizacao; }
  public void setLocalizacao(String localizacao) { this.localizacao = localizacao; }
  public double getSalario() { return salario; }
  public void setSalario(double salario) { this.salario = salario; }
}

Essa classe Vaga serve como base para os dados que cada vaga vai ter. Agora, era hora de guardar as vagas em algum lugar.

4. Repositório de Vagas (Repository)

Juninho criou o pacote repository e, dentro dele, uma classe VagaRepository. Ele decidiu que, para fins de simplicidade, usaria uma lista para simular um banco de dados.

package com.exemplo.sistemavagas.repository;

import com.exemplo.sistemavagas.model.Vaga;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.List;

@Repository
public class VagaRepository {
  private List<Vaga> vagas = new ArrayList<>();
  private Long idCounter = 1L;

  public List<Vaga> listarTodas() {
      return vagas;
  }

  public Vaga salvar(Vaga vaga) {
      vaga.setId(idCounter++);
      vagas.add(vaga);
      return vaga;
  }
}

Assim, VagaRepository possibilita:

listarTodas(): retornar todas as vagas cadastradas.
salvar(Vaga vaga): adicionar uma nova vaga à lista e dar um ID a ela.

5. Serviço de Vagas (Service)

No pacote service, Juninho criou VagaService, uma classe que contém a lógica de negócios. Isso inclui o que fazer com os dados antes e depois de passar pelo repositório.

package com.exemplo.sistemavagas.service;

import com.exemplo.sistemavagas.model.Vaga;
import com.exemplo.sistemavagas.repository.VagaRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class VagaService {

  private final VagaRepository vagaRepository;

  @Autowired
  public VagaService(VagaRepository vagaRepository) {
      this.vagaRepository = vagaRepository;
  }

  public List<Vaga> listarVagas() {
      return vagaRepository.listarTodas();
  }

  public Vaga cadastrarVaga(Vaga vaga) {
      return vagaRepository.salvar(vaga);
  }
}

Em VagaService, temos:

listarVagas(): chama o repositório para listar todas as vagas.
cadastrarVaga(Vaga vaga): chama o repositório para salvar uma nova vaga.

6. Controlador de Vagas (Controller)

Juninho partiu então para o pacote controller, onde ele criou VagaController, o ponto de entrada para as requisições de API.

package com.exemplo.sistemavagas.controller;

import com.exemplo.sistemavagas.model.Vaga;
import com.exemplo.sistemavagas.service.VagaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/vagas")
public class VagaController {

  private final VagaService vagaService;

  @Autowired
  public VagaController(VagaService vagaService) {
      this.vagaService = vagaService;
  }

  @GetMapping
  public List<Vaga> listarVagas() {
      return vagaService.listarVagas();
  }

  @PostMapping
  public Vaga cadastrarVaga(@RequestBody Vaga vaga) {
      return vagaService.cadastrarVaga(vaga);
  }
}

O VagaController tem dois endpoints principais:

@GetMapping para listar as vagas (/vagas).
@PostMapping para cadastrar uma nova vaga.

7. Testando a Aplicação

Com tudo configurado, Juninho executou a classe principal SistemaVagasApplication para iniciar o servidor.

Ele testou os endpoints:

Listar vagas: acessando http://localhost:8080/vagas.
Cadastrar vaga: Enviando um POST para http://localhost:8080/vagas com o seguinte JSON:

{
  "titulo": "Desenvolvedor Java Jr",
  "descricao": "Desenvolvimento de APIs em Spring Boot",
  "localizacao": "São Paulo",
  "salario": 3000.0
}

Cada novo POST adicionava uma vaga à lista!

Conclusão: Parabéns, Juninho!

Juninho conseguiu criar uma aplicação simples de cadastro e consulta de vagas de emprego! Com Spring Boot, ele entendeu o básico da arquitetura de backend e como cada camada colabora na aplicação.

Próximos Passos para o BackEnzo

Agora que o básico está dominado, ele planeja:

Integrar a aplicação com um banco de dados real.
Adicionar validações aos dados das vagas.
Implementar novos endpoints para atualizar e excluir vagas.

Essa foi a primeira de muitas aventuras no mundo do backend para o nosso "BackEnzo". E você, está pronto para começar a sua?