部署和管理 Red Hat Process Automation Manager 服务

流程

1. 在 Red Hat Process Automation Manager 安装目录中，进入 standalone-full.xml 文件。例如，如果您为 Red Hat Process Automation Manager 使用 Red Hat JBoss EAP 安装，请转至 $EAP_HOME/standalone/configuration/standalone-full.xml。

2. 打开 standalone-full.xml 文件并在 < system-properties&gt; 标签下设置以下 JVM 属性：

   表 2.1. KIE 服务器实例的 JVM 属性

   属性	值	备注
   org.kie.server.id	default-kie-server	KIE 服务器 ID。
   org.kie.server.controller	http://localhost:8080/business-central/rest/controller	Business Central 的位置。用于连接到 Business Central API 的 URL。
   org.kie.server.controller.user	controllerUser	具有可登录到 Business Central 的角色 rest-all 的用户名。
   org.kie.server.controller.pwd	controllerUser1234;	可以登录到 Business Central 的用户的密码。
   org.kie.server.location	http://localhost:8080/kie-server/services/rest/server	KIE 服务器的位置。用于连接到 KIE 服务器的 API 的 URL。

   表 2.2. Business Central 实例的 JVM 属性

   属性	值	备注
   org.kie.server.user	controllerUser	角色 kie-server 的用户名。
   org.kie.server.pwd	controllerUser1234;	用户的密码。

   以下示例演示了如何配置 KIE 服务器实例：

   <property name="org.kie.server.id" value="default-kie-server"/>
   <property name="org.kie.server.controller" value="http://localhost:8080/business-central/rest/controller"/>
   <property name="org.kie.server.controller.user" value="controllerUser"/>
   <property name="org.kie.server.controller.pwd" value="controllerUser1234;"/>
   <property name="org.kie.server.location" value="http://localhost:8080/kie-server/services/rest/server"/>

   以下示例演示了如何为 Business Central 实例配置：

   <property name="org.kie.server.user" value="controllerUser"/>
   <property name="org.kie.server.pwd" value="controllerUser1234;"/>

3. 要验证 KIE 服务器是否已成功启动，请在 KIE 服务器运行时向 http://SERVER:PORT/kie-server/services/rest/server/ 发送 GET 请求。有关在 KIE 服务器上运行 Red Hat Process Automation Manager 的更多信息，请参阅 运行 Red Hat Process Automation Manager。

   成功验证后，您会收到类似以下示例的 XML 响应：

   <response type="SUCCESS" msg="Kie Server info">
       <kie-server-info>
           <capabilities>KieServer</capabilities>
           <capabilities>BRM</capabilities>
           <capabilities>BPM</capabilities>
           <capabilities>CaseMgmt</capabilities>
           <capabilities>BPM-UI</capabilities>
           <capabilities>BRP</capabilities>
           <capabilities>DMN</capabilities>
           <capabilities>Swagger</capabilities>
           <location>http://localhost:8230/kie-server/services/rest/server</location>
           <messages>
               <content>Server KieServerInfo{serverId='first-kie-server', version='7.5.1.Final-redhat-1', location='http://localhost:8230/kie-server/services/rest/server', capabilities=[KieServer, BRM, BPM, CaseMgmt, BPM-UI, BRP, DMN, Swagger]}started successfully at Mon Feb 05 15:44:35 AEST 2018</content>
               <severity>INFO</severity>
               <timestamp>2018-02-05T15:44:35.355+10:00</timestamp>
           </messages>
           <name>first-kie-server</name>
           <id>first-kie-server</id>
           <version>7.5.1.Final-redhat-1</version>
       </kie-server-info>
   </response>

4. 验证注册是否成功：

   1. 登录 Business Central。

   2. 点 Menu → Deploy → Execution Servers。

      如果注册成功，您会看到注册的服务器 ID。

流程

1. 要配置 KIE 服务器环境模式，请将 org.kie.server.mode 系统属性设置为 org.kie.server.mode=development 或 org.kie.server.mode=production。

2. 要在 Business Central 中为项目配置部署行为，请转至 Settings → General Settings → Version，并切换 Development Mode 选项。

   注意

   默认情况下，Business Central 中的 KIE 服务器和所有新项目都处于开发模式。

   您不能部署启用了 开发模式 的项目，或手动将 SNAPSHOT 版本后缀添加到处于生产环境模式的 KIE 服务器中。

流程

1. 创建一个 Maven settings.xml 文件，其中包含外部存储库的连接和访问详情。有关 settings.xml 文件的详情，请查看 Maven 设置参考。
2. 将文件保存到已知位置，例如 /opt/custom-config/settings.xml。
3. 在 Red Hat Process Automation Manager 安装目录中，进入 standalone-full.xml 文件。例如，如果您为 Red Hat Process Automation Manager 使用 Red Hat JBoss EAP 安装，请转至 $EAP_HOME/standalone/configuration/standalone-full.xml。

4. 打开 standalone-full.xml 并在 & lt;system-properties > 标签下，将 kie.maven.settings.custom 属性设置为 settings.xml 文件的完整路径名称。

   例如：

   <property name="kie.maven.settings.custom" value="/opt/custom-config/settings.xml"/>

5. 启动或重启 Business Central 和 KIE 服务器。

流程

1. 在 Business Central 中，进入 Menu → Design → Projects，点项目名称，然后选择项目中的任何资产。
2. 在屏幕左侧的 Project Explorer 菜单中，点 Customize View gear 图标并选择 Repository View → pom.xml。

3. 在项目 pom.xml 文件的末尾添加以下设置(</project&gt ; 关闭标签之前)。这些值必须与您在 settings.xml 文件中定义的设置对应。

   <distributionManagement>
   <repository>
   <id>${maven-repo-id}</id>
   <url>${maven-repo-url}</url>
   <layout>default</layout>
   </repository>
   </distributionManagement>

4. 点 Save 保存 pom.xml 文件更改。

流程

1. 在 Business Central 中，进入 Menu → Design → Projects，然后点击项目名称。

2. 在右上角，单击 Deploy 以构建项目并将其部署到 KIE 服务器中。要在不将其部署到 KIE 服务器的情况下编译项目，请点 Build。

   注意

   您还可以选择 Build & Install 选项来构建项目，并将 KJAR 文件发布到配置的 Maven 存储库，而无需部署到 KIE Server。在开发环境中，您可以点 Deploy 将构建的 KJAR 文件部署到 KIE 服务器中，而不停止任何正在运行的实例（如果适用），或者点 Redeploy 来部署构建的 KJAR 文件并替换所有实例。您下次部署或重新部署构建的 KJAR 时，以前的部署单元(KIE 容器)会在相同的目标 KIE 服务器中自动更新。在生产环境中，Redeploy 选项被禁用，您可以点 Deploy only 将构建的 KJAR 文件部署到 KIE Server 上的新部署单元(KIE 容器)。

   要配置 KIE 服务器环境模式，请将 org.kie.server.mode 系统属性设置为 org.kie.server.mode=development 或 org.kie.server.mode=production。要在 Business Central 中为对应项目配置部署行为，请转至 Project Settings → General Settings → Version 并切换 Development Mode 选项。默认情况下，Business Central 中的 KIE 服务器和所有新项目都处于开发模式。您不能部署启用了 开发模式 的项目，或手动将 SNAPSHOT 版本后缀添加到处于生产环境模式的 KIE 服务器中。

   如果只有一个 KIE 服务器连接到 Business Central，或者所有连接的 KIE 服务器都位于同一服务器配置中，则项目中的服务会在部署单元(KIE 容器)中自动启动。

   如果有多个服务器配置，在 Business Central 中会显示一个部署对话框，提示您指定服务器和部署详情。

3. 如果出现部署对话框，请验证或设置以下值：

   • 部署单元 Id / Deployment Unit Alias ： 验证在 KIE 服务器中运行该服务的部署单元(KIE 容器)的名称和别名。您通常不需要更改这些设置。有关 KIE 容器别名的更多信息，请参阅 第 2.6.3 节 “KIE 容器别名”。
   • 服务器配置： 选择用于部署此项目的服务器配置。之后，您可以在不重建项目的情况下将其部署到其他配置的服务器。
   • 启动部署单元？： 验证是否选择此框来启动部署单元(KIE 容器)。如果您清除此框，该服务将部署到服务器上，但不会启动。

   要查看项目部署详情，请单击屏幕顶部的部署横幅中的 View deployment details 或 Deploy 下拉菜单。这个选项会将您定向到 Menu → Deploy → Execution Servers 页面。

流程

1. 在 Business Central 中，进入 Menu → Design → Projects，然后点击项目名称。
2. 点 Project Settings 选项卡。

3. 在 General Settings 中，根据需要修改 Group ID、Artifact ID 或 Version 字段。如果您部署了项目并正在开发新版本，通常您需要增加版本号。

   注意

   对于开发目的，您可以在项目 Settings → General Settings → Version 中切换 Development Mode 选项，以便在项目版本中添加 SNAPSHOT 后缀。此后缀指示 Maven 根据 Maven 策略获取新的快照更新。不要使用 Development Mode，或为生产环境手动添加 SNAPSHOT 版本后缀。

4. 单击 Save 以完成。

流程

