Drools Developer’s Cookbook – PDF Free Download

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Artificial Intelligence A. Knowledge representation is the area of A. Expert Systems use Knowledge representation to facilitate the codification of knowledge into a knowledge base which can be used for reasoning, i. Expert Systems are also known as Knowledge-based Systems and Knowledge-based Downloa Systems and are considered to be “applied artificial intelligence”. The process of developing with an Expert System is Downnload Engineering. Whereas early Gulde Systems had their logic drools expert user guide pdf free download, “shells” separated the logic from the system, providing an easy to источник environment for user input.

Drools is a Rule Привожу ссылку that uses the rule-based approach to implement an Expert System and is more correctly classified as a Production Rule System. The term “Production Rule” originates from formal grammars where it is described as “an abstract structure that describes a formal language precisely, i. Business Rule Management Systems build additional value on top of a general purpose Rule Engine by providing business user focused systems for rule creation, guidr, deployment, collaboration, analysis and end user tools.

Further adding to this drools expert user guide pdf free download is the fast evolving and popular methodology “Business Rules Approach”, which is a helping fre formalize the role of Rule Engines in the enterprise.

The term Rule Engine is quite ambiguous in that it can be any system that uses rules, in any form, that can be applied to data to produce outcomes. This includes simple systems like form validation and dynamic expression engines.

The book is actually about how to build and alter a database schema to hold validation rules. The book then shows how to generate VB code from those validation rules to validate data entry. This, while a very valid and useful topic for some, caused quite a surprise to this author, unaware at the time in the subtleties of Rules Engines’ differences, who was hoping to find some hidden secrets to help improve the Drools engine.

At each node it evaluates ther is a rule set that dictates the transition to undertake, and so this is also a Rule Engine. A Production Rule System is Turing complete, with a focus on knowledge representation to express propositional and first order logic in a concise, non-ambiguous and declarative manner. The brain of a Production Rules System is an Inference Engine pdff is able to scale to a large number of rules and facts. The Inference Engine matches facts and data against Production Rules – also called Productions or dodnload Rules – to infer conclusions which result in actions.

A Production Rule is a two-part structure using First Order Logic for reasoning over knowledge representation.

Droosl process of matching the new or existing facts against Production Rules is called Pattern Matching, which is performed by the Inference Engine. There are a number of algorithms fre for Pattern Matching by Inference Engines including:.

Drools implements and extends the Rete algorithm; Leaps used to guire provided but was retired as it became unmaintained. The Drools Rete implementation is called ReteOO, signifying that Drools has an enhanced and optimized implementation of the Rete algorithm for object oriented systems. Facts are asserted into the Working Memory where they may then be modified or retracted. A system with a large number of rules and facts may result in many drools expert user guide pdf free download being true for the same fact assertion; these rules are said to be in conflict.

The Agenda manages the execution order of these conflicting rules using a Conflict Resolution strategy. There are two methods of execution for a rule system: Forward Chaining and Backward Chaining; systems that implement both are called Doqnload Chaining Systems. As of Drools 5. Understanding ссылка на подробности two drools expert user guide pdf free download of operation is the key to understanding why a Drools expert user guide pdf free download Rule System is different and how to get the best from it.

Forward читать полностью is “data-driven” and thus reactionary, with facts being asserted into working memory, which results in one or more rules being drlols true and scheduled for execution by the Agenda.

In short, we start with a fact, it propagates and we end in a conclusion. Backward chaining is “goal-driven”, meaning that we start with a conclusion which the engine tries to satisfy. If it use it then searches for conclusions drools expert user guide pdf free download it can satisfy; these are known as subgoals, that will help satisfy some unknown part of the current goal.

It continues drools expert user guide pdf free download process until either the initial conclusion is proven or there are no more subgoals. Dowlnoad is an example of a Backward Chaining engine.

Drools can also do backward doanload, which we refer to as derivation queries. Why should you exprrt a rule engine instead of a scripting framework, like BeanShell? The key advantage of this point is that using rules can make it easy to express solutions to difficult problems and consequently have those solutions down,oad.

Rules are much easier to read than code. Rule systems are capable of solving very, expegt hard problems, providing dropls explanation of how the solution was arrived at and why each “decision” along the way was made not so easy with other of AI systems like neural networks or the gree brain – I have drools expert user guide pdf free download idea why I scratched the side of the car.

Your data is in ueer domain objects, the logic is in the rules. This is fundamentally breaking the OO coupling of data and logic, which can be an advantage or a disadvantage depending on your point of view. The upshot is that the logic can be much easier to drools expert user guide pdf free download as there are changes in the future, as drool logic is all laid 10 pro bit full freefree in rules.

This can be especially true if the logic is cross-domain or multi-domain logic. Instead of the logic being spread across many domain objects or controllers, it can all be organized in one or more very distinct rules files.

The Rete algorithm,the Leaps algorithm, and their descendants such as Адрес страницы ReteOO, provide very efficient ways of matching rule patterns to your domain object data. Drools expert user guide pdf free download are especially efficient when you have datasets that change in small portions as the rule engine download microsoft essentials for 10 remember past matches.

These algorithms приведенная ссылка battle proven. By using rules, you create a repository of knowledge a knowledge base which is executable. This means it’s a single point of drools expert user guide pdf free download, for business policy, for instance. Ideally rules are so readable that they can also serve iser documentation.

Tools such as Eclipse and in future, Web based user interfaces provide ways to edit and manage rules and get immediate feedback, validation and content assistance. Auditing and debugging guude are also available. Rule systems effectively ppdf an “explanation facility” by being able to log the decisions made by the rule engine along usre why the decisions were made. By creating object models and, optionally, Domain Specific Languages that model your problem domain you can set yourself up to write rules that are very close to natural language.

They lend themselves to logic that is droold to, possibly nontechnical, domain experts as downlkad are expressed in their language, downkoad all the program plumbing, the technical know-how being hidden away in the usual code. The shortest answer to this is “when there is no satisfactory traditional programming approach to solve the problem.

Given вот ссылка short answer, some more explanation is required. The reason why there is no “traditional” approach is possibly one of the following:. The problem may подробнее на этой странице be complex, but you can’t see a non-fragile way of building a solution for drools expert user guide pdf free download.

It is a complex problem to solve, there are no obvious traditional solutions, or basically the problem isn’t fully understood. The logic itself may even be simple but the rules change quite often.

In many organizations software releases are few and far between and pluggable rules can help provide the “agility” that is needed and expected in a reasonably safe way.

Domain experts often possess a wealth of knowledge about business rules and processes. They typically are nontechnical, but can be very logical.

Rules can allow them to express the logic in their own terms. Of course, they still have to downloar critically and be capable of logical thinking. Many people in nontechnical positions do not have training in formal logic, so be careful and work with them, as by codifying business knowledge in rules, you will often expose holes in the way the business rules and processes are currently understood.

If rules are a new technology for your project teams, the overhead in getting going must be factored in. It is not a trivial technology, but this document tries to make it easier to understand.

Typically in a modern Expeet application you would use a rule engine to contain key parts of your business logic, especially the really messy parts. This is an inversion of the OO concept of encapsulating all the logic inside your objects. This is not to say that you throw out OO practices, on the contrary in guixe real gukde application, business logic is just one part of the application. If you ever notice lots of conditional statements such as “if” and “switch”, an overabundance of strategy patterns and other messy logic in your code that just doesn’t feel right: that would be a place canon mf232w scanner driver download windows 10 64 bit rules.

If there is some such logic and you keep coming back to fix it, either because you got it wrong, or the logic or your understanding changes: think about using rules. If you are faced with tough problems for which there are no algorithms or patterns: consider using rules. Rules could be used embedded in odwnload application or perhaps as a service. Often a ddrools engine works best as “stateful” component, being an integral part of an application.

