Lista de motores de reglas en Java

1. Información general

En este artículo, veremos algunos de los motores de reglas más populares para Java.

Dentro de las aplicaciones de misión crítica, el proceso de mantener la lógica empresarial dentro del código fuente puede volverse demasiado complicado. Las reglas comerciales se pueden utilizar para facilitar el desarrollo y el mantenimiento separando la lógica comercial del código fuente.

En el mundo de Java, la mayoría de las bibliotecas de motores de reglas implementan el estándar JSR94 conocido como Java Rule API Engine.

2. Babea

Drools es una solución de Business Rules Management System (BRMS). Drools puede integrarse con jBPM, una herramienta de gestión de procesos de negocio para estandarizar procesos, actividades de eventos, tareas, etc.

Si desea leer más, una introducción a Drools está disponible aquí, junto con un artículo sobre la integración con Spring.

3. Tabletas OpenL

OpenL Tablets es un sistema de gestión de reglas comerciales y un motor de reglas comerciales basado en tablas de decisiones de Excel. Dado que el formato de tablas utilizado por este marco es familiar para los usuarios comerciales, cierra la brecha entre los usuarios comerciales y los desarrolladores.

Aquí hay un ejemplo simple de cómo funciona el marco mediante el uso de un archivo de Excel que contiene tablas de decisiones. Primero, importemos sus dependencias que dependen de los módulos org.openl.core y org.openl.rules:

 org.openl org.openl.core 5.19.4   org.openl.rules org.openl.rules 5.19.4 

Ahora, un usuario POJO:

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

Y una enumeración que representará el resultado de las reglas aplicadas:

public enum Greeting { // ... }

La clase Case envuelve el objeto Usuario con variables que conducen a resultados:

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

La interfaz IRule contiene la regla inyectada por el archivo de Excel:

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

La clase Response maneja la devolución de la regla aplicada:

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

La clase principal, que desencadena la ejecución de la regla:

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. Reglas fáciles

Easy Rules es un motor de reglas Java simple que proporciona un marco ligero y basado en POJO para definir negocios. Puede crear reglas complejas a partir de las primitivas utilizando el patrón compuesto.

Este marco, a diferencia de los motores de reglas más tradicionales, no utiliza archivos XML ni ningún archivo de lenguaje específico de dominio para separar las reglas de la aplicación. Utiliza clases y métodos basados ​​en anotaciones para inyectar lógica empresarial en la aplicación.

Easy Rules puede ser útil para que los desarrolladores creen y mantengan aplicaciones con una lógica empresarial que está completamente separada de la aplicación misma. Por otro lado, como este marco no implementa el estándar JSR94 y la lógica empresarial debe codificarse directamente en código Java.

Aquí proporcionamos un ejemplo de "Hola, mundo". Importemos las dependencias requeridas basadas en el módulo easy-rules-core:

 org.jeasy easy-rules-core 3.0.0 

A continuación, creamos una clase que define una regla:

@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"); } }

Finalmente, creamos la clase 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. Libro de reglas

RuleBook es un marco de trabajo de Java que aprovecha las lambdas de Java 8 y el patrón de cadena de responsabilidad para definir reglas utilizando un enfoque BDD simple.

Como la mayoría de los motores de reglas, RuleBook hace uso del concepto de " hechos ", que son datos proporcionados a las reglas. RuleBook permite que las reglas modifiquen el estado de los hechos, que luego pueden leerse y modificarse mediante reglas más adelante en la cadena. Para aquellas reglas que leen datos ( Hechos ) de un tipo y generan un resultado de otro tipo, RuleBook tiene Decisiones .

RuleBook se puede integrar con Spring usando Java DSL.

Aquí, proporcionamos un ejemplo simple de "Hola, mundo" usando RuleBook. Agreguemos su dependencia que se basa en el módulo principal del libro de reglas:

 com.deliveredtechnologies rulebook-core 0.6.2 

Ahora, creamos la regla:

public class HelloWorldRule { public RuleBook defineHelloWorldRules() { return RuleBookBuilder .create() .addRule(rule -> rule.withNoSpecifiedFactType() .then(f -> System.out.print("Hello "))) .addRule(rule -> rule.withNoSpecifiedFactType() .then(f -> System.out.println("World"))) .build(); } } 

Finalmente, la clase principal:

public static void main(String[] args) { HelloWorldRule ruleBook = new HelloWorldRule(); ruleBook .defineHelloWorldRules() .run(new FactMap()); } 

6. Conclusión

En este artículo rápido, analizamos algunas bibliotecas conocidas que proporcionan motores para la abstracción de la lógica empresarial.

Como siempre, los ejemplos de este artículo están disponibles en nuestro repositorio de GitHub.