---> o arquivo pom.

xml no projeto do springboot é o arquivo responsável para que o

Maven(gerenciador de dependências) baixe todas as coisas(libs) que nós colocamos
nos requisitos do projeto quando criamos ele. Todos essas libs ele colocou dentro
do pom.xml. Esse cara tem uma série de coisas(description,nome do projeto, tipo de
pacote, versão do java,SQLconector, Tomcat).

**TOMCAT: quando queremos hospedar uma aplicação web em java, precisamos de um

servidor web. No PHP usamos o Apache, aqui nós usamos o Tomcat que é responsável
por hospedar páginas na web em java. Para fazer isso, precisamos baixar o TOmcat e
configurar ele para que possamos ter disponível nossas páginas do java hospedadas
na web. O tomcat usa a porta 8080(apache usa a 80). A configuração do tomcat dá um
certo trabalho pois são uma série de passos e detalhes a serem seguidos. O
springboot já vem com uma coisa chamada Microserviços.

**MICROSERVIÇOS: é uma espécie de máquina virtual que já vem com uma série de
coisas dentro. Uma dessas coisas é o tomcat configurado. Dessa maneira, toda vez
que executarmos a aplicação, ele levanta um servidor tomcat(não precisa ter o
tomcat instalado na máquina) e já lança o nosso arquivo na pasta certa e já sai
tudo funcionando.
-->Se quisermos pegar o web service de uma máquina e levar para outra e executar, é
só colocar java-c e o nome do pacote e o springboot já levanta o tomcat e sai tudo
funcionando.

**UTILIDADE DE INSTALAR O SERVIDOR WEB **

->Configuração: geralmente é usado para testes, agora, para produção, precisamos
ter certos cuidados na hora de configurar o servidor(como HTTPS,usuários adm do
servidor), por isso, fazemos na mão essa configuração.

--> o Persistence.xml que tinhamos no JPA não existe mais no springboot.No

springboot,dentro de java resources, temos uma pasta resources que tem um arquivo
chamado Application.properties.

**APPLICATION.PROPERTIES: é o arquivo onde vamos configurar o persistence.xml, onde

colocamos a URL do banco de dados, qual o usuário e senha do banco de dados, o
dialeto que vamos usar e qual é o driver que vamos usar para a comunicação com o
banco de dados.

---> As classes ficam na pasta(arquivo) Java e aqui dentro temos que colocar nossas
packages. Criar packages é uma forma de otimizar a arquitetura do projeto para não
misturar as resposabilidades de cada coisa. Os pacotes que criamos são: model,
repository e controller.
=>MODEL: onde colocamos todos os POJOS do banco de dados.
=>REPOSITORY: O padrão de projetos DAO está presente nesse conceito de web services
também. Aqui colocamos todos os comando JPQL para acessar o banco de dados.
Normalmente criamos uma pasta DAO, mas, no Springboot usamos uma coisa mais
simples(com muitas coisas prontas), uma pasta chamada Repository.
--->O springboot tem uma classe repository com várias coisas implementadas, como o
CRUD. Geralmente no DAO temos que fazer essas ações todas a mão, mas no springboot
não, pois ele usa SpringData.
**SPRINGDATA: uma biblioteca do spring responsável por fazer mapeamento de objeto
relacional(acesso e ligação com banco).Os comandos que tinhamos no JPQL para buscar
as coisas não precisamos mais fazer, a não ser que seja uma busca fora do padrão,
como buscar um usuário pelo nome. Consultas como buscar por id, buscar todos,
listar todos, apagar todos e etc, já vem inclusos no springboot.
=>CONTROLLER: Existe o modelo MVC(model,view e controller) onde temos a model que é
o banco de dados, a view que é a tela e controller que liga os dois. NO springboot
não temos a view(tela), ou seja, só temos o controller e a model.
**WEB SERVICE: Nada mais é que uma classe java que vai receber um conjunto de
informações do cliente, vai processar tendo que buscar do banco, inserindo algo no
banco ou outra coisa e devolvendo uma resposta. A função do web service nada mais é
que um controlador dentro desse modelo.

$$ESTRUTURA DE DIRETÓRIOS $$
Temos dois arquivos que são os principais(main do java) e junto com eles a mesma
estrutura de pastas. Dentro de java resources encontramos a pasta src/main/java que
possui o pacote do nosso projeto. Dentro deles temos duas classes: Application.java
e ServletInitializer.java

**APPLICATION.JAVA : essa classe é o nosso main e é o responsável por levantar os

