Documentação Spring Boot

Spring Framework
O Spring Framework é o projeto base do Spring, na qual ele é dividido em 8
grupos sendo eles:

Data Access / Integration - Transações com banco de dados

Web - Construção de Aplicações Web
AOP - Programação Orientada a aspectos
Instrumentation
Messaging - Orientação a Mensagens
Test - testes unitários e testes integrados

E por final o core container o mais importante de todos.

Spring Framework - Core Container

O Core Container é considerado o mais importante pois é dentro dele que é
implementado a Inversão de Controle (IoC).

Inversão de Controle é um padrão de projeto, em que o objeto apenas declara suas

dependências sem criá-las e delega a tarefa de construir tais dependências a um
Container Ioc (Core Container)
Para fazer o Spring Framework utiliza a injeção de dependência, que é a implementação
da inversão de controle onde ela possui.

Essas dependências são chamadas de Beans, que são objetos instanciados, montados e
gerenciados por um container do Spring através da Inversão de Controle (IoC) e Injeção
de Dependências.

Spring Boot

Criando Models utilizando Spring Boot + postgres

Dentro do pacote principal do nosso projeto iremos criar um pacote com o nome
models.Dentro desse pacote é onde ficará as classes das nossas tabelas que serão
criadas no banco de dados.

Para criarmos uma tabela utilizando JPA seguimos a seguinte sintaxe.

@Entity
@Table(name = "nome da tabela")
public class nomeDaModel implements Serializable{
public static final long serialVersionUID = 1l;
}

Legenda:
● @Entity - Serve para dizer que a classe é uma entidade. Uma entidade
representa uma tabela no banco de dados e cada instância dessa entidade
representa um linha dessa tabela.
● @Table - Diz que a classe abaixo é uma tabela.
● serialVersionUID - Controle das conversões feitas pela JVM.

Para definirmos o ID dessa tabela usamos @Id e para gerar os valores

automaticamente desse Id utilizamos em embaixo do @Id :
@GeneratedValue(strategy = GenerationType.AUTO)
Para criarmos as colunas da tabela utilizamos @Column().Dentro dos
parênteses de @Column() podemos passar alguns parâmetros como:
● nullable - Definir se a coluna pode ser iniciada com um valor nulo ou não.
Recebe true ou false com valores.
● length = Define a quantidade de caracteres que a coluna pode armazenar,
recebe números inteiros como valor.
● unique - Define que não pode existir dois valores iguais dentro dessa
coluna, os valores têm que serem únicos. Recebe como valor true ou false.

Existem outros parâmetros que podem serem usados no @Column(), para vez
mais acesse :

https://docs.jboss.org/hibernate/jpa/2.1/api/javax/persistence/Column.html

Após o @Column iremos criar um atributo embaixo dele, na qual definirá o tipo
de dado e o nome da coluna.

EX :
@Column(paremetros de configuração da coluna)
private TipoDeDado nomeDaColuna;

Após criarmos as colunas da nossa classe, devemos criar os métodos de getter e

setter. Para isso clicamos com o botão direito do mouse dentro da nossa classe
model, clicamos em generate e depois em getter e setter, após isso selecionamos
todos os atributos que criamos e damos ok.
Criação da Interface utilizando Spring Boot + postgres

Dentro do pacote principal da nossa aplicação, criamos um pacote chamado

repositories, dentro desse pacote criamos um interface.
Dentro do arquivo interface que criamos seguimos a seguinte sintaxe:

@Repository
public interface nomeDaInterface extends JpaRepository
<nomeDaModel, UUID>{
}

Nós utilizaremos esta interface para usar métodos do JpaRepository que servem
para transações com o banco de dados como buscar um recurso no banco de
dados, atualizar um recurso, deletar um recurso, etc.

Após isso, dentro do pacote principal da nossa aplicação criamos um pacote

chamado service. Dentro desse pacote criamos um arquivo Java Class, dentro
desse arquivo seguimos a seguinte sintaxe:
@Service
public class ParkingSpotService {
}

OBS: O arquivo de serviço da nossa aplicação geralmente é onde ficam as regras

de negócio da nossa aplicação. Regras de negócio é a maneira como a coisa vai
funcionar em nossa aplicação, como o sistema deve tratar cada evento.

Neste exemplo que iremos fazer agora iremos utilizar a classe de serviço como
uma camada intermediária entre o controller e o repository, na qual ela terá que
acionar o repository em determinados casos como, quando for salvar um no
registro, quando for deletar, atualizar etc. Dessa maneira ao invés do controller
requisitar diretamente o repository ele ira requisitar o service que acionar o
repository.

Para fazer essa injeção de dependências entre o service e o repository seguimos

a seguinte sintaxe:

@Service
public class ClasseService{
@Autowired
nomeDaInterfaceDoRepository nomeDaInstacia;
}
A anotação @Autowired serve para dizer ao Spring que naquele ponto deve ser
feita a injeção das dependências de repository em service.