However, there have been successful cases of creating reusable rule services which are stateless. For your organization it is important адрес decide about the process you will drools expert user guide pdf free download for updating rules in systems that are in fdee. The options are many, but different organizations have different requirements. Frequently, rules maintenance is out of the control of the application vendors or project developers.

It seems to me that in the excitement of working with rules engines, that people forget that a rules engine is only one piece of a complex application or solution. Rules engines are not really intended to handle workflow or process executions nor are workflow engines or http://replace.me/569.txt management tools designed to do rules.

Use the right tool rxpert the job. Sure, a pair of downlooad can be used as a hammering tool in a pinch, but that’s not what it’s designed for. As rule engines are dynamic dynamic in the sense that the rules can be stored and managed and updated as datathey are often looked at as a solution to the problem of deploying software.

Most IT departments seem to exist for the purpose of preventing software being rolled out. If this is the reason you wish to use a rule engine, be aware that rule engines work best when you are able to write declarative rules. As an alternative, you can consider data-driven microsoft office powerpoint 2010 crack free lookup tablesor script processing engines where the scripts are managed in a database and are able to be updated on the fly.

Alternatives are script-based engines that provide the drive for “changes on the fly”, and there are many such solutions. Alternatively Process Engines also capable of pef such as jBPM allow you to graphically or programmatically describe steps in a process.

Those steps can also involve decision points which are in drools expert user guide pdf free download a simple rule. Process engines and rules often can work nicely together, so they are pxf mutually exclusive. One key point to note with rule engines is that some rule engines are really scripting engines.

The downside of scripting engines is that you are tightly coupling your application to the scripts. If they are rules, you are effectively calling rules directly and this may cause more difficulty in future maintenance, as they tend to grow in complexity over time.

The upside of scripting engines is that they can be easier to implement initially, producing results quickly, and are conceptually simpler for imperative programmers.

 
 

 

Drools Tutorial: Drools Rule Engine Architecture & Examples

 

Final Release date: New and Noteworthy in drools 7. Latest 6. Other downloads: Older community releases can be found in the release archive. Maven Repository The latest releases, including 7. Eclipse update site We stopped to release Eclipse tools synchronously with Drools, thus the recent version of Drools and of latest released Eclipse tools updatesite may differ. Upcoming events. Drools Engine. Drools and jBPM integration. KIE Execution Server.

WAR files for all supported containers. Drools Workbench. Drools and jBPM tools. Miss Manners and Benchmarking 9. Introduction 9. Indepth Discussion 9. Output Summary 9. Introduction and Background Artificial Intelligence A. Knowledge representation is the area of A. Expert Systems use Knowledge representation to facilitate the codification of knowledge into a knowledge base which can be used for reasoning, i.

Expert Systems are also known as Knowledge-based Systems and Knowledge-based Expert Systems and are considered to be “applied artificial intelligence”. The process of developing with an Expert System is Knowledge Engineering.

Whereas early Expert Systems had their logic hard-coded, “shells” separated the logic from the system, providing an easy to use environment for user input. Drools is a Rule Engine that uses the rule-based approach to implement an Expert System and is more correctly classified as a Production Rule System.

The term “Production Rule” originates from formal grammars where it is described as “an abstract structure that describes a formal language precisely, i. Business Rule Management Systems build additional value on top of a general purpose Rule Engine by providing business user focused systems for rule creation, management, deployment, collaboration, analysis and end user tools.

Further adding to this value is the fast evolving and popular methodology “Business Rules Approach”, which is a helping to formalize the role of Rule Engines in the enterprise.

The term Rule Engine is quite ambiguous in that it can be any system that uses rules, in any form, that can be applied to data to produce outcomes. This includes simple systems like form validation and dynamic expression engines. The book is actually about how to build and alter a database schema to hold validation rules. The book then shows how to generate VB code from those validation rules to validate data entry.

This, while a very valid and useful topic for some, caused quite a surprise to this author, unaware at the time in the subtleties of Rules Engines’ differences, who was hoping to find some hidden secrets to help improve the Drools engine.

At each node it evaluates ther is a rule set that dictates the transition to undertake, and so this is also a Rule Engine.

A Production Rule System is Turing complete, with a focus on knowledge representation to express propositional and first order logic in a concise, non-ambiguous and declarative manner. The brain of a Production Rules System is an Inference Engine that is able to scale to a large number of rules and facts. The Inference Engine matches facts and data against Production Rules – also called Productions or just Rules – to infer conclusions which result in actions.

A Production Rule is a two-part structure using First Order Logic for reasoning over knowledge representation. There are a number of algorithms used for Pattern Matching by Inference Engines including: Linear Rete Treat Leaps Drools implements and extends the Rete algorithm; Leaps used to be provided but was retired as it became unmaintained.

The Drools Rete implementation is called ReteOO, signifying that Drools has an enhanced and optimized implementation of the Rete algorithm for object oriented systems. Facts are asserted into the Working Memory where they may then be modified or retracted.

A system with a large number of rules and facts may result in many rules being true for the same fact assertion; these rules are said to be in conflict.

The Agenda manages the execution order of these conflicting rules using a Conflict Resolution strategy. Figure 1. As of Drools 5. Understanding these two modes of operation is the key to understanding why a Production Rule System is different and how to get the best from it.

Forward chaining is “data-driven” and thus reactionary, with facts being asserted into working memory, which results in one or more rules being concurrently true and scheduled for execution by the Agenda. In short, we start with a fact, it propagates and we end in a conclusion. Forward Chaining Backward chaining is “goal-driven”, meaning that we start with a conclusion which the engine tries to satisfy.

If it can’t it then searches for conclusions that it can satisfy; these are known as subgoals, that will help satisfy some unknown part of the current goal. It continues this process until either the initial conclusion is proven or there are no more subgoals. Prolog is an example of a Backward Chaining engine. Drools can also do backward chaining, which we refer to as derivation queries.

Backward Chaining 1. Some frequently asked questions: 1. When should you use a rule engine? What advantage does a rule engine have over hand coded “if Why should you use a rule engine instead of a scripting framework, like BeanShell? We will attempt to address these questions below. The key advantage of this point is that using rules can make it easy to express solutions to difficult problems and consequently have those solutions verified. Rules are much easier to read than code.

Rule systems are capable of solving very, very hard problems, providing an explanation of how the solution was arrived at and why each “decision” along the way was made not so easy with other of AI systems like neural networks or the human brain – I have no idea why I scratched the side of the car. Logic and Data Separation Your data is in your domain objects, the logic is in the rules.

This is fundamentally breaking the OO coupling of data and logic, which can be an advantage or a disadvantage depending on your point of view. The upshot is that the logic can be much easier to maintain as there are changes in the future, as the logic is all laid out in rules. This can be especially true if the logic is cross-domain or multi-domain logic.

Instead of the logic being spread across many domain objects or controllers, it can all be organized in one or more very distinct rules files. Speed and Scalability The Rete algorithm,the Leaps algorithm, and their descendants such as Drools’ ReteOO, provide very efficient ways of matching rule patterns to your domain object data.

These are especially efficient when you have datasets that change in small portions as the rule engine can remember past matches. These algorithms are battle proven.

Centralization of Knowledge By using rules, you create a repository of knowledge a knowledge base which is executable. This means it’s a single point of truth, for business policy, for instance.

Ideally rules are so readable that they can also serve as documentation. Tool Integration Tools such as Eclipse and in future, Web based user interfaces provide ways to edit and manage rules and get immediate feedback, validation and content assistance.

Auditing and debugging tools are also available. Explanation Facility Rule systems effectively provide an “explanation facility” by being able to log the decisions made by the rule engine along with why the decisions were made. Understandable Rules By creating object models and, optionally, Domain Specific Languages that model your problem domain you can set yourself up to write rules that are very close to natural language. They lend themselves to logic that is understandable to, possibly nontechnical, domain experts as they are expressed in their language, with all the program plumbing, the technical know-how being hidden away in the usual code.

