Engenharia de Software

Denis Siqueira Moura – RA: 3132898405

ATIVIDADE PRÁTICA
PROGRAMAÇÃO WEB

Jacareí/SP Data: 25/10/2023

0
Denis Siqueira Moura RA: 3132898405

ATIVIDADE PRÁTICA
PROGRAMAÇÃO WEB

Trabalho apresentado à Universidade UNOPAR, como

requisito parcial para a obtenção de média na disciplina
programação web.

Jacareí/SP Data: 25/10/2023

1
 SUMÁRIO

1 INTRODUÇÃO3
2 DESENVOLVIMENTO4
2.1 PROCEDIMENTOS4

3 CONCLUSÃO19

2
1 INTRODUÇÃO

O presente portfólio relata uma aula prática de Programação Web que teve como
objetivo principal criar um projeto Spring Boot Java para o gerenciamento de usuários
em um sistema. O projeto, estruturado como uma Rest API, visa disponibilizar
endpoints para realizar operações de gerenciamento de usuários, seguindo o padrão
CRUD (Create, Retrieve, Update, Delete). Durante a aula prática, foram abordados
diversos aspectos essenciais no desenvolvimento de aplicações web, incluindo a
criação de um modelo de domínio, a estruturação das camadas lógicas (resource,
service, repository), a configuração de um banco de dados de teste (H2), a população
inicial do banco de dados e a implementação de tratamentos de exceções.

O desenvolvimento desse projeto se baseou no uso do Spring Framework, uma das

tecnologias mais relevantes para a construção de aplicativos Java empresariais e que
proporciona um ambiente robusto e eficiente para o desenvolvimento de aplicações
web. O Spring Tool Suite, uma IDE baseada no Eclipse, foi a ferramenta escolhida
para facilitar a criação e gerenciamento do projeto, uma vez que já incorpora os
plugins essenciais para o ecossistema Spring.

Além disso, para testar e validar as operações da API, foi utilizado o Postman, um
aplicativo que se destaca por sua capacidade de testar requisições HTTP, permitindo
obter respostas detalhadas que facilitam a verificação do funcionamento correto dos
endpoints.

Neste portfólio, serão detalhados os passos seguidos durante a aula prática, desde a
criação do projeto até a implementação das funcionalidades essenciais. Também
serão destacados os desafios enfrentados e as soluções encontradas ao longo do
processo de desenvolvimento. A aula prática teve como objetivo proporcionar uma
experiência real no desenvolvimento de uma aplicação web, abordando conceitos
fundamentais e práticos de programação web.

3
2 DESENVOLVIMENTO

2.1 PROCEDIMENTOS

A aula prática de Programação Web proporcionou a oportunidade de desenvolvimento

de um projeto Spring Boot Java abordando diversos aspectos cruciais no
desenvolvimento de aplicações web. A seguir, descreve-se detalhadamente as etapas
realizadas durante essa experiência de aprendizado:

1) Criação do Projeto Base com Spring Boot:

- Iniciamos a aula prática criando o projeto base com a estrutura Spring

utilizando o link disponibilizado. Selecionamos as opções adequadas, como o uso do
Maven, Java versão 17, Spring 3.0.10, e adicionamos a dependência do Spring Web.

2) Configuração do Ambiente de Desenvolvimento:

Abrimos o Spring Tool Suite e importamos o projeto recém-criado no

workspace.

3) Modelo de Domínio - Classe User:

- Em seguida, criamos uma classe chamada "User" no pacote "entities". Esta

classe representa os usuários do sistema e possui atributos como id, nome, e-mail,
telefone e senha.

- Implementamos construtores vazios e com todos os atributos, bem como os

métodos getters e setters.

- Também geramos a implementação dos métodos hashCode() e equals().

- Adicionamos as anotações @Entity e @Table(name = "tb_user") para mapear

a classe como uma entidade JPA.

4
O seguinte código foi utilizado:

package entities;

import java.io.Serializable;
import java.util.Objects;

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

@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 nome;
private String email;
private String telefone;
private String password;

public User() {
}

public User(Long id, String nome, String email, String telefone, String password) {
this.id = id;
this.nome = nome;
this.email = email;
this.telefone = telefone;
this.password = password;
}

