--> Nesse método iremos buscar alguma pessoa especifica através do seu id.

NO
exemplo anterior, criamos um WS buscando todas as pessoas.

Buscando pessoa por id:

package com.aulawb.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.aulawb.model.Pessoa;
import com.aulawb.repository.PessoaRepository;

@Controller
@RequestMapping(path="")
public class PessoaController {

@Autowired
private PessoaRepository pessoaRepository;

@RequestMapping(value="/pessoa/{id}", method = RequestMethod.GET) // agora

temos que passar na barra de navegação a informação do id da pessoa que queremos
buscar , para isso, no caminho da URI do recurso, temos que colocar entre chaves
essa informação. O método é um GET pois queremos buscar no banco.

public ResponseEntity<Pessoa> buscarPorId(@PathVariable("id") Integer id){ //

aqui estamos criando o método para buscar a pessoa pelo id. Agora, esse método não
retorna uma lista de pessoas e sim, uma pessoa com o id específico, portante, o
método retorna um objeto pessoa. Temos que passar como parametro desse método o id
que queremos buscar. Para botar o parametro,temos que dizer que ele é o mesmo da
URI do recurso, ou seja, dizemos que ele tem que ser o parametro do método. Para
isso, pegamos a variável do caminho e vamos vincular com o tipo do atributo id.

Pessoa pes = pessoaRepository.findOne(id);// a primeira coisa que temos

que fazer é buscar no banco para ver se existe alguma pessoa com o id informado.
Para buscar pelo id, usamos um método que já vem implementado na interface
Repository, o findOne. Esse método executa o SELECT p FROM Pessoa p WHERE p.id = id
no nosso banco de dados.

if(pes == null){ // se essa pessoa for nula, sigfica que não tem
ninguém com o id informado cadastrado no banco.
return new ResponseEntity(HttpStatus.NOT_FOUND); // se essa
pessoa for nula, retornamos o Status NOT FOUND do HTTP, ou seja, dizendo que essa
pessoa não foi encontrada.

}
return new ResponseEntity<Pessoa>(pes, HttpStatus.OK); // caso essa
pessoa buscada exista no banco, retornamos ela junto de uma mensagem HTTP de
sucesso.
 }

--->Agora vamos cadastrar alguém no banco de dados

cadastrando pessoa no banco:

package com.aulawb.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.aulawb.model.Pessoa;
import com.aulawb.repository.PessoaRepository;

@Controller
@RequestMapping(path="")
public class PessoaController {

@Autowired
private PessoaRepository pessoaRepository;

@RequestMapping(value = "/pessoa/", method=RequestMethod.POST) // como agora

iremos criar um cadastro, temos que usar o método POST.

public ResponseEntity<?> cadastrarPessoa(@RequestBody Pessoa pes){ // agora o

nosso método não tem retorno, logo, colocamos uma "?"(basicamente quer dizer que o
retorno é qualquer coisa). Para cadastrar temos que colocar como parametro um
objeto da classe pessoa. Supondo que esses dados vão estar no body do
HttpRequest(no body na nossa solicitação, vai ter um JSON com os atributos dessa
pessoa). Então,temos que dizer que essa pessoa vem do BODY da solicitação, logo,
temso que usar a anotação @RequestBody, com isso, dizemos que o que vier do corpo
da solicitação, o JSON transforma em uma pessoa e salva.

Pessoa temp = pessoaRepository.save(pes); // estamos colocando dentro

do save o objeto pessoa que salvamos + a chave primária, ou seja, dentro do temp
agora temos isso, para que se quisermos fazer algo no nosso objeto com a chave
primária, já podemos fazer.

return new ResponseEntity(HttpStatus.OK); // retornando o status de

sucesso no cadastro.
}

--> Agora vamos deletar uma pessoa do banco de dados

deletando uma pessoa:

package com.aulawb.controller;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.aulawb.model.Pessoa;
import com.aulawb.repository.PessoaRepository;

@Controller
@RequestMapping(path="")
public class PessoaController {

@Autowired
private PessoaRepository pessoaRepository;

@RequestMapping(value = "/pessoa/{id}", method = RequestMethod.DELETE) //

agora vamos usar o método DELETE para deletar a pessoa. Colocamos no caminho entre
chaves o id da pessoa.

public ResponseEntity<?> excluirPessoa(@PathVariable("id") Integer id){ // o

delete não vai retornar ningué, logo, colocamos o "?" de novo. Porém, a pessoa que
queremos apagar, ele vem por parametro com o id da pessoa que queremos apagar.
Vinculamos a variavel do caminho com o tipo de dado do atributo id da pessoa.

Pessoa pes = pessoaRepository.findOne(id); // primeiro de tudo temos

que encontrar(buscar) a pessoa com o id informado. Logo, vamos excluir a pessoa por
id.

if(pes == null){ // se a pessoa for nula, ela não existe.

return new ResponseEntity(HttpStatus.NOT_FOUND); // retornando
status NOT FOUND(não encontrada a pessoa).
}
pessoaRepository.delete(id); // se a pessoa existir, usamos o método
delete passando como parametro o id da pessoa que queremos apagar.

return new ResponseEntity(HttpStatus.OK); // retornando o status de

sucesso.

-----------------------------------------------------------------------------------
-------------------------------------------------------------

** IMPORTANTE **

=> Agora vamos aprender a resolver um erro muito comum no web service. Se em algum
momento nós não pararmos um servidor antes de inicializar outro, o web service
acaba tentando abrir os dois paralelamente e aí dá um erro: porta já está em uso.
Quando isso acontece, ele não deixa a gente fechar o que está em uso. Quando isso
acontecer, temos que ir no terminal e fazer o seguinte:

1. Digitar no terminal a linha: ps ax

-> isso vai listar todos processos que estão rodando na máquina.
2. Um desses processos vai ser o /usr/java/bin... esse aqui é o servidor rodando.
3. Após encontrar o servidor, temos que procurar pelo id dele.
4. O próximo passo é matar o processo, para isso, fazemos o seguinte: kill -9
4480(o id do processo)

=> Isso vai finalizar o processo, assim permitindo que possamos executar novamente
o web service.

-----------------------------------------------------------------------------------
-------------------------------------------------------------

--> Agora vamos fazer um update com o web service.

atualizando pessoa:

package com.aulawb.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.aulawb.model.Pessoa;
import com.aulawb.repository.PessoaRepository;

@Controller
@RequestMapping(path="")
public class PessoaController {

@Autowired
private PessoaRepository pessoaRepository;

@RequestMapping(value = "/pessoa/{id}", method = RequestMethod.PUT) // agora

vamos usar o método PUT para atualizar.No caminho da URI temos que dizer o id da
pessoa que queremos atualizar.

public ResponseEntity<Pessoa> atualizarPessoa(@PathVariable("id") Integer id,

@RequestBody Pessoa pes){ // a pessoa atualizada vai vir como retorno do método.
Nosso método vai receber a variavel do caminho vinculada ao tipo de dado do
atributo id, porém , agora, tem que vir como parametro também as novas informações
que queremos atualizar(pessoa).

Pessoa dadosAtuais = pessoaRepository.findOne(id); // primeiro temos

que procurar a pessoa que queremos atualizar pelo seu id, ou seja, estamos buscando
os dados atuais dessa pessoa.

if(pes == null){ // se essa pessoa com esse id não existe, retornamos o

status NOT FOUND.
return new ResponseEntity(HttpStatus.NOT_FOUND);
}
dadosAtuais.setNome(pes.getNome()); // se a pessoa existir, podemos
atualizar ela. Então, setamos o nome que é o atributo da pessoa passando como
parametro o nome. Aqui estamos atualizando os dados atuais da pessoa.
 pessoaRepository.save(dadosAtuais); // salvando os dados atuais da
pessoa.

return new ResponseEntity(HttpStatus.OK); // retornando status de

sucesso
}