When should you use a Rule Engine? The shortest answer to this is “when there is no satisfactory traditional programming approach to solve the problem.

Given that short answer, some more explanation is required. The reason why there is no “traditional” approach is possibly one of the following: The problem is just too fiddle for traditional code. The problem may not be complex, but you can’t see a non-fragile way of building a solution for it.

The problem is beyond any obvious algorithmic solution. It is a complex problem to solve, there are no obvious traditional solutions, or basically the problem isn’t fully understood.

The logic changes often The logic itself may even be simple but the rules change quite often. In many organizations software releases are few and far between and pluggable rules can help provide the “agility” that is needed and expected in a reasonably safe way.

Domain experts or business analysts are readily available, but are nontechnical. Domain experts often possess a wealth of knowledge about business rules and processes.

They typically are nontechnical, but can be very logical. Rules can allow them to express the logic in their own terms. Of course, they still have to think critically and be capable of logical thinking. Many people in nontechnical positions do not have training in formal logic, so be careful and work with them, as by codifying business knowledge in rules, you will often expose holes in the way the business rules and processes are currently understood. If rules are a new technology for your project teams, the overhead in getting going must be factored in.

It is not a trivial technology, but this document tries to make it easier to understand. Typically in a modern OO application you would use a rule engine to contain key parts of your business logic, especially the really messy parts. This is an inversion of the OO concept of encapsulating all the logic inside your objects. This is not to say that you throw out OO practices, on the contrary in any real world application, business logic is just one part of the application.

If you ever notice lots of conditional statements such as “if” and “switch”, an overabundance of strategy patterns and other messy logic in your code that just doesn’t feel right: that would be a place for rules. If there is some such logic and you keep coming back to fix it, either because you got it wrong, or the logic or your understanding changes: think about using rules. If you are faced with tough problems for which there are no algorithms or patterns: consider using rules.

Rules could be used embedded in your application or perhaps as a service. Often a rule engine works best as “stateful” component, being an integral part of an application.

However, there have been successful cases of creating reusable rule services which are stateless. For your organization it is important to decide about the process you will use for updating rules in systems that are in production. The options are many, but different organizations have different requirements. Frequently, rules maintenance is out of the control of the application vendors or project developers. When not to use a Rule Engine To quote a Drools mailing list regular: It seems to me that in the excitement of working with rules engines, that people forget that a rules engine is only one piece of a complex application or solution.

Rules engines are not really intended to handle workflow or process executions nor are workflow engines or process management tools designed to do rules. Use the right tool for the job. Sure, a pair of pliers can be used as a hammering tool in a pinch, but that’s not what it’s designed for.

Most IT departments seem to exist for the purpose of preventing software being rolled out. If this is the reason you wish to use a rule engine, be aware that rule engines work best when you are able to write declarative rules.

As an alternative, you can consider data-driven designs lookup tables , or script processing engines where the scripts are managed in a database and are able to be updated on the fly. Scripting or Process Engines Hopefully the preceding sections have explained when you may want to use a rule engine.

Alternatives are script-based engines that provide the drive for “changes on the fly”, and there are many such solutions. Alternatively Process Engines also capable of workflow such as jBPM allow you to graphically or programmatically describe steps in a process. Those steps can also involve decision points which are in themselves a simple rule.

Process engines and rules often can work nicely together, so they are not mutually exclusive. One key point to note with rule engines is that some rule engines are really scripting engines. The downside of scripting engines is that you are tightly coupling your application to the scripts. If they are rules, you are effectively calling rules directly and this may cause more difficulty in future maintenance, as they tend to grow in complexity over time. The upside of scripting engines is that they can be easier to implement initially, producing results quickly, and are conceptually simpler for imperative programmers.

Many people have also implemented data-driven systems successfully in the past where there are control tables that store meta-data that changes your applications behavior – these can work well when the control can remain very limited.

However, they can quickly grow out of control if extended too much such that only the original creators can change the applications behavior or they cause the application to stagnate as they are too inflexible. Strong and Loose Coupling No doubt you have heard terms like “tight coupling” and “loose coupling” in systems design.

Generally people assert that “loose” or “weak” coupling is preferable in design terms, due to the added flexibility it affords.

Similarly, you can have “strongly coupled” and “weakly coupled” rules. Strongly coupled in this sense means that one rule “firing” will clearly result in another rule firing, and so on; in other words, there is a clear probably obvious chain of logic.

If your rules are all strongly coupled, the chances are that the will turn out to be inflexible, and, more significantly, that a rule engine is an overkill. A clear chain can be hard coded, or implemented using a Decision Tree. This is not to say that strong coupling is inherently bad, but it is a point to keep in mind when considering a rule engine and the way you capture the rules. Chapter 2. Knowledge Agent 2. Stateless Knowledge Session So where do we get started, there are so many use cases and so much functionality in a rule engine such as Drools that it becomes beguiling.

Have no fear my intrepid adventurer, the complexity is layered and you can ease yourself into with simple use cases. Stateless session, not utilising inference, forms the simplest use case. A stateless session can be called like a function passing it some data and then receiving some results back. Some common use cases for stateless sessions are, but not limited to: Validation Is this person eligible for a mortgage? Calculation Compute a mortgage premium.

Routing and Filtering Filter incoming messages, such as emails, into folders. Send incoming messages to a destination. So let’s start with a very simple example using a driving license application. We assume that the application uses rules to refute invalid applications. As this is a simple validation use case we will add a single rule to disqualify any applicant younger than When the Applicant instance is inserted into the engine it is evaluated against the constraints of the rules, in this case just two constraints for one rule.

DRL ; if kbuilder. If there are no errors, we can add the resulting packages to our Knowledge Base. Since the applicant is under the age of 18, the application is marked as invalid. So far we’ve only used a single instance, but what if we want to use more than one? We can execute against any object implementing Iterable, such as a collection. Let’s add another class called Application, which has the date of the application, and we’ll also move the boolean valid field to the Application class.

The code shown below executes against an iterable list, where all collection elements are inserted before any matched rules are fired. A CommandFactory is used to create commands, so that the following is equivalent to execute Iterable it : ksession. Stateful Knowledge Session Stateful Sessions are longer lived and allow iterative changes over time.

Some common use cases for Stateful Sessions are, but not limited to: Monitoring Stock market monitoring and analysis for semi-automatic buying. Diagnostics Fault finding, medical diagnostics Logistics Parcel tracking and delivery provisioning Compliance Validation of legality for market trades. In contrast to a Stateless Session, the dispose method must be called afterwards to ensure there are no memory leaks, as the Knowledge Base contains references to Stateful Knowledge Sessions when they are created.

StatefulKnowledgeSession also supports the BatchExecutor interface, like StatelessKnowledgeSession, the only difference being that the FireAllRules command is not automatically called at the end for a Stateful Session. We illustrate the monitoring use case with an example for raising a fire alarm. Using just four classes, we represent rooms in a house, each of which has one sprinkler.

If a fire starts in a room, we represent that with a single Fire instance. That example assumed that only a single instance of each object type was ever inserted and thus only used literal constraints. However, a house has many rooms, so rules must express relationships between objects, such as a sprinkler being in a certain room. This is best done by using a binding variable as a constraint in a pattern.

This “join” process results in what is called cross products, which are covered in the next section. When a fire occurs an instance of the Fire class is created, for that room, and inserted into the session. The rule uses a binding on the room field of the Fire object to constrain matching to the sprinkler for that room, which is currently off. When this rule fires and the consequence is executed the sprinkler is turned on.

It may contain a series of comma separated Java expressions, i. This modifies the data, and makes the engine aware of those changes so it can reason over them once more. This process is called inference, and it’s essential for the working of a Stateful Session. Stateless Sessions typically do not use inference, so the engine does not need to be aware of changes to data. Inference can also be turned off explicitly by using the sequential mode. So far we have rules that tell us when matching data exists, but what about when it does not exist?