1. 在项目的 ~/resources/META-INF 目录中，创建一个包含以下内容的 kmodule.xml 元数据文件：

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

   这个空的 kmodule.xml 文件足以生成一个默认 KIE 基础，其中包含 项目资源 路径下找到的所有文件。默认 KIE 基础还包括一个默认 KIE 会话，该会话会在构建时在应用程序中创建 KIE 容器时触发。

   以下示例是更高级的 kmodule.xml 文件：

   <?xml version="1.0" encoding="UTF-8"?>
   <kmodule xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.drools.org/xsd/kmodule">
     <configuration>
         <property key="drools.evaluator.supersetOf" value="org.mycompany.SupersetOfEvaluatorDefinition"/>
     </configuration>
     <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>

   这个示例定义了两个 KIE 基础。KIE 基础中包含特定规则资产 软件包。以这种方式指定软件包时，您必须使用反映指定软件包的文件夹结构来组织您的规则文件。两个 KIE 会话是从 KBase1 KIE 基础实例化的，来自 KBase2 的 KIE 会话。KBase2 中的 KIE 会话是一个 无状态 KIE 会话，这意味着之前调用 KIE 会话（之前会话状态）的数据在会话调用之间被丢弃。KIE 会话还指定文件（或控制台）日志记录器、WorkItemHandler 以及显示的三种类型的监听程序： ruleRuntimeEventListener、MuterEventListener 和 processEventListener。& lt;configuration > 元素定义了可用于进一步自定义 kmodule.xml 文件的可选属性。

   作为手动将 kmodule.xml 文件手动附加到项目的替代选择，您可以使用 Java 应用程序中的 KieModuleModel 实例以编程方式创建一个 kmodule.xml 文件来定义 KIE 基础和 KIE 会话，然后将项目中的所有资源添加到 KIE 虚拟文件系统 KieFileSystem。

   以编程方式创建 kmodule.xml，并将其添加到 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_1")
     .setDefault(true)
     .setType(KieSessionModel.KieSessionType.STATEFUL)
     .setClockType(ClockTypeOption.get("realtime"));
   
   KieFileSystem kfs = kieServices.newKieFileSystem();
   kfs.writeKModuleXML(kieModuleModel.toXML());

2. 在项目中手动配置 kmodule.xml 文件后，以编程方式从 KIE 容器检索 KIE 基础和 KIE 会话以验证配置：

   KieServices kieServices = KieServices.Factory.get();
   KieContainer kContainer = kieServices.getKieClasspathContainer();
   
   KieBase kBase1 = kContainer.getKieBase("KBase1");
   KieSession kieSession1 = kContainer.newKieSession("KSession1_1"),
       kieSession2 = kContainer.newKieSession("KSession1_2");
   
   KieBase kBase2 = kContainer.getKieBase("KBase2");
   StatelessKieSession kieSession3 = kContainer.newStatelessKieSession("KSession2_1");

   如果 kmodule.xml 文件中的 KieBase 或 KieSession 配置为 default="true"，如前面的 kmodule.xml 示例中所示，您可以在不传递任何名称的情况下从 KIE 容器检索它们：

   KieContainer kContainer = ...
   
   KieBase kBase1 = kContainer.getKieBase();
   KieSession kieSession1 = kContainer.newKieSession(),
       kieSession2 = kContainer.newKieSession();
   
   KieBase kBase2 = kContainer.getKieBase();
   StatelessKieSession kieSession3 = kContainer.newStatelessKieSession();

   要增加或减少决策引擎中缓存的 KIE 模块或工件版本的最大数量，您可以在 Red Hat Process Automation Manager 发行版本中修改以下系统属性值：

   • kie.repository.project.cache.size ：在决策引擎中缓存的最大 KIE 模块数。默认值 ：100
   • kie.repository.project.versions.cache.size: 在决策引擎中缓存的同一工件的最大版本数。默认值 ：10

   如需 KIE 存储库配置的完整列表，请从红帽客户门户网站下载 Red Hat Process Automation Manager 7.11.0 Source Distribution ZIP 文件，并进入 ~/rhpam-7.11.0-sources/src/drools-$VERSION/drools-compiler/src/main/java/org/drools/compiler/kie/builder/impl/KieRepositoryImpl.java。https://access.redhat.com/jbossnetwork/restricted/listSoftware.html

流程

1. 在 Maven 项目的 pom.xml 文件中，将打包类型设置为 kjar，并添加 kie-maven-plugin 构建组件：

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

   kjar 打包类型激活 kie-maven-plugin 组件以验证和预编译工件资源。& lt;version > 是项目中当前使用的 Red Hat Process Automation Manager 的 Maven 工件版本（例如： 7.52.0.Final-redhat-00007）。需要这些设置来正确地打包 Maven 项目进行部署。

   注意

   考虑将 Red Hat Business Automation Manager (BOM)依赖项添加到项目 pom.xml 文件，而不是为单个依赖项指定 Red Hat Process Automation Manager < version >。Red Hat Business Automation BOM 适用于 Red Hat Decision Manager 和 Red Hat Process Automation Manager。当您添加 BOM 文件时，项目中包含了来自提供的 Maven 存储库传输性依赖关系的正确版本。

   BOM 依赖项示例：

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

   有关 Red Hat Business Automation BOM 的更多信息，请参阅 Red Hat Process Automation Manager 和 Maven 库版本之间的映射是什么？

2. 可选：如果您的项目包含 Decision Model 和 Notation (DMN)资产，还要在 pom.xml 文件中添加以下依赖项来启用 DMN 可执行模型。DMN 可执行模型可让 DMN 项目中的 DMN 决策表逻辑更有效地评估。

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

3. 在 Maven 项目的 ~/resources 目录中，创建一个包含以下内容的 META-INF/kmodule.xml 元数据文件：

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

   此 kmodule.xml 文件是所有 Red Hat Process Automation Manager 项目所需的 KIE 模块描述符。您可以使用 KIE 模块来定义一个或多个 KIE 基础，以及每个 KIE 基础的一个或多个 KIE 会话。

   有关 kmodule.xml 配置的详情，请参考 第 3.1 节 “配置 KIE 模块描述符文件”。

4. 在 Maven 项目中的相关资源中，配置 .java 类来创建 KIE 容器和 KIE 会话来加载 KIE 基础：

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

   在本例中，KIE 容器读取要从 testApp 项目的类路径构建的文件。KieServices API 可让您访问所有 KIE 构建和运行时配置。

   您还可以通过将项目 ReleaseId 传递给 KieServices API 来创建 KIE 容器。ReleaseId 通过项目 pom.xml 文件中的 GroupId、ArterfactId 和 Version (GAV) 值生成。

   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. 在命令终端中，导航到 Maven 项目目录，并运行以下命令来构建项目：

   mvn clean install

   对于 DMN 可执行模型，请运行以下命令：

   mvn clean install -DgenerateDMNModel=YES

   如果构建失败，请解决命令行错误消息中描述的任何问题，并尝试验证文件，直到构建成功为止。

   注意

   如果 Maven 项目中的规则资产默认没有从可执行文件规则模型构建，请验证以下依赖项是否在项目的 pom.xml 文件中，并重建项目：

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

   默认情况下，Red Hat Process Automation Manager 中的规则资产需要此依赖项。此依赖项作为 Red Hat Process Automation Manager 核心打包的一部分包括，但取决于您的 Red Hat Process Automation Manager 升级历史记录，您可能需要手动添加此依赖项来启用可执行的规则模型行为。

   有关可执行规则模型的详情请参考 第 3.4 节 “可执行规则模型”。

6. 成功在本地构建并测试项目后，将项目部署到远程 Maven 存储库：

   mvn deploy

流程

1. 可选：如果您的项目包含 Decision Model 和 Notation (DMN)资产，请将以下依赖项添加到 Java 项目的相关类路径中，以启用 DMN 可执行模型。DMN 可执行模型可让 DMN 项目中的 DMN 决策表逻辑更有效地评估。

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

   & lt;version > 是项目中当前使用的 Red Hat Process Automation Manager 的 Maven 工件版本（例如： 7.52.0.Final-redhat-00007）。

   注意

   考虑将 Red Hat Business Automation Manager (BOM)依赖项添加到项目 pom.xml 文件，而不是为单个依赖项指定 Red Hat Process Automation Manager < version >。Red Hat Business Automation BOM 适用于 Red Hat Decision Manager 和 Red Hat Process Automation Manager。当您添加 BOM 文件时，项目中包含了来自提供的 Maven 存储库传输性依赖关系的正确版本。

   BOM 依赖项示例：

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

   有关 Red Hat Business Automation BOM 的更多信息，请参阅 Red Hat Process Automation Manager 和 Maven 库版本之间的映射是什么？

2. 使用 KieServices API 创建带有所需 KIE 基础和 KIE 会话的 KieModuleModel 实例。KieServices API 可让您访问所有 KIE 构建和运行时配置。KieModuleModel 实例为您的项目生成 kmodule.xml 文件。

   有关 kmodule.xml 配置的详情，请参考 第 3.1 节 “配置 KIE 模块描述符文件”。

3. 将您的 KieModuleModel 实例转换为 XML，并将 XML 添加到 KieFileSystem。

   以编程方式创建 kmodule.xml，并将其添加到 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. 将项目中使用的剩余的 Red Hat Process Automation Manager 资产添加到 KieFileSystem 实例中。工件必须采用 Maven 项目文件结构。

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

   在本例中，项目资产同时添加为 String 变量和 Resource 实例。您可以使用 KieResources 工厂创建 Resource 实例，也由 KieServices 实例提供。KieResources 类提供了将 InputStream, URL, 和 File 对象，或一个代表您的文件系统路径的 String 转换到一个 KieFileSystem 可以管理的 Resource 实例的方法。

   当将项目工件添加到 KieFileSystem 时，您还可以为 Resource 对象明确分配一个 ResourceType 属性：

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

5. 使用带有 buildAll （） 方法的 KieBuilder 来构建 KieFileSystem 的内容，并创建一个 KIE 容器来部署它：

   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 );
     kieBuilder.buildAll()
     assertEquals(0, kieBuilder.getResults().getMessages(Message.Level.ERROR).size());
   
     KieContainer kieContainer = kieServices
       .newKieContainer(kieServices.getRepository().getDefaultReleaseId());

   构建 ERROR 表示项目编译失败，没有生成 KieModule，且不会将任何内容添加到 KieRepository 单例中。WARNING 或 INFO 结果表示项目的编译成功，其中包含构建过程的相关信息。

   注意

   要从可执行规则模型构建 Java 应用程序项目中的规则资产，请验证以下依赖项是否在项目的 pom.xml 文件中：

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

   Red Hat Process Automation Manager 中的规则资产需要这个依赖项，才能从可执行规则模型构建。此依赖项作为 Red Hat Process Automation Manager 核心打包的一部分包括，但取决于您的 Red Hat Process Automation Manager 升级历史记录，您可能需要手动添加此依赖项来启用可执行的规则模型行为。

   验证依赖项后，使用以下修改后的 buildAll （） 选项来启用可执行模型：

   kieBuilder.buildAll(ExecutableModelProject.class)

   有关可执行规则模型的详情请参考 第 3.4 节 “可执行规则模型”。

