Procedure

1. In Decision Central, go to Menu → Design → Projects and click the project name.
2. Click Add Asset → Data Object.

3. Enter a unique Data Object name and select the Package where you want the data object to be available for other rule assets. Data objects with the same name cannot exist in the same package. The package that you specify must be the same package where the rule assets that require those data objects have been assigned or will be assigned.

   Importing data objects from other packages

   You can also import an existing data object from another package into the package of the rule asset. Select the relevant rule asset within the project and in the asset designer, go to Data Objects → New item to select the object to be imported.

4. To make your data object persistable, select the Persistable checkbox. Persistable data objects are able to be stored in a database according to the JPA specification. The default JPA is Hibernate.
5. Click Ok.

6. In the data object designer, click add field to add a field to the object with the attributes Id, Label, and Type. Required attributes are marked with an asterisk (*).

   • Id: Enter the unique ID of the field.
   • Label: (Optional) Enter a label for the field.
   • Type: Enter the data type of the field.

   • List: Select this check box to enable the field to hold multiple items for the specified type.

     Figure 3.1. Add data fields to a data object

     

7. Click Create to add the new field, or click Create and continue to add the new field and continue adding other fields.

   Note

   To edit a field, select the field row and use the general properties on the right side of the screen.

Procedure

1. In the DRL designer, enter when within the rule to begin adding condition statements. The when section consists of zero or more fact patterns that define conditions for the rule.

   If the when section is empty, then actions in the then section are executed every time a fireAllRules() call is made in the decision engine. This is useful if you want to use rules to set up the decision engine state.

   Rule without conditions

   rule "bootstrap"
     when   // empty
   
     then   // actions to be executed once
       insert( new Applicant() );
   end
   
   // The above rule is internally rewritten as:
   
   rule "bootstrap"
     when
       eval( true )
     then
       insert( new Applicant() );
   end

2. Enter a pattern for the first condition to be met, with optional constraints, bindings, and other supported DRL elements. A basic pattern format is patternBinding : patternType ( constraints ). Patterns are based on the available data objects in the package and define the conditions to be met in order to trigger actions in the then section.

   • Simple pattern: A simple pattern with no constraints matches against a fact of the given type. For example, the following condition is only that the applicant exists.

     when
       Applicant( )

   • Pattern with constraints: A pattern with constraints matches against a fact of the given type and the additional restrictions in parentheses that are true or false. For example, the following condition is that the applicant is under the age of 21.

     when
       Applicant( age < 21 )

   • Pattern with binding: A binding on a pattern is a shorthand reference that other components of the rule can use to refer back to the defined pattern. For example, the following binding a on LoanApplication is used in a related action for underage applicants.

     when
       a : LoanApplication( )
       Applicant( age < 21 )
     then
       a.setApproved( false );
       a.setExplanation( "Underage" )

3. Continue defining all condition patterns that apply to this rule. The following are some of the keyword options for defining DRL conditions:

   • and: Use this to group conditional components into a logical conjunction. Infix and prefix and are supported. By default, all listed conditions or actions are combined with and when no conjunction is specified.

     a : LoanApplication( ) and Applicant( age < 21 )
     
     a : LoanApplication( )
     and Applicant( age < 21 )
     
     a : LoanApplication( )
     Applicant( age < 21 )
     
     // All of the above are the same.

   • or: Use this to group conditional components into a logical disjunction. Infix and prefix or are supported.

     Bankruptcy( amountOwed == 100000 ) or IncomeSource( amount == 20000 )
     
     Bankruptcy( amountOwed == 100000 )
     or IncomeSource( amount == 20000 )

   • exists: Use this to specify facts and constraints that must exist. Note that this does not mean that a fact exists, but that a fact must exist. This option is triggered on only the first match, not subsequent matches.

     exists (Bankruptcy( yearOfOccurrence > 1990 || amountOwed > 10000 ))

   • not: Use this to specify facts and constraints that must not exist.

     not (Applicant( age < 21 ))

   • forall: Use this to set up a construct where all facts that match the first pattern match all the remaining patterns.

     forall( app : Applicant( age < 21 )
                   Applicant( this == app, status = 'underage' ) )

   • from: Use this to specify a source for data to be matched by the conditional pattern.

     Applicant( ApplicantAddress : address )
     Address( zipcode == "23920W" ) from ApplicantAddress

   • entry-point: Use this to define an Entry Point corresponding to a data source for the pattern. Typically used with from.

     Applicant( ) from entry-point "LoanApplication"

   • collect: Use this to define a collection of objects that the construct can use as part of the condition. In the example, all pending applications in the decision engine for each given mortgage are grouped in ArrayLists. If three or more pending applications are found, the rule is executed.

     m : Mortgage()
     a : ArrayList( size >= 3 )
         from collect( LoanApplication( Mortgage == m, status == 'pending' ) )

   • accumulate: Use this to iterate over a collection of objects, execute custom actions for each of the elements, and return one or more result objects (if the constraints evaluate to true). This option is a more flexible and powerful form of collect. Use the format accumulate( <source pattern>; <functions> [;<constraints>] ). In the example, min, max, and average are accumulate functions that calculate the minimum, maximum and average temperature values over all the readings for each sensor. Other supported functions include count, sum, variance, standardDeviation, collectList, and collectSet.

     s : Sensor()
     accumulate( Reading( sensor == s, temp : temperature );
                 min : min( temp ),
                 max : max( temp ),
                 avg : average( temp );
                 min < 20, avg > 70 )

     Advanced DRL options

     These are examples of basic keyword options and pattern constructs for defining conditions. For more advanced DRL options and syntax supported in the DRL designer, see the Drools Documentation online.

