3.2. Packaging and deploying a Red Hat Decision Manager project in Maven

Procedure

1. In the pom.xml file of your Maven project, set the packaging type to kjar and add the kie-maven-plugin build component:

   <packaging>kjar</packaging>
   ...
   <build>
     <plugins>
       <plugin>
         <groupId>org.kie</groupId>
         <artifactId>kie-maven-plugin</artifactId>
         <version>${rhdm.version}</version>
         <extensions>true</extensions>
       </plugin>
     </plugins>
   </build>

   The kjar packaging type activates the kie-maven-plugin component to validate and pre-compile artifact resources. 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). These settings are required to properly package the Maven project for deployment.

   注記

   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. Add the following dependencies to the pom.xml file 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>

3. In the ~/resources directory of your Maven project, create a META-INF/kmodule.xml metadata file with at least 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 is required for all Red Hat Decision Manager projects. You can use the KIE module to define one or more KIE bases and one or more KIE sessions from each KIE base.

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

4. In the relevant resource in your Maven project, configure a .java class to create a KIE container and a KIE session to load the KIE base:

   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();
   
   }

   In this example, the KIE container reads the files to be built from the class path for a testApp project. The KieServices API enables you to access all KIE building and runtime configurations.

   You can also create the KIE container by passing the project ReleaseId to the KieServices API. The ReleaseId is generated from the GroupId, ArtifactId, and Version (GAV) values in the project pom.xml file.

   import org.kie.api.KieServices;
   import org.kie.api.builder.ReleaseId;
   import org.kie.api.runtime.KieContainer;
   import org.kie.api.runtime.KieSession;
   import org.drools.compiler.kproject.ReleaseIdImpl;
   
   public void testApp() {
   
     // Identify the project in the local repository:
     ReleaseId rid = new ReleaseIdImpl("com.sample", "my-app", "1.0.0");
   
     // Load the KIE base:
     KieServices ks = KieServices.Factory.get();
     KieContainer kContainer = ks.newKieContainer(rid);
     KieSession kSession = kContainer.newKieSession();
   
   }

5. In a command terminal, navigate to your Maven project directory and run the following command to build the project from an executable model:

   mvn clean install -DgenerateModel=<VALUE>

   The -DgenerateModel=<VALUE> property enables the project to be built as a model-based KJAR instead of a DRL-based KJAR, so that rule assets are built in an executable rule model.

   Replace <VALUE> with one of three values:

   • YES: Generates the executable model corresponding to the DRL files in the original project and excludes the DRL files from the generated KJAR.
   • WITHDRL: Generates the executable model corresponding to the DRL files in the original project and also adds the DRL files to the generated KJAR for documentation purposes (the KIE base is built from the executable model regardless).
   • NO: Does not generate the executable model.

   Example build command:

   mvn clean install -DgenerateModel=YES

   For DMN executable models, run the following command:

   mvn clean install -DgenerateDMNModel=YES

   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.

6. After you successfully build and test the project locally, deploy the project to the remote Maven repository:

   mvn deploy