public Long getId() {

return id;
}

public void setId(Long id) {

this.id = id;
}

public String getNome() {

return nome;
5
}

public void setNome(String nome) {

this.nome = nome;
}

public String getEmail() {

return email;
}

public void setEmail(String email) {

this.email = email;
}

public String getTelefone() {

return telefone;
}

public void setTelefone(String telefone) {

this.telefone = telefone;
}

public String getPassword() {

return password;
}

public void setPassword(String password) {

this.password = password;
}

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return Objects.equals(id, user.id);
}

@Override
public int hashCode() {
return Objects.hash(id);
}
}

6
 4) Criação do Controller - UserResource:

- No pacote "resource", criamos a classe "UserResource" que atua como nosso

controller.

- Adicionamos as anotações @RestController e @RequestMapping (value =

"/users") para definir a rota base para os endpoints relacionados a usuários.

O seguinte código foi utilizado:

package resource;

import entities.User;
import exceptions.ResourceNotFoundException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import services.UserService;

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(users);
}

@GetMapping(value = "/{id}")
public ResponseEntity<User> findById(@PathVariable Long id) {
User user = userService.findById(id);
return ResponseEntity.ok(user);
}

@PostMapping
public ResponseEntity<User> insert(@RequestBody User user) {
user = userService.insert(user);
return ResponseEntity.ok(user);

7
 }

@DeleteMapping(value = "/{id}")
public ResponseEntity<Void> delete(@PathVariable Long id) {
userService.delete(id);
return ResponseEntity.noContent().build();
}

@PutMapping(value = "/{id}")
public ResponseEntity<User> update(@PathVariable Long id, @RequestBody
User user) {
try {
user = userService.update(id, user);
return ResponseEntity.ok(user);
} catch (ResourceNotFoundException e) {
return ResponseEntity.notFound().build();
}
}
}

5) Configuração do Banco de Dados H2:

- Optamos por utilizar o banco de dados H2, um banco de dados relacional em

memória. Adicionamos as dependências necessárias no arquivo pom.xml.

- Configuramos o arquivo application.properties para definir a URL do banco de

dados, usuário e senha.

Os seguintes códigos foram utilizados:

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>

# Configuração do perfil ativo

spring.profiles.active=test

# Configuração do JPA para manter a visualização aberta

spring.jpa.open-in-view=true

8
 6) População do Banco de Dados:

- Criamos a classe TestConfig no pacote "config", que implementa a interface

CommandLineRunner. Isso nos permitiu popular o banco de dados com alguns dados
de exemplo durante a inicialização da aplicação.

Os seguintes códigos foram utilizados:

# Configurações do banco de dados H2 em memória para testes

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.username=sa
spring.datasource.password=

# Configuração da console do H2
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

# Configuração para mostrar as consultas SQL no console

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

7) Criação do Service - UserService:

- No pacote "services", criamos a interface UserService com a anotação

@Service.

- Utilizamos a anotação @Autowired para injetar o repositório UserRepository.

- Implementamos os métodos para realizar operações de CRUD, como findAll,

findById, insert, delete e update.

9
Os seguintes códigos foram utilizados:

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

