How chxvxxs/coinly-converter works
Tipo e propósito do projeto (o que seu diagrama precisa comunicar)
Pelo file_tree e README, isto é um aplicativo Java “console-based” (não é web, não é full-stack) cujo objetivo é:
• Exibir um menu interativo no terminal (mín. 6 opções de conversão).
• Buscar taxas de câmbio em tempo real via ExchangeRate-API usando java.net.http.HttpClient.
• Fazer parse de JSON com Gson.
• Calcular e exibir o valor convertido.
Então o “sistema” aqui é pequeno, mas o diagrama pode (e deve) ser bem explícito sobre:
• Camada de interação (console/UI)
• Camada de aplicação (orquestração do fluxo)
• Camada de integração (HTTP client + API externa)
• Configuração/segredos (variável de ambiente API_KEY_CONVERSION)
• Modelo/DTO de resposta (como a resposta vira um objeto via Gson)
• Fluxo de dados: input do usuário → request → JSON → taxa → cálculo → output
O que a estrutura de arquivos indica (componentes reais)
Pelos arquivos:
• Main.java: entrypoint + menu + captura de input + orquestração.
• SearchCoin.java: integração HTTP com ExchangeRate-API.
• Conversion.java: parsing/extração de taxa + cálculo da conversão.
Diagramas recomendados (para ficar “o mais acurado possível”)
Como é um projeto pequeno, eu desenharia 2 diagramas complementares:
C4 – System Context (nível 1)
Mostra o sistema e as dependências externas:
• Usuário
• Aplicação Conversor de Moedas (Java CLI)
• ExchangeRate-API (serviço externo)
• Ambiente do Sistema Operacional (onde vive API_KEY_CONVERSION)
Esse diagrama explica rapidamente “quem fala com quem” e quais fronteiras são externas.
Mostra as classes como componentes e o fluxo entre elas:
• Main (UI/Controller)
• SearchCoin (HTTP Gateway / External API Client)
• Conversion (Domain Service / Calculation + JSON parsing)
• Dependências técnicas: HttpClient, Gson
Componentes principais que você deve colocar no desenho
Separe em “o máximo de componentes possível” sem inventar microserviços:
Atores/Externos
OS Env Vars / Config (fonte da API key)
Dentro do aplicativo (Java CLI)
Main.java
• Menu (6 opções)
• Leitura de input (ex: Scanner)
• Chama SearchCoin e Conversion
• Exibe output e mensagens de erro
SearchCoin.java
• Monta URL (base/target ou base + rates)
• Lê API_KEY_CONVERSION
• Faz requisição HTTP (HttpClient)
• Retorna JSON (string) ou objeto parseado
Conversion.java
• Usa Gson para interpretar JSON
• Extrai taxa relevante (ex.: USD->BRL)
• Calcula valorConvertido = valorEntrada * taxa
• Devolve resultado formatado
Bibliotecas/Infra (como caixas menores ou “anotações”)
Relacionamentos e interações (setas que não podem faltar)
Modele isso com setas direcionais e rotuladas:
Usuário → Main
• “Seleciona opção / informa valor / moeda”
Main → SearchCoin
• “Solicita taxa para (base, target)”
SearchCoin → OS Env
• “Lê API_KEY_CONVERSION”
SearchCoin → ExchangeRate-API (HTTPS)
• “GET / endpoint + apiKey”
ExchangeRate-API → SearchCoin
• “JSON com taxas”
SearchCoin → Conversion
• “Entrega JSON + parâmetros (base/target/valor)” (ou “taxa” se SearchCoin já extrair)
Conversion → Gson
• “Parse JSON → objeto”
Conversion → Main
• “Retorna valor convertido / taxa usada”
Main → Usuário
• “Exibe resultado / erros”
Se quiser máxima precisão, acrescente fluxos alternativos (linhas tracejadas):
• Falha HTTP / sem internet
• API key ausente/inválida
• Opção inválida no menu
• Erro de parse JSON
Padrões/decisões arquiteturais a evidenciar (mesmo sendo simples)
• Separação de responsabilidades por classe:
• Main = interação/orquestração
• SearchCoin = integração com API externa
• Conversion = lógica de domínio (cálculo) + parsing
• Boundary clara com serviço externo (ExchangeRate-API)
• Config via variáveis de ambiente (não hardcode de segredos)
• Dependência explícita de bibliotecas (HttpClient/Gson)
Template textual de diagrama (o que você desenharia literalmente)
Context (C4 L1):
• [User] ⇄ (Coin Converter CLI - Java) ⇄ [ExchangeRate-API]
• (Coin Converter CLI - Java) ⇄ [OS Environment Variables: API_KEY_CONVERSION]
Component (interno):
• [User] → (Main.java: Menu/UI)
• (Main.java) → (SearchCoin.java: HTTP Client Wrapper)
• (SearchCoin.java) → (HttpClient)
• (HttpClient) → [ExchangeRate-API] (HTTPS)
• [ExchangeRate-API] → (HttpClient) → (SearchCoin.java) (JSON)
• (SearchCoin.java) → (Conversion.java: Parsing + Calculation)
• (Conversion.java) → (Gson) (parse)
• (Conversion.java) → (Main.java) (result)
• (Main.java) → [User] (print)
O que NÃO colocar (para não poluir)
• Não invente camadas que não existem (ex.: “database”, “backend server”, “queue”).
• Não desenhe “microservices” — é um executável console.
• Não detalhe IDE (.idea) ou arquivos de projeto (.iml) como arquitetura runtime.
Se você seguir isso, seu diagrama ficará extremamente fiel ao projeto: um CLI Java com 3 classes principais, dependências explícitas (HttpClient/Gson), uma integração externa (ExchangeRate-API) e configuração por variável de ambiente — tudo com setas claras de fluxo de dados e pontos de falha bem definidos.