Episódio 17 – Reatividade temporal e comportamento automático com base em tempo decorrido
A essa altura, já mostramos como construir uma estrutura dinâmica para execução de ações, inclusive com suporte a filtros, condicionais e parâmetros vindos de JSON. Mas ainda estamos trabalhando com um modelo "ativo": alguém precisa chamar a engine e dizer "execute agora".
Mas... e se as ações pudessem ser agendadas automaticamente? E se pudéssemos construir rotinas reativas, disparadas por tempo, eventos ou ciclos?
É aí que entra nosso próximo passo: reatividade programada.
⏱ O conceito de reatividade temporal
Imagine que seu sistema precise:
- Executar backups a cada 6 horas
- Verificar atualizações a cada 30 segundos
- Sincronizar dados com o servidor todos os dias às 3h
Essas ações não são disparadas por cliques ou chamadas manuais: elas reagem ao tempo, ao calendário, ao relógio.
💡 Uma arquitetura orientada ao ciclo
Para isso, vamos integrar nossa engine com um scheduler interno. A ideia é simples:
- Cada ação pode ter um gatilho de execução (manual, condicional ou temporizado)
- Se for temporizado, o sistema deve:
- Verificar se o tempo já expirou
- Executar a ação
- Reagendar, se necessário
Isso pode ser feito usando uma thread de verificação contínua, como uma "central de alarme" que percorre os agendamentos e dispara os que estão prontos.
🔄 Exemplo de estrutura reativa
{
"acao": "SincronizarDados",
"repetir": "diariamente",
"hora": "03:00"
}
Ou ainda:
{
"acao": "VerificarAtualizacoes",
"intervalo": "30 segundos"
}
Ou:
{
"acao": "ExecutarBackup",
"aCada": "6 horas"
}
Esses elementos serão traduzidos internamente para tarefas agendadas, que ficam sob vigilância de uma thread autônoma que só acorda para executar o necessário.
🧠 Benefícios da reatividade
- Você não precisa mais codificar chamadas explícitas
- As ações são executadas automaticamente, com base em tempo
- É possível ativar/desativar temporizadores por JSON
- O código do sistema fica limpo e focado na lógica de negócio
E o melhor: tudo isso sem framework, sem mágica, sem dependências externas. Puro Delphi, pura clareza.
Próximos passos
No próximo episódio, vamos mostrar como:
- Persistir agendamentos de tarefas entre execuções
- Tratar falhas e reagendamentos automáticos
- Integrar logs e alertas em uma engine que parece viva
Estamos chegando na maturidade dessa arquitetura. O próximo nível é a observabilidade.
