APLICANDO PRINCÍPIOS SOLID PARA ESCALABILIDADE EM UMA APLICAÇÃO RUST DE VERIFICAÇÃO DE SAÚDE
1. Introdução
Neste artigo, apresentamos uma aplicação desenvolvida em Rust, onde as principais funcionalidades foram organizadas em módulos distintos. O objetivo do aplicativo é oferecer ao usuário quatro tipos de verificações de saúde, permitindo a escolha entre realizar todas ou apenas uma delas. Considerando a possibilidade de expansão futura para incluir novas verificações, a arquitetura foi planejada para ser flexível e extensível desde o início. O conteúdo é direcionado a desenvolvedores com conhecimento intermediário em Rust, interessados em aplicar boas práticas de design de software, especialmente os princípios SOLID, para garantir manutenibilidade e escalabilidade.
2. Justificativa para a aplicação do padrão SOLID
A adoção dos princípios SOLID é fundamental para o desenvolvimento desta aplicação em Rust, pois garante que o código seja modular, de fácil manutenção e preparado para futuras expansões. Ao seguir SOLID, evitamos a criação de módulos monolíticos e promovemos a separação clara de responsabilidades, facilitando a adição de novas verificações de saúde sem impactar funcionalidades já existentes.
Vantagens gerais:
- Facilita a manutenção e evolução do código.
- Reduz o acoplamento entre módulos.
- Melhora a legibilidade e testabilidade da aplicação.
Ganho técnico: A principal vantagem técnica é a possibilidade de adicionar novas verificações de saúde de forma simples, apenas criando novos módulos e implementando as interfaces necessárias, sem alterar o código já existente, minimizando riscos de regressão.
3. Fundamentos técnicos da arquitetura da solução
A aplicação está estruturada em múltiplos módulos, cada um responsável por uma verificação de saúde específica (por exemplo, pressão arterial, glicemia, IMC, frequência cardíaca). Cada módulo é implementado como um arquivo separado dentro do diretório src, seguindo o padrão de organização de projetos Rust.
O padrão SOLID se manifesta principalmente através da definição de traits (interfaces) para as verificações, permitindo que cada módulo implemente sua lógica de forma independente. O diretório src contém arquivos como body_fat.rs, bmi/calculator.rs, metabolism/tmb.rs e whr/calculator.rs, além do arquivo principal main.rs.
Ferramentas e dependências:
- Rust padrão (sem dependências externas obrigatórias).
- Ferramenta de testes integrada:
cargo test.
4. Detalhamento da implementação
Implementação dos módulos
Cada módulo define uma struct e implementa um trait comum chamado HealthCheck, que exige o método run_check().
Exemplo de trait e módulo (Exemplo teórico):
// src/health_check.rs
pub trait HealthCheck {
fn run_check(&self) -> String;
}
// src/blood_pressure.rs
use crate::health_check::HealthCheck;
pub struct BloodPressureCheck;
impl HealthCheck for BloodPressureCheck {
fn run_check(&self) -> String {
"Verificação de pressão arterial realizada.".to_string()
}
}
Os demais módulos (body_fat.rs, bmi/calculator.rs, metabolism/tmb.rs e whr/calculator.rs) seguem o mesmo padrão, mudando apenas a lógica interna de cada verificação.
Implementação no main.rs
O arquivo main.rs importa os módulos e permite ao usuário escolher quais verificações deseja realizar. O código utiliza polimorfismo para tratar as verificações de forma genérica.
(Exemplo teórico)
// src/main.rs
mod health_check;
mod blood_pressure;
mod glucose;
mod bmi;
mod heart_rate;
use health_check::HealthCheck;
use blood_pressure::BloodPressureCheck;
use glucose::GlucoseCheck;
use bmi::BmiCheck;
use heart_rate::HeartRateCheck;
fn main() {
let checks: Vec<Box<dyn HealthCheck>> = vec![
Box::new(BloodPressureCheck),
Box::new(GlucoseCheck),
Box::new(BmiCheck),
Box::new(HeartRateCheck),
];
for check in checks {
println!("{}", check.run_check());
}
}
5. Testes e validação
Todos os testes foram realizados utilizando a ferramenta padrão do Rust, o cargo test.
Testes unitários:
Cada módulo possui seus próprios testes unitários, garantindo que a lógica de cada verificação funcione corretamente. (Exemplo do projeto)
#[test]
fn test_calculate_male() {
let data = BodyFatData {
weight: 70.0,
height: 1.75,
age: 30,
gender: Gender::Male,
};
// verifica se próximo ao valor 22.86 para homens.
let bmi = BodyFatCalculator::calculate_bmi(&data);
assert!((bmi - 22.86).abs() < 1e-2);
}
Testes de integração:
O arquivo integration_main.rs contém testes de integração, validando o funcionamento conjunto dos módulos e a integração com o main.rs. (Exemplo do projeto)
use fourv_saude::bmi::calculator::{BmiCalculator, BmiData};
use fourv_saude::body_fat::{BodyFatCalculator, BodyFatData};
#[test]
fn integration_bmi_and_body_fat_male() {
// Dados de exemplo para um homem
let data = BodyFatData {
weight: 80.0,
height: 1.80,
age: 35,
gender: Gender::Male,
};
// Calcula o BMI usando o módulo BMI
let bmi = BodyFatCalculator::calculate_bmi(&data);
assert!((bmi - BmiCalculator::calculate(&BmiData { weight: 80.0, height: 1.80 })).abs() < 1e-2);
// Calcula o percentual de gordura corporal usando o BMI calculado
let pgc = BodyFatCalculator::calculate_pgc(bmi, data.age, &data.gender);
6. Comparações com outras linguagens
Comparando com C++, Python ou Java, Rust oferece vantagens como:
- Segurança de memória: Rust previne erros comuns de ponteiros e vazamentos de memória sem precisar de garbage collector.
- Performance: O desempenho é comparável ao C++, mas com garantias de segurança em tempo de compilação.
7. Considerações finais
A aplicação demonstrou que a adoção dos princípios SOLID em Rust facilita a manutenção e expansão do sistema. Entre as limitações, destaca-se a ausência de interface gráfica e a dependência de execução via terminal. Para melhorias futuras, recomenda-se a implementação de uma interface web e a inclusão de novas verificações de saúde.
8. Referências
- Autor: Sandro Reis. (Com apoio de prompts de IA)
- Canal Youtube: https://www.youtube.com/@veteranoedev
- Link do repositório no Github: https://github.com/consultorsandro/4V_HEALTH.git
- Link da documentação oficial da linguagem: https://doc.rust-lang.org/book/