流程

1. 在项目中相关的 .java 类中，注册并启动 KIE 扫描程序，如下例所示：

   为 KIE 容器注册并启动 KIE 扫描程序

   import org.kie.api.KieServices;
   import org.kie.api.builder.ReleaseId;
   import org.kie.api.runtime.KieContainer;
   import org.kie.api.builder.KieScanner;
   
   ...
   
   KieServices kieServices = KieServices.Factory.get();
   ReleaseId releaseId = kieServices
     .newReleaseId("com.sample", "my-app", "1.0-SNAPSHOT");
   KieContainer kContainer = kieServices.newKieContainer(releaseId);
   KieScanner kScanner = kieServices.newKieScanner(kContainer);
   
   // Start KIE scanner for polling the Maven repository every 10 seconds (10000 ms)
   kScanner.start(10000L);

   在本例中，KIE 扫描程序被配置为使用固定时间间隔运行。最小 KIE 扫描程序轮询的间隔为 1 毫秒 (ms)，最大轮询间隔是数据类型 long 的最大值。轮询间隔为 0 或更少的结果会导致 java.lang.IllegalArgumentException: pollingInterval 必须是正 错误。您还可以通过调用 scanNow （） 方法将 KIE 扫描程序配置为按需运行。

   示例中的项目组 ID、工件 ID 和版本(GAV)设置定义为 com.sample:my-app:1.0-SNAPSHOT。项目版本必须包含 -SNAPSHOT 后缀，以便 KIE 扫描程序能够检索指定工件版本的最新构建。如果您更改了快照项目版本号，如增加到 1.0.1-SNAPSHOT，那么您还必须更新 KIE 扫描程序配置中 GAV 定义中的版本。KIE 扫描程序不会检索带有静态版本的项目的更新，如 com.sample:my-app:1.0。

2. 在 Maven 存储库的 settings.xml 文件中，将 updatePolicy 配置设置为 always，以便 KIE 扫描程序正常工作：

   <profile>
     <id>guvnor-m2-repo</id>
     <repositories>
       <repository>
         <id>guvnor-m2-repo</id>
         <name>BA Repository</name>
         <url>http://localhost:8080/business-central/maven2/</url>
         <layout>default</layout>
         <releases>
           <enabled>true</enabled>
           <updatePolicy>always</updatePolicy>
         </releases>
         <snapshots>
           <enabled>true</enabled>
           <updatePolicy>always</updatePolicy>
         </snapshots>
       </repository>
     </repositories>
   </profile>

   KIE 扫描程序开始轮询后，如果 KIE 扫描程序在指定 KIE 容器中检测到 SNAPSHOT 项目的更新版本，则 KIE 扫描程序会自动下载新项目版本并触发新项目的增量构建。目前，从 KIE 容器创建的所有新 KieBase 和 KieSession 对象都使用新项目版本。

   有关使用 KIE 服务器 API 启动或停止 KIE 扫描程序的详情，请参考 使用 KIE API 与 Red Hat Process Automation Manager 交互。

流程

1. 在 Business Central 中，进入 Menu → Design → Projects。
2. 在屏幕右上角，单击 Add Project 旁边的箭头，然后选择 Try Samples。
3. 选择 Mortgage_Process 并点 Ok。项目的 Assets 视图将打开。
4. 点击您要修改的资产。可以编辑所有资产来满足您的项目要求。

流程

1. 在 Business Central 中，进入 Menu → Design → Projects。
2. 选择或创建您要从 archetype 模板添加新项目的空间。
3. 单击 Add Project。
4. 在 Name 和 Description 字段中输入项目名称和描述。
5. 单击 Configure Advanced Options。
6. 选中 Based on template 复选框。
7. 如果需要，从下拉列表中选择 archetype。选择已在空间中设置的默认 archetype。
8. 点击 Add。

流程

1. 在 Business Central 中，进入 Menu → Design → Projects。
2. 单击项目以创建新分支，如 Mortgage_Process 示例项目。

3. 点 master → Add Branch。

   图 12.1. 创建新分支菜单

   
4. 在 Name 字段中输入 testBranch1，然后从 Add Branch 窗口中选择 master。其中 testBranch1 是您要命名新分支的任何名称。
5. 从 Add Branch 窗口中，选择作为新分支基础的分支。这可以是任何现有分支。

6. 点击 Add。

   图 12.2. 添加新分支窗口

   

流程

1. 单击当前分支名称，然后从下拉列表中选择所需的项目分支。

   图 12.3. 选择分支菜单

   

流程

1. 点击屏幕右上角的 并选择 Delete Branch。

   图 12.4. 删除分支

   
2. 在 Delete Branch 窗口中，输入您要删除的分支的名称。
3. 单击 Delete Branch。分支已删除，项目分支切换到 master 分支。

流程

1. 在 Business Central 中，进入 Menu → Design → Projects，然后点击项目名称。

2. 在右上角，单击 Deploy 以构建项目并将其部署到 KIE Server。

   注意

   您还可以选择 Build & Install 选项来构建项目，并将 KJAR 文件发布到配置的 Maven 存储库，而无需部署到 KIE Server。在开发环境中，您可以点 Deploy 将构建的 KJAR 文件部署到 KIE 服务器中，而不停止任何正在运行的实例（如果适用），或者点 Redeploy 来部署构建的 KJAR 文件并替换所有实例。您下次部署或重新部署构建的 KJAR 时，以前的部署单元(KIE 容器)会在相同的目标 KIE 服务器中自动更新。在生产环境中，Redeploy 选项被禁用，您可以点 Deploy only 将构建的 KJAR 文件部署到 KIE Server 上的新部署单元(KIE 容器)。

   要配置 KIE 服务器环境模式，请将 org.kie.server.mode 系统属性设置为 org.kie.server.mode=development 或 org.kie.server.mode=production。要在 Business Central 中为对应项目配置部署行为，请转至 Project Settings → General Settings → Version 并切换 Development Mode 选项。默认情况下，Business Central 中的 KIE 服务器和所有新项目都处于开发模式。您不能部署启用了 开发模式 的项目，或手动将 SNAPSHOT 版本后缀添加到处于生产环境模式的 KIE 服务器中。

   如果构建失败，请解决屏幕底部的 Alerts 面板中描述的任何问题。

   要查看项目部署详情，请单击屏幕顶部的部署横幅中的 View deployment details 或 Deploy 下拉菜单。这个选项会将您定向到 Menu → Deploy → Execution Servers 页面。

   有关项目部署选项的更多信息，请参阅 打包和部署 Red Hat Process Automation Manager 项目。

流程

1. 在 Business Central 中，进入 Menu → Design → Projects 并选择包含您要合并的更改的空间和项目。

2. 在项目页面上，选择包含更改的分支。

   图 13.1. 选择分支菜单

   

3. 执行以下任务之一以提交更改请求：

   • 点击屏幕右上角的 并选择 Submit Change Request。

   • 单击 Change Requests 选项卡，然后单击 Submit Change Request。

     此时会出现 Submit Change Request 窗口。

4. 输入摘要和描述，选择目标分支，然后单击 Submit。目标分支是更改将被合并的分支。点 Submit 后，将显示更改请求窗口。

流程

1. 在 Business Central 中，进入 Menu → Design → Projects 并选择空格和项目。

2. 在项目页面上，验证您是否位于正确的分支中。

   
3. 点 Change Requests 选项卡。此时会出现待处理的更改请求列表。
4. 要过滤更改请求，请选择 Search 框左面的 Open, Closed, 或 All
5. 要搜索特定的更改请求，请在 Search 框中输入 ID 或文本，然后点放大镜图标。

6. 要查看更改请求详情，请点概述链接。更改请求窗口有两个标签页：

   1. 查看 Overview 选项卡，以了解有关更改请求的常规信息。
   2. 点 Changed Files 选项卡，再展开一个文件来查看提议的更改。

7. 单击右上角的一个按钮。

   • 单击 Squash 和 Merge，将所有提交压缩到单个提交中，并将提交合并到目标分支中。
   • 点 Merge 将更改合并到目标分支中。
   • 单击 Reject 以拒绝更改，并使目标分支保持不变。
   • 点 Close 关闭更改请求，而不拒绝或接受它。请注意，只有创建提交更改请求的用户才能关闭它。
   • 单击 Cancel 以返回到项目窗口，而不进行任何更改。

流程

1. 识别您要发送请求的相关 API 端点，如 [GET] /server/containers，以从 KIE 服务器检索 KIE 容器。

2. 在 REST 客户端或 curl 工具中，为对 /server/containers 的 GET 请求输入以下组件。根据您的用例调整任何请求详情。

   对于 REST 客户端：

   • 身份验证 ：使用 kie-server 角色输入 KIE 服务器用户的用户名和密码。

   • HTTP 标头 ：设置以下标头：

     • 接受:application/json
   • HTTP 方法 ：设置为 GET。
   • URL ：输入 KIE Server REST API 基本 URL 和端点，如 http://localhost:8080/kie-server/services/rest/server/containers。

   对于 curl 工具：

   • -u ：使用 kie-server 角色输入 KIE 服务器用户的用户名和密码。

   • -h: 设置以下标头：

     • 接受:application/json
   • -x: 设置为 GET。
   • URL ：输入 KIE Server REST API 基本 URL 和端点，如 http://localhost:8080/kie-server/services/rest/server/containers。

   curl -u 'baAdmin:password@1' -H "Accept: application/json" -X GET "http://localhost:8080/kie-server/services/rest/server/containers"

