部署和管理红帽流程自动化管理器服务

流程

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 文件，并在 &lt ;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	具有角色 rest-all 的用户名，可以登录到 Business Central。
   org.kie.server.controller.pwd	controllerUser1234;	可以登录到 Business Central 的用户的密码。
   org.kie.server.location	http://localhost:8080/kie-server/services/rest/server	KIE 服务器的位置。连接到 KIE Server 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。

   成功验证后，您会收到类似以下示例的 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 选项。

   注意

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

   您不能部署打开 Development 模式 的项目，或使用手动将 SNAPSHOT 版本后缀添加到生产模式的 KIE 服务器中。

流程

1. 使用连接和访问外部存储库的详情，创建一个 Maven settings.xml 文件。有关 settings.xml 文件的详情，请查看 Maven Settings Reference。
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> 关闭标签前面）。该值必须与您在 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 Server。要编译项目而不将它部署到 KIE Server，请单击 Build。

   注意

   您还可以选择 Build & Install 选项来构建项目，并将 KJAR 文件发布到配置的 Maven 存储库，而无需部署到 KIE 服务器。在开发环境中，您可以点击 Deploy 将构建的 KJAR 文件部署到 KIE 服务器，而无需停止任何正在运行的实例（如果适用），或者点击 Redeploy 部署构建的 KJAR 文件并替换所有实例。下次部署或重新部署构建的 KJAR 时，以前的部署单元(KIE 容器)会在同一目标 KIE 服务器中自动更新。在生产环境中，Redeploy 选项被禁用，您可以点 Deploy only 将构建的 KJAR 文件部署到 KIE 服务器上的新部署单元(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 选项。默认情况下，KIE 服务器和 Business Central 中的所有新项目都处于开发模式中。您不能部署打开 Development 模式 的项目，或使用手动将 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. 单击项目 设置 选项卡。

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

   注意

   仅用于开发目的，您可以在项目 Settings → General Settings → Version 中切换 Development Mode 选项，以在项目版本中添加 SNAPSHOT 后缀。此后缀指示 Maven 根据 Maven 策略获取新快照更新。不要使用 Development 模式，或者为生产环境手动添加 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、agendaEventListener 和 processEventListener。& lt;configuration > 元素定义可用于进一步自定义 kmodule.xml 文件的可选属性。

   作为手动将 kmodule.xml 文件附加到项目的替代选择，您可以使用 Java 应用程序中的 KieModuleModel 实例来以编程方式创建用于定义 KIE 基础和 KIE 会话的 kmodule.xml 文件，然后将项目中的所有资源添加到 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 会话，以验证配置：

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

   如果 KieBase 或 KieSession 已在 kmodule.xml 文件中配置为 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.12.0 Source Distribution ZIP 文件，再导航到 ~/rhpam-7.12.0-sources/src/drools-$VERSION/drools-compiler/src/main/java/org/drools/compiler/compiler/kie/builder/impl/KieRepositorympl.java.java.

流程

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.59.0.Final-redhat-00006）。这些设置需要正确打包 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.12.0.redhat-00008</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 决策表逻辑，以便更有效地评估。

   <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 文件是一个 KIE 模块描述符，是所有 Red Hat Process Automation Manager 项目所需的。您可以使用 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 升级历史记录，您可能需要手动添加这个依赖项来启用可执行规则模型行为。

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

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

   mvn deploy

流程

1. 可选： 如果您的项目包含 Decision Model 和 Notation (DMN)资产，请将以下内容添加到 Java 项目的相关类路径中，以启用 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.59.0.Final-redhat-00006）。

   注意

   考虑将 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.12.0.redhat-00008</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. 将项目中任何剩余的红帽流程自动化管理器资产添加到 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 factory 创建 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 升级历史记录，您可能需要手动添加这个依赖项来启用可执行规则模型行为。

   验证依赖项后，使用以下修改后的 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 Server 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. 选择 基于模板 复选框。
7. 如果需要，从下拉列表中选择 archetype from-down 选项。选择了已在空间中设置的默认 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 服务器。在开发环境中，您可以点击 Deploy 将构建的 KJAR 文件部署到 KIE 服务器，而无需停止任何正在运行的实例（如果适用），或者点击 Redeploy 部署构建的 KJAR 文件并替换所有实例。下次部署或重新部署构建的 KJAR 时，以前的部署单元(KIE 容器)会在同一目标 KIE 服务器中自动更新。在生产环境中，Redeploy 选项被禁用，您可以点 Deploy only 将构建的 KJAR 文件部署到 KIE 服务器上的新部署单元(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 选项。默认情况下，KIE 服务器和 Business Central 中的所有新项目都处于开发模式中。您不能部署打开 Development 模式 的项目，或使用手动将 SNAPSHOT 版本后缀添加到生产模式的 KIE 服务器中。

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

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

   如需有关项目部署选项的更多信息 ，请参阅打包和部署红帽流程自动化管理器项目。

流程

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

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

   图 13.1. 选择分支菜单

   

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

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

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

     此时会出现 Submit Change Request 窗口。

4. 输入摘要和描述，选择目标分支，然后单击 Submit。target 分支是合并更改的分支。点 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 Server 检索 KIE 容器。

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

   对于 REST 客户端：

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

   • HTTP Headers ：设置以下标头：

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

   对于 curl 工具：

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

   • - 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 和版本 (GAV)数据。

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

   对于 REST 客户端：

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

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

     • 接受:application/json

     • Content-Type:application/json

       注意

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

   • HTTP 方法 ：设置为 PUT。
   • URL ：输入 KIE Server REST API 基础 URL 和端点，如 http://localhost:8080/kie-server/services/rest/server/containers/MyContainer。
   • 请求正文 ：添加带有新 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 Server 用户的用户名和密码。

   • - h ：设置以下标头：

     • 接受:application/json

     • Content-Type:application/json

       注意

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

   • -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 Server 不会将对象卸载到预期的类型。

   进程实例的正确请求正文

   {
     "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 Server 检索 KIE 容器。
3. 点 Try it out，并提供您要过滤结果的任何可选参数。
4. 在 Response 内容类型下拉菜单中，选择服务器响应所需的格式，如用于 JSON 格式的 application/json。

5. 点 Execute 并查看 KIE Server 响应。

   服务器响应示例(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 和版本 (GAV)数据。
7. 在 Swagger 页面中，导航到 KIE Server 和 KIE containers → [PUT] /server/containers/{containerId} 端点，以发送另一个请求以使用复制的项目 GAV 数据部署新的 KIE 容器。根据您的用例调整任何请求详情。

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

   • containerId ：输入新 KIE 容器的 ID，如 MyContainer。
   • body ： 将参数内容类型设置为 所需的请求正文格式，如用于 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 内容类型下拉菜单中，选择服务器响应所需的格式，如用于 JSON 格式的 application/json。

10. 点 Execute 并查看 KIE Server 响应。

    服务器响应示例(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 Server 不会将对象卸载到预期的类型。

    进程实例的正确请求正文

    {
      "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.12.0 Source Distribution，并进入 ~/rhpam-7.12.0-sources/src/droolsjbpm-integration-$VERSION/kie-server-parent/kie-server-remote/kie-server-client/src/main/java/org/kie/server/server/client 来访问 KIE Server Java 客户端。
3. 在 ~/kie/server/client 文件夹 中，识别您要发送的请求的相关 Java 客户端，如 KieServicesClient 访问 KIE 容器和其他资产的客户端服务。

4. 在您的客户端应用中，为 API 请求创建一个 .java 类。类必须包含必要的导入、KIE 服务器位置和用户凭据、KieServicesClient 对象和要执行的客户端方法，如 createContainer 和来自 KieServicesClient 客户端的 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 type ：返回 SUCCESS 或 FAILURE
   • T 结果 ：返回请求的对象

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

   注意

   客户端与集群环境中的特定 KIE 服务器容器之间的对话是通过独特的 对话ID 来保护。使用 X-KIE-ConversationId REST 标头传输 对话 ID。如果更新容器，请取消设置之前的 talk ID。使用 KieServiesClient.completeConversation （） 来取消设置 Java API 的 talk 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 角色输入流程 Automation Manager 控制器用户的用户名和密码，或使用 kie-server 角色输入无头处理 Automation Manager 控制器用户。

   • HTTP Headers ：设置以下标头：

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

   对于 curl 工具：

   • - U ：使用 rest-all 角色或无头进程 Automation Manager 控制器用户输入进程 Automation Manager 控制器 用户的用户名和密码。

   • - 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. 执行请求并查看流程 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 角色输入流程 Automation Manager 控制器用户的用户名和密码，或使用 kie-server 角色输入无头处理 Automation Manager 控制器用户。

   • 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。
   • 请求正文 ：添加带有新 KIE Server 模板配置的 JSON 请求正文：

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

   对于 curl 工具：

   • - U ：使用 rest-all 角色或无头进程 Automation Manager 控制器用户输入进程 Automation Manager 控制器 用户的用户名和密码。

   • - 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 ：添加 JSON 请求正文或文件(@file.json)，其中包含新的 KIE Server 模板的配置：

   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. 执行请求并确认成功完成流程 Automation Manager 控制器响应。

   如果您遇到请求错误，请检查返回的错误消息并相应地调整您的请求。

流程

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

   注意

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

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

5. 点 Execute 并查看 KIE Server 响应。

   服务器响应示例(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。
   • body ： 将参数内容类型设置为 所需的请求正文格式，如用于 JSON 格式的 application/json，并使用新 KIE Server 模板的配置添加请求正文：

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

8. 在 Response 内容类型下拉菜单中，选择服务器响应所需的格式，如用于 JSON 格式的 application/json。

9. 点 Execute 并确认成功处理 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.12.0 Source Distribution，并进入 ~/rhpam-7.12.0-sources/src/droolsjbpm-integration-$VERSION/kie-server-parent/kie-server-controller/kie-server-controller/kie-server-controller/src/main/java/org/kie/server/controller/client 来访问流程自动化管理器 Java 客户端。
3. 在 ~/kie/server/controller/client 文件夹中，识别您要发送的请求的相关 Java 客户端实施，如 RestKieServerControllerClient 实施，以访问 KIE Server 模板和 REST 协议中的 KIE 容器的客户端服务。

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

   创建与 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 客户端：

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

   • HTTP Headers ：设置以下标头：

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

   对于 curl 工具：

   • - U ：输入 Business Central 用户的用户名和密码，以及 rest-all 角色。

   • - 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 客户端：

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

   • HTTP Headers ：设置以下标头：

     • 接受:application/json
     • 接受语言: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 ：输入 Business Central 用户的用户名和密码，以及 rest-all 角色。

   • - h ：设置以下标头：

     • 接受:application/json
     • 接受语言 ：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 Headers ：设置以下标头：

     • 接受: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 Headers ：设置以下标头：

     • 接受: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"
   }

   如果您遇到请求错误，请检查返回的错误消息并相应地调整您的请求。