Criando uma Aplicação com Spring Boot e MongoDB

Olá pessoal hoje iremos ver como criar uma aplicação utilizando Spring Boot e o banco NoSQL MongoDB.

Criando o Projeto

Para criar um sistema usando o SpringBoot a melhor maneira seria criar o projeto via Maven, este processo pode ser realizado de várias maneiras:
Segue como ficou o pom.xml do projeto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>br.com.cvinicius</groupId>
 <artifactId>boot-data-mongodb</artifactId>
 <version>1.0.0-SNAPSHOT</version>
 <packaging>jar</packaging>

 <description>SpringBoot com MongoDB</description>

 <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>1.5.2.RELEASE</version>
 </parent>

 <properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  <java.version>1.8</java.version>
 </properties>

 <dependencies>
  <dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
  </dependency>
 
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-mongodb</artifactId>
  </dependency>

  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
  </dependency>
 </dependencies>

 <build>
  <plugins>
   <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
   </plugin>
  </plugins>
 </build>
</project>

Analisando nossas configurações temos alguns pontos interessantes:
  • Utilizamos o spring-boot-starter-web, este é utilizado para a criação de apps web com SpringWeb;
  • Utilizamos o spring-boot-starter-data-mongodb, este é uma extensão do Spring Data com foco no banco de dados MongoDB.

Configuração do Spring Boot

Após a criação do projeto vamos configurar o Spring Boot, para isso vamos criar/editar o arquivo application.yml, localizado dentro de src/main/resources, nosso arquivo ficará da seguinte forma:

1
2
3
4
5
6
7
8
9
server:
  port: 8080
  
spring:
  data:
    mongodb:
      host: localhost
      port: 27017
      database: boot-mongodb

  • server.port: Aqui configuramos a porta que o servidor embedded irá alocar;
  • spring.data.mongodb.*: Aqui adicionamos detalhes da conexão com o MongoDB, tais como host, port, e database.
Caso a sua instalação do MongoDB esteja com o recurso de autenticação ativada, o application.yml ficará da seguinte forma:

1
2
3
4
5
6
7
8
server:
  port: 8080
  
spring:
  data:
    mongodb:
      uri: mongodb://{user}:{password}@localhost:27017
      database: boot-mongodb

Também temos a classe comum de todo projeto que usa SpringBoot, esta é responsável por inicializar nossa aplicação:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
package br.com.cvinicius.mongo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class BootDataMongodbApplication {

 public static void main(String[] args) {
  SpringApplication.run(BootDataMongodbApplication.class, args);
 }
}

Criando o Domain

Vamos criar o nosso modelo de domínio, aqui iremos adicionar tudo que faz parte da camada de negocio da nossa aplicação:

Entidade Cliente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
package br.com.cvinicius.mongo.domain;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

import lombok.Data;

@Data
@Document(collection="cliente")
public class Cliente {

 @Id
 private String id;
 
 private String razaoSocial;
}

A Entidade possui 2 atributos sendo id e razaoSocial, onde o id (cnpj) é a chave unica representada com o @Id, temos o @Document que mapeia a entidade para a collection no MongoDB, e também utilizando o Lombok para evitar o código boilerplate.

Repository Cliente:

1
2
3
4
5
6
7
package br.com.cvinicius.mongo.domain;

import org.springframework.data.mongodb.repository.MongoRepository;

public interface ClienteRepository extends MongoRepository<Cliente, String>{

}

Aqui apenas fazemos um extends para a interface MongoRepository, assim já herdamos todos os métodos, tais como:  find, count, insert, update e findOne.

Criando a API

Para criar a API iremos utilizar os recursos do SpringMVC, aqui iremos adicionar 2 métodos, sendo uma listagem e um detalhamento:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package br.com.cvinicius.mongo.api;

import java.util.List;
import java.util.Objects;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import br.com.cvinicius.mongo.domain.Cliente;
import br.com.cvinicius.mongo.domain.ClienteRepository;

@RestController
@RequestMapping("/cliente")
public class ClienteAPI {

 @Autowired
 private ClienteRepository repository;
 
 @GetMapping
 public ResponseEntity<?> list(){
  
  List<Cliente> list = repository.findAll();
  
  return ResponseEntity.ok(list);
 }
 
 @GetMapping(path="/{cnpj}")
 public ResponseEntity<Cliente> view(@PathVariable String cnpj){
  
  Cliente cliente = repository.findOne(cnpj);
  
  if(Objects.isNull(cliente)){
   
   return ResponseEntity.noContent().build();
  }
  else{
   return ResponseEntity.ok(cliente);
  }
 }
}

Aqui temos os métodos:
  • list: este retorna uma lista de clientes;
    • URL: http://localhost:8080/cliente
  • view: este retorna detalhes de um cliente a partir de um CNPJ;
    • URL: http://localhost:8080/cliente/{cnpj}

Dados no MongoDB

Após a aplicação estar pronta, é necessário que o MongoDB esteja configurado e funcionando corretamente, para testes criamos o seguinte banco de dados:
  • Database: boot-mongodb
    • Collection: cliente
Collection cliente com 2 registros adicionados.
Após todos os passos temos nossa Aplicação pronta para o uso, para ver o código acesse o repo no GitHub.

https://github.com/cvinicius987/projetos-spring-boot

Referências