Pular para o conteúdo principal

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/frameworks/spring/boot-data-mongodb

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

Postagens mais visitadas deste blog

Utilizando LocalDate, LocalDateTime e LocalTime na Prática

Tudo bem pessoal, hoje iremos avaliar e analisar operações de manipulação de Datas envolvendo a JavaTime API introduzida no Java 8.

Exemplos da java.time API
Já se passaram alguns anos desde o lançamento do Java 8 e mesmo após este período, há empresas que desconhecem o poder da java.time API, esta foi uma nova API de datas introduzida no Java 8 visando resolver problemas que tínhamos com as velhas classes Date e Calendar.

Vamos mostrar vários exemplos práticos do uso da API:
Criação de objetos No exemplo abaixo, estamos criando os objetos para manipulação de datas, perceba que temos 3 tipos, sendo LocalDate para manipular datas, LocalDateTime para manipular data/hora e LocalTime para horas:
LocalDate localDate = LocalDate.now(); LocalDateTime localDateTime = LocalDateTime.now(); LocalTime localTime = LocalTime.now();
Utilizando formatação Aqui realizamos a operação de formatação, perceba que não foi necessário utilizar a classe SimpleDateFormat, que usaríamos em conjunto com D…

Lendo e Manipulando arquivos CSV com Java

Olá hoje veremos como realizar a leitura e manipulação de arquivos CSV com Java, mostrando que as novas versões da plataforma Java deixaram algumas tarefas simples de serem realizadas.

Exemplo de Arquivo Hoje em dia é comum ao realizar integrações ou carga de dados o uso de arquivos CSV, isto porque, este arquivo possui uma estrutura de fácil entendimento e simples de manipular na maioria das plataformas de desenvolvimento.

Para realizar a leitura dos dados vamos manipular um arquivo com as seguintes colunas: namecpfagephone address:

name;cpf;age;phone;address caio;123456789;20;1145223643;AvenidaPaulista vinicius;147852369;18;1125253625;AvenidaManoel sandra;963258741;30;1174587858;RuaTeixeira regina;125478522;40;1145254536;RuaFernando fernando;785245563;42;1145253669;RuaPereira augusto;456123014;50;1125363633;AvenidaPaulinia maria;456123789;10;1125455525;AvenidaNossaSenhora
Para representar os dados em objetos Java iremos utilizar a seguinte classe:

importlombok.AllArgsConstruc…

Versionamento de Banco Dados com Flyway

Olá pessoal, hoje iremos analisar e aprender como realizar o versionamento e gerenciamento das bases de dados relacionais utilizando o framework Flyway.

Versionamento de Banco Dados Ao trabalhar com desenvolvimento de sistemas é comum realizarmos o versionamento, isso porque uma aplicação pode necessitar de correções, novas funcionalidades e evoluções, onde para garantir a compatibilidade e cuidar do seu ciclo de vida, geramos versões onde é especificado quais itens estão presentes em cada release.
Vamos imaginar seguinte cenário: Sistema ERP1.0.0: Entrega dos módulos Financeiro e RH;1.1.0: Entrega do módulo Contas a Receber. Perceba que a ideia é controlar o que cada versão possui de diferente, e para controlar essas mudanças no lado da aplicação existem várias técnicas e ferramentas, mas e para controlar as mudanças no lado do Banco de dados ? 
Para isso podemos utilizar ferramentas de versionamento que ajudam a realizar este controle, a ferramenta que iremos utilizar é o Flyway.
Con…