Lista de mecanismos de regras em Java

1. Visão geral

Neste artigo, veremos alguns dos mecanismos de regras mais populares para Java.

Em aplicativos de missão crítica, o processo de manutenção da lógica de negócios no código-fonte pode se tornar muito complicado. As regras de negócios podem ser usadas para facilitar o desenvolvimento e a manutenção, separando a lógica de negócios do código-fonte.

No mundo Java, a maioria das bibliotecas de mecanismos de regras implementa o padrão JSR94 conhecido comoJava Rule API Engine.

2. Drools

Drools é uma solução de Sistema de Gerenciamento de Regras de Negócios (BRMS). Drools podem ser integrados ao jBPM, uma ferramenta de Gerenciamento de Processos de Negócios para padronização de processos, atividades de eventos, tarefas, etc.

Se você quiser ler mais, uma introdução ao Drools está disponívelhere, junto com um artigo sobreintegration with Spring.

3. Tablets OpenL

OpenL Tablets é um sistema de gerenciamento de regras de negócios e um mecanismo de regras de negócios baseado em tabelas de decisão do Excel. Como o formato das tabelas usadas por essa estrutura é familiar para os usuários corporativos, preenche a lacuna entre usuários corporativos e desenvolvedores.

Aqui está um exemplo simples de como a estrutura funciona usando um arquivo do Excel que contém tabelas de decisão. Primeiro, vamos importar suas dependências que dependem dos módulosorg.openl.coreeorg.openl.rules:


    org.openl
    org.openl.core
    5.19.4


    org.openl.rules
    org.openl.rules
    5.19.4

Agora, um POJOUser:

public class User {
    private String name;
    // getters and setters
}

E uma enumeração que representará o resultado das regras aplicadas:

public enum Greeting {
    // ...
}

A classeCase envolve o objetoUser com variáveis que levam aos resultados:

public class Case {
    // Variables to infer outcomes
    // getters and setters
}

A interfaceIRule contém a regra injetada pelo arquivo Excel:

public interface IRule {
    void helloUser(Case aCase, final Response response);
}

A classeResponse lida com o retorno da regra aplicada:

public class Response {
    private String result;
    private Map map = new HashMap<>();
}

A classe principal, que aciona a execução da regra:

public class Main {
    private IRule instance;

    public static void main(String[] args) {
        Main rules = new Main();
        // setup user and case here
        rules.process(aCase);
    }

    public void process(Case aCase) {
        EngineFactory engineFactory = new RulesEngineFactory(
          getClass().getClassLoader()
            .getResource("openltablets/HelloUser.xls"), IRule.class);
        instance = engineFactory.newEngineInstance();
        instance.helloUser(aCase, new Response());
    }
}

4. Regras fáceis

O Easy Rules é um mecanismo de regras Java simples que fornece uma estrutura leve e baseada em POJO para definir negócios. Ele pode criar regras complexas a partir de regras primitivas usando o padrão composto.

Essa estrutura, em contraste com os mecanismos de regras mais tradicionais, não utiliza arquivos XML ou arquivos de idioma específico do domínio para separar regras do aplicativo. Ele usa classes e métodos baseados em anotação para injetar lógica de negócios no aplicativo.

Regras fáceis podem ser úteis para desenvolvedores criar e manter aplicativos com lógica de negócios que é totalmente separada do próprio aplicativo. Por outro lado, comothis framework doesn’t implement the JSR94 standarde a lógica de negócios deve ser codificada diretamente para o código Java.

Aqui nós fornecemos um exemplo "Olá, mundo". Vamos importar as dependências necessárias com base no móduloeasy-rules-core:


    org.jeasy
    easy-rules-core
    3.0.0

Em seguida, criamos uma classe que define uma regra:

@Rule(name = "Hello World rule", description = "Always say hello world")
public class HelloWorldRule {

    @Condition
    public boolean when() {
        return true;
    }

    @Action
    public void then() throws Exception {
        System.out.println("hello world");
    }
}

Por fim, criamos a classe principal:

public class Launcher {
    public static void main(String... args) {
        // create facts
        Facts facts = new Facts();

        // create rules
        Rules rules = new Rules();
        rules.register(new HelloWorldRule());

        // create a rules engine and fire rules on known facts
        RulesEngine rulesEngine = new DefaultRulesEngine();
        rulesEngine.fire(rules, facts);
    }
}

5. Livro de Regras

O RuleBook é uma estrutura Java que utiliza o Java 8 lambdas e o Padrão de Cadeia de Responsabilidade para definir regras usando a abordagem simples do BDD.

Como a maioria dos mecanismos de regras, o RuleBook usa o conceito de “Facts”, que são dados fornecidos às regras. O RuleBook permite que as regras modifiquem o estado dos fatos, que podem ser lidas e modificadas por regras mais abaixo na cadeia. Para aquelas regras que lêem dados (Facts) de um tipo e geram um resultado de um tipo diferente, o RuleBook temDecisions.

O RuleBook pode ser integrado ao Spring usando Java DSL.

Aqui, fornecemos um exemplo simples "Olá, mundo" usando o RuleBook. Vamos adicionar sua dependência que está contando com o módulorulebook-core:


    com.deliveredtechnologies
    rulebook-core
    0.6.2

Agora, criamos a regra:

public class HelloWorldRule {
    public RuleBook

TOC

Lista de mecanismos de regras em Java