Backend

CRUD

Objetivo geral:

Implementar operações de CRUD e de casos de uso conforme boas práticas de Engenharia de Software. Competências:

• Implementar requisições POST, GET, PUT e DELETE para inserir, obter, atualizar e deletar entidades, respectivamente, seguindo boas práticas REST e de desenvolvimento em camadas.
• Trabalhar com DTO (Data Transfer Object)
• Trabalhar com paginação de dados
• Trabalhar com validação de dados com Bean Validation (javax.validation)
• Criar validações customizadas
• Fazer tratamento adequado de exceções (incluindo integridade referencial e validação)
• Efetuar consultas personalizadas ao banco de dados Nota: ressaltamos novamente que CRUD's também são casos de uso, mas estamos chamando de casos de uso os usos do sistema correspondentes a processos de negócio que não se enquadram em CRUD's comuns

Anotações de estudo

• Trabalhar com DTO (Data Transfer Object),Ele vai ser o objeto para definir os dados que você quer trafegar quando for fazer operações básicas

Apresentando o caso de uso

Criando o método POST

(Resource)

@RequestMapping(method = RequestMethod.POST)
	public ResponseEntity<Void> insert(@RequestBody Categoria obj) {
		obj = service.insert(obj);
    // chamada que pega a URI do novo recurso que foi inserido
    URI uri = ServletUriComponentsBuilder.fromCurrentRequest().path("/{id}").buildAndExpand(obj.getId()).toUri();

		return ResponseEntity.created(uri).build();
	}

(Service)

public Categoria insert(Categoria obj) {
		obj.setId(null);
		return repo.save(obj);
	}

Testando no Postmam (categorias/{id} POST )

Criando o método PUT

(Resource)

@RequestMapping(value = "/{id}", method = RequestMethod.PUT)
	public ResponseEntity<Void> update(@RequestBody Categoria obj, @PathVariable Integer id){
		obj.setId(id);
		obj = service.update(obj);
		return ResponseEntity.noContent().build();
	}

(Service)

public Categoria update(Categoria obj) {
		find(obj.getId());
		return repo.save(obj);
	}

Criando o método DELETE

(Resource)

@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
	public ResponseEntity<Void> delete(@PathVariable Integer id) {
		service.delete(id);

		return ResponseEntity.noContent().build();
	}

Tratamento de Erro e mensagem personalizada

public class DataIntegrityException  extends RuntimeException{


	private static final long serialVersionUID = 1L;

	public DataIntegrityException(String msg) {
		super(msg);
	}

	public DataIntegrityException(String msg, Throwable cause) {
		super(msg, cause);
	}

}

@ExceptionHandler(DataIntegrityException.class)
	public ResponseEntity<StandardError> dataIntegrity(DataIntegrityException e, HttpServletRequest request){

		StandardError err = new StandardError(HttpStatus.BAD_REQUEST.value(), e.getMessage(), System.currentTimeMillis());
		return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(err);
	}

(Service)

public void delete(Integer id) {
		find(id);
		try {
			repo.deleteById(id);
		}
		 catch (DataIntegrityViolationException e) {
			throw new DataIntegrityException("Não é possível excluir uma categoria que possui produto");
		}
	}

Testando no Postmam (categorias/{id} DELETE )

Criando a CategoriaDTO

Ele vai ser o objeto para definir os dados que você quer trafegar quando for fazer operações básicas de Categoria. Obs:Nela também acompanha Getters e Setters, mas não foi colocado na parte da documentação para não atrapalhar a visualização.

(DTO)

public class CategoriaDTO implements Serializable {
	private static final long serialVersionUID = 1L;

	private Integer id;
	private String nome;

	public CategoriaDTO() {
	}

  public CategoriaDTO(Categoria obj) {
		id = obj.getId();
		nome = obj.getNome();
	}
}  

método GET que lista todas as categorias

(Resource)

@RequestMapping( method = RequestMethod.GET)
	public ResponseEntity<List<CategoriaDTO>> findAll() {
	// busca as listas de categoria do Banco
	List<Categoria> list = service.findAll();
	// vai ter que percorrer a list e para cada elemento da lista vai instanciar o DTO correspondente(converter para DTO)
	List<CategoriaDTO>	listDto = list.stream().map(obj -> new CategoriaDTO(obj)).collect(Collectors.toList());
	return ResponseEntity.ok().body(listDto);
	}

Testando no Postman categorias/

paginação com parâmetros opcionais na requisição

(Resouce)

@RequestMapping(value="/pages", method = RequestMethod.GET)
	public ResponseEntity<Page<CategoriaDTO>> findPage(
			@RequestParam(value ="page", defaultValue="0")Integer page,
			@RequestParam(value ="linesPerPage", defaultValue="24")Integer linesPerPage,
			@RequestParam(value ="orderBy", defaultValue="nome")String orderBy,
			@RequestParam(value ="direction", defaultValue="ASC")String direction) {
	// busca as páginas de categoria do Banco
	Page<Categoria> list = service.findPage(page, linesPerPage, orderBy, direction);
	// vai ter que percorrer as páginas e para cada elemento da vai instanciar o DTO correspondente(converter para DTO)
	Page<CategoriaDTO>	listDto = list.map(obj -> new CategoriaDTO(obj));
	return ResponseEntity.ok().body(listDto);

	}

(Service)