import com.example.demo.entities.User;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {

import java.util.Arrays;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.CommandLineRunner;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.Profile;

import com.example.demo.entities.User;

import com.example.demo.repositories.UserRepository;

@Configuration

@Profile("test")

public class TestConfig implements CommandLineRunner {

@Autowired

private UserRepository userRepository;

10
 @Override

public void run(String... args) throws Exception {

User u1 = new User(null, "Denis Brown", "[email protected]",

"988888888", "123456");

User u2 = new User(null, "Moura Siqueira", "[email protected]", "977777777",

"123456");

userRepository.saveAll(Arrays.asList(u1, u2));

import java.util.List;

import com.example.demo.entities.User;

public interface UserService {

List<User> findAll();
User findById(Long id);
User insert(User user);
void delete(Long id);
User update(Long id, User user);
}

import java.util.List;
import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.example.demo.entities.User;
import com.example.demo.repositories.UserRepository;

@Service
public class UserServiceImpl implements UserService {

@Autowired
private UserRepository userRepository;

@Override
11
@Transactional(readOnly = true)
public List<User> findAll() {
return userRepository.findAll();
}

@Override
@Transactional(readOnly = true)
public User findById(Long id) {
Optional<User> obj = userRepository.findById(id);
return obj.orElse(null);
}

@Override
@Transactional
public User insert(User user) {
return userRepository.save(user);
}

@Override
@Transactional
public void delete(Long id) {
userRepository.deleteById(id);
}

@Override
@Transactional
public User update(Long id, User updatedUser) {
User entity = userRepository.getOne(id);
updateUserEntity(entity, updatedUser);
return userRepository.save(entity);
}

private void updateUserEntity(User entity, User updatedUser) {

entity.setNome(updatedUser.getNome());
entity.setEmail(updatedUser.getEmail());
entity.setTelefone(updatedUser.getTelefone());
entity.setPassword(updatedUser.getPassword());
}
}

12
 8) Na classe UserResource, que injeta o serviço UserService e implementa
as rotas findAll, findById, insert, delete e update:

import java.net.URI;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;

import com.example.demo.entities.User;
import com.example.demo.services.UserService;

@RestController
@RequestMapping(value = "/users")
public class UserResource {

@Autowired
private UserService userService;

@GetMapping
public ResponseEntity<List<User>> findAll() {
List<User> list = userService.findAll();
return ResponseEntity.ok().body(list);
}

@GetMapping(value = "/{id}")
public ResponseEntity<User> findById(@PathVariable Long id) {
User obj = userService.findById(id);
return ResponseEntity.ok().body(obj);
}

@PostMapping
public ResponseEntity<User> insert(@RequestBody User user) {
User obj = userService.insert(user);
URI uri =
ServletUriComponentsBuilder.fromCurrentRequest().path("/{id}").buildAndExpand(obj
.getId()).toUri();

13
 return ResponseEntity.created(uri).body(obj);
}

@DeleteMapping(value = "/{id}")
public ResponseEntity<Void> delete(@PathVariable Long id) {
userService.delete(id);
return ResponseEntity.noContent().build();
}

@PutMapping(value = "/{id}")
public ResponseEntity<User> update(@PathVariable Long id, @RequestBody
User updatedUser) {
User obj = userService.update(id, updatedUser);
return ResponseEntity.ok().body(obj);
}
}

9) Tratamento de Exceções:

- Implementamos uma classe de exceção personalizada chamada

ResourceNotFoundException no pacote "exceptions".

- Criamos a classe ResourceExceptionHandler no mesmo pacote para lidar

com essa exceção, retornando um objeto StandardError com informações detalhadas
sobre o erro:

package com.example.demo.services.exceptions;

public class ResourceNotFoundException extends RuntimeException {

private static final long serialVersionUID = 1L;

public ResourceNotFoundException(String message) {

super(message);
}
}

import java.io.Serializable;
import java.time.Instant;

public class StandardError implements Serializable {

private static final long serialVersionUID = 1L;

14
 private Instant timestamp;
private Integer status;
private String error;
private String message;
private String path;

public StandardError() {
}

public StandardError(Instant timestamp, Integer status, String error, String

message, String path) {
this.timestamp = timestamp;
this.status = status;
this.error = error;
this.message = message;
this.path = path;
}

public Instant getTimestamp() {

return timestamp;
}

public void setTimestamp(Instant timestamp) {

this.timestamp = timestamp;
}

public Integer getStatus() {

return status;
}

public void setStatus(Integer status) {

this.status = status;
}

public String getError() {

return error;
}

public void setError(String error) {

this.error = error;
}

public String getMessage() {

return message;
}

public void setMessage(String message) {

this.message = message;
}
15
 public String getPath() {
return path;
}

public void setPath(String path) {

this.path = path;
}
}

import java.time.Instant;

import javax.servlet.http.HttpServletRequest;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

import com.example.demo.services.exceptions.ResourceNotFoundException;

@ControllerAdvice
public class ResourceExceptionHandler {

@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity<StandardError>
resourceNotFound(ResourceNotFoundException e, HttpServletRequest request) {
HttpStatus status = HttpStatus.NOT_FOUND;
StandardError err = new StandardError(
Instant.now(),
status.value(),
"Resource not found",
e.getMessage(),
request.getRequestURI()
);
return ResponseEntity.status(status).body(err);
}
}

16
 10) Na classe UserService com os métodos findById, delete e update
