2f4f25d2-019d-41fc-adb5-041fdb247c1b

Prévia do material em texto

SISTEMA DE ENSINO Á DISTÂNCIA 
ENGENHARIA DE SOFTWARE 
 
ROSELI A. DEFASSIO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
RELATÓRIO DE AULA PRÁTICA 
PROGRAMAÇÃO WEB 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Londrina 
2023 
 
 
 
 
 
 
ROSELI A. DEFASSIO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
RELATÓRIO DE AULA PRÁTICA 
PROGRAMAÇÃO WEB 
 
 
 
 
 
 
 
 
Trabalho apresentado ao Curso de Engenharia de 
Software da UNOPAR - Universidade Norte do Paraná, 
para a disciplina PROGRAMAÇÃO WEB 
 
Orientador: Prof. Vinicius Camargo Prattes 
 
 
 
 
 
 
 
 
 
 
 
 
 
Londrina 
2023 
 
 
 
 
 
SUMÁRIO 
 
1 INTRODUÇÃO ..................................................................................................... 3 
2 DESENVOLVIMENTO ......................................................................................... 4 
2.1 METODOLOGIA ............................................................................................... 4 
2.2 RESULTADOS ................................................................................................. 8 
3 CONCLUSÃO .................................................................................................... 16 
REFERÊNCIAS ......................................................................................................... 17 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3 
 
 
 
 
1 INTRODUÇÃO 
Spring Boot é um framework da plataforma Spring que acelera e simplifica o 
processo de desenvolvimento de aplicativos em Java. Ele foi projetado com o objetivo 
de permitir que desenvolvedores de todos os níveis possam criar aplicativos com rapidez 
e facilidade, sem a necessidade de configurar manualmente o ambiente de 
desenvolvimento. 
Com o Spring Boot, é possível iniciar rapidamente um projeto utilizando uma 
configuração padrão, que já inclui muitas das bibliotecas e dependências necessárias 
para a construção de aplicativos web. Além disso, ele oferece uma estrutura robusta de 
autoconfiguração, que permite que as aplicações sejam configuradas automaticamente 
com base no ambiente em que estão sendo executadas. 
Outro benefício do Spring Boot é que ele suporta uma ampla variedade de bancos 
de dados e bibliotecas de terceiros, o que permite que os desenvolvedores criem 
aplicativos mais eficientes e flexíveis. Com sua arquitetura modular e bem estruturada, 
o Spring Boot também é fácil de estender e personalizar, tornando-o uma opção atraente 
para muitos desenvolvedores Java. 
O objetivo deste projeto foi criar um sistema de gerenciamento de usuários 
baseado em Rest API utilizando o framework Spring. 
Neste relatório de aula prática, foi criado um projeto Backend em RestAPI, 
utilizando a linguagem Java, e o framkework Spring na IDE Eclipse. O projeto possui 
endpoints para uma CRUD, retornando usuários criados no banco de dados. 
 Um projeto base com a estrutura do Spring foi criado com as opções Maven, Java 
17, Spring 3.0.6, JAR packaging, Spring Web dependences. Além de um plug-in do 
Spring Tools instalado pelo marketplace do Eclipse e implementado os tratamentos de 
exceções para lidar com possíveis erros que possam ocorrer durante o uso do sistema. 
4 
 
 
 
 
2 DESENVOLVIMENTO 
Uma grande utilização do Java é para criação de aplicações Web e APIs REST 
e um dos melhores frameworks para isso é o Spring-boot. 
O Spring-boot surpreende pela facilidade para criar uma aplicação web em 
minutos e com pouco código. O modo mais fácil de criar uma aplicação com Spring-
Boot, é utilizando o Spring Initializr. 
Nesta atividade foi criado um projeto utilizando o framework Spring para o 
gerenciamento de usuários de um sistema, tratando um projeto backend baseado em 
Rest API, onde foram disponibilizados os endpoints necessários para realizar as 
operações de gerenciamento de usuários (CRUD). O projeto foi MVC e foi necessário 
realizar o modelo logico para a criação da base de dados, bem como a conexão com 
ele. Além da logica base, foi necessário realizar os tratamentos de exceções. 
 
2.1 METODOLOGIA 
 