web services. Nesse classe iremos mexer apenas quando quisermos configurar a mão o
servidor, aí teremos que criar um método para que o springboot não levante o
servidor tomcat com as configurações padrões. Caso contrário, não iremos mexer
nessa classe.

**SERVLETINITIALIZER.JAVA : essa classe busca os códigos fontes que iremos e criar

e vincula isso ao application.java

Criando pessoa dentro da model:

package com.aula4k.model;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Pessoa implements Serializable{

/**
*
*/
private static final long serialVersionUID = 1L; // quando serializamos nós
pegamos essa classe e transformamos ela em uma sequência de bytes para poder mandar
o arquivo nessa sequência para depois ser serializado, ou seja, pegar o arquivo de
bytes e transformar na classe de novo. Cada arquivo que mandamos tem que ter um id,
por esse motivo ele tem que ter esse serialversion, para que ele tenha um id
diferente para saber a versão dessa serialização.

@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private String nome;
public Integer getId() {
return id;
}
public void setId(Integer id) {
id = id;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
 this.nome = nome;
}
public Pessoa() {
super();
}

criando pessoarepository:

package com.aula4k.repository;

import org.springframework.data.jpa.repository.JpaRepository;

import com.aula4k.model.Pessoa;

public interface PessoaRepository extends JpaRepository<Pessoa, Integer> { // Essa

classe repository vai ser uma interface, pois não tem implementação de códigos, só
tem métodos e é filho da classe JpaRepository, que por sua vez, também é uma
interface. Essa interface JpaRepository possui os métodos do CRUD implementados
nela e ele recebe dois parametros: primeiro temos que passar qual a classe que esse
repository vai usar como POJO(model) e o tipo de dado da chave primária dessa
classe.

** Caso queiramos criar algum método de busca mais elaborado, é aqui que iremos
criar o nome do método, pois a maioria das coisas já é implementada, então, pelo
nome ele já sabe o que tem que fazer. Ex: findbynome ele sabe que tem que fazer um
select nome from pessoa where nome="alguma coisa".

criando pessoacontroller:

package com.aula4k.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import com.aula4k.repository.PessoaRepository;

@Controller // a primeira coisa que temos para fazer é dizer para o string que essa
classe é um controlador, para fazer isso, usamos a anotação @Controller.
@RequestMapping(path="") // como falamos antes, nós temos o protocolo, o endereço
host do servidor e o caminho das pastas que vão passeando para acessar o web
service. Aqui temos que dizer para o web service qual o caminho dele, para isso,
usamos essa anotação. Nós queremos botar ele para quando colocarmos o endereço, ele
já entrar dentro do endereço. Nos próximos passos colocaremos qual web service ele
deve acessar.
public class PessoaController {

@Autowired // para dizer que teremos uma injeção de dependência no

PessoaRepository, usamos essa anotação. Aqui estamos dizendo que ele está ligado
por fio, ou seja, vai ser injetado nele um objeto PessoaRepository.
private PessoaRepository pessoaRepository; // temos que criar um objeto
repository para fazermos as consultas no banco de dados.
** Para criar esse objeto, nós precisamos instanciá-lo. Aqui nós só criamos o
atributo. Agora, temos mais um grande detalhe em que o springboot revolucionou.
Aqui temos um padrão de projetos chamado injeção de dependência.

**INJEÇÃO DE DEPENDÊNCIA: se temos um atributo em que temos que criar um objeto

dele, nós vamos copular ele para fazer uma série de coisas(é o padrão que usamos).
Porém, temos um detalhe, vamos supor que mudou alguma coisa no PessoaRepository,
como por exemplo: foi adcionado mais um atributo e nós tinhamos um construtor com
todos os atributos. Pensando hipoteticamente, se tinhamos dois atributos e um
construtor com esses dois atributos, a partir do momento que temos mais um
atributo, esse construtor tem três atributos. Pensando nisso, o que acontece com o
código? Vai dar erro. A injeção de dependência inverte esse processo.EX: queremos
criar um objeto da classe passarinho. Ele vai na classe passarinho, vai no
construtor dela, cria o atributo e faz tudo para a gente e nos devolve o objeto.
Dessa maneira, ele cria o objeto pra gente, qualquer mudança, ele faz para a gente
automaticamente.

---> Auto acoplamento é quando temos dependência entre duas coisas, a minha depende
da outra existir. Baixo acomplamento é quando a minha não depende da outra. A
injeção de dependência faz justamente isso, quebra o acoplamento.

public bucarTodasPessoas;