---> Nesse exemplo vamos fazer um web service de busca pelo cpf da pessoa.

Para
isso, temos que atualizar nossa model colocando o atributo cpf.

model pessoa:

package com.aulawb.model;

import java.io.Serializable;

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

@Entity
@Table(name="Pessoa")
public class Pessoa implements Serializable {

/**
*
*/
private static final long serialVersionUID = 1L;

@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private String nome;
private String cpf; // criando o atributo cpf
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}

public String getCpf() {

return cpf;
}
public void setCpf(String cpf) {
this.cpf = cpf;
}
public Pessoa() {
super();
}

}
---> Depois de criar o atributo cpf na model, vamos no pessoaRepository e vamos
criar a assinatura do método para buscar pelo cpf.

pessoa repository:

package com.aulawb.repository;

import javax.persistence.NamedQuery;

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

import com.aulawb.model.Pessoa;

public interface PessoaRepository extends JpaRepository<Pessoa, Integer> {

public Pessoa findByCpfLike(String cpf); // Criando a assinatura do método

busca pelo cpf. Não precisamos criar código para buscar pelo cpf porque assim que o
spring detecta que colocamos um find dentro do repository, ele já sabe que tem que
executar um SELECT. Ao identificar o By ele já sabe que tem que buscar pelo
atributo. Então, passamos como atributo o cpf e ele já sabe automaticamente que ele
tem que buscar pelo atributo cpf. Como o cpf é um string, temos que colocar o Like
para o spring saber que tem que colocar o like quando for executar o SELECT.

---> Feito isso, vamos criar o web service para buscar pelo cpf na classe
pessoacontroller.

pessoa controller:

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 org.springframework.web.bind.annotation.RequestParam;

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.GET) // criando o

método GET para buscar essa pessoa. Porém, aqui temos um detalhe: nós já temos um
método GET onde passamos a informação na barra de endereço e ele busca a pessoa
correspondente nesse caminho /pessoa/. ENtão, precisamos mudar para que ao invés de
ele buscar diretamente na barra de endereços, nós tenhamos que passar pela
estrutura par chave valor na barra de endereço. Outro detalhe é que o caminho não
tem barra depois do pessoa, vai ser só /pessoa porque no lugar da outra barra vai
ser o par chave e valor(? e &).

public ResponseEntity<Pessoa> buscarPorCpf(@RequestParam(value="cpf") String

cpf){ // criando o método buscarporcpf. Para não confundir com o busca por id,
vamos colocar a anotação @RequestParam. Dessa maneira, o caminho para acessar esse
web service vai ser /pessoa?cpf(o nome da variável) = (aqui passamos o cpf). Com
essa anotação ele pega o parametro cpf na barra de endereço e salva esse conteúdo
na variavel cpf.

** DIFERENÇA DO @REQUESTPARAM E @PATHVARIABLE **

No pathvariable ele entende que o conteúdo da barra de endereço é o conteúdo da
variável, ou seja, é um variável de caminho onde ele considera que o caminho já é a
própria variável. No requestparam nós temos o parametro da requisição, ou seja, ele
entende que tem um parametro da variavel que tem o conteúdo que temos que salvar
dentro da variavel.

Pessoa pes = pessoaRepository.findByCpfLike(cpf); // lembrando que no

busca por id nós tinhamos o método findone. Como nós criamos um método específico
para buscar por cpf dentro do pessoaRepository, já podemos chamá-lo aqui passando o
cpf como parametro.

if(pes == null){ // se a pessoa com esse cpf não existir, retornamos

uma mensagem not found.
return new ResponseEntity(HttpStatus.NOT_FOUND);
}
return new ResponseEntity<Pessoa>(pes, HttpStatus.OK); // se ele
existir, retorna a pessoa com o cpf fornecido e a mensagem de status OK.
}

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

## IMPORTANTE ##
1 - Pensando em uma situação onde temos que pegar mais de um campo, por exemplo,
buscar por nome e data de nascimento(SELECT * from pessoa where nome like mario and
datanascimento like 09/09/1998). Partindo do ponto que duas pessoas tem o mesmo
nome, devemos diferenciar pela data de nascimento. Pensando nisso, podemos fazer
dois RequestParam colocando em um o nome e no outro a data de nascimento. Criamos
lá no repository um método findByNomeLikeAndDataNascimento. Dessa forma, ele monta
para a gente. Ou seja, podemos fazer uma busca com mais de um parametro.

2 - Digamos que queremos fazer uma busca mais incrementada do que uma busca por
atributos. Para isso, temos que usar JPQL através da anotação @NamedQuery. Por
exemplo:

No pessoa repository:

@NamedQuery(name="buscarMedia", query = "SELECT AVG(p.salario) FROM Pessoa p WHERE

p.cpf LIKE:cpf)
public Double buscarMedia(int salario);

Ou seja, se tivermos que criar um método que fuja do que o findBy ou os métodos já
existentes no repository possam resolver, podemos criar usando JPQL.

-----------------------------------------------------------------------------------
--------------------------------------------------------------
---> AGora vamos criar um método para deletar tudo.

pessoa controller:

pessoa controller:

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 org.springframework.web.bind.annotation.RequestParam;

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.DELETE) // usando

método delete.
public ResponseEntity<?> deletarTudo(){
pessoaRepository.deleteAll(); // usando o método da classe repository
que apaga tudo.
return new ResponseEntity(HttpStatus.OK); // retornando mensagem OK
caso tenha apagado tudo.
}

** Também podemos mandar uma mensagem personalizada para o usuário além do

HTTPStatus indicando o que está acontecendo. Para isso, fazemos o seguinte>

Pessoa pes = pessoaRepository.findByCpfLike(cpf);

if(pes == null){
return new ResponseEntity("Nenhuma pessoa com esse CPF foi
encontrada", HttpStatus.NOT_FOUND); // caso não exista nenhuma pessoa com o cpf
informado, podemos retornar uma mensagem personalizada no BODY da resposta.
}