DSL em Java: criando linguagens específicas de domínio do zero

Seu código fala a linguagem dos negócios? Hora de criar DSL em Java

Imagine: você não escreve mais aqueles chatos if-else e for, mas sim um código que se lê como uma instrução para um colega. Não acredita? Pois é. As linguagens específicas de domínio (DSL) em Java não são mágica, mas sim uma ferramenta pragmática que transforma lógica complexa em construções elegantes.

Neste artigo, vamos explorar como criar uma DSL em Java que tornará seu código mais limpo e o trabalho com ele mais compreensível para analistas de negócios. Você aprenderá a diferença entre uma DSL interna e uma externa, como construir uma fluent API e quando vale a pena criar seu próprio parser. Vamos nessa!

O que é DSL e por que um desenvolvedor Java precisa dela?

DSL (Domain-Specific Language) é uma linguagem criada para resolver problemas em um domínio específico. Ao contrário de uma linguagem de programação de propósito geral (Java, Python), a DSL é estreitamente especializada. Exemplos da vida real: SQL para bancos de dados, expressões regulares para manipulação de strings, HTML para desenvolvimento web.

Em Java, a DSL é usada para:

\n
• Aumentar a legibilidade do código — a lógica de negócios se torna declarativa;
\n
• Reduzir a barreira de entrada — analistas podem ajustar regras sem conhecimento profundo de Java;
\n
• Diminuir o número de erros — a sintaxe limitada impede ações inadequadas;
\n
• Acelerar o desenvolvimento — em vez de milhares de linhas de código, dezenas de comandos claros.
\n

Importante: criar uma DSL em Java não exige escrever um compilador. Na maioria das vezes, usamos DSLs internas — camadas sobre a sintaxe padrão do Java.

DSL Interna vs DSL Externa: qual escolher?

DSLs Internas (Embedded DSL)

São DSLs que vivem dentro do Java. Você usa métodos, encadeamento de chamadas, lambdas e sobrecarga de operadores (através de métodos). Exemplo: a Java Stream API é uma DSL interna para processamento de coleções.

List<String> result = orders.stream()\n    .filter(o -> o.getAmount() > 1000)\n    .map(Order::getCustomerName)\n    .collect(Collectors.toList());

Vantagens: não precisa escrever um parser, é totalmente integrada ao Java, fácil de debugar. Desvantagens: a sintaxe é limitada pelas capacidades do Java.

DSLs Externas (External DSL)

São linguagens separadas com sua própria sintaxe. Você escreve um parser (por exemplo, com ANTLR ou JavaCC) e um interpretador. Exemplo: SQL é uma DSL externa que você envia para o banco de dados.

Vantagens: total liberdade de sintaxe, pode ficar muito elegante. Desvantagens: é necessário escrever e manter um parser, mais difícil de debugar.

Para a maioria das tarefas, uma DSL interna é suficiente. DSLs externas são justificadas quando a linguagem será usada por muitas pessoas (como o SQL) ou quando a sintaxe é fundamentalmente importante.

Prática: criando uma DSL interna em Java para um sistema de monitoramento

Suponha que estamos construindo um sistema de monitoramento de servidores. Em vez de escrever:

AlertRule rule = new AlertRule();\nrule.setMetric("cpu_usage");\nrule.setOperator(GREATER_THAN);\nrule.setThreshold(90.0);\nrule.setDuration(5, TimeUnit.MINUTES);\nrule.setAction(new SendEmailAction("admin@example.com"));

Queremos escrever assim:

AlertRule rule = AlertRuleBuilder\n    .whenMetric("cpu_usage")\n    .isGreaterThan(90.0)\n    .forDuration(5, TimeUnit.MINUTES)\n    .thenSendEmail("admin@example.com")\n    .build();

Bonito, não é? Vamos implementar essa fluent API.

Passo 1: Criar a classe AlertRule

public class AlertRule {\n    private String metric;\n    private String operator;\n    private double threshold;\n    private long duration;\n    private TimeUnit timeUnit;\n    private String actionType;\n    private String actionTarget;\n\n    // Getters e setters omitidos para brevidade\n}

Passo 2: Construir o builder com fluent API