3. 执行请求并查看 KIE 服务器响应。

   服务器响应示例(JSON)：

   {
     "type": "SUCCESS",
     "msg": "List of created containers",
     "result": {
       "kie-containers": {
         "kie-container": [
           {
             "container-id": "itorders_1.0.0-SNAPSHOT",
             "release-id": {
               "group-id": "itorders",
               "artifact-id": "itorders",
               "version": "1.0.0-SNAPSHOT"
             },
             "resolved-release-id": {
               "group-id": "itorders",
               "artifact-id": "itorders",
               "version": "1.0.0-SNAPSHOT"
             },
             "status": "STARTED",
             "scanner": {
               "status": "DISPOSED",
               "poll-interval": null
             },
             "config-items": [],
             "container-alias": "itorders"
           }
         ]
       }
     }
   }

4. 在本例中，从响应返回的其中一个部署的 KIE 容器复制或记下项目 group-id、artifact-id 和 version (GAV)数据。

5. 在 REST 客户端或 curl 实用程序中，发送带有以下内容的另外一个 API 请求，它向 /server/containers/{containerId} 发送一个 PUT 请求，以使用复制的项目 GAV 数据部署新的 KIE 容器。根据您的用例调整任何请求详情。

   对于 REST 客户端：

   • 身份验证 ：使用 kie-server 角色输入 KIE 服务器用户的用户名和密码。

   • HTTP 标头 ：设置以下标头：

     • 接受:application/json

     • content-Type:application/json

       注意

       将 fields=not_null 添加到 Content-Type 时，null 字段会从 REST API 响应中排除。

   • HTTP 方法 ：设置为 PUT。
   • URL ：输入 KIE Server REST API 基本 URL 和端点，如 http://localhost:8080/kie-server/services/rest/server/containers/MyContainer。
   • Request body ：使用新 KIE 容器的配置项添加 JSON 请求正文：

   {
     "config-items": [
       {
         "itemName": "RuntimeStrategy",
         "itemValue": "SINGLETON",
         "itemType": "java.lang.String"
       },
       {
         "itemName": "MergeMode",
         "itemValue": "MERGE_COLLECTIONS",
         "itemType": "java.lang.String"
       },
       {
         "itemName": "KBase",
         "itemValue": "",
         "itemType": "java.lang.String"
       },
       {
         "itemName": "KSession",
         "itemValue": "",
         "itemType": "java.lang.String"
       }
     ],
     "release-id": {
       "group-id": "itorders",
       "artifact-id": "itorders",
       "version": "1.0.0-SNAPSHOT"
     },
     "scanner": {
       "poll-interval": "5000",
       "status": "STARTED"
     }
   }

   对于 curl 工具：

   • -u ：使用 kie-server 角色输入 KIE 服务器用户的用户名和密码。

   • - h ：设置以下标头：

     • 接受:application/json

     • content-Type:application/json

       注意

       将 fields=not_null 添加到 Content-Type 时，null 字段会从 REST API 响应中排除。

   • -x ：设置为 PUT。
   • URL ：输入 KIE Server REST API 基本 URL 和端点，如 http://localhost:8080/kie-server/services/rest/server/containers/MyContainer。
   • -d ：添加 JSON 请求正文或文件(@file.json)，其中包含新 KIE 容器的配置项目：

   curl -u 'baAdmin:password@1' -H "Accept: application/json" -H "Content-Type: application/json" -X PUT "http://localhost:8080/kie-server/services/rest/server/containers/MyContainer" -d "{ \"config-items\": [ { \"itemName\": \"RuntimeStrategy\", \"itemValue\": \"SINGLETON\", \"itemType\": \"java.lang.String\" }, { \"itemName\": \"MergeMode\", \"itemValue\": \"MERGE_COLLECTIONS\", \"itemType\": \"java.lang.String\" }, { \"itemName\": \"KBase\", \"itemValue\": \"\", \"itemType\": \"java.lang.String\" }, { \"itemName\": \"KSession\", \"itemValue\": \"\", \"itemType\": \"java.lang.String\" } ], \"release-id\": { \"group-id\": \"itorders\", \"artifact-id\": \"itorders\", \"version\": \"1.0.0-SNAPSHOT\" }, \"scanner\": { \"poll-interval\": \"5000\", \"status\": \"STARTED\" }}"

   curl -u 'baAdmin:password@1' -H "Accept: application/json" -H "Content-Type: application/json" -X PUT "http://localhost:8080/kie-server/services/rest/server/containers/MyContainer" -d @my-container-configs.json

6. 执行请求并查看 KIE 服务器响应。

   服务器响应示例(JSON)：

   {
     "type": "SUCCESS",
     "msg": "Container MyContainer successfully deployed with module itorders:itorders:1.0.0-SNAPSHOT.",
     "result": {
       "kie-container": {
         "container-id": "MyContainer",
         "release-id": {
           "group-id": "itorders",
           "artifact-id": "itorders",
           "version": "1.0.0-SNAPSHOT"
         },
         "resolved-release-id": {
           "group-id": "itorders",
           "artifact-id": "itorders",
           "version": "1.0.0-SNAPSHOT"
         },
         "status": "STARTED",
         "scanner": {
           "status": "STARTED",
           "poll-interval": 5000
         },
         "config-items": [],
         "messages": [
           {
             "severity": "INFO",
             "timestamp": {
               "java.util.Date": 1540584717937
             },
             "content": [
               "Container MyContainer successfully created with module itorders:itorders:1.0.0-SNAPSHOT."
             ]
           }
         ],
         "container-alias": null
       }
     }
   }

   如果您遇到请求错误，请查看返回的错误代码信息并相应地调整您的请求。

   进程实例的 REST API 请求

   对于将复杂数据对象发送到进程实例端点 /server/containers/{containerId}/processes/{processId}/instances 的 REST API 请求，请确保在请求正文中包含完全限定类名称（如 com.myspace.Person）或简单类名称（如 Person）。请求正文需要类名称才能映射到 Red Hat Process Automation Manager 中的正确业务对象。如果您从请求中排除类名称，KIE 服务器不会将对象 unmarshall 到预期的类型。

   正确的进程实例请求正文

   {
     "id": 4,
     "lease": {
       "com.myspace.restcall.LeaseModel": {
         "annualRent": 109608,
         "isAutoApproved": false
       }
     }
   }

   进程实例请求正文不正确

   {
     "id": 4,
     "lease": {
       "annualRent": 109608,
       "isAutoApproved": false
     }
   }

流程

1. 在 Web 浏览器中，导航到 http://SERVER:PORT/kie-server/docs，如 http://localhost:8080/kie-server/docs，并使用 KIE Server 用户的用户名和密码登录，并具有 kie-server 角色。
2. 在 Swagger 页面中，选择要发送请求的相关 API 端点，如 KIE Server 和 KIE containers → [GET] /server/containers，以从 KIE 服务器检索 KIE 容器。
3. 点 Try it out，并提供您要过滤结果（如果需要）的任何可选参数。
4. 在 Response content type 下拉菜单中，选择服务器响应所需的格式，如 JSON 格式的 application/json。

5. 点 Execute 并查看 KIE 服务器响应。

   服务器响应示例(JSON)：

   {
     "type": "SUCCESS",
     "msg": "List of created containers",
     "result": {
       "kie-containers": {
         "kie-container": [
           {
             "container-id": "itorders_1.0.0-SNAPSHOT",
             "release-id": {
               "group-id": "itorders",
               "artifact-id": "itorders",
               "version": "1.0.0-SNAPSHOT"
             },
             "resolved-release-id": {
               "group-id": "itorders",
               "artifact-id": "itorders",
               "version": "1.0.0-SNAPSHOT"
             },
             "status": "STARTED",
             "scanner": {
               "status": "DISPOSED",
               "poll-interval": null
             },
             "config-items": [],
             "container-alias": "itorders"
           }
         ]
       }
     }
   }

6. 在本例中，从响应返回的其中一个部署的 KIE 容器复制或记下项目 group-id、artifact-id 和 version (GAV)数据。
7. 在 Swagger 页面中，导航到 KIE Server 和 KIE containers → [PUT] /server/containers/{containerId} 端点，以发送另一个请求以使用复制的项目 GAV 数据部署新的 KIE 容器。根据您的用例调整任何请求详情。

8. 点 Try it out 并为请求输入以下组件：

   • containerID ：输入新 KIE 容器的 ID，如 MyContainer。
   • 正文 ：将 参数内容类型设置为 所需的请求正文格式，如 JSON 格式的 application/json，并使用新 KIE 容器的配置项目添加请求正文：

   {
     "config-items": [
       {
         "itemName": "RuntimeStrategy",
         "itemValue": "SINGLETON",
         "itemType": "java.lang.String"
       },
       {
         "itemName": "MergeMode",
         "itemValue": "MERGE_COLLECTIONS",
         "itemType": "java.lang.String"
       },
       {
         "itemName": "KBase",
         "itemValue": "",
         "itemType": "java.lang.String"
       },
       {
         "itemName": "KSession",
         "itemValue": "",
         "itemType": "java.lang.String"
       }
     ],
     "release-id": {
       "group-id": "itorders",
       "artifact-id": "itorders",
       "version": "1.0.0-SNAPSHOT"
     },
     "scanner": {
       "poll-interval": "5000",
       "status": "STARTED"
     }
   }

9. 在 Response content type 下拉菜单中，选择服务器响应所需的格式，如 JSON 格式的 application/json。