Para a realização desta aula pratica foi utilizar um editor de texto, recomendável 
o Eclipse com Spring Tool: https://spring.io/tools. Ademais, foi preciso ter o Postman 
instalado: https://www.postman.com/downloads/. 
1. Crie o projeto base com a estrutura Spring a partir do seguinte link: 
https://start.spring.io/. Selecione as seguintes opções: 
• Maven 
• Java, versão 17 
• Versão do Spring: 3.0.0 
• JAR packaging 
• Add dependencies: Spring Web 
 
2. Clique em “generate”. Descompacte o projeto que foi baixado no seu workspace. 
3. Abra o Spring Tool Suite e escolha seu workspace. 
• Em “File > Import > Maven > Existing Maven projects”: escolha a pasta do projeto 
base gerado nos passos 1 e 2. Selecione o arquivo pom.xml que aparecerá e clique 
em “Finish”. 
 
4. Em src/main/java, crie um pacote “entities” e dentro dele crie a classe User. 
• Crie os atributos básicos: id, nome, e-mail, telefone, password. 
• Crie um construtor vazio e um construtor usando todos os atributos (campos). 
• Crie os getters e setters. 
 
 
https://spring.io/tools
https://www.postman.com/downloads/
https://start.spring.io/
5 
 
 
 
 
• Gere a implementação para o método hashCode() e equals() (botão direito > source > 
• generate hashCode...). 
• Faça com que sua classe implemente a interface Serializable e crie o atributo 
serialVersionUID (ele vai ser útil caso seja necessário salvar o objeto em um arquivo 
etc.) 
• Adicione a esta classe as seguintes annotations: 
 
5. Em src/main/java, crie um pacote “resource” e dentro dele crie a classe 
UserResource (esta classe ira ser o nosso controller). Adicione as seguintes 
annotations: 
 
 
6. Nosso banco de dados será o H2 que é um banco de dados relacional que pode 
ser executado no modo cliente-servidor. Iremos utilizar JPA para persistir os dados. 
Vamos então configurar nosso projeto para incluir a dependência destes dois recursos: 
Para isto adicione as seguintes dependências no arquivo pom.xml: 
 
7. Em src/main/resources, crie o arquivo application.properties (ele nos servirá para 
armazenar propriedades de escopo do aplicativo). Adicione as seguintes linhas: 
 
• spring.profiles.active=test spring.jpa.open-in-view=true 
 
8. Em src/main/resources, crie o arquivo application-test.properties (ele nos servirá 
para armazenar propriedades de escopo do aplicativo para a realização dos testes 
locais). Adicione as seguintes linhas: 
 
 
 
6 
 
 
 
 
9. Em src/main/java, crie um pacote “repositories” e dentro dele crie a interface 
UserRepository. Estenda a classe JpaRepository e passe como definição ao 
JpaRepository a entidade “User” e o tipo da chave primaria (id): 
 
• JpaRepository<User, Long> 
 
10. Crie uma classe de configuração que irá rodar toda vez que executarmos o 
projeto no modo teste. Ela irá nos servir para popular alguns dados no banco em tempo 
de execução (o H2 é um banco de dados em memória, portanto quando a aplicação for 
finalizada seus dados deixarão de existir). 
 
• Em src/main/java, crie um pacote “config” e dentro dele crie a classe 
TestConfig que irá implementar a interface CommandLineRunner. 
• Vamos injetar um atributo do tipo UserRepository à esta classe utilizando 
a annotation @Autowired. 
• Implemente o método run, adicionando as seguintes linhas: 
 
11. Em src/main/java, crie um pacote “services” e dentro dele crie a interface 
UserService, utilize nesta classe a annotation @Service. 
• Injete um atributo do tipo UserRepository à esta classe utilizando a annotation 
@Autowired. 
• Crie os seguintes métodos e implemente cada um deles: 
• findAll 
• findById 
• insert 
• delete 
• update 
 
12. Em src/main/java/resources, na classe UserResource, injete um atributo do tipo 
UserService à esta classe utilizando a annotation @Autowired. Em seguida, implemente 
as seguintes rotas: 
• findAll (GET) 
• findById (GET) 
• insert (POST) 
• delete(DELETE) 
• update (PUT) 
 
 
7 
 
 
 
 
13. Em src/main/java/service, crie um pacote “exceptions” e dentro dele crie a classe 
ResourceNotFoundException. 
• Estenda a classe RuntimeException. 
• Implemente o construtor da classe fazendo a chamada para o construtor pai, 
passando uma mensagem personalizada. 
 
