Portfólio Programação Web

Prévia do material em texto

Cidade/UF 
2024 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
NOME RA: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
RELATÓRIO DE AULA PRÁTICA PROGRAMAÇÃO WEB 
 
UNIVERSIDADE ANHANGUERA – UNIDERP 
CENTRO DE EDUCAÇÃO À DISTÂNCIA 
ENGENHARIA DE SOFTWARE 
 
 
CURSO 
 
Cidade/UF 
2024 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
RELATÓRIO DE AULA PRÁTICA PROGRAMAÇÃO WEB 
Roteiro Aula Prática apresentado a Universidade 
Anhanguera como requisito para obtenção de média 
para a disciplina de Programação Web. 
 
Tutor(a) à Distância: Vinicius Camargo Prattes 
 
NOME RA: 
 
 
 
 
 
 
 
 
 
 
 
 
SUMÁRIO 
1 INTRODUÇÃO ..................................................................................................... 3 
2 DESENVOLVIMENTO ......................................................................................... 4 
2.1 PREPARAÇÃO DO AMBIENTE DE DESENVOLVIMENTO ................................ 4 
3 CONCLUSÃO .................................................................................................... 11 
REFERÊNCIAS ......................................................................................................... 12 
 
 
 
 
 
 
 
 
 
 
 
 
 3 
1 INTRODUÇÃO 
Neste projeto, abordamos a criação e o desenvolvimento de uma aplicação 
back-end robusta utilizando o Spring Boot, um framework amplamente reconhecido 
por sua eficiência e simplicidade no desenvolvimento de aplicações Java. O foco do 
projeto é o gerenciamento de usuários, uma funcionalidade essencial em muitos 
sistemas modernos, que exige uma compreensão abrangente tanto do framework 
utilizado quanto dos princípios de design de API REST. 
Através desta atividade prática, visamos aprofundar nosso entendimento 
sobre a estruturação de aplicações baseadas em Spring Boot, cobrindo aspectos 
cruciais como a modelagem de entidades, a criação de repositórios, serviços e 
controladores, além da configuração de um banco de dados de teste com H2 para 
manipulação dos dados. Complementarmente, a implementação de operações 
CRUD (Create, Retrieve, Update, Delete) nos permite explorar o ciclo de vida 
completo dos dados dentro da aplicação, garantindo uma base sólida para o 
desenvolvimento de funcionalidades mais complexas no futuro. 
Além disso, enfatizamos a importância do tratamento de exceções, 
assegurando que a aplicação possa lidar de maneira elegante com cenários de erro 
e proporcionar feedbacks claros ao usuário ou consumidor da API. Por fim, a 
utilização do Postman para testar os endpoints da API reforça a prática de 
desenvolvimento orientado a testes (TDD), essencial para a construção de 
aplicações confiáveis e de alta qualidade. 
Este relatório documenta o processo de desenvolvimento passo a passo, 
destacando decisões técnicas, desafios enfrentados e as soluções adotadas, 
fornecendo uma visão detalhada e instrutiva sobre a construção de uma aplicação 
Spring Boot do início ao fim. 
 
 
 4 
2 DESENVOLVIMENTO 
2.1 PREPARAÇÃO DO AMBIENTE DE DESENVOLVIMENTO 
Passo a passo do meu projeto de Programação Web, usando Spring Boot 
para criar um sistema de gerenciamento de usuários. Desde a instalação das 
ferramentas até a execução dos testes. 
 
Instalando Tudo que Preciso 
Primeiro de tudo, precisei garantir que meu PC estava pronto pro trabalho. Fiz 
uma lista do que precisava instalar: JDK (Java Development Kit), Eclipse com Spring 
Tools 4, Postman e Git. Aqui vai um breve resumo de como foi: 
 
JDK 17: Verifiquei se já tinha o Java instalado, dando um java -version no 
terminal. Não tinha, então baixei o JDK 17 direto do site da Oracle e instalei. Foi 
tranquilo, só seguir o passo a passo da instalação. 
 
 
 
Eclipse com Spring Tools 4 (STS): Fui até o site do Eclipse, baixei o Eclipse 
IDE for Enterprise Java and Web Developers e instalei. Depois, abri o Eclipse, fui no 
Marketplace e adicionei o Spring Tools 4. Parecia um pouco complicado no começo, 
mas foi só seguir as instruções na tela. 
 
 
 5 