How do we determine that a fire has been extinguished, i. Previously the constraints have been sentences according to Propositional Logic, where the engine is constraining against individual intances. Drools also has support for First Order Logic that allows you to look at sets of data. A pattern under the keyword not matches when something does not exist.

The rule given below turns the sprinkler off as soon as the fire in that room has disappeared. An Alarm object is created when a fire occurs, but only one Alarm is needed for the entire building, no matter how many fires occur. Previously not was introduced to match the absence of a fact; now we use its complement exists which matches for one or more instances of some category. We can then build a Knowledge Base, as before, just using the new name fireAlarm.

The difference is that this time we create a Stateful Session from the Knowledge Base, whereas before we created a Stateless Session. Four Room objects are created and inserted, as well as one Sprinkler object for each room. At this point the engine has done all of its matching, but no rules have fired yet. Calling ksession. A Fact Handle is an internal engine reference to the inserted instance and allows instances to be retracted or modified at a later point in time.

With the fires now in the engine, once fireAllRules is called, the alarm is raised and the respective sprinklers are turned on. This results in the sprinklers being turned off, the alarm being cancelled, and eventually the health message is printed again. That wasn’t so hard and already I’m hoping you can start to see the value and power of a declarative rule system.

Methods versus Rules People often confuse methods and rules, and new rule users regular ask, “How do I call a rule? Specific instances are passed. One call results in a single execution. Rules can never be called directly.

Specific instances cannot be passed to a rule. Depending on the matches, a rule may fire once or several times, or not at all. Cross Products Earlier the term “cross product” was mentioned, which is the result of a join.

The size of cross products is often the source of performance problems for new rule authors. From this it can be seen that it’s always desirable to constrain the cross products, which is done with the variable constraint. Activations, Agenda and Conflict Sets.

So far the data and the matching process has been simple and small. To mix things up a bit a new example will be explored that handles cashflow calculations over date periods. The state of the engine will be illustratively shown at key stages to help get a better understanding of what is actually going on under the hood. Three classes will be used, as shown below. The tables below show that a single fact was inserted for the Account. Also inserted are a series of debits and credits as CashFlow objects for that account, extending over two quarters.

Figure 2. CashFlows and Account Two rules can be used to determine the debit and credit for that quarter and update the Account balance. The two rules below constrain the cashflows for an account for a given time period. AccountingPeriod, CashFlows and Account The two cashflow tables above represent the matched data for the two rules. The data is matched during the insertion stage and, as you discovered in the previous chapter, does not fire straight away, but only after fireAllRules is called.

Meanwhile, the rule plus its matched data is placed on the Agenda and referred to as an Activation. The Agenda is a table of Activations that are able to fire and have their consequences executed, as soon as fireAllRules is called.

Activations on the Agenda are executed in turn. Notice that the order of execution so far is considered arbitrary. CashFlows and Account After all of the above activations are fired, the account has a balance of CashFlows and Account If the AccountPeriod is updated to the second quarter, we have just a single matched row of data, and thus just a single Activation on the Agenda.

CashFlows and Account The firing of that Activation results in a balance of CashFlows and Account What if you don’t want the order of Activation execution to be arbitrary? When there is one or more Activations on the Agenda they are said to be in conflict, and a conflict resolver strategy is used to determine the order of execution. At the simplest level the default strategy uses salience to determine rule priority. Each rule has a default value of 0, the higher the value the higher the priority.

To illustrate this we add a rule to print the account balance, where we want this rule to be executed after all the debits and credits have been applied for all accounts. We achieve this by assigning a negative salience to this rule so that it fires after all rules with the default salience 0.

The three debit and credit rules are shown to be in arbitrary order, while the print rule is ranked last, to execute afterwards. The screenshot below is taken from Eclipse using the Drools plugin.

It has two ruleflow-group nodes which ensures that the calculation rules are executed before the reporting rules. The use of the ruleflow-group attribute in a rule is shown below.

Inference Inference has a bad names these days, as something not relevant to business use cases and just too complicated to be useful. It is true that contrived and complicated examples occur with inference, but that should not detract from the fact that simple and useful ones exist too. But more than this, correct use of inference can crate more agile and less error prone businesses with easier to maintain software. So what is inference? Something is inferred when we gain knowledge of something from using previous knowledge.

For example given a Person fact with an age field and a rule that provides age policy control, we can infer whether a Person is an adult or a child and act on this. This fact is special in that it is known as a relation. Let’s take a government department that are responsible for issuing ID cards when children become adults, hence forth referred to as ID department.

They might have a decision table that includes logic like this, which says when an adult living in london is 18 or over, issue the card: However the ID department does not set the policy on who an adult is.

That’s done at a central government level. If the central government where to change that age to 21 there is a change management process. Someone has to liaise with the ID department and make sure their systems are updated, in time for the law going live. This change management process and communication between departments is not ideal for an agile environment and change become costly and error prone.

Also the card department is managing more information than it needs to be aware of with its “monolothic” approach to rules management which is “leaking” information better placed else where. Instead what if we were to split de-couple the authoring responsibility, so the central government maintains its rules and the ID department maintains its. So its the central governments job to determine who is an adult and if they change the law they just update their central repository with the new rules, which others use: The IsAdult fact, as discussed previously, is inferred from the policy rules.

Now if anyone uses the above rules, they no longer need to be aware of explicit information that determines whether someone is an adult or not. They can just use the inferred fact: While the example is very minimal and trivial it illustrates some important points.

We started with a monolithic and leaky approach to our knowledge engineering. We create a single decision table that had all possible information in it that leaks information from central government that the ID department did not care about and did not want to manage.

We first de-coupled the knowledge process so responsible for only what it needed to know. We leaky knowledge using an inferred fact IsAdult.

The also gave a semantic abstraction to the previously 18″. Inference and TruthMaintenance The previous example was issuing ID cards to over 18s, in this example we now issue bus passes, either a child or adult pass.

As before we can provide a more robust application with a separation of concerns using inference. Here the fact is logically inserted, this fact is dependant on the truth of the “when” clause.

It means that when the rule becomes false the fact is automatically retracted. This works particularly well as the two rules are mutually exclusive.

So in the above rules if the person is under 16 it inserts an IsChild fact, once the person is 16 or over the IsChild fact is automatically retracted and the IsAdult fact inserted. We can now bring back in the code to issue the passes, these two can also be logically inserted, as the TMS supports chaining of logical insertions for a cascading set of retracts.

For bonus points we can combine this with the ‘not’ conditional element to handle notifications, in this situation a request for the returning of the pass. Quite often it’s more desirable to do this via configuration. To facilitate this, Drools supports the “Changeset” feature.

The file changeset. A few examples will be shown to give you the gist of things. A resource approach is employed that uses a prefix to indicate the protocol. All the protocols provided by java. URL, such as “file” and “http”, are supported, as well as an additional “classpath”. Currently the type attribute must always be specified for a resource, as it is not inferred from the file name extension.

Here is a simple example that points to a http location for some rules. The example below is expanded to load the rules from a http URL location, and an Excel decision table from the classpath. It is expected that all the files are of the specified type, since type is not yet inferred from the file name extensions.

Knowledge Agent The Knowlege Agent provides automatic loading, caching and re-loading of resources and is configured from a properties files. The Knowledge Agent can update or rebuild this Knowlege Base as the resources it uses are changed. The strategy for this is determined by the configuration given to the factory, but it is typically pull-based using regular polling.

We hope to add pushbased updates and rebuilds in future versions. Note that the previous KnowledgeBase reference will still exist and you’ll have to call getKnowledgeBase to access the newly built KnowledgeBase. If a directory is specified as part of the change set, the entire contents of that directory will be scanned for changes.