modificados para incluir um try/catch que lança a exceção
ResourceNotFoundException:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class UserService {

private final UserRepository userRepository;

@Autowired
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}

public List<User> findAll() {

return userRepository.findAll();
}

public User findById(Long id) {

Optional<User> user = userRepository.findById(id);
if (user.isEmpty()) {
throw new ResourceNotFoundException("User not found with id: " + id);
}
return user.get();
}

public User insert(User user) {

return userRepository.save(user);
}

public void delete(Long id) {

try {
userRepository.deleteById(id);
} catch (EmptyResultDataAccessException e) {
throw new ResourceNotFoundException("User not found with id: " + id);
}
}

public User update(Long id, User updatedUser) {

try {
User user = userRepository.getOne(id);
updateUserData(user, updatedUser);
17
 return userRepository.save(user);
} catch (EntityNotFoundException e) {
throw new ResourceNotFoundException("User not found with id: " + id);
}
}

private void updateUserData(User user, User updatedUser) {

// Implement logic to update user data here
// For example: user.setName(updatedUser.getName());
// Don't forget to update other fields as needed
}
}

Resumo:

Particularmente este trabalho foi o mais complexo até o presente momento do curso.
Muita lógica envolvida, juntamente com conhecimentos técnicos. As etapas foram
essenciais para a compreensão da estrutura de um projeto Spring Boot, a
configuração do banco de dados, a implementação das camadas lógicas, o tratamento
de exceções e a realização de operações de CRUD em uma aplicação web. A aula
prática proporcionou um ambiente de aprendizado prático e construtivo, preparando
para enfrentar desafios reais no desenvolvimento de aplicações web robustas e
funcionais em que o mercado de trabalho está cada vez mais exigindo do profissional
de desenvolvimento.

18
3 CONCLUSÃO

O desenvolvimento deste projeto de Programação Web, empregando o framework

Spring Boot Java, foi uma experiência profundamente enriquecedora e essencial para
o aprimoramento das habilidades nesta área. Durante a aula prática, foi possível
aplicar conhecimentos teóricos em um contexto prático e desafiador, criando uma
aplicação real que segue as melhores práticas de desenvolvimento de software.
O projeto abordou diversos aspectos cruciais no desenvolvimento de aplicações web,
desde a estruturação do modelo de domínio até a implementação das camadas
lógicas, configuração de banco de dados e tratamento de exceções. Cada etapa foi
uma oportunidade de aprendizado, permitindo a compreensão de como todos esses
elementos se integram para criar uma aplicação funcional e robusta.
A utilização do Spring Framework e da IDE Spring Tool Suite mostrou-se fundamental
para agilizar o desenvolvimento, fornecendo ferramentas e recursos que simplificam
a criação de aplicações empresariais. Além disso, o Postman desempenhou um papel
crucial na fase de teste, permitindo validar e depurar os endpoints da API de maneira
eficaz.
Os resultados alcançados demonstram que os objetivos da aula prática foram
cumpridos com sucesso. Adquiriram-se conhecimentos práticos em Programação
Web, compreendendo-se a importância da estruturação de um projeto de software e
pode-se considerar a preparação para o enfrentamento de desafios reais no
desenvolvimento.

A capacitação em Programação Web é de extrema relevância no cenário atual, onde

a demanda por profissionais qualificados na área de tecnologia da informação
continua crescendo. Além disso, a aplicação dos conhecimentos adquiridos nesta aula
prática contribui para o desenvolvimento de soluções tecnológicas inovadoras.

Portanto, a conclusão deste projeto não representa apenas o término de uma

atividade acadêmica, mas o início de uma jornada promissora no mundo da
Programação Web. O aprendizado contínuo e a aplicação prática de conhecimentos
serão essenciais para o sucesso profissional e para a criação de soluções
tecnológicas que atendam às demandas da sociedade moderna.

19