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

Comentários


  1. I blog quite often and I seriously thank you for your content. The article has truly peaked my interest. I'm going to take a note of your website and keep checking for new information about once per week. I subscribed to your RSS feed as well. capitalone com login

    ResponderExcluir
  2. At this time I am going to do my breakfast, later than having my breakfast coming yet again to read other news. itunes login account

    ResponderExcluir

Postar um comentário

Popular Posts

Criando arquivos de log com Log4J

Monitorando o Tomcat com Java VisualVM

AngularJS - Formatando Datas com o Filter Date

Injeção de dependências em Java EE usando @Inject, @EJB e @Resource ?

Gerenciamento de Transações com EJB - Parte 2

JBoss AS 7 - Instalação e Configuração

Configurando o arquivo application.properties do SpringBoot

Métodos Utilitários da Classe String

Lendo e Manipulando arquivos CSV com Java