4. After you define all condition components of the rule, click Validate in the upper-right toolbar of the DRL designer to validate the DRL file. If the file validation fails, address any problems described in the error message, review all syntax and components in the DRL file, and try again to validate the file until the file passes.
5. Click Save in the DRL designer to save your work.

Procedure

1. In the DRL designer, enter then after the when section of the rule to begin adding action statements.

2. Enter one or more actions to be executed on fact patterns based on the conditions for the rule.

   The following are some of the keyword options for defining DRL actions:

   • and: Use this to group action components into a logical conjunction. Infix and prefix and are supported. By default, all listed conditions or actions are combined with and when no conjunction is specified.

     application.setApproved ( false ) and application.setExplanation( "has been bankrupt" );
     
     application.setApproved ( false );
     and application.setExplanation( "has been bankrupt" );
     
     application.setApproved ( false );
     application.setExplanation( "has been bankrupt" );
     
     // All of the above are the same.

   • set: Use this to set the value of a field.

     application.setApproved ( false );
     application.setExplanation( "has been bankrupt" );

   • modify: Use this to specify fields to be modified for a fact and to notify the decision engine of the change.

     modify( LoanApplication ) {
             setAmount( 100 )
     }

   • update: Use this to specify fields and the entire related fact to be modified and to notify the decision engine of the change. After a fact has changed, you must call update before changing another fact that might be affected by the updated values. The modify keyword avoids this added step.

     update( LoanApplication ) {
             setAmount( 100 )
     }

   • delete: Use this to remove an object from the decision engine. The keyword retract is also supported in the DRL designer and executes the same action, but delete is preferred for consistency with the keyword insert.

     delete( LoanApplication );

   • insert: Use this to insert a new fact and define resulting fields and values as needed for the fact.

     insert( new Applicant() );

   • insertLogical: Use this to insert a new fact logically into the decision engine and define resulting fields and values as needed for the fact. The Red Hat Decision Manager decision engine is responsible for logical decisions on insertions and retractions of facts. After regular or stated insertions, facts have to be retracted explicitly. After logical insertions, facts are automatically retracted when the conditions that originally asserted the facts are no longer true.

     insertLogical( new Applicant() );

     Advanced DRL options

     These are examples of basic keyword options and pattern constructs for defining actions. For more advanced DRL options and syntax supported in the DRL designer, see the Drools Documentation online.

3. After you define all action components of the rule, click Validate in the upper-right toolbar of the DRL designer to validate the DRL file. If the file validation fails, address any problems described in the error message, review all syntax and components in the DRL file, and try again to validate the file until the file passes.
4. Click Save in the DRL designer to save your work.

Procedure

1. In the Red Hat JBoss Developer Studio, click File → New → Project.
2. In the New Project window that opens, select Drools → Drools Project and click Next.
3. Click the second icon to Create a project and populate it with some example files to help you get started quickly. Click Next.

4. Enter a Project name and select the Maven radio button as the project building option. The GAV values are generated automatically. You can update these values as needed for your project:

   • Group ID: com.sample
   • Artifact ID: my-project
   • Version: 1.0.0-SNAPSHOT

