Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Saiba por que o MongoDB foi selecionado como um líder no 2024 Gartner_Magic Quadrupnt()
Desenvolvedor do MongoDB
Centro de desenvolvedores do MongoDB
chevron-right
Produtos
chevron-right
MongoDB
chevron-right

Spring Data Unlocked: Começando com Java e MongoDB

Ricardo Mello5 min read • Published Nov 08, 2024 • Updated Nov 11, 2024
SpringMongoDBFramework de agregaçãoJava
APLICATIVO COMPLETO
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
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.

Pré-requisitos

SpringData

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:
  1. 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.
  2. Derivação de query : Podemos criar queries rápidas usando a assinatura de método, o que é ideal para quem busca agilidade.
  3. Mapeamento e serialização: simplifique o mapeamento e a serialização de objetos por meio de anotações.
  4. 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 .
  5. 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).

O modelo de negócios

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.

O aplicação Java

Para construir nosso aplicação, vamos usar o Spring Initializr usando as seguintes opções:
  1. Projeto: Gradle - Kotlin
  2. Linguagem: Java
  3. 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 ).
imagem initializr de primavera
Depois disso, basta clicar em "Gerar" e abrir o projeto no seu IDE favorito (estou usando o IntelliJ).

Configurando o aplicação

Para se conectar ao MongoDB usando o Spring, usaremos o application.properties arquivo e definiremos as seguintes variáveis:
1spring.application.name=SpringShop
2spring.data.mongodb.uri=<YOUR_CONNECTION_STRING>
3spring.data.mongodb.database=springshop

A classe de transação

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:
1package com.mongodb;
2
3import lombok.Data;
4import org.springframework.data.annotation.Id;
5import org.springframework.data.mongodb.core.mapping.Document;
6import java.time.LocalDateTime;
7
8@Document(collection = "transactions")
9@Data
10public class Transaction {
11 @Id
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.

MongoTemplate e MongoRepository

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.
mongo Comparação do repositório mongo mongo versus modelo mongo
Tudo bem, agora que podemos diferenciá-los, podemos escolher um (ou ambos) para trabalhar.

TransactionRepository

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:
1package com.mongodb;
2
3import org.springframework.data.mongodb.repository.MongoRepository;
4import org.springframework.stereotype.Repository;
5
6@Repository
7public 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 .

Serviço e controlador

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 :
1package com.mongodb;
2import org.springframework.stereotype.Service;
3import java.util.List;
4
5@Service
6public 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:
1package com.mongodb;
2
3import org.springframework.http.HttpStatus;
4import org.springframework.http.ResponseEntity;
5import org.springframework.web.bind.annotation.*;
6
7import java.util.List;
8
9@RestController
10@RequestMapping("/transactions")
11public class TransactionController {
12
13 private final TransactionService transactionService;
14
15 public TransactionController(TransactionService transactionService, TransactionRepository transactionRepository) {
16 this.transactionService = transactionService;
17 }
18
19 @GetMapping
20 public List<Transaction> getTransactions() {
21 return transactionService.getTransactions();
22 }
23
24 @PostMapping
25 public ResponseEntity<Transaction> create(@RequestBody 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.

Testando nosso endpoint

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:
1curl --location 'http://localhost:8080/transactions'
Estou usando o Postman para realizar as solicitações de cURL e ver os resultados.
Endpoint da transação do Postman
Como você pode ver, nosso documento inserido corresponde ao modelo que definimos inicialmente.

Conclusão

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.
Iniciar a conversa

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Relacionado
Tutorial

Criar um microsserviço de preços dinâmicos com Vertex AI e MongoDB Atlas


Jan 22, 2025 | 18 min read
Início rápido

Início rápido: tipos de dados BSON - Data


Sep 23, 2022 | 2 min read
exemplo de código

Crie uma ferramenta de linha de comando com Swift e MongoDB


Sep 11, 2024 | 13 min read
Tutorial

Otimize e ajuste o desempenho do MongoDB com índices ocultos


Oct 01, 2024 | 5 min read
Sumário
  • Pré-requisitos