Is there a standard library/API/tool for implementing basic "rule chains" in Java? -
i writing servlet conditionally modifying http headers according user-definable rules. (edit: these rules defined in xml file read @ start-up.) example, add "x-ua-compatible: ie=edge,chrome=1" response header if not exist , if request specified "user-agent" header matching known pattern. not having better ideas, attempted make own pojos representing these rules. "works" feel there must more standard or more flexible way this.
are there general-purpose libraries or tools (whether built-in or 3rd-party) solve problem? have heard , read little "rules engines" seem more complex/heavy tools not meant problems simple mine.
to illustrate i'm trying do, i've created simplified program applies "rules" numbers based on "conditions" "is number". here is, sorry it's bit lengthy.
main.java
package my.example; import java.util.*; import my.example.conditions.*; import my.example.rules.*; public class main { public static void main(string args[]) { // sample objects evaluate collection<integer> numbers = arrays.aslist(0, 1, 2, 3, 4, 5, 6, 7, 8); print(numbers); // define rules collection<rule<integer>> rules = new arraylist<rule<integer>>(); rules.add(createruletomultiplyevennumbersby4()); rules.add(createruletoadd1toeverynumber()); // process rules each sample object collection<integer> newnumbers = new arraylist<integer>(); (integer number : numbers) { integer newnumber = number; (rule<integer> rule : rules) newnumber = rule.apply(newnumber); newnumbers.add(newnumber); } print(newnumbers); } private static rule<integer> createruletomultiplyevennumbersby4() { multiplynumberrule rule = new multiplynumberrule(true, 4); rule.addcondition(new numberisevencondition()); return rule; } private static rule<integer> createruletoadd1toeverynumber() { addnumberrule rule = new addnumberrule(true, 1); rule.addcondition(new constantcondition<integer>(true)); return rule; } private static void print(collection<integer> numbers) { system.out.print("numbers: "); (integer number : numbers) { system.out.print(number); system.out.print(" "); } system.out.print("\r\n"); } } condition.java
package my.example.conditions; public interface condition<t> { boolean appliesto(t obj); } constantcondition.java
package my.example.conditions; public class constantcondition<t> implements condition<t> { private boolean constant; public constantcondition(boolean alwaysreturnthisvalue) { constant = alwaysreturnthisvalue; } @override public boolean appliesto(t target) { return constant; } } numberisevencondition.java
package my.example.conditions; public class numberisevencondition implements condition<integer> { @override public boolean appliesto(integer i) { return (i % 2 == 0); } } rule.java
package my.example.rules; public interface rule<t> { t apply(t target); } abstractrule.java
package my.example.rules; import java.util.*; import my.example.conditions.condition; public abstract class abstractrule<t> implements rule<t> { private collection<condition<t>> conditions; private boolean requireallconditions; public abstractrule(boolean requireallconditions) { conditions = new arraylist<condition<t>>(); this.requireallconditions = requireallconditions; } public void addcondition(condition<t> condition) { conditions.add(condition); } @override public t apply(t target) { boolean isapplicable; if (requireallconditions) isapplicable = allconditionssatisfied(target); else isapplicable = atleastoneconditionsatisfied(target); if (isapplicable) target = process(target); return target; } // check if conditions met protected boolean allconditionssatisfied(t target) { (condition<t> condition : conditions) { if (!condition.appliesto(target)) return false; } return true; } // check if conditions met protected boolean atleastoneconditionsatisfied(t target) { (condition<t> condition : conditions) { if (condition.appliesto(target)) return true; } return false; } abstract t process(t target); } addnumberrule.java
package my.example.rules; public class addnumberrule extends abstractrule<integer> { private integer addend; public addnumberrule(boolean requireallconditions) { this(requireallconditions, 0); } public addnumberrule(boolean requireallconditions, integer addend) { super(requireallconditions); this.addend = addend; } @override public integer process(integer i) { return + addend; } } multiplynumberrule.java
package my.example.rules; public class multiplynumberrule extends abstractrule<integer> { private integer factor; public multiplynumberrule(boolean requireallconditions) { this(requireallconditions, 1); } public multiplynumberrule(boolean requireallconditions, integer factor) { super(requireallconditions); this.factor = factor; } @override public integer process(integer i) { return * factor; } }
well, i'd use commons chain
a popular technique organizing execution of complex processing flows "chain of responsibility" pattern, described (among many other places) in classic "gang of four" design patterns book. although fundamental api contracts required implement design patten extremely simple, useful have base api facilitates using pattern, , (more importantly) encouraging composition of command implementations multiple diverse sources.
it's common design pattern, guess fits problem
Comments
Post a Comment