public Page<Categoria> findPage(Integer page, Integer linesPerPage, String orderBy, String direction) {
		PageRequest pageRequest = PageRequest.of(page, linesPerPage, Direction.valueOf(direction),
				orderBy);
		return repo.findAll(pageRequest);
	}

testando no Postmam (categorias/pages?linesPerPage=3)

Validações de dados

• Sem acesso a dados

  • Sintáticas

    • Campo não pode ser vazio
    • Valor numérico mínimo e máximo
    • Comprimento de string mínimo e máximo
    • Somente dígitos
    • Padrão (expressão regular): (##)-####-####

  • Outros

    • Data futura / passada

  • Mais de um campo

    • Confirmação de senha igual à senha

• Com acesso a dados

  • Email não pode ser repedito
  • Cada cliente pode cadastrar no máximo três cupons por mês

validação sintática bom Bean Validation

(CategoriaDTO)

@NotEmpty(message="Preenchimento obrigatório")
	@Length(min=5, max=80, message="O tamanho deve ser entre 5 e 80 caracteres")
	private String nome;

(CategoriaService)

// método auxiliar que instancia uma categoria através de um DTO
	public Categoria fromDTO(CategoriaDTO objDto) {
		return new Categoria(objDto.getId(), objDto.getNome());
	}

(CategoriaResource) Atualização no POST

@RequestMapping(method = RequestMethod.POST)

	public ResponseEntity<Void> insert(@Valid @RequestBody CategoriaDTO objDto) {
		Categoria obj = service.fromDTO(objDto);
		obj = service.insert(obj);
		URI uri = ServletUriComponentsBuilder.fromCurrentRequest().path("/{id}").buildAndExpand(obj.getId()).toUri();

		return ResponseEntity.created(uri).build();
	}
}

(CategoriaResource) Atualização no PUT

@RequestMapping(value = "/{id}", method = RequestMethod.PUT)
	public ResponseEntity<Void> update(@Valid @RequestBody CategoriaDTO objDto, @PathVariable Integer id) {
		Categoria obj = service.fromDTO(objDto);
		obj.setId(id);
		obj = service.update(obj);
		return ResponseEntity.noContent().build();
}		

Testando o Preenchimento obrigatório

Testando o limite de criação

Personalizando a validação

(Criando a FielMessage)

public class FieldMessage implements Serializable {
	private static final long serialVersionUID = 1L;

	private String fieldName;
	private String message;

	public FieldMessage() {

	}

	public FieldMessage(String fieldName, String message) {
		super();
		this.fieldName = fieldName;
		this.message = message;
	}

	public String getFielName() {
		return fieldName;
	}

	public void setFielName(String fieldName) {
		this.fieldName = fieldName;
	}

	public String getMessage() {
		return message;
	}

	public void setMessage(String message) {
		this.message = message;
	}

}

(Criando validationError)

public class ValidationError extends StandardError {

	private static final long serialVersionUID = 1L;


	private List<FieldMessage> errors  = new ArrayList<>();


	public ValidationError(Integer status, String msg, Long timeStamp) {
		super(status, msg, timeStamp);

	}


	public List<FieldMessage> getErrors() {
		return errors;
	}


	public void addError(String fieldName, String messagem) {
		errors.add(new FieldMessage(fieldName, messagem));
	}

}

Criando a ClienteDTO

Ele vai ser o objeto para definir os dados que você quer trafegar quando for fazer operações básicas de cliente e com algumas validações. Obs:Nela também acompanha Getters e Setters, mas não foi colocado na parte da documentação para não atrapalhar a visualização.

(DTO)

public class ClienteDTO implements Serializable {
	private static final long serialVersionUID = 1L;

	private Integer id;

	@NotEmpty(message="Preenchimento obrigatório")
	@Length(min=5, max=120, message="O tamanho deve ser entre 5 e 120 caracteres")
	private String nome;

	@NotEmpty(message="Preenchimento obrigatório")
	@Email(message="Email inválido")
	private String email;
}	  

método GET/PUT e DELETE para cliente

(Resource)

@RequestMapping(value = "/{id}", method = RequestMethod.PUT)
	public ResponseEntity<Void> update(@Valid @RequestBody ClienteDTO objDto, @PathVariable Integer id) {
		Cliente obj = service.fromDTO(objDto);
		obj.setId(id);
		obj = service.update(obj);
		return ResponseEntity.noContent().build();
	}

	@RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
	public ResponseEntity<Void> delete(@PathVariable Integer id) {
		service.delete(id);

		return ResponseEntity.noContent().build();

	}

	@RequestMapping( method = RequestMethod.GET)
	public ResponseEntity<List<ClienteDTO>> findAll() {
	// busca as listas de clientes do Banco
	List<Cliente> list = service.findAll();
	// vai ter que percorrer a list e para cada elemento da lista vai instanciar o DTO correspondente(converter para DTO)
	List<ClienteDTO>	listDto = list.stream().map(obj -> new ClienteDTO(obj)).collect(Collectors.toList());
	return ResponseEntity.ok().body(listDto);

	}

paginação com parâmetros opcionais na requisição

(Resouce)

@RequestMapping(value="/pages", method = RequestMethod.GET)
	public ResponseEntity<Page<ClienteDTO>> findPage(
			@RequestParam(value ="page", defaultValue="0")Integer page,
			@RequestParam(value ="linesPerPage", defaultValue="24")