Outra maneira que podemos utilizar para fazer isso é através de um constructor,
como mostra o código abaixo:

@Service
public class ClasseService{
final nomeDaInterfaceDoRepository nomeDaInstacia;

public ClasseService(nomeDaInterfaceDoRepository
nomeDaInstacia){
this.nomeDaInstacia = nomeDaInstacia;
}

OBS: Construtores são basicamente funções de inicialização de uma classe, as

quais são invocadas no momento em que objetos desta classe são criados. Eles
permitem inicializar campos internos da classe e alocar recursos que um objeto
da classe possa demandar, tais como memória, arquivos, semáforos, soquetes,
etc.

Criando o Controller
Dentro do pacote principal da nossa aplicação iremos criar um pacote com o
nome controller, dentro desse pacote criamos uma JavaClass. Dentro dessa java
class seguimos a seguinte sintaxe..

@RestController
@CrossOrigin(origins = "*", maxAge = 3600)
@RequestMapping("/NomeDaRota")
public class ClassController{

}
Legenda:

● @RestController - Essa anotação nos permite criar um controlador

com características REST e que pode manipular as requisições feitas pelos
nossos clientes. OBS : A utilização da arquitetura REST, portanto, permite a
comunicação entre aplicações. Ao abrir o navegador, ele estabelece uma
conexão TCP/IP com o servidor de destino e envia uma requisição GET
HTTP, com o endereço buscado. O servidor, então, interpreta a requisição,
retornando com uma resposta HTTP ao navegador. Essa resposta pode ser
completa, com representações em formato HTML, ou apresentar erro,
afirmando que o recurso solicitado não foi encontrado.

● @CrossOrigin - OBS: Cross Origin também conhecido como CORS

(Compartilhamento de recursos com origens diferentes) é um mecanismo
que usa http header adicionais para informar a um navegador que permita
que uma aplicação web rodando em um servidor x possa acessar recursos
de uma aplicação rodando em um servidor y. Um aplicativo web executa um
requisição Cross origin HTTP que solicita um recurso que esteja presente
em um domínio distinto da sua própria origem. O cross origin em spring
pode receber dois parâmetros: origins = domínios que podem acessar e
maxAge = 3600.
● @RequestMapping()- Essa anotação tem a função de definir que os
recursos de um determinada classe controller serão acessados a partir de
um determinada rota.

Depois temos que injetar as dependências da classe service em nosso controller

utilizando um construtor como vimos anteriormente:

@RestController
@CrossOrigin(origins = "*", maxAge = 3600)
@RequestMapping("/nomeRota")
public class ClasseController{

final ClasseService nomeDaIntancia;

public ClasseController(ClasseService nomeInstacia){

this.nomeInstacia = nomeInstacia;
}

}
Criando o dto

O dto ou Data Transfer Object é um padrão de projeto utilizado para o

transporte de dados entre diferentes componentes de um sistema.

No caso que iremos ver agora faremos um validação dos dados antes de eles
serem enviados para o banco de dados.

Primeiramente criaremos um pacote dentro do pacote principal da nossa

aplicação chamado dto. Após isso criaremos uma Java Class e dentro da classe
passaremos os atributos que serão enviados ao banco de dados, porém em cima
de cada atributo usaremos algumas anotações que irão fazer uma verificação no
atributo e ver se ele está válido.
Ex:
public class ClasseDto {

@NotBlank
private String atributoDB;

Existem várias anotações que podem ser utilizadas para validar o atributo como
exemplo:
● @NotBlank - O elemento anotado não deve ser nulo e deve conter pelo
menos um caractere que não seja espaço em branco.
● @NotEmpty - O elemento anotado não deve ser nulo nem vazio
● @Size - O tamanho do elemento anotado deve estar entre os limites
especificados (incluídos).
● @Email - A string deve ser um endereço de e-mail bem formado.

Existem vários tipos, para vez mais acesse:

https://javaee.github.io/javaee-spec/javadocs/javax/validation/constraints/packa
ge-summary.html

Após anotar os atributos devemos criar os métodos getter e setter igualmente

como mostramos mais acima.
Criando método Post

Para criarmos um método Post iremos ir no arquivo controller de nossa

aplicação. No arquivo de controller seguiremos a seguinte sintaxe:

@RestController
@CrossOrigin(origins = "*", maxAge = 3600)
@RequestMapping("/rota")
public class ClassController{

final ClassService classSevice;

public ClassContoller(ClassService classService){

this.classService = classService;
}

@PostMapping
public ResponseEntity<Object> nomeDoMetodo(@RequestBody
@Valid ClassDto classDto){
var nomeInstaciaModel = new ClassModel();
BeanUtils.copyProperties(classDto, instaciaModel);

}
}