5. Click Finish to create the project.

   This configuration sets up a basic project structure, class path, and sample rules. The following is an overview of the project structure:

   my-project
    `-- src/main/java
       | `-- com.sample
       |    `-- DecisionTableTest.java
       |    `-- DroolsTest.java
       |    `-- ProcessTest.java
       |
    `-- src/main/resources
       | `-- dtables
       |    `-- Sample.xls
       | `-- process
       |    `-- sample.bpmn
       | `-- rules
       |    `-- Sample.drl
       | `-- META-INF
       |
    `-- JRE System Library
       |
    `-- Maven Dependencies
       |
    `-- Drools Library
       |
    `-- src
       |
    `-- target
       |
    `-- pom.xml

   Notice the following elements:

   • A Sample.drl rule file in the src/main/resources directory, containing an example Hello World and GoodBye rules.
   • A DroolsTest.java file under the src/main/java directory in the com.sample package. The DroolsTest class can be used to execute the Sample.drl rule.
   • The Drools Library directory, which acts as a custom class path containing JAR files necessary for execution.

   You can edit the existing Sample.drl file and DroolsTest.java files with new configurations as needed, or create new rule and object files. In this procedure, you are creating a new rule and new Java objects.

6. Create a Java object on which the rule or rules will operate.

   In this example, a Person.java file is created in my-project/src/main/java/com.sample. The Person class contains getter and setter methods to set and retrieve the first name, last name, hourly rate, and the wage of a person:

     public class Person {
       private String firstName;
       private String lastName;
       private Integer hourlyRate;
       private Integer wage;
   
       public String getFirstName() {
         return firstName;
       }
   
       public void setFirstName(String firstName) {
         this.firstName = firstName;
       }
   
       public String getLastName() {
         return lastName;
       }
   
       public void setLastName(String lastName) {
         this.lastName = lastName;
       }
   
       public Integer getHourlyRate() {
         return hourlyRate;
       }
   
       public void setHourlyRate(Integer hourlyRate) {
         this.hourlyRate = hourlyRate;
       }
   
       public Integer getWage(){
         return wage;
       }
   
       public void setWage(Integer wage){
         this.wage = wage;
       }
     }

7. Click File → Save to save the file.

8. Create a rule file in .drl format in my-project/src/main/resources/rules. The DRL file must contain at minimum a package specification, an import list of data objects to be used by the rule or rules, and one or more rules with when conditions and then actions.

   The following Wage.drl file contains a Wage rule that imports the Person class, calculates the wage and hourly rate values, and displays a message based on the result:

   package com.sample;
   
   import com.sample.Person;
   
   dialect "java"
   
   rule "Wage"
     when
       Person(hourlyRate * wage > 100)
       Person(name : firstName, surname : lastName)
     then
       System.out.println("Hello" + " " + name + " " + surname + "!");
       System.out.println("You are rich!");
   end

9. Click File → Save to save the file.

10. Create a main class and save it to the same directory as the Java object that you created. The main class will load the KIE base and execute rules.

    Note

    You can also add the main() method and Person class within a single Java object file, similar to the DroolsTest.java sample file.

11. In the main class, add the required import statements to import KIE services, a KIE container, and a KIE session. Then load the KIE base, insert facts, and execute the rule from the main() method that passes the fact model to the rule.

    In this example, a RulesTest.java file is created in my-project/src/main/java/com.sample with the required imports and main() method:

    package com.sample;
    
    import org.kie.api.KieServices;
    import org.kie.api.runtime.KieContainer;
    import org.kie.api.runtime.KieSession;
    
    public class RulesTest {
      public static final void main(String[] args) {
        try {
          // Load the KIE base:
          KieServices ks = KieServices.Factory.get();
          KieContainer kContainer = ks.getKieClasspathContainer();
          KieSession kSession = kContainer.newKieSession();
    
          // Set up the fact model:
          Person p = new Person();
          p.setWage(12);
          p.setFirstName("Tom");
          p.setLastName("Summers");
          p.setHourlyRate(10);
    
          // Insert the person into the session:
          kSession.insert(p);
    
          // Fire all rules:
          kSession.fireAllRules();
          kSession.dispose();
        }
    
        catch (Throwable t) {
          t.printStackTrace();
        }
      }
    }

12. Click File → Save to save the file.
13. After you create and save all DRL assets in your project, right-click your project folder and select Run As → Java Application to build the project. If the project build fails, address any problems described in the Problems tab of the lower window in Developer Studio, and try again to validate the project until the project builds.

Procedure

1. Create a Java object on which the rule or rules will operate.

   In this example, a Person.java file is created in a directory my-project. The Person class contains getter and setter methods to set and retrieve the first name, last name, hourly rate, and the wage of a person:

     public class Person {
       private String firstName;
       private String lastName;
       private Integer hourlyRate;
       private Integer wage;
   
       public String getFirstName() {
         return firstName;
       }
   
       public void setFirstName(String firstName) {
         this.firstName = firstName;
       }
   
       public String getLastName() {
         return lastName;
       }
   
       public void setLastName(String lastName) {
         this.lastName = lastName;
       }
   
       public Integer getHourlyRate() {
         return hourlyRate;
       }
   
       public void setHourlyRate(Integer hourlyRate) {
         this.hourlyRate = hourlyRate;
       }
   
       public Integer getWage(){
         return wage;
       }
   
       public void setWage(Integer wage){
         this.wage = wage;
       }
     }

2. Create a rule file in .drl format under the my-project directory. The DRL file must contain at minimum a package specification (if applicable), an import list of data objects to be used by the rule or rules, and one or more rules with when conditions and then actions.

   The following Wage.drl file contains a Wage rule that calculates the wage and hourly rate values and displays a message based on the result:

   package com.sample;
   
   import com.sample.Person;
   
   dialect "java"
   
   rule "Wage"
     when
       Person(hourlyRate * wage > 100)
       Person(name : firstName, surname : lastName)
     then
       System.out.println("Hello" + " " + name + " " + surname + "!");
       System.out.println("You are rich!");
   end

3. Create a main class and save it to the same directory as the Java object that you created. The main class will load the KIE base and execute rules.

4. In the main class, add the required import statements to import KIE services, a KIE container, and a KIE session. Then load the KIE base, insert facts, and execute the rule from the main() method that passes the fact model to the rule.

   In this example, a RulesTest.java file is created in my-project with the required imports and main() method:

   import org.kie.api.KieServices;
   import org.kie.api.runtime.KieContainer;
   import org.kie.api.runtime.KieSession;
   
   public class RulesTest {
     public static final void main(String[] args) {
       try {
         // Load the KIE base:
         KieServices ks = KieServices.Factory.get();
         KieContainer kContainer = ks.getKieClasspathContainer();
         KieSession kSession = kContainer.newKieSession();
   
         // Set up the fact model:
         Person p = new Person();
         p.setWage(12);
         p.setFirstName("Tom");
         p.setLastName("Summers");
         p.setHourlyRate(10);
   
         // Insert the person into the session:
         kSession.insert(p);
   
         // Fire all rules:
         kSession.fireAllRules();
         kSession.dispose();
       }
   
       catch (Throwable t) {
         t.printStackTrace();
       }
     }
   }

5. Download the Red Hat Decision Manager 7.1.0 Source Distribution ZIP file from the Red Hat Customer Portal and extract it under my-project/dm-engine-jars/.

6. In the my-project/META-INF directory, create a kmodule.xml metadata file with the following content:

   <?xml version="1.0" encoding="UTF-8"?>
   <kmodule xmlns="http://www.drools.org/xsd/kmodule">
   </kmodule>

   This kmodule.xml file is a KIE module descriptor that selects resources to KIE bases and configures sessions. This file enables you to define and configure one or more KIE bases, and to include DRL files from specific packages in a specific KIE base. You can also create one or more KIE sessions from each KIE base.

   The following example shows a more advanced kmodule.xml file:

   <?xml version="1.0" encoding="UTF-8"?>
   <kmodule xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.drools.org/xsd/kmodule">
     <kbase name="KBase1" default="true" eventProcessingMode="cloud" equalsBehavior="equality" declarativeAgenda="enabled" packages="org.domain.pkg1">
       <ksession name="KSession1_1" type="stateful" default="true" />
       <ksession name="KSession1_2" type="stateful" default="true" beliefSystem="jtms" />
     </kbase>
     <kbase name="KBase2" default="false" eventProcessingMode="stream" equalsBehavior="equality" declarativeAgenda="enabled" packages="org.domain.pkg2, org.domain.pkg3" includes="KBase1">
       <ksession name="KSession2_1" type="stateless" default="true" clockType="realtime">
         <fileLogger file="debugInfo" threaded="true" interval="10" />
         <workItemHandlers>
           <workItemHandler name="name" type="new org.domain.WorkItemHandler()" />
         </workItemHandlers>
         <listeners>
           <ruleRuntimeEventListener type="org.domain.RuleRuntimeListener" />
           <agendaEventListener type="org.domain.FirstAgendaListener" />
           <agendaEventListener type="org.domain.SecondAgendaListener" />
           <processEventListener type="org.domain.ProcessListener" />
         </listeners>
       </ksession>
     </kbase>
   </kmodule>

   This example defines two KIE bases. Two KIE sessions are instantiated from the KBase1 KIE base, and one KIE session from KBase2. The KIE session from KBase2 is a stateless KIE session, which means that data from a previous invocation of the KIE session (the previous session state) is discarded between session invocations. Specific packages of rule assets are included with both KIE bases. When you specify packages in this way, you must organize your DRL files in a folder structure that reflects the specified packages.

7. After you create and save all DRL assets in your Java object, navigate to the my-project directory in the command line and run the following command to build your Java files. Replace RulesTest.java with the name of your Java main class.

   javac -classpath "./dm-engine-jars/*:." RulesTest.java

   If the build fails, address any problems described in the command line error messages and try again to validate the Java object until the object passes.

8. After your Java files build successfully, run the following command to execute the rules locally. Replace RulesTest with the prefix of your Java main class.

   java -classpath "./dm-engine-jars/*:." RulesTest

9. Review the rules to ensure that they executed properly, and address any needed changes in the Java files.

Procedure

1. Navigate to a directory where you want to create a Maven archetype and run the following command:

   mvn archetype:generate -DgroupId=com.sample.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

   This creates a directory my-app with the following structure:

   my-app
   |-- pom.xml
   `-- src
       |-- main
       |   `-- java
       |       `-- com
       |           `-- sample
       |               `-- app
       |                   `-- App.java
       `-- test
           `-- java
               `-- com
                   `-- sample
                       `-- app
                           `-- AppTest.java

   The my-app directory contains the following key components:

   • A src/main directory for storing the application sources
   • A src/test directory for storing the test sources
   • A pom.xml file with the project configuration

2. Create a Java object on which the rule or rules will operate within the Maven archetype.

   In this example, a Person.java file is created in the directory my-app/src/main/java/com/sample/app. The Person class contains getter and setter methods to set and retrieve the first name, last name, hourly rate, and the wage of a person:

   package com.sample.app;
   
     public class Person {
   
       private String firstName;
       private String lastName;
       private Integer hourlyRate;
       private Integer wage;
   
       public String getFirstName() {
         return firstName;
       }
   
       public void setFirstName(String firstName) {
         this.firstName = firstName;
       }
   
       public String getLastName() {
         return lastName;
       }
   
       public void setLastName(String lastName) {
         this.lastName = lastName;
       }
   
       public Integer getHourlyRate() {
         return hourlyRate;
       }
   
       public void setHourlyRate(Integer hourlyRate) {
         this.hourlyRate = hourlyRate;
       }
   
       public Integer getWage(){
         return wage;
       }
   
       public void setWage(Integer wage){
         this.wage = wage;
       }
     }

3. Create a rule file in .drl format in my-app/src/main/resources/rules. The DRL file must contain at minimum a package specification, an import list of data objects to be used by the rule or rules, and one or more rules with when conditions and then actions.

   The following Wage.drl file contains a Wage rule that imports the Person class, calculates the wage and hourly rate values, and displays a message based on the result:

   package com.sample.app;
   
   import com.sample.app.Person;
   
   dialect "java"
   
   rule "Wage"
     when
       Person(hourlyRate * wage > 100)
       Person(name : firstName, surname : lastName)
     then
       System.out.println("Hello " + name + " " + surname + "!");
       System.out.println("You are rich!");
   end

4. In the my-app/src/main/resources/META-INF directory, create a kmodule.xml metadata file with the following content:

   <?xml version="1.0" encoding="UTF-8"?>
   <kmodule xmlns="http://www.drools.org/xsd/kmodule">
   </kmodule>

   This kmodule.xml file is a KIE module descriptor that selects resources to KIE bases and configures sessions. This file enables you to define and configure one or more KIE bases, and to include DRL files from specific packages in a specific KIE base. You can also create one or more KIE sessions from each KIE base.

   The following example shows a more advanced kmodule.xml file:

   <?xml version="1.0" encoding="UTF-8"?>
   <kmodule xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.drools.org/xsd/kmodule">
     <kbase name="KBase1" default="true" eventProcessingMode="cloud" equalsBehavior="equality" declarativeAgenda="enabled" packages="org.domain.pkg1">
       <ksession name="KSession1_1" type="stateful" default="true" />
       <ksession name="KSession1_2" type="stateful" default="true" beliefSystem="jtms" />
     </kbase>
     <kbase name="KBase2" default="false" eventProcessingMode="stream" equalsBehavior="equality" declarativeAgenda="enabled" packages="org.domain.pkg2, org.domain.pkg3" includes="KBase1">
       <ksession name="KSession2_1" type="stateless" default="true" clockType="realtime">
         <fileLogger file="debugInfo" threaded="true" interval="10" />
         <workItemHandlers>
           <workItemHandler name="name" type="new org.domain.WorkItemHandler()" />
         </workItemHandlers>
         <listeners>
           <ruleRuntimeEventListener type="org.domain.RuleRuntimeListener" />
           <agendaEventListener type="org.domain.FirstAgendaListener" />
           <agendaEventListener type="org.domain.SecondAgendaListener" />
           <processEventListener type="org.domain.ProcessListener" />
         </listeners>
       </ksession>
     </kbase>
   </kmodule>

   This example defines two KIE bases. Two KIE sessions are instantiated from the KBase1 KIE base, and one KIE session from KBase2. The KIE session from KBase2 is a stateless KIE session, which means that data from a previous invocation of the KIE session (the previous session state) is discarded between session invocations. Specific packages of rule assets are included with both KIE bases. When you specify packages in this way, you must organize your DRL files in a folder structure that reflects the specified packages.

5. In the my-app/pom.xml configuration file, specify the libraries that your application requires. Provide the Red Hat Decision Manager dependencies as well as the group ID, artifact ID, and version (GAV) of your application.

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.sample.app</groupId>
   <artifactId>my-app</artifactId>
   <version>1.0.0</version>
   <repositories>
     <repository>
       <id>jboss-ga-repository</id>
       <url>http://maven.repository.redhat.com/ga/</url>
     </repository>
   </repositories>
   <dependencies>
     <dependency>
       <groupId>org.drools</groupId>
       <artifactId>drools-compiler</artifactId>
       <version>VERSION</version>
     </dependency>
     <dependency>
       <groupId>org.kie</groupId>
       <artifactId>kie-api</artifactId>
       <version>VERSION</version>
     </dependency>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.11</version>
       <scope>test</scope>
     </dependency>
   </dependencies>
   </project>

   For information about Maven dependencies and the BOM (Bill of Materials) in Red Hat Decision Manager, see What is the mapping between Red Hat Decision Manager and Maven library version?.

6. Use the testApp method in my-app/src/test/java/com/sample/app/AppTest.java to test the rule. The AppTest.java file is created by Maven by default.

7. In the AppTest.java file, add the required import statements to import KIE services, a KIE container, and a KIE session. Then load the KIE base, insert facts, and execute the rule from the testApp() method that passes the fact model to the rule.

   import org.kie.api.KieServices;
   import org.kie.api.runtime.KieContainer;
   import org.kie.api.runtime.KieSession;
   
   public void testApp() {
   
     // Load the KIE base:
     KieServices ks = KieServices.Factory.get();
     KieContainer kContainer = ks.getKieClasspathContainer();
     KieSession kSession = kContainer.newKieSession();
   
     // Set up the fact model:
     Person p = new Person();
     p.setWage(12);
     p.setFirstName("Tom");
     p.setLastName("Summers");
     p.setHourlyRate(10);
   
     // Insert the person into the session:
     kSession.insert(p);
   
     // Fire all rules:
     kSession.fireAllRules();
     kSession.dispose();
   }

8. After you create and save all DRL assets in your Maven archetype, navigate to the my-app directory in the command line and run the following command to build your files:

   mvn clean install

   If the build fails, address any problems described in the command line error messages and try again to validate the files until the build is successful.

9. After your files build successfully, run the following command to execute the rules locally. Replace com.sample.app with your package name.

   mvn exec:java -Dexec.mainClass="com.sample.app"

10. Review the rules to ensure that they executed properly, and address any needed changes in the files.