14. Em src/main/java/resources, crie um pacote “exceptions” e dentro dele crie as 
seguintes classes: 
• StandardError. 
• ResourceExceptionHandler. 
 
15. Em StandardError: 
 
• Crie os atributos básicos: timestamp, status, error, message, path. 
• Crie um construtor vazio e um construtor usando todos os atributos (campos). 
• Crie os getters e setters. 
• Faça com que sua classe implemente a interface Serializable e crie o atributo 
serialVersionUID (ele vai ser útil caso seja necessário salvar o objeto em um 
arquivo etc.) 
 
16. Em ResourceExceptionHandler: 
• Adicione a seguinte anotação à classe: @ControllerAdvice. Vai servir pra 
interceptar a exceção lançada quando não for encontrado um usuário. 
• Crie o método resourceNotFound: ele retornará um objeto do tipo 
ResponseEntity<StandardError> e deverá receber como parâmetro o objeto 
ResourceNotFoundException. 
• Adicione a anotação @ExceptionHandler(ResourceNotFoundException.class) ao 
método criado. 
• Na implementação do método, além de passar uma mensagem customizada, é 
interessante mudar o código de erro da exceção, passando o tipo 
 
17. Em src/main/java/services, na classe UserService, modifique os métodos 
findById, delete e update adicionando um try/catch que lance a exceção do tipo 
ResourceNotFoundException. 
 
18. Teste a aplicação utilizando o postman. 
 
 
8 
 
 
 
 
2.2 RESULTADOS 
O primeiro passo foi realizar o download dos softwares abaixo: 
 
• Eclipse com Spring Tool: é uma IDE baseada em Eclipse, para realização de 
projetos utilizando Spring Boot, que é uma IDE que já vem com os plugins da Spring 
que facilitam o desenvolvimento com o ecosistema spring. O software eclipse será o 
editor de texto. 
Figura 1: Spring Tools 4 for Eclipse 
 
 
• Postman: é um aplicativo utilizado para testes de API. É um client HTTP que 
testa requisições HTTP, utilizando uma interface gráfica com o usuário, através da 
qual obtemos diferentes tipos de respostas que precisam ser posteriormente 
validadas. 
 
Figura 2: Postman
 
 
 
 
9 
 
 
 
 
Criado o projeto base com a estrutura Spring a partir do seguinte link: 
https://start.spring.io/, foram selecionadas as seguintes opções: Maven, Java versão 
17, Versão do Spring 3.0.0, JAR packaging, Add dependencies: Spring Web. Clicado 
em “generate”. Descompactado o projeto que foi baixado no workspace. 
Aberto o Spring Tool Suite e acessado o projeto base através do caminho: “File 
> Import > Maven > Existing Maven projects”: selecionada a pasta recém criada. 
Selecionado o arquivo pom.xml clicado em “Finish”. 
• Foi criada a classe User dentro do pacote entities em src/main/java. 
• Foram criados os atributos básicos: id, nome, e-mail, telefone, password. 
• Foi criado um construtor vazio e um construtor usando todos os atributos 
(campos). Criados os getters e setters. 
• Gerada a implementação para o método hashCode() e equals() (botão direito > 
source generate hashCode...). 
• Adicionada a esta classe as annotations @Entity e @Table(name = "tb_user") 
 
Figura 3: Criação da classe User 
 
 
 
 
 
https://start.spring.io/
10 
 
 
 
 
 
Em src/main/java, crido um pacote “resource” e dentro dele crida a classe 
UserResource (esta classe ira ser o nosso controller). Adicionada as annotations 
@RestController e @RequestMapping(value = "/users"). 
O banco de dados foi o H2 que é um banco de dados relacional que pode ser 
executado no modo cliente-servidor. Iremos utilizar JPA para persistir os dados. 
Vamos então configurar nosso projeto para incluir a dependência destes dois 
recursos. Para isto foi adicionado as seguintes dependências no arquivo pom.xml 
conforme a figura a seguir: 
 
Figura 4: Adição de dependências no arquivo pom.xml 
 
 
11 
 
 
 
 
 
 
Em src/main/resources, criado o arquivo application.properties (ele nos servirá 
para armazenar propriedades de escopo do aplicativo). Adicionadas as seguintes 
linhas: spring.profiles.active=test e spring.jpa.open-in-view=true 
 
 Figura 5: Criado o arquivo application.properties 
 