The way modifications are applied depends on drools. For polling to occur, the polling and notifier services must be started: ResourceFactory.

Knowledge Agent and Custom ClassLoaders Because Knowledge Agent could scan and process remote resources, it could ends up failing when compiling or executing rules, queries, functions, etc. If this is your case, you could take 2 approach: use a custom classloader for agent’s kbuilder or force the agent to use the same classloader that its kbase has. If you need to pass custom configuration to these compilers you could pass a KnowledgeBuilderConfiguration object to KnowledgeAgentFactory. This object will be used in every builder the agent creates.

Using a KnowledgeBuilderConfiguration you can specify a custom classloader. Reuse KnowledgeBase ClassLoader Most of the times, the classloader you wan’t to use in the compilation process of remote resources is the same needed in the agent’s kbase, so the rules could be executed. If you want to use this approach, you will need to setup the desired ClassLoader to the agen’t kbase and use the “drools.

This approach lets you modify agent’s kbuilder classloader in runtime by modifying the classloader the agent’s kbase uses. This will serve also when not using incremental change set processing see the section below.

When the kbase is recreated its configuration is reused, so the classloader is maintained. Incremental Change Set Processing Knowledge Agent can process change sets in two different ways: recreating the knowledge base every time a new change set is processed or applying the change set in the cached knowledge base without destroying it. This behavior is controlled by the “newInstance” property of the KnowledgeAgentConfiguration object passed to the Agent’s constructor.

When “newInstace” is set to true the default value , the agent will destroy the cached Knowledge Base it contains and populate a new one containing the change set modifications. When “newInstance” is set to “false” change sets are applied directly to the cached Knowledge Base. The rule that were not modified in the change sets’ resources are not replaced in the Knowledge Base, the modified or deleted rules are modified or deleted from the cached Knowledge Base.

Functions, Queries and Definition Types are always replaced in the cached Knowledge Base whether they are modified or not. To survive a restart when a resource is no longer available remotely eg the remote server is being restarted then you can set a System Property: drools.

For example, using the java command line: Ddrools. Chapter 3. Rete Algorithm 3. Truth Objects Maintenance with Logical After regular inserts you have to retract facts explicitly. With logical assertions, the fact that was asserted will be automatically retracted when the conditions that asserted it in the first place are no longer true.

Actually, it’s even cleverer then that, because it will be retracted only if there isn’t any single condition that supports the logical assertion. Normal insertions are said to be stated, i. Using a HashMap and a counter, we track how many times a particular equality is stated; this means we count how many different instances are equal. When we logically insert an object during a RHS execution we are said to justify it, and it is considered to be justified by the firing rule.

For each logical insertion there can only be one equal object, and each subsequent equal logical insertion increases the justification counter for this logical assertion. A justification is removed by the LHS of the creating rule becoming untrue, and the counter is decreased accordingly.

As soon as we have no more justifications the logical object is automatically retracted. If we try to logically insert an object when there is an equal stated object, this will fail and return null. When the property is set to discard we use the existing handle and replace the existing instance with the new Object, which is the default behavior; otherwise we override it to stated but we create an new FactHandle.

This can be confusing on a first read, so hopefully the flow charts below help. When it says that it returns a new FactHandle, this also indicates the Object was propagated through the network.

Figure 3. Stated Insertion Figure 3. Logical Insertion 3. Example Scenario An example may make things clearer. Imagine a credit card processing application, processing transactions for a given account and we have a working memory accumulating knowledge about a single account transaction. The rule engine is doing its best to decide whether transactions are possibly fraudulent or not. Imagine that this rule base basically has rules that kick in when there is “reason to be suspicious” and when “everything is normal”.

Of course there are many rules that operate no matter what, performing standard calculations, etc. Now there are possibly many reasons as to what could trigger a “reason to be suspicious”: someone notifying the bank, a sequence of large transactions, transactions for geographically disparate locations, or even reports of credit card theft. Rather then smattering all the little conditions in lots of rules, imagine there is a fact class called “SuspiciousAccount”. Then there can be a series of rules whose job is to look for things that may raise suspicion, and if they fire, they logically insert a new SuspiciousAccount instance.

All the other rules just have conditions like “not SuspiciousAccount ” or “SuspiciousAccount ” depending on their needs. Note that this has the advantage of allowing there to be many rules around raising suspicion, without touching the other rules. After all the facts causing the SuspiciousAccount insertion are removed, the account handling reverts to a normal mode of operation where, for instance, a rule with “not SuspiciousAccount ” may kick in, which flushes through any blocked transactions.

If you have followed this far, you will note that truth maintenance, like logical assertions, allows rules to behave a little like a human would, and can certainly make the rules more manageable. Lazy Truth Maintenance You no longer need to enable or disable truth maintenance, via the kbase configuration.

It is now handled automatically and turned on only when needed. This was done along with the code changes so that all entry points use the same code, previous to this the default entry point and named entry points used different code, to avoid TMS overhead for event processing. Important note: Equality for Java objects It is important to note that for Truth Maintenance and logical assertions to work at all, your Fact objects which may be JavaBeans must override equals and hashCode methods from java.

Object correctly. As the truth maintenance system needs to know when two different physical objects are equal in value, both equals and hashCode must be overridden correctly, as per the Java standard. Two objects are equal if and only if their equals methods return true for each other and if their hashCode methods return the same values.

Rete Algorithm The Rete algorithm was invented by Dr. Charles Forgy and documented in his PhD thesis in The latin word “rete” means “net” or “network”. The Rete algorithm can be broken into 2 parts: rule compilation and runtime execution.

The compilation algorithm describes how the Rules in the Production Memory are processed to generate an efficient discrimination network. In nontechnical terms, a discrimination network is used to filter data as it propagates through the network. The nodes at the top of the network would have many matches, and as we go down the network, there would be fewer matches.

At the very bottom of the network are the terminal nodes. In Dr. Forgy’s paper, he described 4 basic nodes: root, 1-input, 2-input and terminal. Rete Nodes The root node is where all objects enter the network.

From there, it immediately goes to the ObjectTypeNode. The purpose of the ObjectTypeNode is to make sure the engine doesn’t do more work than it needs to.

One key point to note with rule engines is that some rule engines are really scripting engines. The downside of scripting engines is that you are tightly coupling your application to the scripts. If they are rules, you are effectively calling rules directly and this may cause more difficulty in future maintenance, as they tend to grow in complexity over time.

The upside of scripting engines is that they can be easier to implement initially, producing results quickly, and are conceptually simpler for imperative programmers. Many people have also implemented data-driven systems successfully in the past where there are control tables that store meta-data that changes your applications behavior – these can work well when the control can remain very limited.

However, they can quickly grow out of control if extended too much such that only the original creators can change the applications behavior or they cause the application to stagnate as they are too inflexible. No doubt you have heard terms like “tight coupling” and “loose coupling” in systems design. Generally people assert that “loose” or “weak” coupling is preferable in design terms, due to the added flexibility it affords.

Similarly, you can have “strongly coupled” and “weakly coupled” rules. Strongly coupled in this sense means that one rule “firing” will clearly result in another rule firing, and so on; in other words, there is a clear probably obvious chain of logic. If your rules are all strongly coupled, the chances are that the will turn out to be inflexible, and, more significantly, that a rule engine is an overkill.

A clear chain can be hard coded, or implemented using a Decision Tree. This is not to say that strong coupling is inherently bad, but it is a point to keep in mind when considering a rule engine and the way you capture the rules. So where do we get started, there are so many use cases and so much functionality in a rule engine such as Drools that it becomes beguiling.

Have no fear my intrepid adventurer, the complexity is layered and you can ease yourself into with simple use cases. Stateless session, not utilising inference, forms the simplest use case.

