Un patrón de diseño simple para desarrollar un pequeño Rule-Engine

Question

Tengo un requisito que toma muchas reglas validadas contra los objetos de valor de Java y produce resultados. (No podemos usar ninguna aplicación de motor de reglas en nuestra empresa, muchos trámites y muchas preguntas para responder). Entonces, en lugar de implementar las reglas como si fuesen 'en código Java, sugerí implementar un motor de reglas pequeño, simple y extensible. ¿Qué patrón de diseño seguir?

He añadido debajo una estructura xml aproximada de las reglas definidas.

<rule-set>  
    <name>Example1</name> 
    <description>Example rules defined</description> 

    <beans> 
     <bean class="com.example.Customer" alias="cust"/> 
     <bean class="com.example.Account" alias="acnt"/> 
     <bean class="com.example.Transaction" alias="trans"/> 
    </beans> 

    <rule name="CustomerInfo" description="This rule validates if all the customer values are present"> 
     <if lhs="cust.getFirstName" rhs="null" operator="!="/> 
     <if lhs="cust.getLastName" rhs="null" operator="!=" logicaloperator="&amp;&amp;"/> 
     <if lhs="cust.getCountry" rhs="null" operator="!=" logicaloperator="||"/> 
     <if lhs="cust.getCity" rhs="null" operator="!=" logicaloperator="&amp;&amp;"/> 
     <if lhs="cust.getPhone" rhs="null" operator="!=" logicaloperator="&amp;&amp;"/> 
     <if lhs="cust.getEmail" rhs="null" operator="!=" logicaloperator="&amp;&amp;"/> 
     <then do="cust.completeFlag" arg1="true"/> 
    </rule> 

    <rule name="Transaction" description="Transfer the money from one ac to another"> 
     <if lhs="trans.fromAccount" operator="!=" rhs="null"/> 
     <if lhs="trans.toAccount" operator="!=" rhs="null"/> 
     <if lhs="trans.fromAccount.balance" operator=">" rhs="trans.getTransaferAmount"/> 
     <then do="trans.fromAccount.debit" arg1="trans.getTransaferAmount"/> 
     <then do="trans.toAccount.credit" arg1="trans.getTransaferAmount"/> 
    </rule> 

</rule-set> 

Answer 1

Yo recomendaría una Factory Method Pattern. Cada regla tendrá una fábrica que pueda crear esas reglas. Luego encapsularía todas estas fábricas de reglas en un Abstract Factory.

O bien, puede crear un Motor de reglas como generador (utilizando un Builder Pattern) que permita pasar conjuntos de reglas y construir una regla.

Eso es lo que haría mejor, pero dado que no conozco los requisitos exactos de su motor de reglas, eso fue lo que se le ocurrió.

¿Quizás un Strategy Pattern podría ayudarle?

Answer 2

Realmente depende de la complejidad de las reglas que está tratando de implementar. La idea clave en la programación declarativa es que las reglas se tratan como datos. Entonces, la forma más sencilla de comenzar es ver si todas sus reglas se pueden representar como datos en una tabla. Por ejemplo, si sus reglas son del tipo si a = 10, entonces b = 7, entonces puede representar lo mismo en una tabla y escribir un método genérico que pueda manejar todos sus casos.

Por otro lado, si sus reglas permiten múltiples condiciones (y/o cláusulas, así como operadores de comparación), un diseño basado en tablas no ayudará.

En ese caso, debe especificar la gramática de sus reglas, generar un lexer y un analizador. El analizador analizaría tus reglas reales en un árbol de sintaxis abstracta. Una vez que llegue a esa etapa, puede tomar ese árbol y dirigirlo a un motor de reglas existente o su propio motor de reglas que sepa cómo ejecutar el árbol.

Answer 3

No es exactamente lo que usted pidió (es decir, el patrón), pero tal vez pueda encontrar el siguiente enfoque útil si desea rodar su propia:

http://mcqueeney.com/blog/creating-a-simple-rules-engine-using-the-java-scripting-api/