Em src/main/resources, criado o arquivo application-test.properties (ele nos 
servirá para armazenar propriedades de escopo do aplicativo para a realização dos 
testes locais). Adicionadas as seguintes linhas: 
 
 Figura 6: Criado o arquivo application-test.properties 
 
 
 
Em src/main/java, criado um pacote “repositories” e dentro dele criado a 
interface UserRepository. Estendida a classe JpaRepository e passado como 
definição ao JpaRepository a entidade “User” e o tipo da chave primaria (id): 
JpaRepository<User, Long> 
 
 
12 
 
 
 
 
Criada uma classe de configuração que irá rodar toda vez que executado o 
projeto no modo teste. Ela irá nos servir para popular alguns dados no banco em 
tempo de execução (o H2 é um banco de dados em memória, portanto quando a 
aplicação for finalizada seus dados deixarão de existir). Em src/main/java, criado um 
pacote “config” e dentro dele crie a classe TestConfig que irá implementar a interface 
CommandLineRunner. 
Foi injetado um atributo do tipo UserRepository à esta classe utilizando a 
annotation @Autowired. Implementado o método run, adicionando as seguintes linhas: 
 
• User u1 = new User(null, "Maria Brown", "maria@gmail.com", "988888888", 
"123456"); 
• User u2 = new User(null, "Alex Green", "alex@gmail.com", "977777777", 
"123456"); userRepository.saveAll(Arrays.asList(u1, u2)); 
 
Em src/main/java, criado um pacote “services” e dentro dele criada a interface 
UserService, utilizando nesta classe a annotation @Service. Injetado um atributo do 
tipo UserRepository à esta classe utilizando a annotation @Autowired. Criados os 
seguintes métodos e implementado cada um deles: findAll, findById, insert, delete e 
update. Em src/main/java/resources, na classe UserResource, injetado um atributo do 
tipo UserService à esta classe utilizando a annotation @Autowired. Em seguida, 
implementadas as seguintes rotas: findAll (GET), findById (GET), insert (POST), 
delete (DELETE), update (PUT). 
Figura 7: Criação das rotas 
 
 
 
mailto:maria@gmail.com
mailto:alex@gmail.com
13 
 
 
 
 
• Em src/main/java/service, criado um pacote “exceptions” e dentro dele criado a 
classe ResourceNotFoundException. Estendida a classe RuntimeException e 
implementado o construtor da classe fazendo a chamada para o construtor pai, 
passando uma mensagem personalizada. 
• Em src/main/java/resources, crie um pacote “exceptions” e dentro dele criadas 
as seguintes classes: StandardError e ResourceExceptionHandler. 
• Em StandardError criados os atributos básicos: timestamp, status, error, 
message, path. Criados um construtor vazio e um construtor usando todos os 
atributos (campos). Criados os getters e setters. 
 
Feito com que sua classe implemente a interface Serializable e criado o atributo 
serialVersionUID (ele vai ser útil caso seja necessário salvar o objeto em um arquivo 
etc.). 
Em ResourceExceptionHandler: adicionada a seguinte anotação à classe: 
@ControllerAdvice. Vai servir pra interceptar a exceção lançada quando não for 
encontrado um usuário. 
Criado o método resourceNotFound: ele retornará um objeto do tipo 
ResponseEntity<StandardError> e que recebeu como parâmetro o objeto 
ResourceNotFoundException. 
 
Adicionada a anotação abaixo ao método criado. 
@ExceptionHandler (ResourceNotFoundException.class) 
 
Na implementação do método, além de passar uma mensagem customizada, 
foi alterado o código de erro da exceção, passando o tipo 
 
HttpStatus status = HttpStatus.NOT_FOUND; 
 
Emsrc/main/java/services, na classe UserService, modificados os métodos 
findById, delete e update adicionando um try/catch que lance a exceção do tipo 
ResourceNotFoundException. 
 
 
 
 
 
 
14 
 
 
 
 
Testando a aplicação utilizando o postman. 
 
Figura 8: Teste de usuários com Postman 
 
 
Figura 9: Busca por id com o Postman 
 
15 
 
 
 
 
 
Figura 10: Criação de usuário com a rota POST 
 
 
Figura 10: Estrutura 
 
