|
|
|
| [Home](home) | [Escopo e Cronograma](escopo) | [Processo](processo) | [Design/Mockups](design_mockups) | [Configuração](configuracao) | [**Arquitetura**](modelo_arquitetural) | [Código](codigo) | [BD](banco_dados) | [Qualidade](qualidade) | [Utilização](utilizacao) | [Padrão Merge Request](Padrão Merge Request)
|
|
|
|
| :--------------: | :---------------------------: | :------------------: | :--------------: | :--------------------------: | :------------------------: | :--------------: | :---------------: | :--------------------: | :----------------------: | :-------------------------------------------:|
|
|
|
|
|
|
|
|
# Tecnologias
|
|
|
|
|
|
|
|
|
|
|
|
### Spring Boot (Backend)
|
|
|
|
|
|
|
|
Spring Boot é uma microestrutura de código aberto mantida por uma empresa chamada Pivotal. Ele fornece aos desenvolvedores Java uma plataforma para começar a usar um aplicativo Spring de nível de produção configurável automaticamente. Com ele, os desenvolvedores podem começar rapidamente sem perder tempo na preparação e configuração de seu aplicativo Spring. No contexto do projeto _Alpha_ foi escolhido como a tecnologia a ser usada para o desenvolvimento do backend.
|
|
|
|
|
|
|
|
### Vue.js (Frontend)
|
|
|
|
|
|
|
|
Vue.js é uma biblioteca para construir interfaces web interativas. O objetivo do Vue.js é fornecer os benefícios da vinculação de dados reativa e componentes de visualização combináveis com uma API que seja o mais simples possível. No contexto do projeto _Alpha_ foi escolhida como a tecnlogia a ser usada para o desenvolvimento do frontend.
|
|
|
|
|
|
|
|
### PostgreSQL (Banco de Dados)
|
|
|
|
|
|
|
|
O PostgreSQL é um sistema de banco de dados relacional orientado a objetos poderoso e de código aberto, com mais de 30 anos de desenvolvimento ativo, que tem uma alta confiabilidade, robustez de recursos e desempenho. No contexto do projeto _Alpha_ é a tecnologia escolhida para o banco de dados da aplicação.
|
|
|
|
|
|
|
|
### Firebase Authentication (Autenticação)
|
|
|
|
|
|
|
|
O objetivo do Firebase Authentication é facilitar o desenvolvimento de um sistema de autenticação seguro, além de melhorar a experiência de login e integração para os usuários finais. Ele oferece uma solução de identidade completa, compatível com contas de e-mail/senha, autenticação por telefone, login do Google, Twitter, Facebook, GitHub e outros. No contexto do projeto _Alpha_ foi escolhido como o provider de autenticação e autorização dos usuários cadastrados acessaram a aplicação.
|
|
|
|
|
|
|
|
### Jenkins (Integração Contínua)
|
|
|
|
|
|
|
|
O Jenkins é uma ferramenta de automação de código aberto. Ajuda a automatizar as partes do desenvolvimento de software relacionadas à construção, teste e implantação, integração contínua e entrega contínua. No contexto do projeto _Alpha_ foi escolhido é utilizado no pipeline de entrega continua junto ao Gitlab Runner para subida do código em produção na AWS.
|
|
|
|
|
|
|
|
### Docker (Conteinerização)
|
|
|
|
|
|
|
|
Docker é um conjunto de produtos de plataforma como serviço (PaaS) que usam virtualização de nível de sistema operacional para entregar software em pacotes chamados contêineres. No contexto do projeto _Alpha_ foi escolhido é ferramenta de conteinerização do artefatos que irão ser executados em maquinas EC2 no AWS.
|
|
|
|
|
|
|
|
## Comunicação entre as tecnologias utilizadas
|
|
|
|
|
|
|
|
|
|
|
|
# Modelo Arquitetural REST
|
|
|
|
|
|
|
|
Para o escopo deste projeto foi desenvolvido uma API REST. REST API é uma interface de programação de aplicativo (API ou API da web) que está em conformidade com as restrições do estilo de arquitetura REST e permite a interação com serviços da web, REST significa transferência de estado representacional. A aplicação em Vue serve como nosso cliente rest, responsavél por lidar com a requisições a serviço REST. O Serviço REST é a api desenvolvida com o Spring Boot onde são definidos os endpoints para a realização das requisições pelo cliente.
|
|
|
|
|
|
|
|
## Definições do Modelo Arquitetural REST
|
|
|
|
|
|
|
|
* Arquitetura cliente-servidor: A interface do usuário do site / aplicativo deve ser separada da solicitação / armazenamento de dados, para que cada parte possa ser dimensionada individualmente.
|
|
|
|
|
|
|
|
* Statelessness: a comunicação deve ter no contexto do cliente armazenado no servidor. Isso significa que cada solicitação ao servidor deve ser feita com todos os dados necessários e nenhuma suposição deve ser feita se o servidor possui dados de solicitações anteriores.
|
|
|
|
|
|
|
|
* Sistema em camadas: o cliente não deve saber se está se comunicando diretamente com o servidor ou com algum intermediário. Esses servidores intermediários (sejam proxy ou balanceadores de carga) permitem escalabilidade e segurança do servidor subjacente.
|
|
|
|
|
|
|
|
## Fluxograma em alto nível de chamadas de uma API REST
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Estrutura de Arquivos do Backend
|
|
|
|
|
|
|
|
```
|
|
|
|
alpha-backend/
|
|
|
|
└── src/
|
|
|
|
├── main/
|
|
|
|
│ ├── java/
|
|
|
|
│ │ └── br.com.alpha.api/
|
|
|
|
│ │ ├── api/
|
|
|
|
│ │ │ ├── controller/
|
|
|
|
│ │ │ │ └── ExampleController.ja
|
|
|
|
│ │ │ └── ExampleApi.java
|
|
|
|
│ │ ├── config/
|
|
|
|
│ │ │ └── ExampleConfig.java
|
|
|
|
│ │ ├── dto/
|
|
|
|
│ │ │ └── ExampleDto.java
|
|
|
|
│ │ ├── exception/
|
|
|
|
│ │ │ └── ExampleException.java
|
|
|
|
│ │ ├── handler/
|
|
|
|
│ │ │ └── ExampleHandler.java
|
|
|
|
│ │ ├── mapper/
|
|
|
|
│ │ │ └── ExampleMapper.java
|
|
|
|
│ │ ├── model/
|
|
|
|
│ │ │ ├── entity/
|
|
|
|
│ │ │ │ └── ExampleEntity.ja
|
|
|
|
│ │ │ └── enumeration/
|
|
|
|
│ │ │ └── enum.java
|
|
|
|
│ │ ├── repository/
|
|
|
|
│ │ │ └── ExampleRepository.java
|
|
|
|
│ │ ├── service/
|
|
|
|
│ │ │ ├── ExampleService.java
|
|
|
|
│ │ │ └── impl/
|
|
|
|
│ │ │ └── ExampleServiceImpl.java
|
|
|
|
│ │ ├── validator/
|
|
|
|
│ │ │ ├── ExampleValidator.java
|
|
|
|
│ │ │ └──
|
|
|
|
│ └── resources
|
|
|
|
│ └── application.yml
|
|
|
|
└── test/
|
|
|
|
```
|
|
|
|
|
|
|
|
### Explicativo dos diretórios do backend
|
|
|
|
|
|
|
|
**api**: Impelementação dos endpoints da aplicação, no direitorio _controller_ estão os contratos do endpoints que possuem as anotações do swagger para documentação da api no código.
|
|
|
|
|
|
|
|
**config**: Arquivos anotados com anotação @Configuration, para indicar as classes que serão usadas para configurações e definições de beans.
|
|
|
|
|
|
|
|
**dto**: Classes java para comunicação rest entre a backend e o front, com a finalidade de não expor as classes de domínios.
|
|
|
|
|
|
|
|
**exception**: Classes customizadas para lançamento de exceção.
|
|
|
|
|
|
|
|
**handler**: Classe responsável por lidar e formatar as exceções lançadas no backened para melhor entendimento do erro no frontend.
|
|
|
|
|
|
|
|
**model**: Classes que descrevem o nosso modelo de domínio, sendo a representação visual de classes conceituais ou objetos do mundo real em um domínio de interesse, também representam as entidades da modelagem do banco de dados.
|
|
|
|
|
|
|
|
**Repository**: Interface JPA para comunicação com o banco de dados.
|
|
|
|
|
|
|
|
**service**: Classes responsáveis pela lógica de negócio.
|
|
|
|
|
|
|
|
**validator**: Classes com o intuito de validar os dados das requisições que vem do cliente.
|
|
|
|
|
|
|
|
**resources**: Recursos e configurações de propriedades da aplicação.
|
|
|
|
|
|
|
|
|
|
|
|
# Estrutura de Arquivos do Frontend
|
|
|
|
|
|
|
|
```plaintext
|
|
|
|
alpha-frontend/
|
|
|
|
└── src/
|
|
|
|
| ├── assets/
|
|
|
|
| │ └── Example.png
|
|
|
|
| └── components/
|
|
|
|
| | ├── buttons/
|
|
|
|
| | │ └── ExampleButton.vue
|
|
|
|
| | ├── modals/
|
|
|
|
| | │ └── Example.vue
|
|
|
|
| | └── Example.vue
|
|
|
|
| ├── screens/
|
|
|
|
| │ ├── Example.vue
|
|
|
|
| ├── store/
|
|
|
|
| | └── Example.js
|
|
|
|
| ├── .gitignore
|
|
|
|
├── public/
|
|
|
|
| └── Example.ico
|
|
|
|
├── babel.config.js
|
|
|
|
└── package.json
|
|
|
|
```
|
|
|
|
|
|
|
|
### Explicativo dos diretórios do frontend
|
|
|
|
|
|
|
|
**assets**: Arquivos estáticos como imagens para serem carregados em tela.
|
|
|
|
|
|
|
|
**components**: Classes dos componentes reutilizáveis usados em tela.
|
|
|
|
|
|
|
|
**screens**: Classes que representam as telas do cliente.
|
|
|
|
|
|
|
|
**store**: Classes que contém os endpoints das requisições dos serviços utilizados pelo cliente.
|
|
|
|
|
|
|
|
|
|
|
|
 |