A stateless session can be called like a function passing it some data and then receiving some results back. Some common use cases for stateless sessions are, but not limited to:. Now that we have our data model we can write our first rule. We assume that the application uses rules to refute invalid applications. As this is a simple validation use case we will add a single rule to disqualify any applicant younger than To make the engine aware of data, so it can be processed against the rules, we have to insert the data, much like with a database.

When the Applicant instance is inserted into the engine it is evaluated against the constraints of the rules, in this case just two constraints for one rule. An object type constraint plus its zero or more field constraints is referred to as a pattern. When an inserted instance satisfies both the object type constraint and all the field constraints, it is said to be matched. There its properties can be updated. The process of matching patterns against the inserted data is, not surprisingly, often referred to as pattern matching.

Let’s assume that the rules are in the same folder as the classes, so we can use the classpath resource loader to build our first KnowledgeBase. A Knowledge Base is what we call our collection of compiled definitions, such as rules and processes, which are compiled using the KnowledgeBuilder.

The above code snippet looks on the classpath for the licenseApplication. If there are no errors, we can add the resulting packages to our Knowledge Base. Now we are ready to build our session and execute against some data:. The preceding code executes the data against the rules. Since the applicant is under the age of 18, the application is marked as invalid.

So far we’ve only used a single instance, but what if we want to use more than one? We can execute against any object implementing Iterable, such as a collection. Let’s add another class called Application , which has the date of the application, and we’ll also move the boolean valid field to the Application class. We can also add another rule to validate that the application was made within a period of time.

Unfortunately a Java array does not implement the Iterable interface, so we have to use the JDK converter method Arrays. The code shown below executes against an iterable list, where all collection elements are inserted before any matched rules are fired. The two execute methods execute Object object and execute Iterable objects are actually convenience methods for the interface BatchExecutor ‘s method execute Command command.

A CommandFactory is used to create commands, so that the following is equivalent to execute Iterable it :. Batch Executor and Command Factory are particularly useful when working with multiple Commands and with output identifiers for obtaining results. Stateful Sessions are longer lived and allow iterative changes over time. Some common use cases for Stateful Sessions are, but not limited to:. In contrast to a Stateless Session, the dispose method must be called afterwards to ensure there are no memory leaks, as the Knowledge Base contains references to Stateful Knowledge Sessions when they are created.

StatefulKnowledgeSession also supports the BatchExecutor interface, like StatelessKnowledgeSession , the only difference being that the FireAllRules command is not automatically called at the end for a Stateful Session.

We illustrate the monitoring use case with an example for raising a fire alarm. Using just four classes, we represent rooms in a house, each of which has one sprinkler. If a fire starts in a room, we represent that with a single Fire instance. In the previous section on Stateless Sessions the concepts of inserting and matching against data was introduced. That example assumed that only a single instance of each object type was ever inserted and thus only used literal constraints.

However, a house has many rooms, so rules must express relationships between objects, such as a sprinkler being in a certain room. This is best done by using a binding variable as a constraint in a pattern. This “join” process results in what is called cross products, which are covered in the next section. When a fire occurs an instance of the Fire class is created, for that room, and inserted into the session. The rule uses a binding on the room field of the Fire object to constrain matching to the sprinkler for that room, which is currently off.

When this rule fires and the consequence is executed the sprinkler is turned on. Whereas the Stateless Session uses standard Java syntax to modify a field, in the above rule we use the modify statement, which acts as a sort of “with” statement.

It may contain a series of comma separated Java expressions, i. This modifies the data, and makes the engine aware of those changes so it can reason over them once more. This process is called inference, and it’s essential for the working of a Stateful Session. Stateless Sessions typically do not use inference, so the engine does not need to be aware of changes to data. Inference can also be turned off explicitly by using the sequential mode.

So far we have rules that tell us when matching data exists, but what about when it does not exist? How do we determine that a fire has been extinguished, i. Previously the constraints have been sentences according to Propositional Logic, where the engine is constraining against individual intances. Drools also has support for First Order Logic that allows you to look at sets of data. A pattern under the keyword not matches when something does not exist.

The rule given below turns the sprinkler off as soon as the fire in that room has disappeared. While there is one sprinkler per room, there is just a single alarm for the building.

An Alarm object is created when a fire occurs, but only one Alarm is needed for the entire building, no matter how many fires occur.

Previously not was introduced to match the absence of a fact; now we use its complement exists which matches for one or more instances of some category.

Likewise, when there are no fires we want to remove the alarm, so the not keyword can be used again. Finally there is a general health status message that is printed when the application first starts and after the alarm is removed and all sprinklers have been turned off. The above rules should be placed in a single DRL file and saved to some directory on the classpath and using the file name fireAlarm.

We can then build a Knowledge Base, as before, just using the new name fireAlarm. The difference is that this time we create a Stateful Session from the Knowledge Base, whereas before we created a Stateless Session. With the session created it is now possible to iteratvely work with it over time. Four Room objects are created and inserted, as well as one Sprinkler object for each room. At this point the engine has done all of its matching, but no rules have fired yet. Calling ksession. We now create two fires and insert them; this time a reference is kept for the returned FactHandle.

A Fact Handle is an internal engine reference to the inserted instance and allows instances to be retracted or modified at a later point in time.

With the fires now in the engine, once fireAllRules is called, the alarm is raised and the respective sprinklers are turned on. After a while the fires will be put out and the Fire instances are retracted.

This results in the sprinklers being turned off, the alarm being cancelled, and eventually the health message is printed again. Everyone still with me? That wasn’t so hard and already I’m hoping you can start to see the value and power of a declarative rule system. People often confuse methods and rules, and new rule users regular ask, “How do I call a rule?

Earlier the term “cross product” was mentioned, which is the result of a join. Imagine for a moment that the data from the fire alarm example were used in combination with the following rule where there ar no field constraints:.

These cross products can obviously become huge, and they may very well contain spurious data. The size of cross products is often the source of performance problems for new rule authors. From this it can be seen that it’s always desirable to constrain the cross products, which is done with the variable constraint. This results in just four rows of data, with the correct Sprinkler for each Room.

So far the data and the matching process has been simple and small. To mix things up a bit a new example will be explored that handles cashflow calculations over date periods.

The state of the engine will be illustratively shown at key stages to help get a better understanding of what is actually going on under the hood.

Three classes will be used, as shown below. By now you already know how to create Knowledge Bases and how to instantiate facts to populate the StatefulKnowledgeSession , so tables will be used to show the state of the inserted data, as it makes things clearer for illustration purposes. The tables below show that a single fact was inserted for the Account. Also inserted are a series of debits and credits as CashFlow objects for that account, extending over two quarters. Two rules can be used to determine the debit and credit for that quarter and update the Account balance.

The two rules below constrain the cashflows for an account for a given time period. If the AccountPeriod is set to the first quarter we constrain the rule “increase balance for credits” to fire on two rows of data and “decrease balance for debits” to act on one row of data.

The two cashflow tables above represent the matched data for the two rules. The data is matched during the insertion stage and, as you discovered in the previous chapter, does not fire straight away, but only after fireAllRules is called. Meanwhile, the rule plus its matched data is placed on the Agenda and referred to as an Activation. The Agenda is a table of Activations that are able to fire and have their consequences executed, as soon as fireAllRules is called. Activations on the Agenda are executed in turn.

Notice that the order of execution so far is considered arbitrary. If the AccountPeriod is updated to the second quarter, we have just a single matched row of data, and thus just a single Activation on the Agenda. What if you don’t want the order of Activation execution to be arbitrary?

When there is one or more Activations on the Agenda they are said to be in conflict, and a conflict resolver strategy is used to determine the order of execution. At the simplest level the default strategy uses salience to determine rule priority. Each rule has a default value of 0, the higher the value the higher the priority. To illustrate this we add a rule to print the account balance, where we want this rule to be executed after all the debits and credits have been applied for all accounts.