16 
 
 
 
 
 
3 CONCLUSÃO 
O Spring Boot é um framework para desenvolvimento de aplicações Java que 
simplifica a infraestrutura necessária para construir um sistema robusto e escalável. Ele 
oferece recursos de configuração automática e um conjunto abrangente de bibliotecas, 
que permitem aos desenvolvedores concentrarem-se no desenvolvimento de recursos de 
negócio, ao invés de se preocupar com a configuração da infraestrutura. Além disso, o 
Spring Boot também é altamente extensível, o que permite aos desenvolvedores 
personalizar e adaptar o ambiente de execução de suas aplicações. 
Dessa forma, o Spring Boot é uma excelente opção para empresas que buscam 
desenvolver aplicações Java com rapidez e eficiência, sem abrir mão da escalabilidade e 
da segurança. Com ele, os desenvolvedores podem criar sistemas complexos com 
facilidade, tornando o processo de desenvolvimento e manutenção muito mais ágil e 
seguro. 
O projeto foi concluído com sucesso, e o uso do framework Spring facilitou a 
implementação de um sistema seguro e eficiente para gerenciamento de usuários. O uso 
da Rest API possibilitou a interoperabilidade com outros sistemas, permitindo a utilização 
de dados para outros fins. A documentação adequada garantiu que o sistema possa ser 
mantido e modificado por outros desenvolvedores no futuro. 
 
 
 
 
 
 
 
 
 
 
 
 
 
17 
 
 
 
 
 
REFERÊNCIAS 
 
BRITO, Michelli. Spring Boot | Curso Completo 2022. 2022. Disponível em: 
https://www.youtube.com/watch?v=LXRU-Z36GEU&t=38s. Acesso em: 6 out. 2023. 
 
 
CLARK, Mariana. Top Frameworks para Java. 2023. Disponível em: 
https://blog.back4app.com/pt/frameworks-java/#O_que_e_um_Framework. Acesso em: 
13 out. 2023. 
 
 
BARANCELLI JUNIOR, Gaspar. Banco de dados H2 com Spring Boot. 2023. 
Disponível em: https://www.gasparbarancelli.com/post/banco-de-dados-h2-com-spring-
boot. Acesso em: 12 out. 2023. 
 
 
FADATARE, RAMESH. Spring Boot CRUD Example with H2 Database. JAVA 
GUIDES. Disponível em: https://www.javaguides.net/2020/04/spring-boot-h2-jpa-
hibernate-restful-crud-api-tutorial.html. Acesso em: 08 out 2023. 
 
 
FRANCO, DEBRA. Retrieving Request's URI from WebRequest in Spring. 
COPYPROGRAMMING, 2023. Disponível em: https://copyprogramming.com/howto/how-
to-get-request-s-uri-from-webrequest-in-spring. Acesso em 09 out 2023. 
 
 
MOREIRA, DHIONSON PLASTER. Criando o Backend de um E-commerce com Java 
e Spring Boot - Parte 1. LINKEDIN, 2023. Disponível em: 
https://pt.linkedin.com/pulse/criando-o-backend-de-um-e-commerce-com-java-e-spring-
plaster-moreira?trk=portfolio_article-card_title. Acesso em 09 out 2023. 
 
 
MOREIRA, DHIONSON PLASTER. Configurando o Banco de Teste H2 em seu 
Projeto Spring Boot - Parte 2. LINKEDIN, 2023. Disponível em: 
https://pt.linkedin.com/pulse/configurando-o-banco-de-teste-h2-em-seu-projeto-boot-
plaster-moreira?trk=portfolio_article-card_title. Acesso em 09 out 2023. 
 
 
MOREIRA, DHIONSON PLASTER. Desenvolvendo uma API REST com Spring Boot - 
Parte 4: Implementação de Serviços e Testes com Postman. LINKEDIN, 2023. 
Disponível em: https://pt.linkedin.com/pulse/desenvolvendo-uma-api-rest-com-spring-
boot-parte-4-plaster-moreira?trk=portfolio_article-card_title. Acesso em 12 out 2023. 
ZANINI, ANTONELLO. Get Started with Custom Error Handling in Spring Boot 
(Java). AUTH0, 2021. Disponível em: https://auth0.com/blog/get-started-with-custom-
error-handling-in-spring-boot-java/. Acesso em 12 out 2023.