Postman: Esse foi fácil, só baixar do site e instalar. Vou usar bastante para 
testar as APIs que eu criar. 
 
 
 
 
Criando o Projeto Spring Boot 
Depois de ter tudo instalado, fui criar o projeto no Spring Initializr 
(https://start.spring.io/). Escolhi Maven, Java 17, a última versão do Spring Boot 
disponível, e adicionei as dependências para Spring Web e H2 Database. Baixei o 
projeto e o descompactei na minha pasta de trabalho. 
 
 
 
Configurando o Projeto no Eclipse 
Importei o projeto para o Eclipse como um projeto Maven existente. Foi só 
apontar para a pasta onde descompactei o arquivo do Spring Initializr. 
 6 
 
 
 
 
Classe User: 
No pacote com.example.demo.entities, criei a classe User, definindo atributos 
básicos como id, nome, e-mail, telefone, e senha. Implementei os métodos 
hashCode e equals e marquei a classe com as anotações @Entity e @Table. 
 
package com.example.demo.entities; 
 
import javax.persistence.Entity; 
import javax.persistence.GeneratedValue; 
import javax.persistence.GenerationType; 
import javax.persistence.Id; 
import javax.persistence.Table; 
import java.io.Serializable; 
 
@Entity 
@Table(name = "tb_user") 
public class User implements Serializable { 
 private static final long serialVersionUID = 1L; 
 
 @Id 
 @GeneratedValue(strategy = GenerationType.IDENTITY) 
 private Long id; 
 private String name; 
 private String email; 
 private String phone; 
 private String password; 
 
 public User() {} 
 
 public User(Long id, String name, String email, String phone, String password) 
{ 
 this.id = id; 
 7 
 this.name = name; 
 this.email = email; 
 this.phone = phone; 
 this.password = password; 
 } 
 
 // Getters and Setters, hashCode() and equals() methods 
} 
 
 
UserRepository 
No pacote com.example.demo.repositories, implementei a interface 
UserRepository, estendendo JpaRepository para facilitar a interação com o banco de 
dados. 
 
package com.example.demo.repositories; 
 
import com.example.demo.entities.User; 
import org.springframework.data.jpa.repository.JpaRepository; 
 
public interface UserRepository extends JpaRepository<User, Long> { 
} 
 
 
UserService 
No pacote com.example.demo.services, criei a classe UserService, onde 
desenvolvi a lógica de negócios, incluindo métodos para operações CRUD. 
 
package com.example.demo.services; 
 
import com.example.demo.entities.User; 
import com.example.demo.repositories.UserRepository; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
 
import java.util.List; 
import java.util.Optional; 
 
@Service 
public class UserService { 
 
 @Autowired 
 private UserRepository userRepository; 
 
 public List<User> findAll() { 
 return userRepository.findAll(); 
 } 
 
 public User findById(Long id) { 
 Optional<User> result = userRepository.findById(id); 
 return result.orElseThrow(() -> new RuntimeException("User not found")); 
 } 
 8 
 
 // Insert, Delete, Update methods 
} 
 
UserResource: 
No pacote com.example.demo.resources, desenvolvi a classe UserResource, 
que atua como o controlador para definir os endpoints da API. 
 
package com.example.demo.resources; 
 
import com.example.demo.entities.User; 
import com.example.demo.services.UserService; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.http.ResponseEntity; 
import org.springframework.web.bind.annotation.*; 
 
import java.util.List; 
 
@RestController 
@RequestMapping(value = "/users") 
public class UserResource { 
 
 @Autowired 
 private UserService userService; 
 
 @GetMapping 
 public ResponseEntity<List<User>> findAll() { 
 List<User> users = userService.findAll(); 
 return ResponseEntity.ok().body(users); 
 } 
 
 @GetMapping("/{id}")public ResponseEntity<User> findById(@PathVariable Long id) { 
 User user = userService.findById(id); 
 return ResponseEntity.ok().body(user); 
 } 
 
 // POST, DELETE, PUT methods 
} 
 
 
Configuração do H2: 
 
Configurei o application.properties para usar o banco de dados H2 em 
ambiente de teste, definindo URLs, usuário, e senha padrão. Além disso, habilitei a 
console do H2 para facilitar o monitoramento do banco de dados. 
 
# H2 Database 
spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE 
 9 
spring.datasource.driverClassName=org.h2.Driver 
spring.datasource.username=sa 
spring.datasource.password= 
 
# H2 Console 
spring.h2.console.enabled=true 
spring.h2.console.path=/h2-console 
 
# JPA/Hibernate 
spring.jpa.show-sql=true 
spring.jpa.hibernate.ddl-auto=update 
spring.jpa.properties.hibernate.format_sql=true 
 
 
Tratamento de Exceções: 
Implementei ResourceNotFoundException para gerenciar casos onde 
recursos não são encontrados, e ResourceExceptionHandler para tratar exceções 
globalmente. 
 
package com.example.demo.exceptions; 
 
import org.springframework.http.HttpStatus; 
import org.springframework.http.ResponseEntity; 
import org.springframework.web.bind.annotation.ControllerAdvice; 
import org.springframework.web.bind.annotation.ExceptionHandler; 
 
@ControllerAdvice 
public class ResourceExceptionHandler { 
 
 @ExceptionHandler(ResourceNotFoundException.class) 
 public ResponseEntity<StandardError> 
resourceNotFound(ResourceNotFoundException e) { 
 StandardError error = new StandardError(System.currentTimeMillis(), 
HttpStatus.NOT_FOUND.value(), "Resource not found", e.getMessage()); 
 return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error); 
 } 
 
 // StandardError class definition 
} 
 
