Rule Engine--规则引擎

来自: http://udoo.51.net/mt/archives/000010.html

The drools engine uses a modified form of the Rete algorithm called the Rete-OO algorithm. Internally it operates using the same concepts and methods as Forgy's original but adds some node types required for seemless integration with an object-oriented language.
OFBiz Rule Engine Backward chaining is supported. Original code base from "Building Parsers in Java" by Steven John Metsker.
Mandarax Based on backward reasoning. The easy integration of all kinds of data sources. E.g., database records can be easily integrated as sets of facts and reflection is used in order to integrate functionality available in the object model.
Algernon Efficient and concise KB traversal and retrieval. Straightforward access to ontology classes and instances. Supports both forward and backward chaining.
TyRuBa TyRuBa supports higher order logic programming: variables and compound terms are allowed everywhere in queries and rules, also in the position of a functor- or predicate-name. TyRuBa speeds up execution by making specialized copies of the rule-base for each query in the program. It does so incrementally while executing a logic program and builds an index for fast access to rules and facts in the rule base, tuned to the program that is running. The indexing techniques works also for higher-order logic. TyRuBa does 'tabling' of query results.
JTP Java Theorem Prover is based on a very simple and general reasoning architecture. The modular character of the architecture makes it easy to extend the system by adding new reasoning modules (reasoners), or by customizing or rearranging existing ones.
JEOPS JEOPS adds forward chaining, first-order production rules to Java through a set of classes designed to provide this language with some kind of declarative programming.
InfoSapient Semantics of business rules expressed using fuzzy logic.
JShop Simple Hierarchical Ordered Planner (SHOP) written in Java.
RDFExpert RDF-driven expert system shell. The RDFExpert software uses Brian McBride's JENA API and parser. A simple expert system shell that uses RDF for all of its input: knowledge base, inference rules and elements of the resolution strategy employed. It supports forward and backward chaining.
Jena 2 - Jena is a Java framework for writing Semantic Web applications. Jena2 has a reasoner subsystem which includes a generic rule based inference engine together with configured rule sets for RDFS and for the OWL/Lite subset of OWL Full. These reasoners can be used to construct inference models which show the RDF statements entailed by the data being reasoned over. The subsystem is designed to be extensible so that it should be possible to plug a range of external reasoners into Jena, though worked examples of doing so are left to a future release.

其它的：
http://www.pst.com/opsj.htm
http://drools.org/index.html
http://herzberg.ca.sandia.gov/jess/
http://www.ilog.com/

Try those rule solutions before rolling your own.

And, if you're going to create your own rule evaluation engine, at least make it JSR-94 compliant.

http://www.jcp.org/en/jsr/detail?id=94
http://www.idiomsoftware.com
http://www.resolutionebs.com/products.html
http://www.urbandictionary.com
http://www.caucho.com/hessian/

http://www.alphaworks.ibm.com/tech/commonrules
JxBRE - http://sourceforge.net/projects/jxbre
OPSJ: http://www.pst.com (Faster than greased lightning)
Jess: http://herzberg.ca.sandia.gov/jess/ (2nd fastest)
JRules: http://www.ilog.com/products/jrules/ (3rd fastest, lots of bells and whistles)
Blaze Advisor: http://www.fairisaac.com/Fairisaac/Solutions/Enterprise+Decision+Tools/Blaze+Advisor+Rules+Management+Technology.htm