We achieve this by assigning a negative salience to this rule so that it fires after all rules with the default salience 0. The table below depicts the resulting Agenda. The three debit and credit rules are shown to be in arbitrary order, while the print rule is ranked last, to execute afterwards.

Earlier we showed how rules would equate to SQL, which can often help people with an SQL background to understand rules. The two rules above can be represented with two views and a trigger for each view, as below:.

Drools also features ruleflow-group attributes which allows workflow diagrams to declaratively specify when rules are allowed to fire. The screenshot below is taken from Eclipse using the Drools plugin. It has two ruleflow-group nodes which ensures that the calculation rules are executed before the reporting rules.

Inference has a bad names these days, as something not relevant to business use cases and just too complicated to be useful. It is true that contrived and complicated examples occur with inference, but that should not detract from the fact that simple and useful ones exist too. But more than this, correct use of inference can crate more agile and less error prone businesses with easier to maintain software. So what is inference? Something is inferred when we gain knowledge of something from using previous knowledge.

For example given a Person fact with an age field and a rule that provides age policy control, we can infer whether a Person is an adult or a child and act on this. So in the above every Person who is 18 or over will have an instance of IsAdult inserted for them. This fact is special in that it is known as a relation. We can use this inferred relation in any rule:.

So now we know what inference is, and have a basic example, how does this facilitate good rule design and maintenance? Let’s take a government department that are responsible for issuing ID cards when children become adults, hence forth referred to as ID department. They might have a decision table that includes logic like this, which says when an adult living in london is 18 or over, issue the card:.

However the ID department does not set the policy on who an adult is. That’s done at a central government level. If the central government where to change that age to 21 there is a change management process. Someone has to liaise with the ID department and make sure their systems are updated, in time for the law going live. This change management process and communication between departments is not ideal for an agile environment and change become costly and error prone.

Also the card department is managing more information than it needs to be aware of with its “monolothic” approach to rules management which is “leaking” information better placed else where.

Instead what if we were to split de-couple the authoring responsibility, so the central government maintains its rules and the ID department maintains its. So its the central governments job to determine who is an adult and if they change the law they just update their central repository with the new rules, which others use:.

The IsAdult fact, as discussed previously, is inferred from the policy rules. Now if anyone uses the above rules, they no longer need to be aware of explicit information that determines whether someone is an adult or not.

They can just use the inferred fact:. While the example is very minimal and trivial it illustrates some important points. We started with a monolithic and leaky approach to our knowledge engineering.

We create a single decision table that had all possible information in it that leaks information from central government that the ID department did not care about and did not want to manage. We first de-coupled the knowledge process so each department was responsible for only what it needed to know.

We then encapsulated this leaky knowledge using an inferred fact IsAdult. The previous example was issuing ID cards to over 18s, in this example we now issue bus passes, either a child or adult pass. As before the above example is considered monolithic, leaky and providing poor separation of concerns. As before we can provide a more robust application with a separation of concerns using inference. Notice this time we don’t just insert the inferred object, we use “logicalInsert”:.

Here the fact is logically inserted, this fact is dependant on the truth of the “when” clause. It means that when the rule becomes false the fact is automatically retracted. This works particularly well as the two rules are mutually exclusive. So in the above rules if the person is under 16 it inserts an IsChild fact, once the person is 16 or over the IsChild fact is automatically retracted and the IsAdult fact inserted. We can now bring back in the code to issue the passes, these two can also be logically inserted, as the TMS supports chaining of logical insertions for a cascading set of retracts.

Now when the person changes from being 15 to 16, not only is the IsChild fact automatically retracted, so is the person’s ChildBusPass fact. For bonus points we can combine this with the ‘not’ conditional element to handle notifications, in this situation a request for the returning of the pass.

So when the TMS automatically retracts the ChildBusPass object, this rule triggers and sends a request to the person:. Quite often it’s more desirable to do this via configuration. To facilitate this, Drools supports the “Changeset” feature. The file changeset. A few examples will be shown to give you the gist of things.

A resource approach is employed that uses a prefix to indicate the protocol. All the protocols provided by java. URL , such as “file” and “http”, are supported, as well as an additional “classpath”. Currently the type attribute must always be specified for a resource, as it is not inferred from the file name extension. Here is a simple example that points to a http location for some rules.

Changesets can include any number of resources, and they even support additional configuration information, which currently is only needed for decision tables.

The example below is expanded to load the rules from a http URL location, and an Excel decision table from the classpath. It is also possible to specify a directory, to add the contents of that directory.

It is expected that all the files are of the specified type, since type is not yet inferred from the file name extensions. The Knowlege Agent provides automatic loading, caching and re-loading of resources and is configured from a properties files. The Knowledge Agent can update or rebuild this Knowlege Base as the resources it uses are changed.

The strategy for this is determined by the configuration given to the factory, but it is typically pull-based using regular polling.

We hope to add push-based updates and rebuilds in future versions. A KnowledgeAgent object will continuously scan all the added resources, using a default polling interval of 60 seconds and, when some last modification date is updated, it will applied the changes into the cached Knowledge Base using the new resources. Note that the previous KnowledgeBase reference will still exist and you’ll have to call getKnowledgeBase to access the newly built KnowledgeBase.

If a directory is specified as part of the change set, the entire contents of that directory will be scanned for changes. The way modifications are applied depends on drools. Because Knowledge Agent could scan and process remote resources, it could ends up failing when compiling or executing rules, queries, functions, etc.

If this is your case, you could take 2 approach: use a custom classloader for agent’s kbuilder or force the agent to use the same classloader that its kbase has. Knowledge Agent uses KnowledgeBuilder internally in order to compile managed resources.

If you need to pass custom configuration to these compilers you could pass a KnowledgeBuilderConfiguration object to KnowledgeAgentFactory. This object will be used in every builder the agent creates. Using a KnowledgeBuilderConfiguration you can specify a custom classloader. Most of the times, the classloader you wan’t to use in the compilation process of remote resources is the same needed in the agent’s kbase, so the rules could be executed.

If you want to use this approach, you will need to setup the desired ClassLoader to the agen’t kbase and use the “drools. This approach lets you modify agent’s kbuilder classloader in runtime by modifying the classloader the agent’s kbase uses. This will serve also when not using incremental change set processing see the section below. When the kbase is recreated its configuration is reused, so the classloader is maintained.

Knowledge Agent can process change sets in two different ways: recreating the knowledge base every time a new change set is processed or applying the change set in the cached knowledge base without destroying it.

This behavior is controlled by the “newInstance” property of the KnowledgeAgentConfiguration object passed to the Agent’s constructor. When “newInstace” is set to true the default value , the agent will destroy the cached Knowledge Base it contains and populate a new one containing the change set modifications.

When “newInstance” is set to “false” change sets are applied directly to the cached Knowledge Base. The rule that were not modified in the change sets’ resources are not replaced in the Knowledge Base, the modified or deleted rules are modified or deleted from the cached Knowledge Base.

Functions, Queries and Definition Types are always replaced in the cached Knowledge Base whether they are modified or not. The following code snippet creates a new Knowledge Agent with its “newInstace” property set to false. A note on remote HTTP Url Resources: if your knowledge agent is “pulling” resources from a http s URL, then you might rightly be concerned if that resource remote web server suddenly disappears.

To survive a restart when a resource is no longer available remotely eg the remote server is being restarted then you can set a System Property: drools. For example, using the java command line: -Ddrools. After regular inserts you have to retract facts explicitly. With logical assertions, the fact that was asserted will be automatically retracted when the conditions that asserted it in the first place are no longer true.

Actually, it’s even cleverer then that, because it will be retracted only if there isn’t any single condition that supports the logical assertion. Normal insertions are said to be stated , i. Using a HashMap and a counter, we track how many times a particular equality is stated ; this means we count how many different instances are equal. When we logically insert an object during a RHS execution we are said to justify it, and it is considered to be justified by the firing rule.

