# Trilha 1 - Java Springboot Mercado de Trabalho
## Aula 02
:::info
👨💻 **Prof** Edson Belem de Souza Junior
📞 **Celular/Whatsapp:** (21) 98199-0108
✉ **E-mail:** profedsonbelem@gmail.com
:::
.
:::info
👨💻 **Profª** Luciana de Vasconcelos Medeiros
📞 **Celular/Whatsapp:** (21) 98201-2525
✉ **E-mail:** lu.vmedeiros@gmail.com
:::
.
:::info
📕 **Aula:** 01/07/2024
🌐 **Site:** https://www.edsonbelemtreinamento.com.br/
**Blog**: https://edsonbelemtreinamento.com.br/#/blog
**Youtube:** https://www.youtube.com/@EdsonBelemTreinamento
**Instagram:** https://www.instagram.com/edson_belem_treinamento/
**Linkedin:** https://www.linkedin.com/in/edsonbelemsjunior/
:::
# Tema da aula:
Springboot Java 17, Conceitos Maven, springboot, mongodb, pom, Melhores pratica api, Criação de projeto, Annotations, Interface, application.properties,
## Aula Spring Boot 1 Aula Maven
* Recursos Utilizados Java _ ainda na versão 17.
* Maven 3.9.8
* Banco de Dados Mongo _ Banco de Dados Não Relacional versão 4.5 , 5.0
**Outros:**
* Gradle Associado a controle melhor, versionamento mais seguro
* Gradle Mobil, kotlin,
* Gradle e Groovy (versionador) tem local que utilizando o Groovy para facilitar a configuração do Projeto ...
* Ambiente Atual (dev) ... test ... homol ... (prod)
* LocalHost (http) _
* OnLine (https) _ Assinatura (na minha toda comunicação que sai, de uma ponta a outra é critografado ...
* Localhost (online) ... Servidor (host) ... On-line ... (Configurada para ter uma segurança , máquina de dev, instala muita brecha) ...
Conta em uma máquina alugada VPS (**contabo**)
https://contabo.com/en/
## Documentação oficial do springboot:
https://spring.io/guides/gs/accessing-data-mysql
Esse é o padrão do Spring Boot, sua empresa alé disso tem outros padrãos ... (Segurança... , qualidade ...)
## Melhores praticas para Design de API
https://learn.microsoft.com/pt-br/azure/architecture/best-practices/api-design
```java=
associacao =
java da Oracle
java 1.0, 2.0, 3.0, 4.0 , java 5 marco, java 6,7, (8
java 11 - 17 - (11 ... 2021) _ (17 _2023) 21 .. 2024)
java 8.0, java 17 marco
Java 17 = maven = 3.9 X _ m2_home
Java 17 = gradle 8.5 = groovy = 4.0
java 21 = gradle 8.8 = groovy = 5.0
https://martinfowler.com/articles/richardsonMaturityModel.html
== Tudo que você pensa, deve girar em torno do resultado final Api...
== Front e Back
== MVC (2016) ... (Microservices )
== src fora da configuração, estou (source fonte), após a configurações
```
## src (ambiente de Programação)
## no raiz (baixa o projeto )
### Arquivo de confiração do maven (3.9.8)
### pom.xml
```java=
<?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
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.7</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>br.com.arq</groupId>
<artifactId>springb2</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springb2</name>
<description>Demo project for Spring Boot</description>
<url/>
<licenses>
<license/>
</licenses>
<developers>
<developer/>
</developers>
<scm>
<connection/>
<developerConnection/>
<tag/>
<url/>
</scm>
<properties>
<java.version>17</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</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-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>
```
### model (mongodb) não trabalho JPA, respository, service, controller (obrigatória)
### entity (jpa) mysql (comunity free) (enterprise pago), maria-db DE GRAÇA GNU, (postgre free gnu), Oracle pago (chato 17) melhor e mais caro, não é rápido (performance) , repository
### Apache (grátis) geralmente é grátis. ... Avançar no Produto
### Linux ... (gnu)
Classe model Users
```java=
package br.com.arq.model;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
@Document(collection="users")
public class Users {
@Id
private String id;
private String name;
private String email; //importante é perigoso ... rastro ... vida 2mfa ... defesa
private String password; // google e a ms (google e a ms) ficam na cola
private String status;
private String token; //security ... nao é nossa vida ...
// 6 keys = values chave = valor ... (dinamicamente ele cria as coleções)
public Users() {
// TODO Auto-generated constructor stub
}
public Users(String id, String name, String email, String password, String status, String token) {
super();
this.id = id;
this.name = name;
this.email = email;
this.password = password;
this.status = status;
this.token = token;
}
@Override
public String toString() {
return "Users [id=" + id + ", name=" + name + ", email="
+ email + ", password=" + password + ", status="
+ status + ", token=" + token + "]";
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getToken() {
return token;
}
public void setToken(String token) {
this.token = token;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
```
Domain
_ entity _ Entidade ou model
Users
_ Dto (classe ) _ IGUAL (personalizado)
_ request (api) _ json (entrada) _ validação
UsersRequest
_ response
UsersReponse
_ interfaces (regras de Negócio)
### DDD
###
br.com.arq
domain ( core )
(Core)
_ Model
_ transferencia de dados DTO
_ entrada (request) Lógica
UsersRequest
_ response (saída)
_
_ Test
br.com.arq
_ request (test)
UsersRequestTest
##
## 2028 ...
# Teorias 📚
## Sprinboot
https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/
O **Spring Boot** é um projeto da Spring que veio para facilitar o processo de configuração e publicação de nossas aplicações. A intenção é ter o seu projeto rodando o mais rápido possível e sem complicação.
Ele consegue isso favorecendo a convenção sobre a configuração. Basta que você diga pra ele quais módulos deseja utilizar (WEB, Template, Persistência, Segurança, etc.) que ele vai reconhecer e configurar.
Você escolhe os módulos que deseja através dos starters que inclui no pom.xml do seu projeto. Eles, basicamente, são dependências que agrupam outras dependências. Inclusive, como temos esse grupo de dependências representadas pelo starter, nosso pom.xml acaba por ficar mais organizado.
Apesar do **Spring Boot**, através da convenção, já deixar tudo configurado, nada impede que você crie as suas customizações caso sejam necessárias.
O maior benefício do **Spring Boot** é que ele nos deixa mais livres para pensarmos nas regras de negócio da nossa aplicação.
O **Spring Boot**, busca solucionar a complexidade da inicialização e gerenciamento de dependências de um projeto com Spring, além de tratar de maneira coesa e eficiente a questão da configuração.
Essencialmente, o **Spring Boot** pode ser considerado um plugin para a ferramenta de building, seja ela o Maven ou o Gradle. Seus principais objetivos são gerenciar dependências de maneira opinativa e automática, e simplificar a execução do projeto em tempo de desenvolvimento e depuração.
O **Spring Boot** também possui a funcionalidade de empacotamento da sua aplicação em um JAR executável contendo todas as dependências necessárias, inclusive o Servlet Container, seja ele o Tomcat, Jetty ou mesmo Undertow, apesar de ainda ser possível empacotar um WAR da forma tradicional.
O principal benefício do Boot, entretanto, é a configuração de recursos baseada no que se encontra no classpath. Se o POM de seu Maven inclui a dependência do JPA e o driver do MySql, ele irá criar uma unidade de persistência baseada no MySql.
Se adicionarmos alguma dependência web, iremos perceber que o **Spring MVC** assumirá configurações default e dependências com relação a diversos aspectos, como a tecnologia de apresentação (o default é o **Thymeleaf**), o mapeamento de recursos e marshalling de JSON (o default é o Jackson) e/ou XML (o default é o JAXB 2) para o tratamento de dados de requisição e resposta, que necessitamos em uma aplicação REST, por exemplo.
### Command Line Runner
Interface usada para indicar que um bean deve ser executado quando estiver contido em um SpringApplication. Vários beans CommandLineRunner podem ser definidos no mesmo contexto de aplicativo e podem ser pedidos usando a interface Ordered ou a anotação ==@Order==.
o **Command Line Runner** é uma interface. Isso significa que não podemos criar uma instância dela, mas podemos implementá-la. Se definirmos uma implementação da interface do **Command Line Runner**, precisaremos substituir o método run. Este método será executado após o contexto do aplicativo ser carregado e logo antes da conclusão do método de execução do Aplicativo Spring.
Lembre-se de que isso será executado após o contexto do aplicativo ser carregado, para que você possa usá-lo para verificar se existem certos beans ou quais são os valores de determinadas propriedades. Outro motivo para usá-lo é carregar alguns dados antes de o aplicativo ser iniciado. Vou dizer que já usei um **Command Line Runner** para esses fins, mas ambos estavam em ambientes de desenvolvimento ou de demonstração.
## Maven:
O Maven é uma ferramenta de gerenciamento e automação de projetos, principalmente usada em projetos Java. Ele fornece uma maneira padronizada de construir, testar, empacotar e gerenciar dependências de software. Criado pela Apache Software Foundation, o Maven é conhecido pela sua simplicidade e eficácia em automatizar tarefas comuns no ciclo de vida de desenvolvimento de software.
Apache Maven, ou simplesmente Maven, é uma ferramenta de automação de compilação utilizada primariamente em projetos Java. Ela é similar à ferramenta Ant, mas é baseada em conceitos e trabalhos diferentes em um modo diferente. Também é utilizada para construir e gerenciar projetos escritos em C#, Ruby, Scala e outras linguagens. O projeto Maven é hospedado pela Apache Software Foundation, que fazia parte do antigo Projeto Jakarta.
O Maven utiliza um arquivo XML (POM) para descrever o projeto de software sendo construído, suas dependências sobre módulos e componentes externos, a ordem de compilação, diretórios e plug-ins necessários. Ele vem com objetivos pré-definidos para realizar certas tarefas bem definidas como compilação de código e seu empacotamento.
O Maven baixa bibliotecas Java e seus plug-ins dinamicamente de um ou mais repositórios, como o Maven 2 Central Repository, e armazena-os em uma área de cache local. Este cache local de artefatos baixados pode também ser atualizado com artefatos criados por projetos locais. Repositórios públicos podem também ser atualizados.
O Maven é construído utilizando uma arquitetura baseada em plugin, que permite que ele faça uso de qualquer aplicação controlável através da entrada padrão. Teoricamente, isto permitiria qualquer um escrever plugins para fazer interface com ferramentas de construção (compiladores, ferramentas de teste de unidade, etc.) para qualquer outra linguagem. De fato, o suporte e uso para linguagens diferentes de Java tem sido mínimas. Atualmente existe um plugin para o framework .NET e é mantido, e um plugin nativoC/C++ é mantido para o Maven 2.
### O que o Maven Faz?
#### **Gerenciamento de Dependências:**
O Maven facilita o gerenciamento de bibliotecas e plugins que seu projeto necessita. Em vez de manualmente baixar e incluir cada biblioteca necessária, você pode declarar dependências no arquivo `pom.xml` (Project Object Model). O Maven então baixa automaticamente essas dependências do repositório central ou de outros repositórios configurados.
```xml
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.3.9</version>
</dependency>
```
#### **Ciclo de Vida do Build:**
O Maven define um ciclo de vida padrão de build que inclui fases como validação, compilação, testes, empacotamento, verificação e implantação. Cada fase tem uma função específica, e você pode definir plugins para executar tarefas em cada fase.
```bash
mvn clean install
```
- `clean`: Remove os arquivos gerados pela build anterior.
- `install`: Compila o código, executa testes e instala o artefato no repositório local.
#### **Gestão de Projetos Múltiplos:**
Para projetos grandes com múltiplos módulos, o Maven permite organizar projetos em uma estrutura hierárquica. Um projeto pai pode agrupar vários subprojetos, cada um com seu próprio `pom.xml`, mas herda configurações comuns do projeto pai.
```xml
<modules>
<module>module-a</module>
<module>module-b</module>
</modules>
```
#### **Padronização:**
O Maven promove convenções sobre configuração. Isso significa que muitos padrões são predefinidos, como a estrutura de diretórios e as fases do ciclo de vida do build, reduzindo a quantidade de configuração que você precisa fazer.
- `src/main/java`: Código fonte Java.
- `src/test/java`: Código de teste Java.
#### **Repositórios:**
O Maven usa repositórios para armazenar dependências. Existem três tipos principais:
- **Repositório Central**: Um grande repositório online mantido pela Apache, de onde o Maven baixa dependências.
- **Repositório Local**: Um cache local onde o Maven armazena dependências baixadas e artefatos construídos.
- **Repositório Remoto**: Repositórios específicos da empresa ou organizacionais.
### POM
Este POM apenas define um identificador único para o projeto (coordenadas) e sua dependência do framework JUnit. No entanto, isto já é suficiente para a construção do projeto e execução dos testes de unidade associados ao projeto. O Maven realiza isto adotando a ideia de Convenção sobre configuração, isto é, ele fornece valores padrões para a configuração do projeto. A estrutura de diretórios de um projeto Maven idiomático normal possui as seguintes entradas de diretório:
|Nome do diretório|Propósito|
|-----------------|---------|
|project home |Contém o pom.xml e todos os subdiretórios.|
|src/main/java |Contém o código-fonte Java entregável para o projeto.|
|src/main/resources |Contém os recursos entregáveis para o projeto, tais como arquivos de propriedades.|
|src/test/java |Contém as classes de teste (casos de teste JUnit ou TestNG, por exemplo) para o projeto.|
|src/test/resources |Contém os recursos necessários para teste.|
### Conceitos
**Project Object Model**
Um Project Object Model (POM), ou em português Modelo de Projeto de Objeto, fornece todas as configurações para um único projeto. A configuração geral cobre o nome do projeto, seu proprietário e suas dependências de outros projetos. Também pode configurar fases individuais do processo de construção, que são implementados como plugins. Por exemplo, pode configurar o plugin compilador para usar a versão 1.5 do Java para compilação, ou especificar o empacotamento do projeto mesmo que algumas unidades de teste falhem.
Projetos maiores poderiam ser divididos em vários módulos, ou sub-projetos, cada um com seu próprio POM. Cada um pode então escrever um POM raiz através do qual ele pode compilar todos os módulos com um único comando. POMs também podem herdar configuração de outros POMs. Todos os POMs herdam do Super POM por padrão. O Super POM fornece configuração padrão, tal como os diretórios fonte padrões, plugins padrões e assim por diante.
**Plugins**
Há plugins Maven para construção, teste, gerenciamento de controle de fonte, execução de um servidor web, geração de arquivos de projeto Eclipse e muito mais. Plugins são introduzidos e configurados em uma seção plugins de um arquivo pom.xml. Alguns plugins básicos estão incluídos em todos os projetos por padrão e eles possuem configurações padrões sensíveis.
Plugins são o modo primário de estender o Maven. Desenvolver um plugin Maven pode ser feito através da extensão da classe org.apache.maven.plugin.AbstractMojo. Um exemplo simples é dado na página do Centro de Desenvolvedores de Plugin no site do Maven e mais exemplos detalhados são dados no Apache Maven 3 Cookbook. Código de exemplo e explicação para o plugin Maven para criar uma máquina virtual baseada em nuvem executando em um servidor de aplicação é dado no artigo Automate development and management of cloud virtual machines.
**Dependências**
A seção de exemplo sugeriu ao mecanismo de manipulação de dependências do Maven. Digamos que um projeto que necessita da biblioteca Hibernate tem que declarar as coordenadas do projeto do Hibernate em seu POM. O Maven automaticamente baixará a dependência e as dependências que o próprio Hibernate precisa (chamadas dependências transitivas) e as armazenará em um repositório local do usuário. O Repositório Central do Maven 2 é usado por padrão para procurar bibliotecas, mas pode-se configurar os repositórios usados (e.g., repositórios privados de uma empresa) no POM.
Há motores de busca, como a Central Maven, que podem ser usadas para encontrar coordenadas para diferentes bibliotecas e frameworks de código aberto.
Projetos desenvolvidos em uma única máquina podem depender um do outro através do repositório local. O repositório local é uma estrutura de pasta simples que age tanto como um cache para dependências baixadas e como um local de armazenamento centralizado para construir artefatos localmente. O comando mvn install constrói um projeto e coloca seus binários em um repositório local. Então, outros projetos podem utilizar este projeto por especificação de suas coordenadas em seus POMs.
### Exemplo de Arquivo `pom.xml`
Aqui está um exemplo básico de um arquivo `pom.xml` para um projeto Maven:
```xml
<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>com.example</groupId>
<artifactId>meu-projeto</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
```
### Conclusão
O Maven é uma ferramenta poderosa que automatiza muitos aspectos do desenvolvimento de software, desde o gerenciamento de dependências até a construção e empacotamento de projetos. Ele promove boas práticas de desenvolvimento, facilitando a consistência e reprodutibilidade em projetos de software. Com o Maven, desenvolvedores podem se concentrar mais no código e menos na configuração e gestão de builds.
## Banco de Dados MongoDB
https://www.mongodb.com/try/download/community
**MongoDB** (do inglês humongous, "gigantesco") é uma aplicação de código aberto, de alta performance, sem esquemas, orientado a documentos. Foi escrito na linguagem de programação C++. Além de orientado a documentos, é formado por um conjunto de documentos JSON. Muitas aplicações podem, dessa forma, modelar informações de modo muito mais natural, pois os dados podem ser aninhados em hierarquias complexas e continuar a ser indexáveis e fáceis de buscar. O desenvolvimento de **MongoDB** começou em outubro de 2007 pela 10gen. A primeira versão pública foi lançada em fevereiro de 2009.
Mongo (É um em Banco de dados (3ª camada) em Javascript) / Quem Grava o Projeto tb é Javascript (JSON) Comandos do Json para trabalhar com o Banco ... Velocidade, melhor desempenho, BIG DATA ... Quantidade de Dados, Imagem ... Variedades de Informações / e velocidade de Captura de Informações. NOSQL (Javascript) _ Banco sem sql ... Comandos de Javascript ...
### Introdução
É fato de que a maior parte dos bancos de dados existentes no mercado hoje são do tipo modelo relacional. Mas fatores novos estão mudando essa história, pelo menos no que se refere ao crescimento intenso da quantidade de dados de certas organizações, e algumas limitações do modelo relacional têm ajudado para alternativas de banco de dados apareçam buscando sanar essas limitações. A alternativa que tem ganhado bastante espaço nas organizações são os banco de dados chamados de NoSQL. Neste artigo, são apresentadas as principais características desses bancos de dados e, em especial, veremos as características do Banco de Dados Orientado a Documento **MongoDB**.
### SGBDS Relacionados
Surgido nos anos 70, os SGBDs (Sistemas Gerenciadores de Banco de Dados) relacionais tem recursos que são importantes para facilitar o processo de criação e manutenção de sistemas, alguns deles são: a verificação e garantias de integridade dos dados, o gerenciamento de concorrência, recuperação de falhas, processos de uso de validação, a segurança, a otimização de consultas, etc..
Os Sistemas Gerenciadores de Banco de Dados relacionais mais conhecidos são: SQL Server, Oracle, PostgreSQL, MySQL, etc. Usam uma linguagem de manipulação, consulta e definição chamada SQL (Structured Query Language), que foi criada são as relações (ou tabelas), as quais são compostas de linhas (ou tuplas) e colunas (ou atributos).
Graças ao intenso crescimento do número de aplicações, soluções, recursos e tudo o que se refere a sistemas computacionais nas últimas décadas, o volume de dados associados a tais tipos de sistemas também teve um ritmo de crescimento acelerado. É justamente aí, nesses lugares nos quais o grande volume de dados é o problema, esses bancos baseados no Modelo Relacional, não tem sido eficientes o bastante. E essa é a dificuldade real do uso do Modelo Relacional: a difícil tarefa de conciliar a demanda por escalabilidade cada vez mais intensa.
### Banco de dados NoSql
É na Web que encontramos a maior inspiração para o desenvolvimento de novas tecnologias de Banco de Dados. Tudo por causa da necessidade que surge para suprir as aplicações web que cada vez mais tem um grande volume de dados e requisitos diferenciados, como o elevado grau de disponibilidade a escalabilidade sob demanda, surge então uma nova categoria de SGBDs, conhecida como NoSQL, abreviação de Not Only SQL (não apenas SQL), criada inicialmente para foi proposta com o objetivo de atender aos requisitos de gerenciamento de grandes volumes de dados, semi-estruturados ou não estruturados. Ou seja, sendo utilizado principalmente em casos em que o Modelo Relacional não apresentava performance adequada.
É importante deixar claro que o NoSQL não veio para substituir os bancos de dados relacionais. Os bancos de dados NoSQL servem para uma gama de problemas que nem sempre são os mesmos dos bancos de dados relacionais. E quando se fala em NoSQL sempre se fala das grandes vantagens em termos de escala em comparação aos SGBDs relacionais. Não é verdade que os bancos de dados relacionais não escalam. A verdade é que eles não escalam com facilidade. Abaixo um esquema básico de aplicação web:
Se o sistema acima passar a demanda de usuários aumentarem muito surgem na nossa aplicação problemas com a escalabilidade. O que se pode fazer é aumentar a capacidade do servidor, dando-lhe um upgrade no seu processador, no armazenamento e em sua memória.. Ou então, fazer crescer a quantidade das máquinas de servidores web:
E se a aplicação web continuar a crescer? Certamente o banco de dados não iria suportar atender a todas as requisições em um tempo hábil. E se colocássemos mais máquinas rodando o nosso banco de dados?
Com isso, agora devemos escalar nosso banco de dados através de múltiplas máquinas, o que é mais complicado do que com os nossos servidores web. Na maioria dos casos não podemos simplesmente ligar mais uma máquina rodando o banco e esperar que tudo funcione. Vamos precisar de uma série de configurações e alterações nas nossas aplicações para fazer tudo funcionar na nova arquitetura distribuída. Os bancos de dados NoSQL vem para tornar este processo que muitas vezes é trabalhoso e complicado em um processo mais simples e robusto.
Como exemplo de aplicações que necessitam de um gerenciamento eficaz de grandes quantidades de dados não estruturados estão às redes sociais, exemplos clássicos nós temos o Twitter, Facebook e outras redes, onde a quantidade de informação gerada pelos usuários possui um crescimento que as bases de dados relacionais não conseguem comportar. Tudo isso se deve o fato dos bancos de dados relacionais não serem eficazes nesse requisito.
Esses bancos de dados NoSQL são amplamente adotados em empresas como Facebook, Amazon e Google com o intuito de atender às suas demandas de escalabilidade, alta disponibilidade e dados não estruturados. E vale ressaltar que, atualmente, diversos bancos de dados NoSQL de código livre estão disponíveis, exemplos disso são o Cassandra, Hypertable, **MongoDB**, Redis, CouchDB e Dynamo.
As primeiras e mais importantes implementações de um sistema realmente não-relacional são:
* BigTable – do Google. Surgiu em 2004 como um banco de dados proprietário de alta performance que tinha como objetivo promover maior escalabilidade e disponibilidade.
* Dynamo – da Amazon. Surgiu em 2007, o sistema que tinha como característica básica ser um banco de dados não-relacional, de alta disponibilidade, utilizado pelos web services da Amazon.
* Cassandra, de 2008, projetado para ser um sistema de banco de dados distribuído e de alta disponibilidade, desenvolvido pelo site Facebook para lidar com grandes volumes de dados. No início de 2010, o Cassandra desbancou o MySQL como banco de dados do Twitter, demonstrando sua importância cada vez mais crescente.
* **MongoDB**, lançada em 2009, um banco de dados orientado a documentos, escalável, de alta performance e livre de esquemas. E é o grande foco do nosso estudo.
Antes de falarmos mais sobre as soluções NoSQL, mais precisamente do **MongoDB**, é importante lembrar que o propósito, portanto, não é substituir o Modelo Relacional como um todo, mas apenas em casos nos quais seja necessária uma maior flexibilidade da estruturação do banco.
Criado pelo ex-Fundador do DoubleClick e CTO Dwight Merriman e DoubleClick ex-engenheiro e fundador ShopWiki e Eliot CTO Horowitz. Eles se basearam as suas experiências em construção de grande escala, alta disponibilidade, sistemas robustos para criar um novo tipo de banco de dados. O próprio Eliot dá a definição:
O **MongoDB** não foi concebido em um laboratório. Nós construímos o **MongoDB** com base em nossas experiências na construção de sistemas robustos de grande escala e alta disponibilidade. Não começamos do zero, realmente tentamos descobrir o que estava quebrado, e combater isso. Assim, a maneira que eu penso sobre **MongoDB** é que se você pegar o MySql, e alterar o modelo de dados do relacional para orientado a documento, você ganha uma grande quantidade de recursos: documentos embarcados para velocidade, facilidade de gerenciamento, desenvolvimento ágil com bancos de dados sem “schema”, escalabilidade horizontal mais fácil, pois “joins” não são tão importantes. Há muitas coisas que funcionam muito bem nas bases de dados relacionais: índices, consultas dinâmicas e atualizações para citar alguns, e nós não mudamos muito neste ponto. Por exemplo, a maneira de projetar seus índices no **MongoDB** deve ser exatamente do jeito que você faz isso no MySQL ou Oracle, você só ganha a opção de indexar um campo embarcado.
– Eliot Horowitz, CTO 10gen e Co-fundador
Fazendo uma busca em literatura disponível, podemos resumir **MongoDB** nas características abaixo:
* Open Source;
* Alta Performance;
* Schema (Esquema) Aberto – para fácil evolução do esquema;
* Banco de Dados Orientado a Documento;
* Preparador para trabalhar na nuvem;
**MongoDB** é um banco de dados de documento, e isto quer dizer que podemos armazenar dados como documentos.
E o que são documentos? São as unidades básicas de armazenamento e estes não utilizam necessariamente qualquer tipo de estruturação pré-definida, como é o caso das tabelas do Modelo Relacional. Ou seja, o **MongoDB** armazena coleções de documentos. Um documento, em geral, é um objeto com um identificador único acrescido de um conjunto de campos, que podem ser strings, listas ou documentos aninhados. Neste modelo temos um conjunto de documentos e em cada documento temos um conjunto de campos (chaves) e o valor deste campo. Outra característica importante é que este modelo não depende de um esquema rígido, ou seja, não exige uma estrutura fixa como ocorre nos bancos tradicionais, os relacionais. Assim, é possível que ocorra uma atualização na estrutura do documento, com a adição de novos campos, por exemplo, sem causar problemas na estrutura do banco de dados. Esta flexibilidade é uma das grandes vantagens deste modelo.
O **MongoDB** é um destes bancos que utiliza o modelo de armazenamento orientado a documento que armazena documentos no estilo parecido JSON chamado BSON, como documentos com esquemas dinâmicos, quer dizer que eu não preciso ter a mesma estrutura em casa registro. O objetivo do **MongoDB** é preencher a lacuna entre valores/chave lojas (que são rápidos e escalonáveis) e bancos de dados relacionais (que têm a funcionalidade rica). Atualizações in-place rápidas, ou seja, uma transação atômica. Quem trabalha muito com Banco de Dados Relacionais o **MongoDB** é uma boa quebra de paradigma já que ele não possui schema – o que quer dizer que não é necessário estipular a estrutura dos dados ao criar o banco, basta adicionar o documento(JSON) contendo os campos desejados, inclusive um documento pode conter outros documentos.
Como o formato BSON pode ser estendido, é possível acrescentar outras informações ao objeto aluno, de maneira que ele incorpore mais informações no objeto criado, como um array de dados por exemplo. Para um maior entendimento das características do **MongoDB**, que são expressadas como objetos JSON. O quadro seguinte mostra exemplos da sintaxe SQL e da sintaxe da Linguagem de Consulta do Mongo.
**Termos**
Os bancos de dados NoSQL foram especialmente projetados para atender as características de: maior disponibilidade, menor tempo de resposta para consultas, paralelismo de atualização de dados e maior grau de concorrência. O **MongoDB** inclui um módulo de sharding automático que permite a construção de um cluster de banco de dados escalável horizontalmente projetado para incorporar novas máquinas de forma dinâmica .
### Para instalar o MongoDB no Windows
Fazer o download
:point_right: https://www.mongodb.com/download-center/community
## Vamos à prática!
### Vamos aos scripts!
--mostra os banco de dados
```json=
show databases;
```
-- entrar no banco ou criar o banco
```json=
use exemplo;
```
-- mostrando as tabelas existentes
```json=
show collections;
```
--CRIANDO E ENTRANDO NO BANCO DBALUNO
```json=
use dbaluno;
```
## Annotations do springboot
As annotations do Spring Boot são uma parte essencial do framework Spring, permitindo que você configure e controle o comportamento da aplicação de forma declarativa. Elas são usadas para marcar classes, métodos, campos e parâmetros, informando ao Spring o que fazer com eles. Vamos explorar algumas das principais annotations e seu uso.
### **@SpringBootApplication**
Essa é a annotation principal que marca a classe principal da aplicação Spring Boot. Ela combina três outras annotations: `@Configuration`, `@EnableAutoConfiguration`, e `@ComponentScan`.
```java
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
```
- `@Configuration`: Indica que a classe pode ser usada pelo Spring IoC container como uma fonte de definições de beans.
- `@EnableAutoConfiguration`: Instrui o Spring Boot a configurar automaticamente os beans com base nas dependências presentes no classpath.
- `@ComponentScan`: Permite a varredura de componentes, ou seja, ele procura por beans anotados com `@Component`, `@Service`, `@Repository`, etc., dentro do pacote especificado.
### **@RestController**
Combina `@Controller` e `@ResponseBody`. É usada para criar controladores RESTful.
```java
@RestController
@RequestMapping("/api")
public class UserController {
@GetMapping("/users")
public List<User> getAllUsers() {
// Lógica para retornar todos os usuários
}
}
```
- `@Controller`: Marca a classe como um controlador Spring MVC.
- `@ResponseBody`: Indica que o valor de retorno dos métodos deve ser serializado diretamente na resposta HTTP.
### **@RequestMapping** e Sub-annotations
Usada para mapear solicitações HTTP para métodos específicos em classes controladoras.
```java
@GetMapping("/users")
public List<User> getAllUsers() {
// Lógica para retornar todos os usuários
}
```
- `@GetMapping`: Mapeia solicitações HTTP GET.
- `@PostMapping`: Mapeia solicitações HTTP POST.
- `@PutMapping`: Mapeia solicitações HTTP PUT.
- `@DeleteMapping`: Mapeia solicitações HTTP DELETE.
- `@PatchMapping`: Mapeia solicitações HTTP PATCH.
### **@Autowired**
Usada para realizar injeção de dependência automática. Pode ser aplicada em campos, setters e construtores.
```java
@Autowired
private UserService userService;
```
### **@Service**
Marca uma classe como um serviço, que geralmente contém a lógica de negócios.
```java
@Service
public class UserService {
// Lógica de negócios relacionada a usuários
}
```
### **@Repository**
Marca uma classe como um repositório, que é um mecanismo de encapsulamento do comportamento de armazenamento, recuperação e busca, tipicamente usado com JPA.
```java
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
// Métodos de consulta personalizados
}
```
### **@Entity**
Marca uma classe como uma entidade JPA, que representa uma tabela no banco de dados.
```java
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String email;
// Getters e setters
}
```
### **@Configuration**
Indica que a classe contém definições de beans Spring.
```java
@Configuration
public class AppConfig {
@Bean
public DataSource dataSource() {
// Configuração do DataSource
}
}
```
### **@Value**
Usada para injetar valores de propriedades do arquivo `application.properties` ou `application.yml`.
```java
@Value("${database.url}")
private String databaseUrl;
```
### **@Conditional**
Usada para registrar beans condicionalmente, dependendo de determinadas condições.
```java
@Bean
@Conditional(OnProductionCondition.class)
public MyService myService() {
return new MyService();
}
```
### **@Profile**
Especifica em quais perfis um bean deve ser registrado.
```java
@Profile("dev")
@Bean
public DataSource devDataSource() {
// Configuração do DataSource para desenvolvimento
}
```
### @ResponseBody
A anotação `@ResponseBody` é usada para indicar que o valor de retorno de um método deve ser gravado diretamente na resposta HTTP do cliente (em vez de ser interpretado como um nome de uma view). Ela é especialmente útil em controladores RESTful, onde os dados retornados são geralmente JSON ou XML.
Exemplo:
```java
@GetMapping("/hello")
@ResponseBody
public String sayHello() {
return "Hello, World!";
}
```
Nesse exemplo, o método `sayHello()` retorna uma string que será enviada diretamente na resposta HTTP, em vez de tentar resolver um template de view com o nome "Hello, World!".
### @RestController
A anotação `@RestController` é uma combinação de `@Controller` e `@ResponseBody`. Ela marca a classe como um controlador onde cada método retornará dados diretamente na resposta HTTP (como JSON ou XML), sem precisar usar `@ResponseBody` em cada método.
Exemplo:
```java
@RestController
@RequestMapping("/api/users")
public class UserController {
@GetMapping
public List<User> getAllUsers() {
return userService.findAll();
}
}
```
Nesse exemplo, a classe `UserController` é um controlador RESTful, e todos os métodos dentro dela retornarão dados diretamente na resposta HTTP, sem precisar adicionar `@ResponseBody` a cada método.
### @RequestMapping
A anotação `@RequestMapping` é usada para mapear solicitações HTTP para métodos específicos em classes controladoras. Ela pode ser usada em nível de classe e em nível de método. No nível de classe, define a base da URL para todos os métodos dentro da classe. No nível de método, define o caminho e o tipo de solicitação HTTP (GET, POST, etc.).
Exemplo em nível de classe:
```java
@RestController
@RequestMapping("/api/users")
public class UserController {
@GetMapping
public List<User> getAllUsers() {
return userService.findAll();
}
@GetMapping("/{id}")
public User getUserById(@PathVariable Long id) {
return userService.findById(id).orElseThrow(() -> new UserNotFoundException(id));
}
@PostMapping
public User createUser(@RequestBody User user) {
return userService.save(user);
}
}
```
Nesse exemplo:
- `@RequestMapping("/api/users")` em nível de classe define que todas as rotas dentro desta classe começarão com `/api/users`.
- `@GetMapping` mapeia solicitações HTTP GET para o método `getAllUsers()`.
- `@GetMapping("/{id}")` mapeia solicitações HTTP GET com um parâmetro de caminho (`id`) para o método `getUserById()`.
- `@PostMapping` mapeia solicitações HTTP POST para o método `createUser()`.
### Resumo
- **@ResponseBody**: Indica que o valor de retorno de um método deve ser gravado diretamente na resposta HTTP.
- **@RestController**: Combina `@Controller` e `@ResponseBody`. Marca a classe como um controlador RESTful, onde cada método retorna dados diretamente na resposta HTTP.
- **@RequestMapping**: Mapeia solicitações HTTP para métodos específicos em classes controladoras. Pode ser usado em nível de classe e de método para definir a URL e o tipo de solicitação HTTP.
Essas anotações facilitam a criação de APIs RESTful no Spring Boot, permitindo um desenvolvimento mais intuitivo e eficiente.
As annotations do Spring Boot são poderosas e simplificam significativamente a configuração e o desenvolvimento de aplicações Java. Elas permitem definir o comportamento e a configuração da aplicação de forma declarativa, promovendo uma abordagem mais limpa e gerenciável para o desenvolvimento de software.
## Application.properties
O arquivo `application.properties` é um arquivo de configuração usado no Spring Boot para definir propriedades específicas do aplicativo. Ele permite configurar vários aspectos do comportamento do aplicativo sem a necessidade de modificar o código-fonte.
### Principais Usos do `application.properties`
**Configuração do Servidor**:
Você pode configurar as propriedades do servidor, como a porta em que o aplicativo será executado.
```properties
server.port=8080
```
**Configuração do Banco de Dados**:
Propriedades para configurar a conexão com o banco de dados.
```properties
spring.datasource.url=jdbc:mysql://localhost:3306/meubanco
spring.datasource.username=meuusuario
spring.datasource.password=minhasenha
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
```
**Configuração de JPA/Hibernate**:
Configurações para o uso do JPA (Java Persistence API) e Hibernate.
```properties
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
```
**Configuração de Logs**:
Definir o nível de logging para diferentes pacotes ou classes.
```properties
logging.level.root=WARN
logging.level.org.springframework.web=DEBUG
logging.level.com.seuprojeto=TRACE
```
**Configurações de Internacionalização**:
Definir a localização padrão e o diretório de arquivos de mensagens.
```properties
spring.messages.basename=messages
spring.messages.encoding=UTF-8
spring.messages.fallback-to-system-locale=false
```
**Configuração de Segurança**:
Configurações relacionadas à segurança, como JWT, OAuth2, etc.
```properties
spring.security.user.name=usuario
spring.security.user.password=senha
```
**Configurações Personalizadas**:
Você também pode definir propriedades personalizadas que podem ser usadas no seu código.
```properties
custom.property=valor
```
### Exemplo de `application.properties` Completo
Aqui está um exemplo de um arquivo `application.properties` com várias configurações:
```properties
# Server Configuration
server.port=8080
# Database Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/meubanco
spring.datasource.username=meuusuario
spring.datasource.password=minhasenha
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# JPA/Hibernate Configuration
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
# Logging Configuration
logging.level.root=WARN
logging.level.org.springframework.web=DEBUG
logging.level.com.seuprojeto=TRACE
# Custom Properties
custom.property=valor
```
O `application.properties` é uma ferramenta poderosa para a configuração de aplicativos Spring Boot, permitindo que você ajuste o comportamento do aplicativo de maneira flexível e centralizada.
# Projeto Springboot
## Estrutura do projeto:
## Arquitetura do projeto:
```
D:.
│ .classpath
│ .gitignore
│ .project
│ mvnw
│ mvnw.cmd
│ pom.xml
│ README.md
│
├───.mvn
│ └───wrapper
│ maven-wrapper.properties
│
├───.settings
│ org.eclipse.core.resources.prefs
│ org.eclipse.jdt.apt.core.prefs
│ org.eclipse.jdt.core.prefs
│ org.eclipse.m2e.core.prefs
│ org.springframework.ide.eclipse.prefs
│
├───src
│ ├───main
│ │ ├───java
│ │ │ └───br
│ │ │ └───com
│ │ │ └───arq
│ │ │ │ Springb2Application.java
│ │ │ │
│ │ │ ├───controller
│ │ │ │ UsersController.java
│ │ │ │
│ │ │ ├───model
│ │ │ │ Users.java
│ │ │ │
│ │ │ └───repository
│ │ │ UsersRepository.java
│ │ │
│ │ └───resources
│ │ application.properties
│ │
│ └───test
│ └───java
│ └───br
│ └───com
│ └───arq
│ Springb2ApplicationTests.java
```
## Classes
**pom.xml**
```xml=
<?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
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.7</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>br.com.arq</groupId>
<artifactId>springb2</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springb2</name>
<description>Demo project for Spring Boot</description>
<url/>
<licenses>
<license/>
</licenses>
<developers>
<developer/>
</developers>
<scm>
<connection/>
<developerConnection/>
<tag/>
<url/>
</scm>
<properties>
<java.version>17</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</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-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>
```
**Users.java**
```javascript=
package br.com.arq.model;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
@Document(collection = "users")
public class Users {
@Id
private String id;
private String name;
private String email;
private String password;
private String status;
private String token;
public Users() {
}
public Users(String id, String name, String email, String password, String status, String token) {
super();
this.id = id;
this.name = name;
this.email = email;
this.password = password;
this.status = status;
this.token = token;
}
@Override
public String toString() {
return "Users [id=" + id + ", name=" + name + ", email="
+ email + ", password=" + password + ", status="
+ status + ", token=" + token + "]";
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getToken() {
return token;
}
public void setToken(String token) {
this.token = token;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
```
**UsersRepository.java**
```javascript=
package br.com.arq.repository;
import org.springframework.data.mongodb.repository.MongoRepository;
import br.com.arq.model.Users;
//Classe que irá fazer collecao, Tipo da Chave
public interface UsersRepository extends MongoRepository<Users, String>{
}
```
**UsersController.java**
```javascript=
package br.com.arq.controller;
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.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import br.com.arq.model.Users;
import br.com.arq.repository.UsersRepository;
@ResponseBody
@RestController
@RequestMapping("/api/users")
public class UsersController {
@Autowired
private UsersRepository usersRepository;
@PostMapping("/save")
public ResponseEntity<?> saveUser(@RequestBody Users users) {
try {
Users resultadoGravacao = usersRepository.save(users);
// salva o que vier
return ResponseEntity.status(200).body(resultadoGravacao);
// imprime em json
} catch (Exception ex) {
return ResponseEntity.status(500).body("error :"
+ ex.getMessage()); // imprime em String
// O error
}
}
// jamais crie um findAll em users ...desativa
@GetMapping
public ResponseEntity<?> findAll() {
return ResponseEntity.status(200).body(usersRepository.findAll());
}
}
```
**application.properties**
```=
spring.application.name=springb2
spring.data.mongodb.uri= mongodb://localhost:27017/bancomongo
server.port = 8989
```
**Springb2Application.java**
```javascript=
package br.com.arq;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
**@SpringBootApplication**
public class Springb2Application {
public static void main(String[] args) {
SpringApplication.run(Springb2Application.class, args);
}
}
```
## Para rodar o projeto
Clicar na classe Springb2Application com o botão direito -> Run as -> Java application
*Aguardar rodar*
*Projeto iniciado na porta 8989*
## No banco MongoDB:
```
# criar e entrar no banco
use bancomongo;
# mostrar as coleções
show collections
```
.
## Teste de Api no Postman
**Gravação:**
Selecionar POST -> Digitar a URL http://localhost:8989/api/users/save -> Clicar em BODY -> Clicar em RAW -> Selecionar JSON -> Digitar os dados para gravação -> Clicar em SEND
## No banco Mongodb
Conferindo
.
:::info
**EDSON BELEM TREINAMENTO** - edsonbelemtreinamento.com.br
:::
Sign in with Wallet
Connect another wallet