3.3. Packaging and deploying a Red Hat Decision Manager project in a Java application

Procedure

1. In your client application, add the following dependencies to the relevant classpath of your Java project to generate an executable rule model from your rule assets:

   • drools-canonical-model: Enables an executable canonical representation of a rule set model that is independent from Red Hat Decision Manager
   • drools-model-compiler: Compiles the executable model into Red Hat Decision Manager internal data structures so that it can be executed by the decision engine

   <dependency>
     <groupId>org.drools</groupId>
     <artifactId>drools-canonical-model</artifactId>
     <version>${rhdm.version}</version>
   </dependency>
   
   <dependency>
     <groupId>org.drools</groupId>
     <artifactId>drools-model-compiler</artifactId>
     <version>${rhdm.version}</version>
   </dependency>

   Executable rule models are embeddable models that provide a Java-based representation of a rule set for execution at build time. The executable model is a more efficient alternative to the standard asset packaging in Red Hat Decision Manager and enables KIE containers and KIE bases to be created more quickly, especially when you have large lists of DRL (Drools Rule Language) files and other Red Hat Decision Manager assets.

   For more information about executable rule models, see Designing a decision service using DRL rules.

   To enable Decision Model and Notation (DMN) executable models for DMN assets in your project (if applicable), also add the kie-dmn-core dependency in the pom.xml file:

   <dependency>
     <groupId>org.kie</groupId>
     <artifactId>kie-dmn-core</artifactId>
     <scope>provided</scope>
     <version>${rhdm.version}</version>
   </dependency>

   The <version> is the Maven artifact version for Red Hat Decision Manager currently used in your project (for example, 7.26.0.Final-redhat-00005).

   注記

   Instead of specifying a Red Hat Decision Manager <version> for individual dependencies, consider adding the Red Hat Business Automation bill of materials (BOM) dependency to your project pom.xml file. The Red Hat Business Automation BOM applies to both Red Hat Decision Manager and Red Hat Process Automation Manager. When you add the BOM files, the correct versions of transitive dependencies from the provided Maven repositories are included in the project.

   Example BOM dependency:

   <dependency>
     <groupId>com.redhat.ba</groupId>
     <artifactId>ba-platform-bom</artifactId>
     <version>7.5.1.redhat-00001</version>
     <scope>import</scope>
     <type>pom</type>
   </dependency>

   For more information about the Red Hat Business Automation BOM, see What is the mapping between Red Hat Decision Manager and the Maven library version?.

2. Use the KieServices API to create a KieModuleModel instance with the desired KIE base and KIE session. The KieServices API enables you to access all KIE building and runtime configurations. The KieModuleModel instance generates the kmodule.xml file for your project.

   For more information about kmodule.xml configuration, see 「Configuring a KIE module descriptor file」.

3. Convert your KieModuleModel instance into XML and add the XML to KieFileSystem.

   Creating kmodule.xml programmatically and adding it to KieFileSystem

   import org.kie.api.KieServices;
   import org.kie.api.builder.model.KieModuleModel;
   import org.kie.api.builder.model.KieBaseModel;
   import org.kie.api.builder.model.KieSessionModel;
   import org.kie.api.builder.KieFileSystem;
   
     KieServices kieServices = KieServices.Factory.get();
     KieModuleModel kieModuleModel = kieServices.newKieModuleModel();
   
     KieBaseModel kieBaseModel1 = kieModuleModel.newKieBaseModel("KBase1")
       .setDefault(true)
       .setEqualsBehavior(EqualityBehaviorOption.EQUALITY)
       .setEventProcessingMode(EventProcessingOption.STREAM);
   
     KieSessionModel ksessionModel1 = kieBaseModel1.newKieSessionModel("KSession1")
       .setDefault(true)
       .setType(KieSessionModel.KieSessionType.STATEFUL)
       .setClockType(ClockTypeOption.get("realtime"));
   
     KieFileSystem kfs = kieServices.newKieFileSystem();
     kfs.writeKModuleXML(kieModuleModel.toXML());

4. Add any remaining Red Hat Decision Manager assets that you use in your project to your KieFileSystem instance. The artifacts must be in a Maven project file structure.

   import org.kie.api.builder.KieFileSystem;
   
     KieFileSystem kfs = ...
     kfs.write("src/main/resources/KBase1/ruleSet1.drl", stringContainingAValidDRL)
       .write("src/main/resources/dtable.xls",
         kieServices.getResources().newInputStreamResource(dtableFileStream));

   In this example, the project assets are added both as a String variable and as a Resource instance. You can create the Resource instance using the KieResources factory, also provided by the KieServices instance. The KieResources class provides factory methods to convert InputStream, URL, and File objects, or a String representing a path of your file system to a Resource instance that the KieFileSystem can manage.

   You can also explicitly assign a ResourceType property to a Resource object when you add project artifacts to KieFileSystem:

   import org.kie.api.builder.KieFileSystem;
   
     KieFileSystem kfs = ...
     kfs.write("src/main/resources/myDrl.txt",
       kieServices.getResources().newInputStreamResource(drlStream)
         .setResourceType(ResourceType.DRL));

5. Use KieBuilder with buildAll( ExecutableModelProject.class ) specified to build the content of KieFileSystem from an executable model, and create a KIE container to deploy it:

   import org.kie.api.KieServices;
   import org.kie.api.KieServices.Factory;
   import org.kie.api.builder.KieFileSystem;
   import org.kie.api.builder.KieBuilder;
   import org.kie.api.runtime.KieContainer;
   
     KieServices kieServices = KieServices.Factory.get();
     KieFileSystem kfs = ...
   
     KieBuilder kieBuilder = ks.newKieBuilder( kfs );
     // Build from an executable model
     kieBuilder.buildAll( ExecutableModelProject.class )
     assertEquals(0, kieBuilder.getResults().getMessages(Message.Level.ERROR).size());
   
     KieContainer kieContainer = kieServices
       .newKieContainer(kieServices.getRepository().getDefaultReleaseId());

   After KieFileSystem is built from the executable model, the resulting KieSession uses constraints based on lambda expressions instead of less-efficient mvel expressions. To build the project in the standard method without an executable model, do not specify any argument in buildAll().

   A build ERROR indicates that the project compilation failed, no KieModule was produced, and nothing was added to the KieRepository singleton. A WARNING or an INFO result indicates that the compilation of the project was successful, with information about the build process.