For each logical insertion there can only be one equal object, and each subsequent equal logical insertion increases the justification counter for this logical assertion. A justification is removed by the LHS of the creating rule becoming untrue, and the counter is decreased accordingly. As soon as we have no more justifications the logical object is automatically retracted. If we try to logically insert an object when there is an equal stated object, this will fail and return null.

When the property is set to discard we use the existing handle and replace the existing instance with the new Object, which is the default behavior; otherwise we override it to stated but we create an new FactHandle. This can be confusing on a first read, so hopefully the flow charts below help. When it says that it returns a new FactHandle , this also indicates the Object was propagated through the network.

An example may make things clearer. Imagine a credit card processing application, processing transactions for a given account and we have a working memory accumulating knowledge about a single account transaction. The rule engine is doing its best to decide whether transactions are possibly fraudulent or not. Imagine that this rule base basically has rules that kick in when there is “reason to be suspicious” and when “everything is normal”.

Of course there are many rules that operate no matter what, performing standard calculations, etc. Now there are possibly many reasons as to what could trigger a “reason to be suspicious”: someone notifying the bank, a sequence of large transactions, transactions for geographically disparate locations, or even reports of credit card theft.

Rather then smattering all the little conditions in lots of rules, imagine there is a fact class called “SuspiciousAccount”. Then there can be a series of rules whose job is to look for things that may raise suspicion, and if they fire, they logically insert a new SuspiciousAccount instance.

All the other rules just have conditions like “not SuspiciousAccount ” or “SuspiciousAccount ” depending on their needs. Note that this has the advantage of allowing there to be many rules around raising suspicion, without touching the other rules. After all the facts causing the SuspiciousAccount insertion are removed, the account handling reverts to a normal mode of operation where, for instance, a rule with “not SuspiciousAccount ” may kick in, which flushes through any blocked transactions.

If you have followed this far, you will note that truth maintenance, like logical assertions, allows rules to behave a little like a human would, and can certainly make the rules more manageable. You no longer need to enable or disable truth maintenance, via the kbase configuration. It is now handled automatically and turned on only when needed.

This was done along with the code changes so that all entry points use the same code, previous to this the default entry point and named entry points used different code, to avoid TMS overhead for event processing. It is important to note that for Truth Maintenance and logical assertions to work at all, your Fact objects which may be JavaBeans must override equals and hashCode methods from java.

Object correctly. As the truth maintenance system needs to know when two different physical objects are equal in value, both equals and hashCode must be overridden correctly, as per the Java standard.

Two objects are equal if and only if their equals methods return true for each other and if their hashCode methods return the same values. The Rete algorithm was invented by Dr. Charles Forgy and documented in his PhD thesis in The latin word “rete” means “net” or “network”.

The Rete algorithm can be broken into 2 parts: rule compilation and runtime execution. The compilation algorithm describes how the Rules in the Production Memory are processed to generate an efficient discrimination network. In non-technical terms, a discrimination network is used to filter data as it propagates through the network.

The nodes at the top of the network would have many matches, and as we go down the network, there would be fewer matches. At the very bottom of the network are the terminal nodes. In Dr. Forgy’s paper, he described 4 basic nodes: root, 1-input, 2-input and terminal. The root node is where all objects enter the network. From there, it immediately goes to the ObjectTypeNode. The purpose of the ObjectTypeNode is to make sure the engine doesn’t do more work than it needs to.

For example, say we have 2 objects: Account and Order. If the rule engine tried to evaluate every single node against every object, it would waste a lot of cycles. To make things efficient, the engine should only pass the object to the nodes that match the object type. The easiest way to do this is to create an ObjectTypeNode and have all 1-input and 2-input nodes descend from it. This way, if an application asserts a new Account, it won’t propagate to the nodes for the Order object.

In Drools when an object is asserted it retrieves a list of valid ObjectTypesNodes via a lookup in a HashMap from the object’s Class; if this list doesn’t exist it scans all the ObjectTypeNodes finding valid matches which it caches in the list.

This enables Drools to match against any Class type that matches with an instanceof check. AlphaNodes are used to evaluate literal conditions. Although the paper only covers equality conditions, many RETE implementations support other operations.

For example, Account. When a rule has multiple literal conditions for a single object type, they are linked together. This means that if an application asserts an Account object, it must first satisfy the first literal condition before it can proceed to the next AlphaNode. Forgy’s paper, he refers to these as IntraElement conditions. When a new instance enters the ObjectType node, rather than propagating to each AlphaNode, it can instead retrieve the correct AlphaNode from the HashMap,thereby avoiding unnecessary literal checks.

BetaNodes are used to compare 2 objects, and their fields, to each other. The objects may be the same or different types. By convention we refer to the two inputs as left and right. The left input for a BetaNode is generally a list of objects; in Drools this is a Tuple. The right input is a single object. Two Nodes can be used to implement ‘exists’ checks. BetaNodes also have memory.

The left input is called the Beta Memory and remembers all incoming tuples. The right input is called the Alpha Memory and remembers all incoming objects. Drools extends Rete by performing indexing on the BetaNodes. For instance, if we know that a BetaNode is performing a check on a String field, as each object enters we can do a hash lookup on that String value.

This means when facts enter from the opposite side, instead of iterating over all the facts to find valid joins, we do a lookup returning potentially valid candidates. At any point a valid join is found the Tuple is joined with the Object; which is referred to as a partial match; and then propagated to the next node.

To enable the first Object, in the above case Cheese, to enter the network we use a LeftInputNodeAdapter – this takes an Object as an input and propagates a single Object Tuple.

Terminal nodes are used to indicate a single rule having matched all its conditions; at this point we say the rule has a full match. A rule with an ‘or’ conditional disjunctive connective results in subrule generation for each possible logically branch; thus one rule can have multiple terminal nodes. Drools also performs node sharing. Many rules repeat the same patterns, and node sharing allows us to collapse those patterns so that they don’t have to be re-evaluated for every single instance.

The following two rules share the first pattern, but not the last:. As you can see below, the compiled Rete network shows that the alpha node is shared, but the beta nodes are not. Each beta node has its own TerminalNode. Had the second pattern been the same it would have also been shared. The KnowledgeBuilder is responsible for taking source files, such as a DRL file or an Excel file, and turning them into a Knowledge Package of rule and process definitions which a Knowledge Base can consume.

An object of the class ResourceType indicates the type of resource it is being asked to build. Binaries, such as decision tables Excel. A configuration can be created using the KnowledgeBuilderFactory. This allows the behavior of the Knowledge Builder to be modified. The most common usage is to provide a custom class loader so that the KnowledgeBuilder object can resolve classes that are not in the default classpath. The first parameter is for properties and is optional, i. The options parameter can be used for things like changing the dialect or registering new accumulator functions.

Resources of any type can be added iteratively. Below, a DRL file is added. Unlike Drools 4. It is best practice to always check the hasErrors method after an addition. You should not add more resources or retrieve the Knowledge Packages if there are errors. When all the resources have been added and there are no errors the collection of Knowledge Packages can be retrieved.

It is a Collection because there is one Knowledge Package per package namespace. These Knowledge Packages are serializable and often used as a unit of deployment. Instead of adding the resources to create definitions programmatically it is also possible to do it by configuration, via the ChangeSet XML. The following XML schema is not normative and intended for illustration only.

Currently only the add element is supported, but the others will be implemented to support iterative changes.

The following example loads a single DRL file.

 
 

Drools expert user guide pdf free download

 
 
Drools Planner uses the Drools Expert (rule engine) for score In this work we present a tutorial that discusses some of the main concepts of. Drools. Drools is a business rule management system (BRMS) with a forward chaining Business Rules Engine ‒ Drools Expert using the Rete algorithm and the Drools. PDF | Drools is one of the most popular expert system frameworks. a user-friendly tool supporting visual rule modeling.