10. 点 Execute 并查看 KIE 服务器响应。

    服务器响应示例(JSON)：

    {
      "type": "SUCCESS",
      "msg": "Container MyContainer successfully deployed with module itorders:itorders:1.0.0-SNAPSHOT.",
      "result": {
        "kie-container": {
          "container-id": "MyContainer",
          "release-id": {
            "group-id": "itorders",
            "artifact-id": "itorders",
            "version": "1.0.0-SNAPSHOT"
          },
          "resolved-release-id": {
            "group-id": "itorders",
            "artifact-id": "itorders",
            "version": "1.0.0-SNAPSHOT"
          },
          "status": "STARTED",
          "scanner": {
            "status": "STARTED",
            "poll-interval": 5000
          },
          "config-items": [],
          "messages": [
            {
              "severity": "INFO",
              "timestamp": {
                "java.util.Date": 1540584717937
              },
              "content": [
                "Container MyContainer successfully created with module itorders:itorders:1.0.0-SNAPSHOT."
              ]
            }
          ],
          "container-alias": null
        }
      }
    }

    如果您遇到请求错误，请查看返回的错误代码信息并相应地调整您的请求。

    进程实例的 REST API 请求

    对于将复杂数据对象发送到进程实例端点 /server/containers/{containerId}/processes/{processId}/instances 的 REST API 请求，请确保在请求正文中包含完全限定类名称（如 com.myspace.Person）或简单类名称（如 Person）。请求正文需要类名称才能映射到 Red Hat Process Automation Manager 中的正确业务对象。如果您从请求中排除类名称，KIE 服务器不会将对象 unmarshall 到预期的类型。

    正确的进程实例请求正文

    {
      "id": 4,
      "lease": {
        "com.myspace.restcall.LeaseModel": {
          "annualRent": 109608,
          "isAutoApproved": false
        }
      }
    }

    进程实例请求正文不正确

    {
      "id": 4,
      "lease": {
        "annualRent": 109608,
        "isAutoApproved": false
      }
    }

流程

1. 在客户端应用程序中，确保已将以下依赖项添加到 Java 项目的相关类路径中：

   <!-- For remote execution on KIE Server -->
   <dependency>
     <groupId>org.kie.server</groupId>
     <artifactId>kie-server-client</artifactId>
     <version>${rhpam.version}</version>
   </dependency>
   
   <!-- For runtime commands -->
   <dependency>
     <groupId>org.drools</groupId>
     <artifactId>drools-compiler</artifactId>
     <scope>runtime</scope>
     <version>${rhpam.version}</version>
   </dependency>
   
   <!-- For debug logging (optional) -->
   <dependency>
     <groupId>ch.qos.logback</groupId>
     <artifactId>logback-classic</artifactId>
     <version>${logback.version}</version>
   </dependency>

2. 从红帽客户门户网站下载 Red Hat Process Automation Manager 7.11.0 Source Distribution，进入 ~/rhpam-7.11.0-sources/src/droolsjbpm-integration-$VERSION/kie-server-parent/kie-server-remote/kie-server-remote/kie-server-client/src/main/java/org/kie/server/client 以访问 KIE Server Java 客户端。
3. 在 ~/kie/server/client 文件夹中，标识您要发送的请求的相关 Java 客户端，如 KieServicesClient，以访问 KIE 服务器中 KIE 容器和其他资产的客户端服务。

4. 在客户端应用程序中，为 API 请求创建一个 .java 类。类必须包含必要的导入、KIE 服务器位置和用户凭证、KieServicesClient 对象以及要执行的客户端方法，如来自 KieServicesClient 客户端的 createContainer 和 disposeContainer。根据您的用例调整任何配置详情。

   创建并分离容器

   import org.kie.server.api.marshalling.MarshallingFormat;
   import org.kie.server.client.KieServicesClient;
   import org.kie.server.client.KieServicesConfiguration;
   import org.kie.server.client.KieServicesFactory;
   import org.kie.server.api.model.KieContainerResource;
   import org.kie.server.api.model.ServiceResponse;
   
   public class MyConfigurationObject {
   
     private static final String URL = "http://localhost:8080/kie-server/services/rest/server";
     private static final String USER = "baAdmin";
     private static final String PASSWORD = "password@1";
   
     private static final MarshallingFormat FORMAT = MarshallingFormat.JSON;
   
     private static KieServicesConfiguration conf;
     private static KieServicesClient kieServicesClient;
   
     public static void initialize() {
       conf = KieServicesFactory.newRestConfiguration(URL, USER, PASSWORD);
   
     public void disposeAndCreateContainer() {
         System.out.println("== Disposing and creating containers ==");
   
         // Retrieve list of KIE containers
         List<KieContainerResource> kieContainers = kieServicesClient.listContainers().getResult().getContainers();
         if (kieContainers.size() == 0) {
             System.out.println("No containers available...");
             return;
         }
   
         // Dispose KIE container
         KieContainerResource container = kieContainers.get(0);
         String containerId = container.getContainerId();
         ServiceResponse<Void> responseDispose = kieServicesClient.disposeContainer(containerId);
         if (responseDispose.getType() == ResponseType.FAILURE) {
             System.out.println("Error disposing " + containerId + ". Message: ");
             System.out.println(responseDispose.getMsg());
             return;
         }
         System.out.println("Success Disposing container " + containerId);
         System.out.println("Trying to recreate the container...");
   
         // Re-create KIE container
         ServiceResponse<KieContainerResource> createResponse = kieServicesClient.createContainer(containerId, container);
         if(createResponse.getType() == ResponseType.FAILURE) {
             System.out.println("Error creating " + containerId + ". Message: ");
             System.out.println(responseDispose.getMsg());
             return;
         }
         System.out.println("Container recreated with success!");
         }
     }
   }

   您可以使用 org.kie.server.api.model.ServiceResponse<T> 对象定义服务响应，其中 T 代表返回的响应类型。ServiceResponse 对象具有以下属性：

   • 字符串 消息 ：返回响应消息
   • ResponseType 类型 ：返回 SUCCESS 或 FAILURE
   • T 结果 ：返回请求的对象

   在本例中，当您分离容器时，ServiceResponse 会返回 Void 响应。在创建容器时，ServiceResponse 会返回 KieContainerResource 对象。

   注意

   在集群环境中的客户端和特定 KIE 服务器容器之间的对话是由唯一的 对话ID 进行保护的。对话ID 使用 X-KIE-ConversationId REST 标头进行传输。如果更新容器，请取消设置之前的 dialogID。使用 KieServiesClient.completeConversation （） 取消 Java API 的 dialog ID。

