Aprenda na prática construindo um projeto real — por pouco tempo! Garanta agora
Java: Criando CRUD com Spring Boot
Hoje, eu acordei com uma inspiração enorme e resolvi escrever esse artigo especialmente para você! Se está começando ou até mesmo já deu seus primeiros passos na programação, mas quer se aprofundar em CRUD em Java com Spring Boot, encontrou o que precisava! CRUD é aquela base essencial, presente em praticamente todos os sistemas, e os fundamentos que vamos abordar aqui hoje são beeem importantes para a sua jornada como desenvolvedor.
Meu nome é Fernanda Kipper e espero, de verdade, que esse artigo te ajude de alguma forma. Vamos?
O que é CRUD e por que ele é tão importante?
Primeiro, vamos entender a ideia por trás do CRUD: a sigla significa Create, Read, Update e Delete, ou seja, operações de criação, leitura, atualização e exclusão de dados. Pensa em qualquer sistema de gestão de dados – seja para um e-commerce ou uma rede social – sempre vamos precisar cadastrar usuários, consultar produtos, atualizar informações e excluir registros.
E, sim, eu sei, isso pode até parecer básico, mas é justamente o domínio dessas operações que vai te dar segurança para construir sistemas sólidos e funcionais. É a base para criar aplicativos que manipulam dados e se comunicam com bancos de dados, algo presente em quase todo projeto real. Além disso, no mundo Java, o Spring Boot facilita (e muito!) o desenvolvimento de APIs e back-ends, tornando todo o processo mais rápido e intuitivo.
Pronto para montar seu próprio CRUD em Java com Spring Boot? Então, bora começar!
Preparando o ambiente: configuração do projeto e dependências
Primeiro passo: configurar o ambiente para rodar o nosso CRUD! Vamos criar o projeto com o Spring Initializr, onde configuraremos as dependências essenciais para nosso CRUD em Java com Spring Boot. Essas são as dependências que vamos usar:
- Spring web: permite a criação de uma API REST, o que é perfeito para CRUDs.
- Spring data JPA: simplifica o acesso ao banco de dados.
- H2 database: um banco de dados em memória ótimo para testes, sem precisar de instalações extras.
Escolha o Java como linguagem, insira as dependências, gere o projeto e abra na sua IDE favorita. Agora é partir para os conceitos básicos que você vai precisar para implementar esse CRUD.
Criando a entidade no Spring Boot
Agora que estamos com o ambiente configurado, é hora de criar a nossa entidade. No Spring Boot, a entidade representa a tabela no banco de dados. Vamos construir um CRUD para gerenciar produtos de uma loja, então nossa entidade será a
Product.Olha só como fica o código:
import jakarta.persistence.Entity; import jakarta.persistence.Id; import jakarta.persistence.GeneratedValue; import jakarta.persistence.GenerationType; @Entity public class Product { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private Integer priceInCents; // Getters e Setters }
Aqui, usamos as anotações
@Entity para indicar que essa classe é uma entidade e @Id para a chave primária. Esse é o nosso primeiro passo: mapear os atributos e representá-los como colunas da tabela. Nossa tabela Product terá um id gerado automaticamente e campos para name e priceInCents – afinal, ninguém gosta de erro de arredondamento, né? 😉Repositórios: conectando a aplicação ao banco de dados
Agora, precisamos de um repositório. Com o Spring Data JPA, essa parte é super prática. Vamos criar uma interface que manipula os dados da entidade
Product sem precisar de SQL explícito. Isso deixa o código mais limpo e fácil de manter.Vamos lá:
import org.springframework.data.jpa.repository.JpaRepository; public interface ProductRepository extends JpaRepository<Product, Long> { }
Simples, né? Só com isso, o Spring já cria todos os métodos de CRUD para a gente:
save, findAll, findById, deleteById, e outros. E isso sem a gente escrever uma linha de SQL! É essa simplicidade que torna o Spring Boot tão incrível.Explore o universo Spring Boot com a Rocketseat!
Quer entender mais detalhes que tornam o Spring Boot tão poderoso e como ele simplifica a criação de aplicações Java? O Spring Boot é a escolha ideal para desenvolvedores que buscam produtividade, flexibilidade e praticidade ao desenvolver APIs e microsserviços.
A Rocketseat preparou um material exclusivo e supercompleto: “Por Dentro de uma Aplicação Spring Boot”. Nele, você vai mergulhar fundo nos principais conceitos, descobrir boas práticas e aprender como tirar o máximo proveito desse framework incrível. Acesse agora e veja como o Spring Boot pode revolucionar o seu desenvolvimento Java!
Criando o controller: a magia dos endpoints REST
Agora que temos nossa entidade e repositório, vamos para o controller, que é onde nossos endpoints REST vão ser definidos. A ideia é usar esses endpoints para expor as operações do CRUD:
Create, Read, Update e Delete. Vamos criar um ProductController para organizar tudo isso:import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import java.util.List; @RestController @RequestMapping("/products") public class ProductController { @Autowired private ProductRepository productRepository; // Método para criar um novo produto @PostMapping public Product createProduct(@RequestBody Product product) { return productRepository.save(product); } // Método para listar todos os produtos @GetMapping public List<Product> getAllProducts() { return productRepository.findAll(); } // Método para buscar um produto por ID @GetMapping("/{id}") public Product getProductById(@PathVariable Long id) { return productRepository.findById(id) .orElseThrow(() -> new RuntimeException("Produto não encontrado")); } // Método para atualizar um produto @PutMapping("/{id}") public Product updateProduct(@PathVariable Long id, @RequestBody Product productDetails) { Product product = productRepository.findById(id) .orElseThrow(() -> new RuntimeException("Produto não encontrado")); product.setName(productDetails.getName()); product.setPriceInCents(productDetails.getPriceInCents()); return productRepository.save(product); } // Método para deletar um produto @DeleteMapping("/{id}") public void deleteProduct(@PathVariable Long id) { productRepository.deleteById(id); } }
Pronto! Temos aqui nosso CRUD completo. Aqui vai um resumo de cada endpoint:
@PostMapping: cria um produto.
@GetMapping: lista todos os produtos.
@GetMapping("/{id}"): busca um produto pelo ID.
@PutMapping("/{id}"): atualiza um produto.
@DeleteMapping("/{id}"): deleta um produto.
Validações no Spring Boot: garantindo dados consistentes
Uma API precisa garantir que os dados estão corretos, né? O Spring Boot facilita as validações de dados com o Bean Validation. Basta adicionar algumas anotações na entidade, e o Spring se encarrega de validar as requisições, lançando erros automáticos se algum dado vier fora do esperado. Por exemplo:
import jakarta.validation.constraints.NotBlank; import jakarta.validation.constraints.Positive; @Entity public class Product { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @NotBlank(message = "O nome do produto não pode estar vazio") @Column(nullable = false, length = 100) private String name; @Positive(message = "O preço deve ser maior que zero") private Integer priceInCents; // Getters e Setters }
Agora, se alguém tentar salvar um produto sem nome ou com preço negativo, o Spring avisa que há um erro. Isso é especialmente útil em projetos maiores, onde controlar tudo manualmente seria um caos.
Dicas finais: melhorando a organização do código com Lombok
Para fechar com chave de ouro, vamos falar de um truque para reduzir o código repetitivo: o Lombok! Com ele, dá para evitar aqueles métodos de getters e setters, que deixam o código poluído. Usando as anotações
@Getter, @Setter, @AllArgsConstructor, e @NoArgsConstructor, a gente deixa a classe mais clean:import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; import lombok.Setter; @Getter @Setter @AllArgsConstructor @NoArgsConstructor @Entity public class Product { // código da classe }
E assim, nossa entidade fica mais enxuta e clara, sem perder funcionalidade.
E aí, preparado para criar seu próprio CRUD?
Com esse guia, você tem tudo o que precisa para criar um CRUD em Java com Spring Boot. Desde a configuração inicial, passando pela criação dos endpoints REST, até as validações de dados, o Spring Boot oferece uma base super robusta para o desenvolvimento. E o melhor: você domina a base que será fundamental para o seu crescimento como dev!
Quer se aprofundar ainda mais em Java e construir projetos de alto nível? Então, a formação em Java da Rocketseat é o próximo passo ideal para você. Lá, você vai aprender do zero ao avançado, com uma abordagem prática e conectada ao que o mercado realmente pede. Acesse o link e vem com a gente nessa jornada!
Espero que esse artigo tenha inspirado você a dar os próximos passos e que, mais importante ainda, tenha simplificado o CRUD em Java com Spring Boot. Afinal, nada melhor do que entender os fundamentos e sair programando de verdade. Até a próxima!