package com.example.demo.exceptions; 
 
public class ResourceNotFoundException extends RuntimeException { 
 public ResourceNotFoundException(String message) { 
 super(message); 
 } 
} 
 
 10 
 
 
Testes com Postman 
 
Realizei testes para todas as operações CRUD através do Postman, 
validando o funcionamento adequado da API. 
 
 
 
 
 
 11 
3 CONCLUSÃO 
A conclusão deste projeto de gerenciamento de usuários com Spring Boot 
marca um ponto significativo no meu aprendizado e desenvolvimento como 
desenvolvedor de software. Ao longo deste processo, não apenas solidifiquei meu 
entendimento do framework Spring Boot, mas também aprofundei meu 
conhecimento em conceitos fundamentais da construção de APIs RESTful, 
manipulação de banco de dados em memória com H2, e o essencial tratamento de 
exceções para manter a robustez e a confiabilidade da aplicação. 
Um dos aspectos mais enriquecedores deste projeto foi a implementação das 
operações CRUD, que formam a espinha dorsal de muitas aplicações web 
modernas. Através desta prática, pude compreender melhor como estruturar a lógica 
de negócios de maneira eficiente e responsiva às necessidades do usuário, 
mantendo o código organizado, testável e escalável. 
A configuração do banco de dados H2 para teste mostrou-se uma valiosa 
experiência de aprendizado, permitindo-me explorar o gerenciamento de dados sem 
a necessidade de uma infraestrutura de banco de dados complexa. Isso não apenas 
facilitou o processo de desenvolvimento, mas também destacou a versatilidade do 
Spring Boot em se adaptar a diferentes ambientes de desenvolvimento. 
Utilizar o Postman para testar a API provou ser uma prática crucial, 
reforçando a importância dos testes no ciclo de desenvolvimento de software. Esta 
ferramenta permitiu verificar rapidamente a funcionalidade e a integridade dos 
endpoints da API, garantindo que a aplicação se comportasse conforme esperado 
antes de avançar para fases posteriores de desenvolvimento ou produção. 
Em retrospecto, cada desafio encontrado ao longo deste projeto foi uma 
oportunidade de aprendizado. Seja navegando por erros de configuração, 
aprimorando a lógica de negócios ou garantindo que a aplicação lidasse 
graciosamente com cenários de erro, cada etapa contribuiu para uma compreensão 
mais profunda do desenvolvimento de aplicações com Spring Boot. 
 
 
 
 
 
 12 
REFERÊNCIAS 
Download Postman | Try Postman for Free. Disponível em: 
<https://www.postman.com/downloads/>. 
 
Spring Tools 4 is the next generation of Spring tooling. Disponível em: 
<https://spring.io/tools>. 
 
ECLIPSE FOUNDATION. Eclipse Downloads | The Eclipse Foundation. Disponível 
em: <https://www.eclipse.org/downloads/>.