5. 从项目目录运行配置的 .java 类来执行请求，并查看 KIE 服务器响应。

   如果启用了调试日志，KIE 服务器会根据您配置的 marshalling 格式（如 JSON）响应详细响应。

   新 KIE 容器(log)的服务器响应示例：

   10:23:35.194 [main] INFO  o.k.s.a.m.MarshallerFactory - Marshaller extensions init
   10:23:35.396 [main] DEBUG o.k.s.client.balancer.LoadBalancer - Load balancer RoundRobinBalancerStrategy{availableEndpoints=[http://localhost:8080/kie-server/services/rest/server]} selected url 'http://localhost:8080/kie-server/services/rest/server'
   10:23:35.398 [main] DEBUG o.k.s.c.i.AbstractKieServicesClientImpl - About to send GET request to 'http://localhost:8080/kie-server/services/rest/server'
   10:23:35.440 [main] DEBUG o.k.s.c.i.AbstractKieServicesClientImpl - About to deserialize content:
    '{
     "type" : "SUCCESS",
     "msg" : "Kie Server info",
     "result" : {
       "kie-server-info" : {
         "id" : "default-kieserver",
         "version" : "7.11.0.Final-redhat-00003",
         "name" : "default-kieserver",
         "location" : "http://localhost:8080/kie-server/services/rest/server",
         "capabilities" : [ "KieServer", "BRM", "BPM", "CaseMgmt", "BPM-UI", "BRP", "DMN", "Swagger" ],
         "messages" : [ {
           "severity" : "INFO",
           "timestamp" : {
     "java.util.Date" : 1540814906533
   },
           "content" : [ "Server KieServerInfo{serverId='default-kieserver', version='7.11.0.Final-redhat-00003', name='default-kieserver', location='http://localhost:8080/kie-server/services/rest/server', capabilities=[KieServer, BRM, BPM, CaseMgmt, BPM-UI, BRP, DMN, Swagger], messages=null}started successfully at Mon Oct 29 08:08:26 EDT 2018" ]
         } ]
       }
     }
   }'
    into type: 'class org.kie.server.api.model.ServiceResponse'
   10:23:35.653 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - KieServicesClient connected to: default-kieserver version 7.11.0.Final-redhat-00003
   10:23:35.653 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Supported capabilities by the server: [KieServer, BRM, BPM, CaseMgmt, BPM-UI, BRP, DMN, Swagger]
   10:23:35.653 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Building services client for server capability KieServer
   10:23:35.653 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - No builder found for 'KieServer' capability
   10:23:35.654 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Building services client for server capability BRM
   10:23:35.654 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Builder 'org.kie.server.client.helper.DroolsServicesClientBuilder@6b927fb' for capability 'BRM'
   10:23:35.655 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Capability implemented by {interface org.kie.server.client.RuleServicesClient=org.kie.server.client.impl.RuleServicesClientImpl@4a94ee4}
   10:23:35.655 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Building services client for server capability BPM
   10:23:35.656 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Builder 'org.kie.server.client.helper.JBPMServicesClientBuilder@4cc451f2' for capability 'BPM'
   10:23:35.672 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Capability implemented by {interface org.kie.server.client.JobServicesClient=org.kie.server.client.impl.JobServicesClientImpl@1189dd52, interface org.kie.server.client.admin.ProcessAdminServicesClient=org.kie.server.client.admin.impl.ProcessAdminServicesClientImpl@36bc55de, interface org.kie.server.client.DocumentServicesClient=org.kie.server.client.impl.DocumentServicesClientImpl@564fabc8, interface org.kie.server.client.admin.UserTaskAdminServicesClient=org.kie.server.client.admin.impl.UserTaskAdminServicesClientImpl@16d04d3d, interface org.kie.server.client.QueryServicesClient=org.kie.server.client.impl.QueryServicesClientImpl@49ec71f8, interface org.kie.server.client.ProcessServicesClient=org.kie.server.client.impl.ProcessServicesClientImpl@1d2adfbe, interface org.kie.server.client.UserTaskServicesClient=org.kie.server.client.impl.UserTaskServicesClientImpl@36902638}
   10:23:35.672 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Building services client for server capability CaseMgmt
   10:23:35.672 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Builder 'org.kie.server.client.helper.CaseServicesClientBuilder@223d2c72' for capability 'CaseMgmt'
   10:23:35.676 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Capability implemented by {interface org.kie.server.client.admin.CaseAdminServicesClient=org.kie.server.client.admin.impl.CaseAdminServicesClientImpl@2b662a77, interface org.kie.server.client.CaseServicesClient=org.kie.server.client.impl.CaseServicesClientImpl@7f0eb4b4}
   10:23:35.676 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Building services client for server capability BPM-UI
   10:23:35.676 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Builder 'org.kie.server.client.helper.JBPMUIServicesClientBuilder@5c33f1a9' for capability 'BPM-UI'
   10:23:35.677 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Capability implemented by {interface org.kie.server.client.UIServicesClient=org.kie.server.client.impl.UIServicesClientImpl@223191a6}
   10:23:35.678 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Building services client for server capability BRP
   10:23:35.678 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Builder 'org.kie.server.client.helper.OptaplannerServicesClientBuilder@49139829' for capability 'BRP'
   10:23:35.679 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Capability implemented by {interface org.kie.server.client.SolverServicesClient=org.kie.server.client.impl.SolverServicesClientImpl@77fbd92c}
   10:23:35.679 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Building services client for server capability DMN
   10:23:35.679 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Builder 'org.kie.server.client.helper.DMNServicesClientBuilder@67c27493' for capability 'DMN'
   10:23:35.680 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Capability implemented by {interface org.kie.server.client.DMNServicesClient=org.kie.server.client.impl.DMNServicesClientImpl@35e2d654}
   10:23:35.680 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - Building services client for server capability Swagger
   10:23:35.680 [main] DEBUG o.k.s.c.impl.KieServicesClientImpl - No builder found for 'Swagger' capability
   10:23:35.681 [main] DEBUG o.k.s.client.balancer.LoadBalancer - Load balancer RoundRobinBalancerStrategy{availableEndpoints=[http://localhost:8080/kie-server/services/rest/server]} selected url 'http://localhost:8080/kie-server/services/rest/server'
   10:23:35.701 [main] DEBUG o.k.s.c.i.AbstractKieServicesClientImpl - About to send PUT request to 'http://localhost:8080/kie-server/services/rest/server/containers/employee-rostering3' with payload '{
     "container-id" : null,
     "release-id" : {
       "group-id" : "employeerostering",
       "artifact-id" : "employeerostering",
       "version" : "1.0.0-SNAPSHOT"
     },
     "resolved-release-id" : null,
     "status" : null,
     "scanner" : null,
     "config-items" : [ ],
     "messages" : [ ],
     "container-alias" : null
   }'
   10:23:38.071 [main] DEBUG o.k.s.c.i.AbstractKieServicesClientImpl - About to deserialize content:
    '{
     "type" : "SUCCESS",
     "msg" : "Container employee-rostering3 successfully deployed with module employeerostering:employeerostering:1.0.0-SNAPSHOT.",
     "result" : {
       "kie-container" : {
         "container-id" : "employee-rostering3",
         "release-id" : {
           "group-id" : "employeerostering",
           "artifact-id" : "employeerostering",
           "version" : "1.0.0-SNAPSHOT"
         },
         "resolved-release-id" : {
           "group-id" : "employeerostering",
           "artifact-id" : "employeerostering",
           "version" : "1.0.0-SNAPSHOT"
         },
         "status" : "STARTED",
         "scanner" : {
           "status" : "DISPOSED",
           "poll-interval" : null
         },
         "config-items" : [ ],
         "messages" : [ {
           "severity" : "INFO",
           "timestamp" : {
     "java.util.Date" : 1540909418069
   },
           "content" : [ "Container employee-rostering3 successfully created with module employeerostering:employeerostering:1.0.0-SNAPSHOT." ]
         } ],
         "container-alias" : null
       }
     }
   }'
    into type: 'class org.kie.server.api.model.ServiceResponse'

   如果您遇到请求错误，请查看返回的错误代码信息并相应地调整 Java 配置。

流程

1. 识别您要发送请求的相关 API 端点，如 [GET] /controller/management/servers，以从 Process Automation Manager 控制器检索 KIE Server 模板。

2. 在 REST 客户端或 curl 工具中，为对 controller/management/servers 的 GET 请求输入以下组件。根据您的用例调整任何请求详情。

   对于 REST 客户端：

   • 身份验证 ：使用 rest-all 角色或无头 Process Automation Manager 控制器用户输入 Process Automation Manager 控制器用户的用户名和密码，并带有 kie-server 角色。

   • HTTP 标头 ：设置以下标头：

     • 接受:application/json
   • HTTP 方法 ：设置为 GET。
   • URL ：输入 Process Automation Manager 控制器 REST API 基本 URL 和端点，如 http://localhost:8080/business-central/rest/controller/management/servers。

   对于 curl 工具：

   • -u ：使用 rest-all 角色或无头 Process Automation Manager 控制器用户输入 Process Automation Manager 控制器用户的用户名和密码，并带有 kie-server 角色。

   • -h: 设置以下标头：

     • 接受:application/json
   • -x: 设置为 GET。
   • URL ：输入 Process Automation Manager 控制器 REST API 基本 URL 和端点，如 http://localhost:8080/business-central/rest/controller/management/servers。

   curl -u 'baAdmin:password@1' -H "Accept: application/json" -X GET "http://localhost:8080/business-central/rest/controller/management/servers"

3. 执行请求并查看 Process Automation Manager 控制器响应。

   服务器响应示例(JSON)：

   {
     "server-template": [
       {
         "server-id": "default-kieserver",
         "server-name": "default-kieserver",
         "container-specs": [
           {
             "container-id": "employeerostering_1.0.0-SNAPSHOT",
             "container-name": "employeerostering",
             "server-template-key": {
               "server-id": "default-kieserver",
               "server-name": "default-kieserver"
             },
             "release-id": {
               "group-id": "employeerostering",
               "artifact-id": "employeerostering",
               "version": "1.0.0-SNAPSHOT"
             },
             "configuration": {
               "RULE": {
                 "org.kie.server.controller.api.model.spec.RuleConfig": {
                   "pollInterval": null,
                   "scannerStatus": "STOPPED"
                 }
               },
               "PROCESS": {
                 "org.kie.server.controller.api.model.spec.ProcessConfig": {
                   "runtimeStrategy": "SINGLETON",
                   "kbase": "",
                   "ksession": "",
                   "mergeMode": "MERGE_COLLECTIONS"
                 }
               }
             },
             "status": "STARTED"
           },
           {
             "container-id": "mortgage-process_1.0.0-SNAPSHOT",
             "container-name": "mortgage-process",
             "server-template-key": {
               "server-id": "default-kieserver",
               "server-name": "default-kieserver"
             },
             "release-id": {
               "group-id": "mortgage-process",
               "artifact-id": "mortgage-process",
               "version": "1.0.0-SNAPSHOT"
             },
             "configuration": {
               "RULE": {
                 "org.kie.server.controller.api.model.spec.RuleConfig": {
                   "pollInterval": null,
                   "scannerStatus": "STOPPED"
                 }
               },
               "PROCESS": {
                 "org.kie.server.controller.api.model.spec.ProcessConfig": {
                   "runtimeStrategy": "PER_PROCESS_INSTANCE",
                   "kbase": "",
                   "ksession": "",
                   "mergeMode": "MERGE_COLLECTIONS"
                 }
               }
             },
             "status": "STARTED"
           }
         ],
         "server-config": {},
         "server-instances": [
           {
             "server-instance-id": "default-kieserver-instance@localhost:8080",
             "server-name": "default-kieserver-instance@localhost:8080",
             "server-template-id": "default-kieserver",
             "server-url": "http://localhost:8080/kie-server/services/rest/server"
           }
         ],
         "capabilities": [
           "RULE",
           "PROCESS",
           "PLANNING"
         ]
       }
     ]
   }

4. 在 REST 客户端或 curl 实用程序中，发送带有以下组件的 API 请求，它向 /controller/management/servers/{serverTemplateId} 发送一个 PUT 请求，以创建新的 KIE Server 模板。根据您的用例调整任何请求详情。

   对于 REST 客户端：

   • 身份验证 ：使用 rest-all 角色或无头 Process Automation Manager 控制器用户输入 Process Automation Manager 控制器用户的用户名和密码，并带有 kie-server 角色。

   • HTTP 标头 ：设置以下标头：

     • 接受:application/json
     • content-Type:application/json
   • HTTP 方法 ：设置为 PUT。
   • URL ：输入 Process Automation Manager 控制器 REST API 基本 URL 和端点，如 http://localhost:8080/business-central/rest/controller/management/servers/new-kieserver。
   • Request body ：使用新 KIE Server 模板的配置添加 JSON 请求正文：

   {
     "server-id": "new-kieserver",
     "server-name": "new-kieserver",
     "container-specs": [],
     "server-config": {},
     "capabilities": [
       "RULE",
       "PROCESS",
       "PLANNING"
     ]
   }

   对于 curl 工具：

   • -u ：使用 rest-all 角色或无头 Process Automation Manager 控制器用户输入 Process Automation Manager 控制器用户的用户名和密码，并带有 kie-server 角色。

   • - h ：设置以下标头：

     • 接受:application/json
     • content-Type:application/json
   • -x ：设置为 PUT。
   • URL ：输入 Process Automation Manager 控制器 REST API 基本 URL 和端点，如 http://localhost:8080/business-central/rest/controller/management/servers/new-kieserver。
   • -d ：使用新 KIE Server 模板的配置添加 JSON 请求正文或文件(@file.json)：

   curl -u 'baAdmin:password@1' -H "Accept: application/json" -H "Content-Type: application/json" -X PUT "http://localhost:8080/business-central/rest/controller/management/servers/new-kieserver" -d "{ \"server-id\": \"new-kieserver\", \"server-name\": \"new-kieserver\", \"container-specs\": [], \"server-config\": {}, \"capabilities\": [ \"RULE\", \"PROCESS\", \"PLANNING\" ]}"

   curl -u 'baAdmin:password@1' -H "Accept: application/json" -H "Content-Type: application/json" -X PUT "http://localhost:8080/business-central/rest/controller/management/servers/new-kieserver" -d @my-server-template-configs.json

5. 执行请求，并确认过程自动化管理器控制器响应成功。

   如果您遇到请求错误，请查看返回的错误代码信息并相应地调整您的请求。

流程

1. 在 Web 浏览器中，导航到 http://SERVER:PORT/CONTROLLER/docs，如 http://localhost:8080/business-central/docs，并使用具有 rest-all 角色或无头 Process Automation Manager 控制器用户使用 kie-server 角色的用户名和密码登录。

   注意

   如果您使用内置于 Business Central 中的 Process Automation Manager 控制器，则与 Process Automation Manager 控制器关联的 Swagger 页面被识别为 Business Central REST 服务的" Business Central API"。如果您在没有 Business Central 的情况下使用无头 Process Automation Manager 控制器，则与无头进程自动化管理器控制器关联的 Swagger 页面被识别为 "Controller API"。在这两种情况下，Process Automation Manager 控制器 REST API 端点都是相同的。

2. 在 Swagger 页面中，选择要发送请求的相关 API 端点，如 Controller :: KIE Server 模板和 KIE containers → [GET] /controller/management/servers，以从 Process Automation Manager 控制器检索 KIE 服务器模板。
3. 点 Try it out，并提供您要过滤结果（如果适用）的任何可选参数。
4. 在 Response content type 下拉菜单中，选择服务器响应所需的格式，如 JSON 格式的 application/json。

5. 点 Execute 并查看 KIE 服务器响应。

   服务器响应示例(JSON)：

   {
     "server-template": [
       {
         "server-id": "default-kieserver",
         "server-name": "default-kieserver",
         "container-specs": [
           {
             "container-id": "employeerostering_1.0.0-SNAPSHOT",
             "container-name": "employeerostering",
             "server-template-key": {
               "server-id": "default-kieserver",
               "server-name": "default-kieserver"
             },
             "release-id": {
               "group-id": "employeerostering",
               "artifact-id": "employeerostering",
               "version": "1.0.0-SNAPSHOT"
             },
             "configuration": {
               "RULE": {
                 "org.kie.server.controller.api.model.spec.RuleConfig": {
                   "pollInterval": null,
                   "scannerStatus": "STOPPED"
                 }
               },
               "PROCESS": {
                 "org.kie.server.controller.api.model.spec.ProcessConfig": {
                   "runtimeStrategy": "SINGLETON",
                   "kbase": "",
                   "ksession": "",
                   "mergeMode": "MERGE_COLLECTIONS"
                 }
               }
             },
             "status": "STARTED"
           },
           {
             "container-id": "mortgage-process_1.0.0-SNAPSHOT",
             "container-name": "mortgage-process",
             "server-template-key": {
               "server-id": "default-kieserver",
               "server-name": "default-kieserver"
             },
             "release-id": {
               "group-id": "mortgage-process",
               "artifact-id": "mortgage-process",
               "version": "1.0.0-SNAPSHOT"
             },
             "configuration": {
               "RULE": {
                 "org.kie.server.controller.api.model.spec.RuleConfig": {
                   "pollInterval": null,
                   "scannerStatus": "STOPPED"
                 }
               },
               "PROCESS": {
                 "org.kie.server.controller.api.model.spec.ProcessConfig": {
                   "runtimeStrategy": "PER_PROCESS_INSTANCE",
                   "kbase": "",
                   "ksession": "",
                   "mergeMode": "MERGE_COLLECTIONS"
                 }
               }
             },
             "status": "STARTED"
           }
         ],
         "server-config": {},
         "server-instances": [
           {
             "server-instance-id": "default-kieserver-instance@localhost:8080",
             "server-name": "default-kieserver-instance@localhost:8080",
             "server-template-id": "default-kieserver",
             "server-url": "http://localhost:8080/kie-server/services/rest/server"
           }
         ],
         "capabilities": [
           "RULE",
           "PROCESS",
           "PLANNING"
         ]
       }
     ]
   }

6. 在 Swagger 页面中，导航到 Controller :: KIE Server 模板和 KIE containers → [GET] /controller/management/servers/{serverTemplateId} 端点，以发送另一个请求来创建新的 KIE Server 模板。根据您的用例调整任何请求详情。

7. 点 Try it out 并为请求输入以下组件：

   • serverTemplateId ：输入新 KIE Server 模板的 ID，如 new-kieserver。
   • 正文 ：将 参数内容类型设置为 所需的请求正文格式，如 JSON 格式的 application/json，并使用新 KIE Server 模板的配置添加请求正文：

   {
     "server-id": "new-kieserver",
     "server-name": "new-kieserver",
     "container-specs": [],
     "server-config": {},
     "capabilities": [
       "RULE",
       "PROCESS",
       "PLANNING"
     ]
   }

8. 在 Response content type 下拉菜单中，选择服务器响应所需的格式，如 JSON 格式的 application/json。

9. 点 Execute 并确认 Process Automation Manager 控制器响应成功。

   如果您遇到请求错误，请查看返回的错误代码信息并相应地调整您的请求。

流程

1. 在客户端应用程序中，确保已将以下依赖项添加到 Java 项目的相关类路径中：

   <!-- For remote execution on controller -->
   <dependency>
     <groupId>org.kie.server</groupId>
     <artifactId>kie-server-controller-client</artifactId>
     <version>${rhpam.version}</version>
   </dependency>
   
   <!-- For REST client -->
   <dependency>
     <groupId>org.jboss.resteasy</groupId>
     <artifactId>resteasy-client</artifactId>
     <version>${resteasy.version}</version>
   </dependency>
   
   <!-- For WebSocket client -->
   <dependency>
     <groupId>io.undertow</groupId>
     <artifactId>undertow-websockets-jsr</artifactId>
     <version>${undertow.version}</version>
   </dependency>
   
   <!-- For debug logging (optional) -->
   <dependency>
     <groupId>ch.qos.logback</groupId>
     <artifactId>logback-classic</artifactId>
     <version>${logback.version}</version>
   </dependency>

2. 从红帽客户门户网站下载 Red Hat Process Automation Manager 7.11.0 Source Distribution，进入 ~/rhpam-7.11.0-sources/src/droolsjbpm-integration-$VERSION/kie-server-parent/kie-server-controller/kie-server-controller/src/main/java/org/kie/server/controller/client 以访问 Process Automation Manager 控制器 Java 客户端。
3. 在 ~/kie/server/controller/client 文件夹中，标识您要发送的请求的相关 Java 客户端实施，如 RestKieServerControllerClient 实施，以访问 REST 协议中的 KIE 服务器模板和 KIE 容器的客户端服务。

4. 在客户端应用程序中，为 API 请求创建一个 .java 类。该类必须包含必要的导入、Process Automation Manager 控制器位置和用户凭证、KieServerControllerClient 对象和要执行的客户端方法，如 createServerTemplate 和 createContainer 从 RestKieServerControllerClient 实施中创建Container。根据您的用例调整任何配置详情。

   创建并与 KIE Server 模板和 KIE 容器交互

   import java.util.Arrays;
   import java.util.HashMap;
   import java.util.Map;
   
   import org.kie.server.api.marshalling.MarshallingFormat;
   import org.kie.server.api.model.KieContainerStatus;
   import org.kie.server.api.model.KieScannerStatus;
   import org.kie.server.api.model.ReleaseId;
   import org.kie.server.controller.api.model.spec.*;
   import org.kie.server.controller.client.KieServerControllerClient;
   import org.kie.server.controller.client.KieServerControllerClientFactory;
   
   public class RestTemplateContainerExample {
   
     private static final String URL = "http://localhost:8080/business-central/rest/controller";
     private static final String USER = "baAdmin";
     private static final String PASSWORD = "password@1";
   
       private static KieServerControllerClient client;
   
       public static void main(String[] args) {
           KieServerControllerClient client = KieServerControllerClientFactory.newRestClient(URL,
                                                                                             USER,
                                                                                             PASSWORD,
                                                                                             MarshallingFormat.JSON);
           // Create server template and KIE container, start and stop KIE container, and delete server template
           ServerTemplate serverTemplate = createServerTemplate();
           ContainerSpec container = createContainer(serverTemplate);
           client.startContainer(container);
           client.stopContainer(container);
           client.deleteServerTemplate(serverTemplate.getId());
       }
   
       // Re-create and configure server template
       protected static ServerTemplate createServerTemplate() {
           ServerTemplate serverTemplate = new ServerTemplate();
           serverTemplate.setId("example-client-id");
           serverTemplate.setName("example-client-name");
           serverTemplate.setCapabilities(Arrays.asList(Capability.PROCESS.name(),
                                                        Capability.RULE.name(),
                                                        Capability.PLANNING.name()));
   
           client.saveServerTemplate(serverTemplate);
   
           return serverTemplate;
       }
   
       // Re-create and configure KIE containers
       protected static ContainerSpec createContainer(ServerTemplate serverTemplate){
           Map<Capability, ContainerConfig> containerConfigMap = new HashMap();
   
           ProcessConfig processConfig = new ProcessConfig("PER_PROCESS_INSTANCE", "kieBase", "kieSession", "MERGE_COLLECTION");
           containerConfigMap.put(Capability.PROCESS, processConfig);
   
           RuleConfig ruleConfig = new RuleConfig(500l, KieScannerStatus.SCANNING);
           containerConfigMap.put(Capability.RULE, ruleConfig);
   
           ReleaseId releaseId = new ReleaseId("org.kie.server.testing", "stateless-session-kjar", "1.0.0-SNAPSHOT");
   
           ContainerSpec containerSpec = new ContainerSpec("example-container-id", "example-client-name", serverTemplate, releaseId, KieContainerStatus.STOPPED, containerConfigMap);
           client.saveContainerSpec(serverTemplate.getId(), containerSpec);
   
           return containerSpec;
       }
   }

5. 从项目目录运行配置的 .java 类来执行请求，并查看 Process Automation Manager 控制器响应。

   如果启用了调试日志，KIE 服务器会根据您配置的 marshalling 格式（如 JSON）响应详细响应。如果您遇到请求错误，请查看返回的错误代码信息并相应地调整 Java 配置。

流程

1. 识别您要发送请求的相关 API 端点，如 [GET] /spaces 以检索 Business Central 中的空格。

2. 在 REST 客户端或 curl 工具中，为对 /space 的 GET 请求输入以下组件。根据您的用例调整任何请求详情。

   对于 REST 客户端：

   • Authentication ：使用 rest-all 角色输入 Business Central 用户的用户名和密码。

   • HTTP 标头 ：设置以下标头：

     • 接受:application/json
   • HTTP 方法 ：设置为 GET。
   • URL ：输入 知识库存储 REST API 基本 URL 和端点，如 http://localhost:8080/business-central/rest/spaces。

   对于 curl 工具：

   • -u ：使用 rest-all 角色输入 Business Central 用户的用户名和密码。

   • -h: 设置以下标头：

     • 接受:application/json
   • -x: 设置为 GET。
   • URL ：输入 知识库存储 REST API 基本 URL 和端点，如 http://localhost:8080/business-central/rest/spaces。

   curl -u 'baAdmin:password@1' -H "Accept: application/json" -X GET "http://localhost:8080/business-central/rest/spaces"

3. 执行请求并查看 KIE 服务器响应。

   服务器响应示例(JSON)：

   [
     {
       "name": "MySpace",
       "description": null,
       "projects": [
         {
           "name": "Employee_Rostering",
           "spaceName": "MySpace",
           "groupId": "employeerostering",
           "version": "1.0.0-SNAPSHOT",
           "description": "Employee rostering problem optimisation using Planner. Assigns employees to shifts based on their skill.",
           "publicURIs": [
             {
               "protocol": "git",
               "uri": "git://localhost:9418/MySpace/example-Employee_Rostering"
             },
             {
               "protocol": "ssh",
               "uri": "ssh://localhost:8001/MySpace/example-Employee_Rostering"
             }
           ]
         },
         {
           "name": "Mortgage_Process",
           "spaceName": "MySpace",
           "groupId": "mortgage-process",
           "version": "1.0.0-SNAPSHOT",
           "description": "Getting started loan approval process in BPMN2, decision table, business rules, and forms.",
           "publicURIs": [
             {
               "protocol": "git",
               "uri": "git://localhost:9418/MySpace/example-Mortgage_Process"
             },
             {
               "protocol": "ssh",
               "uri": "ssh://localhost:8001/MySpace/example-Mortgage_Process"
             }
           ]
         }
       ],
       "owner": "admin",
       "defaultGroupId": "com.myspace"
     },
     {
       "name": "MySpace2",
       "description": null,
       "projects": [
         {
           "name": "IT_Orders",
           "spaceName": "MySpace",
           "groupId": "itorders",
           "version": "1.0.0-SNAPSHOT",
           "description": "Case Management IT Orders project",
           "publicURIs": [
             {
               "protocol": "git",
               "uri": "git://localhost:9418/MySpace/example-IT_Orders-1"
             },
             {
               "protocol": "ssh",
               "uri": "ssh://localhost:8001/MySpace/example-IT_Orders-1"
             }
           ]
         }
       ],
       "owner": "admin",
       "defaultGroupId": "com.myspace"
     }
   ]

4. 在 REST 客户端或 curl 实用程序中，发送另外一个带有以下组件的 API 请求，它向 /spaces/{spaceName}/projects 发送一个 POST 请求，以便在一个空间内创建一个项目。根据您的用例调整任何请求详情。

   对于 REST 客户端：

   • Authentication ：使用 rest-all 角色输入 Business Central 用户的用户名和密码。

   • HTTP 标头 ：设置以下标头：

     • 接受:application/json
     • accept-Language:en-US
     • content-Type:application/json
   • HTTP 方法 ：设置为 POST。
   • URL ：输入 知识库存储 REST API 基本 URL 和端点，如 http://localhost:8080/business-central/rest/spaces/MySpace/projects。
   • 请求正文 ：使用新项目的标识数据添加 JSON 请求正文：

   {
     "name": "Employee_Rostering",
     "groupId": "employeerostering",
     "version": "1.0.0-SNAPSHOT",
     "description": "Employee rostering problem optimisation using Planner. Assigns employees to shifts based on their skill."
   }

   对于 curl 工具：

   • -u ：使用 rest-all 角色输入 Business Central 用户的用户名和密码。

   • - h ：设置以下标头：

     • 接受:application/json
     • accept-Language:en-US （如果未定义，则 JVM 中的默认区域设置会被反映）
     • content-Type:application/json
   • -x: 设置为 POST。
   • URL ：输入 知识库存储 REST API 基本 URL 和端点，如 http://localhost:8080/business-central/rest/spaces/MySpace/projects。
   • -d ：添加 JSON 请求正文或文件(@file.json)，其中包含新项目的标识数据：

   curl -u 'baAdmin:password@1' -H "Accept: application/json" -H "Accept-Language: en-US" -H "Content-Type: application/json" -X POST "http://localhost:8080/business-central/rest/spaces/MySpace/projects" -d "{ \"name\": \"Employee_Rostering\", \"groupId\": \"employeerostering\", \"version\": \"1.0.0-SNAPSHOT\", \"description\": \"Employee rostering problem optimisation using Planner. Assigns employees to shifts based on their skill.\"}"

   curl -u 'baAdmin:password@1' -H "Accept: application/json" -H "Accept-Language: en-US" -H "Content-Type: application/json" -X POST "http://localhost:8080/business-central/rest/spaces/MySpace/projects" -d @my-project.json

5. 执行请求并查看 KIE 服务器响应。

   服务器响应示例(JSON)：

   {
     "jobId": "1541017411591-6",
     "status": "APPROVED",
     "spaceName": "MySpace",
     "projectName": "Employee_Rostering",
     "projectGroupId": "employeerostering",
     "projectVersion": "1.0.0-SNAPSHOT",
     "description": "Employee rostering problem optimisation using Planner. Assigns employees to shifts based on their skill."
   }

   如果您遇到请求错误，请查看返回的错误代码信息并相应地调整您的请求。

流程

1. 识别您要发送请求的相关 API 端点，如 [GET] /groups 以检索 Business Central 中的组。

2. 在 REST 客户端或 curl 工具中，为对 /groups 的 GET 请求输入以下组件。根据您的用例调整任何请求详情。

   对于 REST 客户端：

   • 身份验证 ：使用 admin 角色输入 Business Central 用户的用户名和密码。

   • HTTP 标头 ：设置以下标头：

     • 接受:application/json
   • HTTP 方法 ：设置为 GET。
   • URL ：输入安全管理 REST API 基本 URL 和端点，如 http://localhost:8080/business-central/rest/groups。

   对于 curl 工具：

   • -u ：使用 admin 角色输入 Business Central 用户的用户名和密码。

   • -h: 设置以下标头：

     • 接受:application/json
   • -x: 设置为 GET。
   • URL ：输入安全管理 REST API 基本 URL 和端点，如 http://localhost:8080/business-central/rest/groups。

   curl -u 'baAdmin:password@1' -H "Accept: application/json" -X GET "http://localhost:8080/business-central/rest/groups"

3. 执行请求并查看 KIE 服务器响应。

   服务器响应示例(JSON)：

   [
     	{
   		"group1"
   	},
   	{
   		"group2"
   	}
   ]

4. 在 REST 客户端或 curl 实用程序中，发送另外一个带有以下组件的 API 请求，它向 /users/{userName}/groups 发送一个 POST 请求，以便更新为一个用户分配的组。根据您的用例调整任何请求详情。

   对于 REST 客户端：

   • 身份验证 ：使用 admin 角色输入 Business Central 用户的用户名和密码。

   • HTTP 标头 ：设置以下标头：

     • 接受:application/json
     • content-Type:application/json
   • HTTP 方法 ：设置为 POST。
   • URL ：输入安全管理 REST API 基本 URL 和端点，如 http://localhost:8080/business-central/rest/users/newUser/groups。
   • 请求正文 ：使用新组的标识数据添加 JSON 请求正文：

   [
     "newGroup"
   ]

   对于 curl 工具：

   • -u ：使用 admin 角色输入 Business Central 用户的用户名和密码。

   • - h ：设置以下标头：

     • 接受:application/json
     • content-Type:application/json
   • -x: 设置为 POST。
   • URL ：输入安全管理 REST API 基本 URL 和端点，如 http://localhost:8080/business-central/rest/users/newUser/groups。
   • -d ：添加 JSON 请求正文或文件(@file.json)，其中包含新组的标识数据：

   curl -u 'baAdmin:password@1' -H "Accept: application/json" -H "Content-Type: application/json" -X POST "http://localhost:8080/business-central/rest/users/newUser/groups" -d "["newGroup"]"

   curl -u 'baAdmin:password@1' -H "Accept: application/json" -H "Content-Type: application/json" -X POST "http://localhost:8080/business-central/rest/users/newUser/groups" -d @user-groups.json

5. 执行请求并查看 KIE 服务器响应。

   服务器响应示例(JSON)：

   {
     "status": "OK",
     "message": "Groups [newGroup] are assigned successfully to user wbadmin"
   }

   如果您遇到请求错误，请查看返回的错误代码信息并相应地调整您的请求。