Spring Data Unlocked: Começando com Java e MongoDB
Ricardo Mello5 min read • Published Nov 08, 2024 • Updated Nov 11, 2024
APLICATIVO COMPLETO
Avalie esse Tutorial
Se você é um desenvolvedor Java obcecado por MongoDB e Spring, tenho boas notícias: você está no lugar certo. Esta série de artigos explorará como integrar o MongoDB com o Spring Data de uma maneira muito simples e fácil. A ideia principal é ter uma visão de como dar o primeiro passo e, ao mesmo tempo, desenvolver nosso conhecimento explorando os recursos que os dados da Spring Data nos oferecem. Ao final desta série,você terá uma compreensão clara das diferenças entre MongoRepository e MongoTemplate, saberá quando usar cada um e poderá criar queries complexas enquanto melhora seu desempenho usando índices.
- Comece a usar o MongoDB Atlas gratuitamente! Se você ainda não tiver uma conta, o MongoDB oferece um cluster Atlas gratuito para sempre.
- IDE de sua escolha
O Spring Data é uma solução que simplifica o acesso a dados em bancos de dados como o MongoDB. Seu principal objetivo é fornecer uma abordagem fácil e consistente para trabalhar com dados, preservando as características exclusivas do MongoDB. E, é claro, tudo isso está dentro do ecossistema da Spring.
Podemos executar operações CRUD básicas facilmente, e a estrutura pode criar query automaticamente com base nos nomes dos métodos, reduzindo a quantidade de código boilerplate que precisamos escrever. Alguns pontos principais:
- Suporte a repositório: o Spring oferece uma maneira de nos comunicarmos com o MongoDB em um alto nível de abstração, fornecendo operações CRUD muito simples de usar.
- Derivação de query : Podemos criar queries rápidas usando a assinatura de método, o que é ideal para quem busca agilidade.
- Mapeamento e serialização: simplifique o mapeamento e a serialização de objetos por meio de anotações.
- Framework de aggregation : ** **O Spring fornece suporte para o framework de agregação por meio de anotações e também por meio da própria classe de agregação .
- Criação deíndice automático: temos a opção de trabalhar com índices gerenciados pelo próprio Spring (exploraremos isso em mais detalhes na segunda série deste artigo).
Para explorar os recursos do Spring, definiremos um modelo de dados em que trabalharemos com transações entre contas bancárias. Nosso modelo acabará entregando um documento como este:
1 { 2 "id": "672182814338f60133ee26e1", 3 "transactionType": "Debit", 4 "amount": 888.0, 5 "currency": "USD", 6 "status": "In Progress", 7 "description": "Transfer to Ricardo", 8 "createdAt": "2024-10-09T14:00:00", 9 "accountDetails": { 10 "originator": { 11 "accountNumber": "2376543213", 12 "name": "Maria", 13 "bank": "Bank G" 14 }, 15 "beneficiary": { 16 "accountNumber": "2234987651", 17 "name": "Ricardo Mello", 18 "bank": "Bank V" 19 } 20 } 21 }
Como você pode ver, temos vários tipos de campos e subdocumentos, que serão muito úteis para explorar nossas queries.
- Projeto: Gradle - Kotlin
- Linguagem: Java
- Spring Boot: a versão mais recente
Também adicionaremos as seguintes dependências:
- Lombok: simplifica o código gerando automaticamente código boilerplate, como getters e setters.
- Spring Web: usaremos isso para criar pontos de conexão para nosso aplicação.
- Spring Data MongoDB: usaremos isso para armazenar dados em documentos flexíveis e semelhantes a JSON ( BSON ).
Depois disso, basta clicar em "Gerar" e abrir o projeto no seu IDE favorito (estou usando o IntelliJ).
Para se conectar ao MongoDB usando o Spring, usaremos o
application.properties
arquivo e definiremos as seguintes variáveis:1 spring.application.name=SpringShop 2 spring.data.mongodb.uri=<YOUR_CONNECTION_STRING> 3 spring.data.mongodb.database=springshop
Em seguida, criaremos nossa classe de transação (com base em nosso modelo de negócios). Para fazer isso, basta criar uma classe da seguinte maneira:
1 package com.mongodb; 2 3 import lombok.Data; 4 import org.springframework.data.annotation.Id; 5 import org.springframework.data.mongodb.core.mapping.Document; 6 import java.time.LocalDateTime; 7 8 9 10 public class Transaction { 11 12 private String id; 13 private String transactionType; 14 private Double amount; 15 private String currency; 16 private String status; 17 private String description; 18 private LocalDateTime createdAt; 19 private AccountDetails accountDetails; 20 21 public record AccountDetails(Originator originator, Beneficiary beneficiary) {} 22 public record Originator(String accountNumber, String name, String bank) {} 23 public record Beneficiary(String accountNumber, String name, String bank) {} 24 }
A classe de transação é bem simples e inclui as informações do nosso modelo. Aqui, temos três anotações que eu gostaria de discutir:
- @Document: isso indica ao Spring que esta classe é um documento MongoDB .
- @Data: esta é uma anotação do Lombok que gera código boilerplate, como getters, setters, toString, equals e métodos hashCode.
- @Id: isso gerará automaticamente um
_id
(ObjectId) para nós.
Antes de passarmos para a comunicação com o MongoDB, precisamos falar sobre o nível de abstração. MongoTemplate e MongoRepository fazem parte do Spring Data e oferecem diferentes níveis de abstração para interagir com o MongoDB. Enquanto o MongoRepository foi projetado para quem deseja um desenvolvimento mais rápido, o MongoTemplate é mais adequado para quem precisa de mais flexibilidade.
Tudo bem, agora que podemos diferenciá-los, podemos escolher um (ou ambos) para trabalhar.
Agora, é hora de criar nossa classe que lidará com a comunicação com o MongoDB. Nesta primeira parte, focaremos na simplicidade e eficiência e usaremos a
MongoRepository
interface do fornecida pela Spring. Para fazer isso, crie uma classe chamada TransactionRepository
como mostrado abaixo:1 package com.mongodb; 2 3 import org.springframework.data.mongodb.repository.MongoRepository; 4 import org.springframework.stereotype.Repository; 5 6 7 public interface TransactionRepository extends MongoRepository <Transaction, String>{}
Neste exemplo, estamos estendendo a
MongoRepository
interface, o que nos permite herdar vários recursos avançados fornecidos pelo Spring Data que podemos aplicar à nossa Transaction
entidade .Vamos aproveitar o alto nível de abstração fornecido pelo MongoRepository e criar dois métodos para inserção e query. Para fazer isso, criaremos uma classe TransactionService :
1 package com.mongodb; 2 import org.springframework.stereotype.Service; 3 import java.util.List; 4 5 6 public class TransactionService { 7 private final TransactionRepository transactionRepository; 8 9 public TransactionService(TransactionRepository transactionRepository) { 10 this.transactionRepository = transactionRepository; 11 } 12 List<Transaction> getTransactions() { 13 return transactionRepository.findAll(); 14 } 15 public Transaction save(Transaction transaction) { 16 return transactionRepository.save(transaction); 17 } 18 }
Agora, para finalizar esta primeira parte da nossa série, criaremos nosso controlador para testar as operações de inserção e localização. Para fazer isso, basta executar o seguinte código:
1 package com.mongodb; 2 3 import org.springframework.http.HttpStatus; 4 import org.springframework.http.ResponseEntity; 5 import org.springframework.web.bind.annotation.*; 6 7 import java.util.List; 8 9 10 11 public class TransactionController { 12 13 private final TransactionService transactionService; 14 15 public TransactionController(TransactionService transactionService, TransactionRepository transactionRepository) { 16 this.transactionService = transactionService; 17 } 18 19 20 public List<Transaction> getTransactions() { 21 return transactionService.getTransactions(); 22 } 23 24 25 public ResponseEntity<Transaction> create( Transaction transaction) { 26 return ResponseEntity.status(HttpStatus.CREATED).body(transactionService.save(transaction)); 27 } 28 }
Aviso: poderíamos criar algumas classes para lidar melhor com nossos objetos de tráfego. No entanto, vamos nos concentrar na simplicidade por enquanto.
Se você ainda não executou o aplicação , lembre-se de atualizar a string de conexão para seu banco de dados de dados. Com o aplicação em execução, vamos inserir um documento usando o seguinte comando cURL:
1 curl --location 'http://localhost:8080/transactions' \ 2 --header 'Content-Type: application/json' \ 3 --data '{ 4 "transactionType": "Transfer", 5 "amount": 1500.5, 6 "currency": "USD", 7 "status": "Completed", 8 "description": "Transfer to Ricardo", 9 "createdAt": "2024-10-09T14:00:00.000Z", 10 "accountDetails": { 11 "originator": { 12 "accountNumber": "9876543210", 13 "name": "Maria Faria", 14 "bank": "Bank A" 15 }, 16 "beneficiary": { 17 "accountNumber": "1234987654", 18 "name": "Ricardo Mello", 19 "bank": "Bank B" 20 } 21 } 22 }'
Se tudo correr bem, podemos consultar nossos registros usando o
findAll
método:1 curl --location 'http://localhost:8080/transactions'
Estou usando o Postman para realizar as solicitações de cURL e ver os resultados.
Como você pode ver, nosso documento inserido corresponde ao modelo que definimos inicialmente.
Nesta primeira parte da série Spring Data Unlocked , vimos como começar a usar o Spring Data e o MongoDB. O artigo demonstra como criar um projeto do zero e integrá-lo de forma simples e direta. Modelamos nossa entidade que será usada nos próximos artigos, onde exploraremos os recursos do Spring com agregações e queries mais complexas. Para continuar lendo, confira a segunda parte: Queries avançadas com MongoDB.
Se você tiver alguma dúvida, fique à vontade para deixá-la nos comentários. O código completo está disponível em mongo-developer Github Github.
Principais comentários nos fóruns
Ainda não há comentários sobre este artigo.