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

Red Hat Process Automation Manager 7.11

摘要

本文档论述了如何使用 Business Central 接口或使用 KIE API 部署和管理 Red Hat Process Automation Manager 项目和资产。

前言

作为商业决策和流程的开发人员,您必须将开发的 Red Hat Process Automation Manager 项目部署到 KIE 服务器中,以便开始使用您在 Red Hat Process Automation Manager 中创建的服务。您可以使用 Business Central 接口或使用 KIE API 部署和管理 Red Hat Process Automation Manager 项目和资产。

使开源包含更多

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。我们从这四个术语开始:master、slave、黑名单和白名单。由于此项工作十分艰巨,这些更改将在即将推出的几个发行版本中逐步实施。详情请查看 CTO Chris Wright 信息

部分 I. 打包和部署 Red Hat Process Automation Manager 项目

作为自定义规则开发人员,您必须将开发的 Red Hat Process Automation Manager 项目构建和部署到 KIE 服务器,以便开始使用您在 Red Hat Process Automation Manager 中创建的服务。您可以从 Business Central、独立于 Maven 项目、Java 应用程序或使用各种平台的组合来开发和部署项目。例如,您可以在 Business Central 中开发一个项目,并使用 KIE Server REST API 进行部署,或者在配置了 Business Central 的 Maven 中开发项目并使用 Business Central 进行部署。

先决条件

  • 要部署的项目已被开发和测试。对于 Business Central 中的项目,请考虑使用测试场景测试项目中的资产。例如,请参阅使用 测试场景测试决策服务

第 1 章 Red Hat Process Automation Manager 项目打包

Red Hat Process Automation Manager 项目包含您在 Red Hat Process Automation Manager 中开发的业务资产。Red Hat Process Automation Manager 中的每个项目都打包为带有配置文件(如 Maven 项目对象模型文件(pom.xml))的知识库 JAR (KJAR)文件,其中包含项目中资产的构建、环境和其他信息,以及 KIE 模块描述符文件(kmodule.xml),其中包含项目中资产的 KIE 基础和 KIE 会话配置。您可以将打包的 KJAR 文件部署到 KIE 服务器中,该服务器从该 KJAR 文件运行决策服务、进程应用程序和其他可部署资产(收集为服务)。这些服务通过实例化 KIE 容器或 部署单元 在运行时使用。项目 KJAR 文件存储在 Maven 存储库中,由三个值标识: GroupIdArtifactIdVersion (GAV)。Version 值对于可能需要部署的每个新版本都必须是唯一的。要识别工件(包括 KJAR 文件),您需要所有三个 GAV 值。

当您构建和部署项目时,Business Central 中的项目会自动打包。对于 Business Central 之外的项目,如 Java 应用程序中的独立的 Maven 项目或项目,您必须在附加的 kmodule.xml 文件中配置 KIE 模块描述符设置,或直接在 Java 应用程序中配置部署项目。

第 2 章 Business Central 中的项目部署

您可以使用 Business Central 开发您的业务资产和服务,并管理为项目部署的 KIE 服务器。开发项目后,您可以在 Business Central 中构建项目,并自动将其部署到 KIE 服务器中。要启用自动部署,Business Central 包含一个内置 Maven 存储库。在 Business Central 中,您可以启动、停止或删除包含您构建和部署的服务及其项目版本的部署单元(KIE 容器)。

您还可以将多个 KIE 服务器连接到同一个 Business Central 实例,并将其分组到不同的服务器配置中(在 MenuDeployExecution Servers中)。属于同一服务器配置的服务器运行相同的服务,但您可以在不同的配置中部署不同的项目或不同版本的项目。

例如,您可以在 Production 配置中的 Test 配置和生产服务器中测试服务器。随着您在项目中开发业务资产和服务,您可以在 Test 服务器配置上部署项目。当项目版本经过充分测试后,您可以将其部署到 Production 服务器配置中。在本例中,若要保持开发项目,可更改项目设置中的版本。然后,新版本和旧版本在内置 Maven 存储库中被视为不同的工件。您可以在 Test 服务器配置上部署新版本,并在 Production 服务器配置中保留旧版本。此部署过程非常简单,但存在显著的限制。值得注意的是,没有足够访问控制:开发人员可以将项目直接部署到生产环境中。

重要

您不能使用 Business Central 将 KIE 服务器移到不同的服务器配置中。您必须更改服务器的配置文件,以更改其配置名称。

2.1. 配置 KIE 服务器以连接到 Business Central

警告

本节提供了可用于测试目的的设置示例。对于生产环境,一些值不可理解,并被标记为这样。

如果在 Red Hat Process Automation Manager 环境中没有配置 KIE 服务器,或者在 Red Hat Process Automation Manager 环境中需要额外的 KIE 服务器,您必须配置 KIE 服务器来连接到 Business Central。

注意

如果要在 Red Hat OpenShift Container Platform 上部署 KIE 服务器,请参阅使用 Operator 在 Red Hat OpenShift Container Platform 4 上部署 Red Hat Process Automation Manager 环境

先决条件

  • Business Central 和 KIE 服务器安装在 Red Hat JBoss EAP 安装(EAP_HOME)的基础镜像中。
注意

您必须在生产环境中的不同服务器上安装 Business Central 和 KIE 服务器。在本例中,我们只使用一个名为 controllerUser 的用户,其中包含 rest-allkie-server 角色。但是,如果您在同一服务器上安装 KIE 服务器和 Business Central,例如在开发环境中,在共享 standalone-full.xml 文件中进行更改,如本节所述。

  • 存在具有以下角色的用户:

    • 在 Business Central 中,具有角色 rest-all的用户
    • 在 KIE 服务器上,具有角色 kie-server的用户

流程

  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. MenuDeployExecution Servers

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

2.2. 在 KIE 服务器和 Business Central 中配置环境模式

您可以将 KIE 服务器设置为 在生产 模式 或开发 模式下运行。开发模式提供了一个灵活的部署策略,可让您更新现有的部署单元(KIE 容器),同时维护活跃进程实例以进行小更改。它还允许您在更新活跃进程实例以进行较大的更改前重置部署单元状态。生产环境模式最适合生产环境,每个部署都会创建一个新的部署单元。

在开发环境中,您可以点 Deploy in Business Central 将构建的 KJAR 文件部署到 KIE 服务器中,而不停止任何正在运行的实例(如果适用),或者点 Redeploy 来部署构建的 KJAR 文件并替换所有实例。您下次部署或重新部署构建的 KJAR 时,以前的部署单元(KIE 容器)会在相同的目标 KIE 服务器中自动更新。

在生产环境中,Business Central 中的 Redeploy 选项被禁用,您只能点 Deploy 将构建的 KJAR 文件部署到 KIE 服务器上的新部署单元(KIE 容器)。

流程

  1. 要配置 KIE 服务器环境模式,请将 org.kie.server.mode 系统属性设置为 org.kie.server.mode=developmentorg.kie.server.mode=production
  2. 要在 Business Central 中为项目配置部署行为,请转至 SettingsGeneral SettingsVersion,并切换 Development Mode 选项。

    注意

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

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

2.3. 为 Business Central 和 KIE 服务器配置外部 Maven 存储库

您可以将 Business Central 和 KIE 服务器配置为使用外部 Maven 存储库,如 Nexus 或 Artifactory,而不是内置存储库。这可让 Business Central 和 KIE 服务器访问和下载在外部 Maven 存储库中维护的工件。

重要

存储库中的工件不会接收自动安全补丁,因为 Maven 要求工件不可变。因此,缺少已知安全漏洞补丁的工件将保留在存储库中,以避免破坏依赖于它们的构建。补丁工件的版本号会被递增。如需更多信息,请参阅 JBoss Enterprise Maven 存储库

先决条件

流程

  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 服务器。

后续步骤

对于您要导出或推送为 KJAR 工件到外部 Maven 存储库的每个 Business Central 项目,您必须在项目 pom.xml 文件中添加存储库信息。具体说明请查看 第 2.4 节 “将 Business Central 项目导出到外部 Maven 存储库”

2.4. 将 Business Central 项目导出到外部 Maven 存储库

如果您为 Business Central 和 KIE 服务器配置了外部 Maven 存储库,您必须在您要导出或推送到该外部存储库的每个 Business Central 项目的 pom.xml 文件中添加存储库信息。然后,您可以根据需要通过存储库发出项目 KJAR 文件,以实施集成过程,并使用 Business Central 或 KIE Server REST API 部署 KJAR 文件。

先决条件

流程

  1. 在 Business Central 中,进入 MenuDesignProjects,点项目名称,然后选择项目中的任何资产。
  2. 在屏幕左侧的 Project Explorer 菜单中,点 Customize View gear 图标并选择 Repository Viewpom.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 文件更改。

对您要导出或推送为 KJAR 工件的每个 Business Central 项目重复此步骤到外部 Maven 存储库。

2.5. 在 Business Central 中构建和部署项目

开发完项目后,您可以在 Business Central 中构建项目,并将它部署到配置的 KIE 服务器中。Business Central 中的项目会在构建和部署项目时自动打包为 KJARs,以及所有必要组件。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects,然后点击项目名称。
  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=developmentorg.kie.server.mode=production。要在 Business Central 中为对应项目配置部署行为,请转至 Project SettingsGeneral SettingsVersion 并切换 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 detailsDeploy 下拉菜单。这个选项会将您定向到 MenuDeployExecution Servers 页面。

2.6. Business Central 中的部署单元

项目中的服务会在配置的 KIE 服务器上通过实例化 KIE 容器或 部署单元 在运行时被消耗。当您在 Business Central 中构建和部署项目时,部署单元会在配置的服务器中自动创建。您可以根据需要在 Business Central 中启动、停止或删除部署单元。您还可以从之前构建的项目创建额外的部署单元,并在 Business Central 中配置的现有或新的 KIE 服务器中启动它们。

2.6.1. 在 Business Central 中创建部署单元

一个或多个部署单元应该已作为 Red Hat Process Automation Manager 配置的一部分存在,但如果没有,您可以从之前在 Business Central 中构建的项目中创建一个部署单元。

先决条件

  • 您要创建新的部署单元的项目已在 Business Central 中构建。

流程

  1. 在 Business Central 中,进入 MenuDeployExecution servers
  2. Server Configuration 下,选择现有配置,或者点击 New Server Configuration 来创建配置。
  3. Deployment Units 下,点 Add Deployment Unit
  4. 如果需要,在 Alias 字段中添加一个别名。
  5. 在窗口内的表中,选择一个 GAV,然后单击 GAV 旁边的 Select 来填充部署单元数据字段。
  6. 选择 Start Deployment Unit? 复选框来立即启动该服务,或者清除复选框以稍后启动该服务。
  7. Finish

    为该服务创建新部署单元,并放置在为此服务器配置配置的 KIE 服务器中。如果您选择了 Start Deployment Unit?,该服务将启动。

2.6.2. 在 Business Central 中启动、停止和删除部署单元

启动部署单元时,可以使用部署单元中的服务。如果只有一个 KIE 服务器连接到 Business Central,或者所有连接的 KIE 服务器都位于同一服务器配置中,则服务会在项目部署时在部署单元中自动启动。如果有多个服务器配置,会在部署时提示您指定服务器和部署详情并启动部署单元。但是,您可以随时手动启动、停止或删除 Business Central 中的部署单元,以便根据需要管理部署的服务。

流程

  1. 在 Business Central 中,进入 MenuDeployExecution servers
  2. Server Configuration 下,选择一个配置。
  3. Deployment Units 下,选择一个部署单元。
  4. 点右上角的 StartStopRemove。要删除正在运行的部署单元,请停止它,然后将其删除。

2.6.3. KIE 容器别名

KIE 容器(部署单元)的别名是 KIE 服务器实例中的一个代理,可帮助处理同一容器部署的不同版本。您可以将单个别名链接到容器的不同版本。当容器升级时,链接的别名会自动指向容器的新版本。有关创建 KIE 容器别名的详情,请参考 第 2.6.1 节 “在 Business Central 中创建部署单元”

例如,如果客户端应用程序每次部署容器新版本时都会更改,则客户端应用程序可以指向容器别名。部署新容器版本时,相关的别名会被更新,所有请求都会自动路由到新容器,而无需更改客户端应用程序。

考虑包含单个进程并使用以下属性的示例项目:

  • GroupId: org.jbpm
  • artifactId: my-project
  • 版本: 1.0
  • containerID: my-project

当您更新、构建和部署上述项目时,相关的项目会在 KIE 服务器中使用最新版本更新,并包含以下属性:

  • GroupId: org.jbpm
  • artifactId: my-project
  • 版本 :2.0

如果要部署项目的最新版本,则需要将 containerID 更新为 my-project2,因为 my-project 容器指向旧版本。

注意

每个项目版本包含不同的 containerID 名称。关联的客户端应用程序需要了解它们与之交互的所有项目版本。

容器别名还可帮助您管理 KIE 容器。您可以在创建容器时显式设置容器别名,或者根据关联的 ArtifactId 名称隐式设置容器别名。如果需要,您可以为多个容器添加一个别名。如果没有指定容器别名,则项目的 ArtifactId 默认被设置为容器别名。

当您为包含不同 GroupIdArtifactId 名称的多个容器设置别名时,您可以每次都使用相同的别名与 KIE 服务器交互。

您通常在以下用例中使用容器别名:

  • 使用最新版本的 进程在客户端应用程序中启动新的进程实例
  • 与一个进程的现有特定版本进行交互
  • 在一个进程中的现有任务进行交互
  • 与进程定义镜像交互 并形成

例如,在部署项目的 1.0 版本后,您将向以下 KIE Server REST API 端点发送 POST 请求以启动项目中的进程:

/http://localhost:8230/kie-server/services/rest/server/containers/my-project/processes/evaluation/instances

发送的请求从 org.jbpm:my-project:1.0 中启动一个新进程实例,其中 my-project 定义为容器别名。之后,当您部署项目的 2.0 版本并发送同一请求时,新实例从 org.jbpm:my-project:2.0 启动。您可以在不添加 containerID 名称的情况下部署最新版本的进程。

2.7. 编辑 Business Central 中项目的 GAV 值

GroupIdArtifactIdVersion (GAV)值标识 Maven 存储库中的项目。当 Business Central 和 KIE 服务器位于同一文件系统中并使用相同的 Maven 存储库时,每次构建新版本的项目时,项目会在存储库中自动更新。但是,如果 Business Central 和 KIE 服务器位于单独的文件系统中,并使用单独的本地 Maven 存储库,您必须更新项目 GAV 值(通常是版本)用于项目的任何新版本,以确保项目被视为不同的工件和旧版本。

注意

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

您可以在项目 Settings 屏幕中设置 GAV 值。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects,然后点击项目名称。
  2. 点 Project Settings 选项卡。
  3. General Settings 中,根据需要修改 Group IDArtifact IDVersion 字段。如果您部署了项目并正在开发新版本,通常您需要增加版本号。

    注意

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

  4. 单击 Save 以完成。

2.8. Business Central 中重复的 GAV 检测

在 Business Central 中,所有 Maven 存储库都会检查项目中任何重复的 GroupIdArtifactIdVersion (GAV)值。如果存在 GAV 重复,则会取消执行的操作。

注意

开发模式 中的项目禁用重复的 GAV 检测。要在 Business Central 中启用重复的 GAV 检测,请转至 Project SettingsGeneral SettingsVersion,并将 Development Mode 选项切换为 OFF (如果适用)。

每次执行以下操作时都会执行重复的 GAV 检测:

  • 保存项目的项目定义。
  • 保存 pom.xml 文件。
  • 安装、构建或部署项目。

检查以下 Maven 存储库是否有重复的 GAV:

  • pom.xml 文件的 <repositories & gt; 和 <distributionManagement > 元素中指定的软件仓库。
  • Maven settings.xml 配置文件中指定的存储库。

2.8.1. 在 Business Central 中管理重复的 GAV 检测设置

具有 admin 角色的用户,可以修改检查项目的重复 GroupIdArtifactIdVersion (GAV)值的存储库列表。

注意

开发模式 中的项目禁用重复的 GAV 检测。要在 Business Central 中启用重复的 GAV 检测,请转至 Project SettingsGeneral SettingsVersion,并将 Development Mode 选项切换为 OFF (如果适用)。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects,然后点击项目名称。
  2. 单击 Project Settings 选项卡,然后单击 Validation 以打开存储库列表。
  3. 选择或清除任何列出的仓库选项,以启用或禁用重复的 GAV 检测。

    未来,只有您启用了验证的存储库才会报告重复的 GAV。

    注意

    要禁用此功能,请在系统启动时将 Business Central 的 org.guvnor.project.gav.check.disabled 系统属性设置为 true

    $ ~/EAP_HOME/bin/standalone.sh -c standalone-full.xml
    -Dorg.guvnor.project.gav.check.disabled=true

第 3 章 没有 Business Central 的项目部署

作为在 Business Central 界面中开发和部署项目的替代选择,您可以使用独立的 Maven 项目或您自己的 Java 应用程序来开发 Red Hat Process Automation Manager 项目,并将它们部署在 KIE 容器(部署单元)中。然后,您可以使用 KIE Server REST API 启动、停止或删除包含您构建和部署的服务及其项目版本的 KIE 容器。通过这种灵活性,您可以继续使用现有的应用程序工作流来使用 Red Hat Process Automation Manager 功能开发业务资产。

当您构建和部署项目时,Business Central 中的项目会自动打包。对于 Business Central 之外的项目,如 Java 应用程序中的独立的 Maven 项目或项目,您必须在附加的 kmodule.xml 文件中配置 KIE 模块描述符设置,或直接在 Java 应用程序中配置部署项目。

3.1. 配置 KIE 模块描述符文件

KIE 模块是带有额外元数据文件 META-INF/kmodule.xml 的 Maven 项目或模块。所有 Red Hat Process Automation Manager 项目都需要一个 kmodule.xml 文件才能正确打包和部署。此 kmodule.xml 文件是一个 KIE 模块描述符,它为项目中的资产定义 KIE 基础和 KIE 会话配置。KIE 基础是一个存储库,其中包含 Red Hat Process Automation Manager 中的所有规则、进程和其他业务资产,但不包含任何运行时数据。KIE 会话存储并执行运行时数据,如果已在 kmodule.xml 文件中定义 KIE 会话,则从 KIE 基础或直接从 KIE 容器创建。

如果您在 Business Central 外部创建项目,如 Java 应用程序中的独立 Maven 项目或项目,您必须在附加的 kmodule.xml 文件中配置 KIE 模块描述符设置,或者直接在 Java 应用程序中构建和部署项目。

流程

  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、MuterEventListenerprocessEventListener。& 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 文件中的 KieBaseKieSession 配置为 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.javahttps://access.redhat.com/jbossnetwork/restricted/listSoftware.html

有关 kmodule.xml 文件的更多信息,请从 红帽客户门户网站 (如果还没有下载)下载 Red Hat Process Automation Manager 7.11.0 Source Distribution ZIP 文件(如果还没有下载)并查看 $FILE_HOME/rhpam-$VERSION-sources/kie-api-parent-$VERSION/kie-api/src/main/resources/org/kie/api/.

3.1.1. KIE 模块配置属性

您的项目的 KIE 模块描述符文件 (kmodule.xml) 中提供了可选的 <configuration> 项用于定义属性 keyvalue 对,可以进一步自定义您的 kmodule.xml 文件。

kmodule.xml 文件中的配置属性示例

<kmodule>
  ...
  <configuration>
    <property key="drools.dialect.default" value="java"/>
    ...
  </configuration>
  ...
</kmodule>

以下是项目的 KIE 模块描述符文件(kmodule.xml)中支持的 < configuration > 属性键和值:

drools.dialect.default

设置默认 Drools dialect。

支持的值有 java,mvel

<property key="drools.dialect.default"
  value="java"/>
drools.accumulate.function.$FUNCTION

将实施累积功能的类链接到指定功能名称,该名称允许您在决策引擎中添加自定义累积功能。

<property key="drools.accumulate.function.hyperMax"
  value="org.drools.custom.HyperMaxAccumulate"/>
drools.evaluator.$EVALUATION

将实施 evaluator 定义的类链接到指定的 evaluator 名称,以便您可以将自定义评估器添加到决策引擎中。evaluator 与自定义操作器类似。

<property key="drools.evaluator.soundslike"
  value="org.drools.core.base.evaluators.SoundslikeEvaluatorsDefinition"/>
drools.dump.dir

设置 Red Hat Process Automation Manager dump/log 目录的路径。

<property key="drools.dump.dir"
  value="$DIR_PATH/dump/log"/>
drools.defaultPackageName

为您的项目中的业务资产设置默认软件包。

<property key="drools.defaultPackageName"
  value="org.domain.pkg1"/>
drools.parser.processStringEscapes

设置 String 转义功能。如果此属性设为 false,则 \n 字符将不会解释为换行符。

支持的值: true (默认)、false

<property key="drools.parser.processStringEscapes"
  value="true"/>
drools.kbuilder.severity.$DUPLICATE

为构建 KIE 基础时报告重复规则、进程或功能的实例设置严重性。例如,如果您将 duplicateRule 设置为 ERROR,则会在构建 KIE 基础时为检测到的任何重复规则生成一个错误。

支持的密钥后缀: duplicateRule,duplicateProcess,duplicateFunction

支持的值有 INFOWARNINGERROR

<property key="drools.kbuilder.severity.duplicateRule"
  value="ERROR"/>
drools.propertySpecific

设置决策引擎的属性重新活动。

支持的值: DISABLEDALLOWEDALWAYS

<property key="drools.propertySpecific"
  value="ALLOWED"/>
drools.lang.level

设置 DRL 语言级别。

支持的值: DRL5,DRL6,DRL6_STRICT (默认)

<property key="drools.lang.level"
  value="DRL_STRICT"/>

3.1.2. KIE 模块中支持的 KIE 基本属性

KIE 基础是您在 KIE 模块描述符文件(kmodule.xml)中定义的存储库,其中包含 Red Hat Process Automation Manager 中的所有规则、流程和其他业务资产。当您在 kmodule.xml 文件中定义 KIE 基础时,您可以指定某些属性和值来进一步自定义 KIE 基础配置。

kmodule.xml 文件中的 KIE 基础配置示例

<kmodule>
  ...
  <kbase name="KBase2" default="false" eventProcessingMode="stream" equalsBehavior="equality" declarativeAgenda="enabled" packages="org.domain.pkg2, org.domain.pkg3" includes="KBase1" sequential="false">
    ...
  </kbase>
  ...
</kmodule>

以下是项目的 KIE 模块描述符文件(kmodule.xml)支持的 kbase 属性和值:

表 3.1. KIE 模块中支持的 KIE 基本属性

属性支持的值描述

name

任何名称

定义从 KieContainer 检索 KieBase 的名称。此属性是强制的

includes

KIE 模块中其他 KIE 基本对象的逗号分隔列表

定义此 KIE 基础中包含的其他 KIE 基础对象和工件。如果您在模块的 pom.xml 文件中声明为依赖项,则 KIE 基础可以包含在多个 KIE 模块中。

软件包

KIE 基础中包含的软件包列表以逗号分隔的软件包列表

默认: all

定义包括在此 KIE 基础中的工件(如规则和流程)的软件包。默认情况下,~/resources 目录中的所有工件都包含在 KIE 基础中。此属性允许您限制编译的工件数量。只有属于此属性中指定的列表的软件包才会被编译。

default

truefalse

默认:false

确定 KIE 基础是否为模块的默认 KIE 基础,以便它可以从 KIE 容器创建,而无需传递任何名称。每个模块只能有一个默认 KIE 基础。

equalsBehavior

身份相等

默认 : identity

定义在新事实插入工作内存中时 Red Hat Process Automation Manager 的行为。如果设置为 identity,则始终创建新的 factHandle,除非工作内存中已存在同一对象。如果设置为等 相等,则只有在新插入的对象不等于现有事实时,才会创建一个新的 fact Handle,具体取决于插入的事实的等等方法。当您希望根据功能 相等 而不是显式身份评估对象时,请使用相等模式。

eventProcessingMode

Cloud,stream

默认: cloud

决定如何在 KIE 基础中处理事件。如果此属性设置为 cloud,则 KIE 基础会将事件视为正常事实。如果将此属性设置为 ,则允许对事件进行临时的原因。

declarativeAgenda

禁用启用

Default: disabled

决定是否启用声明性议程。

sequential

truefalse

默认:false

决定是否启用后续模式。在后续模式中,决策引擎会按照决策引擎人员中列出的顺序来一次评估规则,而无需考虑工作内存中的更改。如果您使用无状态 KIE 会话,并且您不希望执行规则来影响办公室中的后续规则,请启用此属性。

3.1.3. KIE 模块支持的 KIE 会话属性

KIE 会话存储并执行运行时数据,如果您为项目定义了 KIE 模块描述符文件(kmodule.xml)中的 KIE 会话,则从 KIE 容器创建或直接从 KIE 容器创建。当您在 kmodule.xml 文件中定义 KIE 基础和 KIE 会话时,您可以指定某些属性和值来进一步自定义 KIE 会话配置。

kmodule.xml 文件中的 KIE 会话配置示例

<kmodule>
  ...
  <kbase>
    ...
    <ksession name="KSession2_1" type="stateless" default="true" clockType="realtime">
    ...
  </kbase>
  ...
</kmodule>

以下是项目的 KIE 模块描述符文件(kmodule.xml)支持的 ksession 属性和值:

表 3.2. KIE 模块支持的 KIE 会话属性

属性支持的值描述

name

任何名称

定义从 KieContainer 检索 KieSession 的名称。此属性是强制的

type

有状态无状态

默认: stateful

决定数据是否保留(有状态)还是在 KIE 会话调用之间丢弃(无状态)。将会话设置为 stateful 可让您使用工作内存进行迭代工作;将会话设置为 stateless 通常用于一次性执行的资产。无状态 会话存储了一个知识状态,在每次添加新事实、更新或删除规则时,以及每次执行规则时改变。在 无状态 会话中执行时没有关于之前操作的信息,如规则执行。

default

truefalse

默认:false

确定 KIE 会话是否为模块的默认会话,以便可以从 KIE 容器创建它,而无需传递任何名称。每个模块只能有一个默认 KIE 会话。

clockType

realtime,pseudo

默认: realtime

决定是否由系统时钟或应用程序控制的伪时钟分配事件时间戳。这个时钟对临时规则的单元测试特别有用。

beliefSystem

Simple,jtms,defeasible

默认: simple

定义 KIE 会话使用的适合系统的类型。因此,系统会降低知识(facts)的真实信息。例如,如果基于另一个事实(以后从决策引擎中删除)插入了新的事实,系统也可以确定新插入的事实也应该被删除。

3.2. 在 Maven 中打包和部署 Red Hat Process Automation Manager 项目

如果要将 Business Central 之外的 Maven 项目部署到配置的 KIE 服务器,您可以编辑项目 pom.xml 文件,将项目打包为 KJAR 文件,并使用项目中资产的 KIE 基础和 KIE 会话配置添加一个 kmodule.xml 文件。

先决条件

流程

  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 文件中的 GroupIdArterfactIdVersion (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

3.3. 在 Java 应用程序中打包和部署 Red Hat Process Automation Manager 项目

如果要从您自己的 Java 应用程序部署项目到配置的 KIE 服务器,您可以使用 KieModuleModel 实例以编程方式创建一个 kmodule.xml 文件,该文件定义 KIE 基础和 KIE 会话,然后将项目中的所有资源添加到 KIE 虚拟文件系统 KieFileSystem 中。

先决条件

  • 您有一个包含 Red Hat Process Automation Manager 商业资产的 Java 应用程序。
  • KIE 服务器已安装,并且配置了 kie-server 用户访问。有关安装选项,请参阅 规划 Red Hat Process Automation Manager 安装

流程

  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 单例中。WARNINGINFO 结果表示项目的编译成功,其中包含构建过程的相关信息。

    注意

    要从可执行规则模型构建 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 节 “可执行规则模型”

3.4. 可执行规则模型

Red Hat Process Automation Manager 中的规则资产默认使用标准 kie-maven-plugin 插件从可执行规则模型构建。可执行规则模型是嵌入式模型,为构建时执行的规则提供基于 Java 的表示。可执行模型是之前版本的 Red Hat Process Automation Manager 中打包的标准资产,并允许更快速地创建 KIE 容器和 KIE 基础,特别是在具有大量 DRL (Drools Rule Language)文件和其他 Red Hat Process Automation Manager 资产列表时。

如果不使用 kie-maven-plugin 插件,或者项目中缺少所需的 drools-model-compiler 依赖项,则在没有可执行模型的情况下构建规则资产。因此,要在构建期间生成可执行模型,请确保在 pom.xml 文件中添加 kie-maven-plugin 插件和 drools-model-compiler 依赖项。

可执行规则模型为您的项目提供以下特定优点:

  • 编译时间: 通常,打包的 Red Hat Process Automation Manager 项目(KJAR)包含 DRL 文件和其他 Red Hat Process Automation Manager 工件列表,用于定义规则基础以及一些预生成的类实现约束和结果。当 KJAR 从 Maven 存储库下载并安装到 KIE 容器中时,必须解析并编译这些 DRL 文件。这个过程可能很慢,特别是对于大型规则集。使用可执行模型,您可以在项目 KJAR 中打包,该类实现了项目规则基础的可执行模型,并以更快速的方式重新创建 KIE 容器及其 KIE 基础。在 Maven 项目中,您可以使用 kie-maven-plugin 插件在编译过程中从 DRL 文件中自动生成可执行模型源。
  • 运行时间 : 在可执行模型中,所有约束都定义为 Java lambda 表达式。同样的 lambda 表达式也用于限制评估,因此您不再需要使用 mvel 表达式来解释评估,或即时(JIT)进程将基于 mvel的限制转换为字节码。这会创建更快、效率更高的运行时间。
  • 开发时间: 可执行模型允许您开发和测试决策引擎的新功能,而无需以 DRL 格式直接编码元素或修改 DRL 解析器来支持它们。
注意

对于可执行规则模型中的查询定义,您只能使用最多 10 个参数。

对于可执行规则模型中的规则导致的变量,您只能使用 24 个绑定变量(包括内置 drools 变量)。例如,以下规则结果使用超过 24 个绑定的变量并创建编译错误:

...
then
  $input.setNo25Count(functions.sumOf(new Object[]{$no1Count_1, $no2Count_1, $no3Count_1, ..., $no25Count_1}).intValue());
  $input.getFirings().add("fired");
  update($input);

3.4.1. 在 Red Hat Process Automation Manager 项目中修改或禁用可执行规则模型

Red Hat Process Automation Manager 中的规则资产默认使用标准 kie-maven-plugin 插件从可执行规则模型构建。可执行模型是之前 Red Hat Process Automation Manager 版本中标准资产打包的有效替代方案。但是,如果需要,您可以修改或禁用可执行规则模型,将 Red Hat Process Automation Manager 项目构建为基于 DRL 的 KJAR,而不是默认的基于模型的 KJAR。

流程

以通常的方式构建 Red Hat Process Automation Manager 项目,但根据项目的类型提供一个替代的构建选项:

  • 对于 Maven 项目,在命令终端中导航到 Maven 项目目录,并运行以下命令:

    mvn clean install -DgenerateModel=<VALUE>

    <VALUE > 替换为三个值之一:

    • YES_WITHDRL: (默认)生成与原始项目中 DRL 文件对应的可执行模型,同时还将 DRL 文件添加到生成的 KJAR 中目的( KIE 基础自可执行模型构建)。
    • YES :生成与原始项目中的 DRL 文件对应的可执行模型,并从生成的 KJAR 中排除 DRL 文件。
    • no: 不生成可执行模型。

    禁用默认可执行模型行为的 build 命令示例:

    mvn clean install -DgenerateModel=NO
  • 对于以编程方式配置的 Java 应用程序,默认禁用可执行模型。在 KIE 虚拟文件系统 KieFileSystem 中添加规则资产,并使用 KieBuilder 和以下 buildAll () 方法之一:

    • buildAll () (默认)或 buildAll (DrlProject.class) :不生成可执行模型。
    • buildAll (ExecutableModelProject.class) :生成与原始项目中 DRL 文件对应的可执行模型。

    启用可执行模型行为的代码示例:

    import org.kie.api.KieServices;
    import org.kie.api.builder.KieFileSystem;
    import org.kie.api.builder.KieBuilder;
    
      KieServices ks = KieServices.Factory.get();
      KieFileSystem kfs = ks.newKieFileSystem()
      kfs.write("src/main/resources/KBase1/ruleSet1.drl", stringContainingAValidDRL)
      .write("src/main/resources/dtable.xls",
        kieServices.getResources().newInputStreamResource(dtableFileStream));
    
      KieBuilder kieBuilder = ks.newKieBuilder( kfs );
      // Enable executable model
      kieBuilder.buildAll(ExecutableModelProject.class)
      assertEquals(0, kieBuilder.getResults().getMessages(Message.Level.ERROR).size());

3.5. 使用 KIE 扫描程序来监控和更新 KIE 容器

Red Hat Process Automation Manager 中的 KIE 扫描程序会监控您的 Maven 存储库是否有新版本的 Red Hat Process Automation Manager 项目,然后将项目的最新版本部署到指定的 KIE 容器中。您可以在开发环境中使用 KIE 扫描程序,在有新版本可用时更有效地维护 Red Hat Process Automation Manager 项目部署。

重要

对于生产环境,请不要使用带有 SNAPSHOT 项目版本的 KIE 扫描程序,以避免意外或意外项目更新。KIE 扫描程序主要用于使用 SNAPSHOT 项目版本的开发环境。

避免使用带有业务进程的 KIE 扫描程序。将 KIE 扫描程序与进程搭配使用可能会导致无法预计的更新,然后在更改与正在运行的进程实例不兼容时导致长时间运行的进程出现错误。

先决条件

  • kie-ci.jar 文件位于 Red Hat Process Automation Manager 项目的类路径中。

流程

  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 容器创建的所有新 KieBaseKieSession 对象都使用新项目版本。

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

3.6. 在 KIE 服务器中启动服务

如果您已经从 Business Central 之外的 Maven 或 Java 项目部署了 Red Hat Process Automation Manager 资产,您可以使用 KIE Server REST API 调用来启动 KIE 容器(部署单元)和服务。无论部署类型是什么,您可以使用 KIE Server REST API 启动服务,包括从 Business Central 部署,但从 Business Central 部署的项目会自动启动,或者在 Business Central 接口中启动。

先决条件

流程

在命令终端中,运行以下 API 请求,将服务加载到 KIE 服务器中的 KIE 容器中,并启动该服务:

$ curl --user "<username>:<password>" -H "Content-Type: application/json" -X PUT -d '{"container-id" : "<containerID>","release-id" : {"group-id" : "<groupID>","artifact-id" : "<artifactID>","version" : "<version>"}}' http://<serverhost>:<serverport>/kie-server/services/rest/server/containers/<containerID>

替换以下值:

  • <username > , <password> : 具有 kie-server 角色的用户的用户名和密码。
  • <containerID> : KIE 容器的标识符(部署单元)。您可以使用任何随机标识符,但在命令(URL 和数据)中的两个位置都必须相同。
  • <groupID>, <artifactID>, <version>: 项目的 GAV 值。
  • <serverhost> : 如果您在与 KIE 服务器相同的主机上运行命令,则 KIE 服务器或 localhost 的主机名。
  • <serverport> : KIE 服务器的端口号。

Example:

curl --user "rhpamAdmin:password@1" -H "Content-Type: application/json" -X PUT -d '{"container-id" : "kie1","release-id" : {"group-id" : "org.kie.server.testing","artifact-id" : "container-crud-tests1","version" : "2.1.0.GA"}}' http://localhost:39043/kie-server/services/rest/server/containers/kie1

3.7. 在 KIE 服务器中停止和删除服务

如果您已经从 Business Central 之外的 Maven 或 Java 项目启动 Red Hat Process Automation Manager 服务,您可以使用 KIE Server REST API 调用来停止和删除包含服务的 KIE 容器(部署单元)。您可以使用 KIE Server REST API 停止服务,而不考虑您的部署类型,包括从 Business Central 部署,但来自 Business Central 的服务也可以在 Business Central 接口内停止。

先决条件

流程

在命令终端中,运行以下 API 请求来停止和删除 KIE 服务器上的服务:

$ curl --user "<username>:<password>" -X DELETE http://<serverhost>:<serverport>/kie-server/services/rest/server/containers/<containerID>

替换以下值:

  • <username > , <password> : 具有 kie-server 角色的用户的用户名和密码。
  • <containerID> : KIE 容器的标识符(部署单元)。您可以使用任何随机标识符,但在命令(URL 和数据)中的两个位置都必须相同。
  • <serverhost> : 如果您在与 KIE 服务器相同的主机上运行命令,则 KIE 服务器或 localhost 的主机名。
  • <serverport> : KIE 服务器的端口号。

Example:

curl --user "rhpamAdmin:password@1" -X DELETE http://localhost:39043/kie-server/services/rest/server/containers/kie1

第 4 章 其他资源

部分 II. 在 Business Central 中管理项目

作为流程管理员,您可以在 Red Hat Process Automation Manager 中使用 Business Central 来管理单个或多个分支上的新的、示例和导入的项目。

先决条件

第 5 章 Red Hat Process Automation Manager 项目

Red Hat Process Automation Manager 项目包含在 Red Hat Process Automation Manager 中开发的业务资产,并分配到一个空间(例如,MySpace中的 MyProject )。项目还包含 Maven 项目对象模型文件(pom.xml)等配置文件,其中包含项目中资产的构建、环境和其他信息,以及 KIE 模块描述符文件(kmodule.xml),其中包含项目中资产的 KIE Base 和 KIE Session 配置。

第 6 章 将业务流程迁移到新的流程设计程序

Business Central 中的旧进程设计程序在 Red Hat Process Automation Manager 7.11.0 中已弃用。它将在以后的 Red Hat Process Automation Manager 发行版本中删除。传统的进程设计程序将不会收到任何新的增强或功能。如果要使用新的流程设计程序,请开始将进程迁移到新的设计程序。在新的进程设计器中创建所有新进程。

注意

流程引擎将继续支持在 KIE 服务器中执行和部署使用传统设计器生成的业务进程的执行和部署。如果您有一个旧的业务流程正常工作,且您不会更改,则目前不会强制迁移到新的设计人员。

您只能迁移在新的设计人员中包含受支持的业务流程节点的业务流程。在以后的 Red Hat Process Automation Manager 版本中会添加更多节点。

先决条件

  • 您有一个现有项目,其中包含使用旧流程设计器创建的业务进程资产。

流程

  1. 在 Business Central 中,点击 MenuDesignProjects
  2. 点您要迁移的项目,如 Mortgage_Process
  3. Ok 以打开项目的资产列表。
  4. 点项目的 Business Process 资产在旧进程设计程序中打开它。
  5. MigrateMigrate Diagram

    图 6.1. 迁移确认信息

    迁移确认信息
  6. 选择 YesNo 来确认是否进行了更改。只有在您更改了旧业务流程时,此选项才可用。

    图 6.2. 保存图形更改确认

    保存图形更改确认

如果迁移成功,业务流程会在新的流程设计程序中打开,业务流程的扩展从 *.bpmn2 改为 *.bpmn。

如果因为不支持的节点类型造成迁移失败,则 Business Central 会显示以下出错信息:

图 6.3. 迁移失败信息

迁移失败信息

第 7 章 修改 Business Central 中的现有项目

Business Central 包括多个示例项目,可用于熟悉产品及其功能。示例项目经过设计和创建,以演示各种业务场景。您可以修改示例项目,以满足您的特定业务需求。例如,Red Hat Process Automation Manager 7.11 包含 Mortgage_Process 示例项目,它由预定义的数据对象、指导决策表、指导规则、表单和迁移过程组成。您可以编辑示例来优化您的业务流程。

如果任何现有的 Business Central 项目样本与您的要求一致,您可以创建新项目或从 Git 存储库导入。更多信息请参阅 第 9 章 从 Git 存储库导入项目。您可以从 Git 导入任何其他项目。例如,在另一个 Business Central 实例中开发的项目。

第 8 章 创建 mortgage-process 项目

项目是用于资产(如数据对象、业务进程、指导规则、决策表和表单)的容器。您要创建的项目与 Business Central 中现有的 Mortgage_Process 示例项目类似。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects

    Red Hat Process Automation Manager 提供名为 MySpace 的默认空间,如下图所示。您可以使用默认空间来创建和测试示例项目。

    图 8.1. 默认空间

    空格团队
  2. 单击 Add Project
  3. Name 字段中输入 mortgage-process
  4. Configure Advanced Options 并使用以下值修改 GAV 字段:

    • 组 ID:com.myspace
    • 工件 ID :mortgage-process
    • Version:1.0.0
  5. 点击 Add

项目的 Assets 视图将打开。

8.1. 修改 Mortgage_Process 示例项目

Mortgage_Process 示例项目由预定义的数据对象、指导路由表、指导规则、表单和流程组成。使用示例项目提供了与红帽流程自动化管理器加速的方法。在现实业务场景中,您可以通过提供特定于您的业务需求的数据来创建所有资产。

导航到 Mortgage_Process 示例项目,以查看预定义的资产。

流程

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

8.2. 使用 archetypes 创建项目

archetypes 是在 Apache Maven 存储库中安装并包含特定模板结构的项目。您还可以使用 archetypes 生成项目模板的参数化版本。当您使用 archetype 创建项目时,会将其添加到连接到 Red Hat Process Automation Manager 安装的 Git 存储库中。

先决条件

  • 您已创建了 archetype,并将其添加到 Business Central Settings 中的 Archetypes 页面中。有关创建 archetypes 的详情,请参考创建存档类型指南
  • 您已在 Business Central 的空间中设置了默认的 archetype。

有关架构管理的更多信息,请参阅配置 Business Central 设置和属性

流程

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

项目的 Assets 视图会根据所选的 archetype 模板打开。

第 9 章 从 Git 存储库导入项目

Git 是一个分布式版本控制系统。它将修订版本实施为提交对象。当您将更改保存到存储库时,会在 Git 存储库中创建一个新的提交对象。

Business Central 使用 Git 来存储项目数据,包括规则和流程等资产。当您在 Business Central 中创建项目时,它将添加到连接到 Business Central 的 Git 存储库中。如果您在 Git 存储库中有项目,可以通过 Business Central 空格将项目的 master 分支或导入 master 分支以及其他特定的分支导入到 Business Central Git 存储库中。

先决条件

  • Red Hat Process Automation Manager 项目存在于外部 Git 存储库中。
  • 您有读取该外部 Git 存储库所需的权限所需的凭证。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects
  2. 选择或创建您要将项目导入到的空间。默认空间为 MySpace
  3. 在屏幕右上角,单击 Add Project 旁边的箭头,然后选择 Import Project
  4. Import Project 窗口中,输入 Git 存储库的 URL 和凭据,其中包含您要导入的项目,然后单击 Import。此时会显示 Import Projects 页面。
  5. 可选: 要导入 master 和特定分支,请执行以下任务:

    1. Import Projects 页面中,点分支 branch icon 图标。
    2. 要导入的分支 窗口中,从列表中选择分支。

      注意

      您必须最少选择 master 分支。

    3. 确定
  6. Import Projects 页面上,确保项目被突出显示并单击 Ok

第 10 章 查看项目版本

在构建和部署项目的新实例前,您可以重新查看 Red Hat Process Automation Manager 中的项目的版本号。如果新版本的项目出现问题,则项目的新版本会保留旧版本,您需要恢复。

先决条件

  • KIE 服务器部署并连接到 Business Central。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects
  2. 点您要部署的项目,如 Mortgage_Process
  3. 单击 Deploy

    • 如果没有具有项目名称的容器,则会自动创建具有默认值的容器。
    • 如果部署了项目的旧版本,请转至项目设置并更改项目版本。完成后,保存更改并点 Deploy。这将部署带有最新更改的同一项目的新版本,以及旧版本。

      注意

      您还可以选择 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=developmentorg.kie.server.mode=production。要在 Business Central 中为对应项目配置部署行为,请转至 Project SettingsGeneral SettingsVersion 并切换 Development Mode 选项。默认情况下,Business Central 中的 KIE 服务器和所有新项目都处于开发模式。您不能部署启用了 开发模式 的项目,或手动将 SNAPSHOT 版本后缀添加到处于生产环境模式的 KIE 服务器中。

  4. 要查看项目部署详情,请单击屏幕顶部的部署横幅中的 View deployment detailsDeploy 下拉菜单。这个选项会将您定向到 MenuDeployExecution Servers 页面。
  5. 要验证进程定义,请点击 MenuManageProcess Definitions,然后点击 btn refresh
  6. 点击 Actions 列中的 dots 并选择 Start 来启动进程的新实例。

第 11 章 配置项目设置

从 Red Hat Process Automation Manager 7.11 开始,verer Central 在新的进程设计程序中包含额外的项目设置类别。

先决条件

  • 您已创建了 Business Central 项目。

流程

  1. 要访问项目 Settings 选项卡,在 Business Central 中进入 MenuDesignProjects
  2. 点项目名称。
  3. Settings 查看或修改以下项目设置:

    • 常规设置 - 允许用户设置项目的名称描述组 ID工件 ID版本 (GAV)和 开发模式 属性。它还包括以下选项:

      • URL - 用于指定一个只读 URL,用于将项目克隆为 git 存储库。
      • 禁用 GAV 冲突检查 - 确定是否启用或禁用 GAV 冲突检查。禁用此功能可让项目具有相同的 GAV 值。
      • 允许子 GAV 版本 - 允许子项目的 GAV 版本。
    • 依赖项 - 通过输入 组 ID、工件 ID 和版本,或者从 Business Central 中的存储库项目添加依赖项。对于每个依赖项,为 Package white list 选项设置 AllNone
    • KIE Bases - 之前称为 知识库文章的新名称。您必须指定一个 KIE 基础作为默认值。提供以下详情来添加 Kie 基础:

      • 名称
      • 包括 KIE 基础
      • 软件包
      • 平等行为 - IdentityEquality
      • 事件处理模型 - 或云
      • KIE 会话
    • External Data Objects - 在规则作者可能需要的项目或项目依赖项中未显式定义数据对象。外部数据对象通常由 Java 运行时提供,如 java.util.List
    • 验证 - 在创建新项目或模块或将项目安装到 Maven 存储库时,用于检查项目的 GAV 的唯一性的 Maven 存储库。
    • 服务任务 - 可以将以下服务任务添加到项目中:

      • BusinessRuleTask - 执行业务规则任务
      • 决策任务 - 执行 DMN 决策任务
      • 电子邮件 - 发送电子邮件
      • JMSSendTask - 发送 JMS 消息
      • REST - 执行 Rest 调用
      • ServiceTask - 执行服务任务
      • Webservice - 执行 Web 服务调用
    • Deployment - 部署分为以下类别:

      • 常规设置 - 运行时策略持久性单元名称持久性模式审计持久性 单元名称 和审计模式
      • Marshalling 策略
      • 全局
      • 事件监听程序
      • 所需角色
      • 可远程类
      • 任务事件监听程序
      • 配置
      • 环境条目
      • 工作项目处理程序
    • Persistence - Persistence 分为以下类别:

      • 持久性单元
      • 持久性供应商
      • 数据源
      • properties - 用于为以下属性设置值并创建新属性:

        • hibernate.dialect
        • hibernate.max_fetch_depth
        • hibernate.hbm2ddl.auto
        • hibernate.show_sql
        • hibernate.id.new_generator_mappings
        • hibernate.transaction.jta.platform
      • Project Persistable Data Objects
    • 分支管理 - 根据分支名称和分配的用户角色提供分支角色访问。
  4. 点击 Save

第 12 章 Business Central 中的多个分支

Business Central 中的多个分支支持能够基于现有分支创建新分支,包括其所有资产。所有新的、导入和示例项目在默认 master 分支中打开。您可以根据需要创建任意数量的分支,并可互换处理多个分支,而不影响 master 分支的原始项目。

Red Hat Process Automation Manager 7.11 包括对保留分支的支持,这意味着 Business Central 会记住使用的最后分支,并在重新登录时在该分支中打开。

12.1. 创建分支

您可以在 Business Central 中创建新分支,并将它们命名为您需要的任何分支。最初,您将具有默认的 master 分支。当您为项目创建新分支时,您要生成所选分支的副本。您可以在新分支上更改项目,而不影响原始 master 分支版本。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects
  2. 单击项目以创建新分支,如 Mortgage_Process 示例项目。
  3. masterAdd Branch

    图 12.1. 创建新分支菜单

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

    图 12.2. 添加新分支窗口

    添加新分支 testBranch1

添加新分支后,您将重定向到该分支,它将包含 master 分支中项目中已有的所有资产。

12.2. 选择分支

您可以在分支间切换,以对项目资产进行修改并测试修改后的功能。

流程

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

    图 12.3. 选择分支菜单

    选择分支菜单

选择分支后,您将重定向到包含项目以及您定义的所有资产的分支。

12.3. 删除分支

您可以删除除 master 分支之外的任何分支。Business Central 不允许删除 master 分支以避免破坏您的环境。您必须位于 master 以外的任何分支中,才能使以下步骤正常工作。

流程

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

    图 12.4. 删除分支

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

12.4. 构建和部署项目

开发完项目后,您可以从 Business Central 中指定的分支构建项目,并将它部署到配置的 KIE 服务器中。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects,然后点击项目名称。
  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=developmentorg.kie.server.mode=production。要在 Business Central 中为对应项目配置部署行为,请转至 Project SettingsGeneral SettingsVersion 并切换 Development Mode 选项。默认情况下,Business Central 中的 KIE 服务器和所有新项目都处于开发模式。您不能部署启用了 开发模式 的项目,或手动将 SNAPSHOT 版本后缀添加到处于生产环境模式的 KIE 服务器中。

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

    要查看项目部署详情,请单击屏幕顶部的部署横幅中的 View deployment detailsDeploy 下拉菜单。这个选项会将您定向到 MenuDeployExecution Servers 页面。

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

第 13 章 更改 Business Central 中的请求

如果您在 Business Central 项目中有多个分支,且您要合并到另一个分支的分支中,您可以创建更改请求。任何有权查看目标分支(通常是 master 分支)的用户都可以看到更改请求。

13.1. 创建更改请求

在项目更改后,您可以在 Business Central 项目中创建更改请求,例如向资产添加或删除属性后。

先决条件

  • 您有多个 Business Central 项目的分支。
  • 您在要合并到另一个分支的一个分支中进行了更改。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects 并选择包含您要合并的更改的空间和项目。
  2. 在项目页面上,选择包含更改的分支。

    图 13.1. 选择分支菜单

    选择分支菜单
  3. 执行以下任务之一以提交更改请求:

    • 点击屏幕右上角的 dots 并选择 Submit Change Request
    • 单击 Change Requests 选项卡,然后单击 Submit Change Request

      此时会出现 Submit Change Request 窗口。

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

13.2. 使用更改请求

您可以查看您可以访问的任何分支的更改请求。您必须具有管理员权限才能接受更改请求。

先决条件

  • 您有多个 Business Central 项目的分支。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects 并选择空格和项目。
  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 以返回到项目窗口,而不进行任何更改。

部分 III. 在 Business Central 中管理资产

作为流程管理员,您可以在 Red Hat Process Automation Manager 中使用 Business Central 来管理资产,如规则、流程和决策表。

先决条件

第 14 章 资产概述

在 Business Central 中创建的新规则、进程定义文件和其他资源都存储在由 KIE 服务器访问的 Artifact 存储库(Knowledge Store)中。

Artifact 存储库是企业知识的集中存储库。它连接多个 GIT 存储库,以便您可以从一个环境中访问它们,同时将不同类型的知识和工件存储在不同的位置。GIT 是一个分布式版本控制系统,它将修订版本实施为提交对象。每次您将更改保存到存储库时,这会在 GIT 存储库中创建一个新的提交对象。同样,用户也可以复制现有的存储库。此复制过程通常称为克隆,生成的存储库可以被称为克隆。每个克隆都包含文件集合的完整历史记录,克隆的存储库与原始存储库具有相同的内容。

Business Central 提供了一个 web 前端,可让您查看和更新存储的内容。要访问 Artifact 存储库资产,请转至 Business Central 中的 MenuDesignProjects,然后点击项目名称。

第 15 章 资产类型

Business Central 存储库中可以版本化的任何内容都是资产。项目可以包含特定于项目要求的规则、软件包、业务进程、决策表、事实模型、域特定语言(DSL)或任何其他资产。

下图显示了 Red Hat Process Automation Manager 7.11 中的可用资产。

PAM 的资产类型
注意

问题单管理(Preview)和问题单定义资产类型仅在项目时才可用。

以下小节描述了 Red Hat Process Automation Manager 7.11 中的每种资产类型。

  • 商业流程

    商业流程旨在描述实现业务目标所需的步骤。

  • 问题单管理(Preview)

    问题单管理是 Business Process Management (DSL)的一个扩展,可让您管理适应的商业流程。问题单管理为非不可变、无法预计的流程提供问题解析,而不是用于日常的可预测任务的 DIT 方法。当无法提前预测进程时,它管理一次性的情况。

    重要

    业务流程应用程序示例仅包含技术预览。红帽产品服务等级协议(SLA)不支持技术预览功能,且不建议在生产环境中使用。这些技术预览功能可以使用户提早试用新的功能,并有机会在开发阶段提供反馈意见。

  • 问题单定义

    情况是使用 Business Central 中的问题单定义流程设计器设计的。问题单设计是问题单管理的基础,并为每个情况设置特定的目标和任务。可以通过添加动态任务或进程,在运行时动态修改问题单流。

  • 数据对象

    数据对象是您创建的规则资产的构建块。数据对象是在项目的指定软件包中作为 Java 对象实现的自定义数据类型。例如,您可以创建一个带有数据字段 Name, Address, 和 Date of Birth 的 Person 对象,以指定 loan 应用程序规则的个人详情。这些自定义数据类型决定了您的资产和您决定服务所基于的数据。

  • 决策表(Spreadsheet)

    决策表是以电子表格或 Red Hat Decision Manager 用户界面中存储的规则集合,作为指导决策表。在外部 XLS 或 XLSX 文件中定义规则后,您可以在 Business Central 的项目中上传该文件作为决策表。

    重要

    您通常只根据 Business Central 中的规则软件包上传一个电子的决策表,其中包含所有必要的 RuleTable 定义。您可以为单独的软件包上传单独的路由表电子表,但在同一软件包中上传多个电子表可能会导致 RuleSetRuleTable 属性中的编译错误,因此不建议这样做。

  • DMN

    决策模型和表示法(DMN)为业务决策设计和决策实施之间的差距造成标准化桥接。您可以使用 Business Central 中的 DMN 设计程序来设计 DMN 决策要求图(DRD),并为完整的功能 DMN 决策模型定义决策逻辑。

  • DRL 文件

    规则文件通常是具有 .drl 扩展名的文件。在 DRL 文件中,您可以有多个规则、查询和功能,以及一些资源声明,如导入、全局和属性,它们由您的规则和查询分配和使用。但是,您还可以将规则分散到多个规则文件中(在这种情况下,扩展 .rule 会被建议),但不需要)- 将规则分散到文件中有助于管理大量规则。DRL 文件只是文本文件。

  • DSL 定义

    域特定语言(DSL)是一种创建专用于您的问题域的规则语言的方法。组 DSL 定义包括从 DSL "sentences" 转换到 DRL 构造,可让您使用所有底层规则语言和决策引擎功能。

  • Enumeration

    数据枚举是一个可选的资产类型,可以配置为为指导设计人员提供下拉列表。它们像任何其他资产一样存储和检索,并应用到它们所属的软件包。

  • 格式

    表单用于收集业务进程的用户数据。Business Central 提供自动生成表单的选项,然后可以对其进行编辑以满足特定的业务流程要求。

  • 全局变量

    全局变量用于使应用程序对象可供规则使用。通常,它们用于提供规则使用的数据或服务,特别是规则中使用的应用程序服务,并从规则返回数据,如规则结果中添加的日志或值,或者规则与应用程序交互的规则,执行回调。

  • 主要决策表

    决策表是以电子表格或 Red Hat Decision Manager 用户界面中存储的规则集合,作为指导决策表。

  • 指导决策图形

    指导决策图形是相关的指导决策表的集合,显示在单一设计人员中。您可以使用此设计器来更好地视觉化,并在一个位置处理各种相关的路由表。另外,当一个表中的条件或操作使用与条件相同的数据类型或另一个表中的操作时,表将与表图设计器中的一行物理链接。

    例如,如果一个决策表决定 loan 应用程序率,另一个表使用应用程序率来确定某些其他操作,那么两个决策表会在指导决策表中链接。

  • 指导规则

    规则提供要对其执行的决策引擎的逻辑。规则包括名称、属性、规则左侧的 when 语句,以及规则右侧的 then 语句。

  • 指导规则模板

    指导规则模板为多个规则提供可重复使用的规则结构,它们被编译到 dols 规则语言(DRL)中,并为项目形成决策服务的核心。

  • 软件包

    所有资产都包含在 Business Central 中的软件包中。软件包是规则的文件夹,也充当"命名空间"。

  • solver 配置

    Solver 配置由 Solver 设计器创建,可以在部署 KJAR 后在 Execution Solver 或 plain Java 代码中运行。您可以在 Business Central 中编辑并创建 Solver 配置。

  • 测试场景

    通过 Red Hat Process Automation Manager 测试场景,您可以在将规则、型号和事件部署到生产环境中前验证规则、型号和事件的功能。测试场景将数据用于类似事实或项目模型实例的条件。这些数据与给定规则集合匹配,如果预期结果与实际结果匹配,测试可以成功。如果预期结果与实际结果不匹配,则测试会失败。

  • 测试场景(Legacy)

    Red Hat Process Automation Manager 7.11 包括对旧测试场景的支持,因为默认的 Test Scenario 资产仍在开发中。

  • 工作站定义

    工作项目定义定义了如何显示自定义任务。例如,任务名称、图标、参数和类似属性。

第 16 章 创建资产

您可以在 Business Central 项目中创建业务进程、规则、DRL 文件和其他资产。

注意

迁移业务流程是一个不良的过程。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects,然后点击项目名称。例如,评估
  2. Add Asset 并选择 asset 类型。
  3. Create new asset_type 窗口中,添加所需信息并点 Ok

    图 16.1. 定义资产

    创建新弹出对话框的屏幕截图
注意

如果您还没有创建项目,您可以添加项目,使用示例项目或导入现有项目。如需更多信息,请参阅在 Business Central 中管理项目

第 17 章 重命名、复制或删除资产

创建并定义资产后,您可以使用 Project ExplorerRepository View 根据需要复制、重命名、删除或存档资产。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects,然后点击项目名称。
  2. 点资产名称,点左上角的 expand proj explorer 来扩展 Project Explorer
  3. 点击 Project Explorer 工具栏中的 4766 并选择 Repository View 来显示组成资产的文件夹和文件。
  4. 根据需要,使用每个列出的资产旁边的图标复制、重命名、删除或归档资产。其中一些选项可能并不适用于所有资产。

    图 17.1. 复制、重命名、删除或存档资产

    资产重命名
  5. 使用以下工具栏按钮复制、重命名或删除资产。

    图 17.2. 工具栏选项

    工具

第 18 章 管理资产元数据和版本历史记录

Business Central 中的大多数资产都有与它们关联的元数据和版本信息,以帮助您在项目中识别和组织它们。您可以从 Business Central 中的资产设计器管理资产元数据和版本历史记录。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects,然后点击项目名称。
  2. 从列表中选择资产以打开资产设计器。
  3. 在资产设计器窗口中,选择 Overview。如果资产没有 Overview 选项卡,则没有与资产关联的元数据。

    6593
  4. 选择 Version HistoryMetadata 选项卡来编辑和更新版本和元数据详情。

    meta 数据
    注意

    更新资产工作版本的另一种方法是,点资产设计器右上角的 Latest Version

    图 18.1. 资产的最新版本

    获取最新版本的资产
  5. Save 保存更改。

第 19 章 按标签过滤资产

您可以在每个资产元数据中应用标签,然后根据 Project Explorer 中的标签对资产进行分组。这个功能可帮助您快速搜索特定类别的资产。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects,然后点击项目名称。
  2. 点资产名称打开资产编辑器。
  3. 在资产编辑器窗口中,转至 Overview → Metadata
  4. Tags 字段中输入新标签的名称,然后点 Add new tag。您可以通过将标签名称与空格分开,来为资产分配多个标签。

    图 19.1. 创建标签

    在元数据视图中创建标签

    分配的标签显示为 Tags 字段旁边的按钮。

    图 19.2. 元数据视图中的标签

    元数据视图中创建的标签

    单击标签按钮上的回收图标,以删除该标签。

    图 19.3. 删除元数据视图中的标签

    删除元数据视图中的标签
  5. Save 保存您的更改。
  6. 点击左上角的 expand proj explorer ,展开 Project Explorer
  7. 点击 Project Explorer 工具栏中的 5461 并选择 Enable Tag 过滤

    图 19.4. 启用标签过滤

    在自定义视图中启用标签过滤

    这会在 Project Explorer 中显示 Filter by Tag 下拉菜单。

    图 19.5. 按标签过滤

    在自定义视图中启用标签过滤

    您可以通过此过滤器对资产进行排序,以显示包含所选元数据标签的所有资产和服务任务。

第 20 章 解锁资产

默认情况下,每当您在 Business Central 中打开和修改资产时,都会自动锁定该资产,以避免多余设置中的冲突。当会话结束或保存或关闭资产时,这个锁定会自动释放。这个锁定功能可确保用户不会相互覆盖其他更改。

但是,如果您需要编辑由其他用户锁定的文件,您可以强制解锁资产。

流程

  1. 在 Business Central 中,进入 MenuDesignProjects,然后点击项目名称。
  2. 从列表中选择资产以打开资产设计器。
  3. 进入 Overview → Metadata 并查看 锁定状态

    图 20.1. 解锁元数据视图

    解锁元数据视图

    如果资产已经被其他用户编辑,则会在 Lock status 字段中显示以下内容:

    被 <user_name> 锁定

  4. Force unlock asset 解锁。

    此时会显示以下确认弹出信息:

    您确定要释放此资产锁定吗?这可能导致 <user_name> 丢失未保存的更改!

  5. 单击 Yes 以确认。

    资产返回到解锁的状态,且资产旁边会显示 lock 图标选项。

部分 IV. 使用 KIE API 与 Red Hat Process Automation Manager 交互

作为自定义规则开发人员或系统管理员,您可以使用 KIE API 与 Red Hat Process Automation Manager 中的 KIE 服务器、KIE 容器和业务资产交互。您可以使用 KIE Server REST API 和 Java 客户端 API 与 KIE 容器和业务资产(如新规则、流程和程序)交互,流程自动化管理器控制器 REST API 和 Java 客户端 API 与 KIE Server 模板和实例交互,以及知识库 REST API 与 Business Central 中的空格和项目交互。

KIE 服务器和 Process Automation Manager 控制器的 REST API 端点

KIE 服务器和 Process Automation Manager 控制器的 REST API 端点列表与本文档分开发布,并动态维护,以确保端点选项和数据尽可能当前。使用本文档了解 KIE 服务器和进程 Automation Manager 控制器 REST API 可让您操作以及如何使用它们,并将 REST API 端点单独维护列表用于特定端点详情。

有关 KIE Server REST API 端点和描述的完整列表,请使用以下资源之一:

  • 在 jBPM 文档页面的 Execution Server REST API(静态)
  • http://SERVER:PORT/kie-server/docs (动态,需要运行 KIE Server REST)的 KIE Server REST API 的 Swagger UI

如需流程 Automation Manager 控制器 REST API 端点和描述的完整列表,请使用以下资源之一:

先决条件

  • Red Hat Process Automation Manager 已安装并运行。有关安装和启动选项,请参阅 规划 Red Hat Process Automation Manager 安装
  • 您可以使用以下用户角色访问 Red Hat Process Automation Manager:

    • kie-server :用于访问 KIE 服务器 API 功能,以及在没有 Business Central (如果适用)的情况下对无头流程自动化管理器控制器 API 功能的访问。
    • REST-all :用于访问内置流程自动化管理器控制器和 Business Central 知识库存储的 Business Central API 功能
    • Admin :获得对 Red Hat Process Automation Manager 的完全管理访问权限

      虽然每个 KIE API 都不需要这些用户角色,但请考虑获取所有这些用户角色,以确保您可以在不中断的情况下访问任何 KIE API。有关用户角色的更多信息,请参阅 规划 Red Hat Process Automation Manager 安装

第 21 章 KIE 服务器 REST API 用于 KIE 容器和业务资产

Red Hat Process Automation Manager 提供了一个 KIE Server REST API,可用于在不使用 Business Central 用户界面的情况下与 Red Hat Process Automation Manager 中的 KIE 容器和业务资产(如业务逻辑、流程和程序)交互。通过这个 API 支持,您可以更有效地维护 Red Hat Process Automation Manager 资源,并使用 Red Hat Process Automation Manager 优化您的集成和开发。

使用 KIE Server REST API,您可以执行以下操作:

  • 部署或取消 KIE 容器
  • 检索和更新 KIE 容器信息
  • 返回 KIE 服务器状态和基本信息
  • 检索和更新业务资产信息
  • 执行业务资产(如规则和流程)

KIE Server REST API 请求需要以下组件:

身份验证

KIE Server REST API 需要 HTTP 基本身份验证或基于令牌的身份验证用于用户角色 kie-server。要查看 Red Hat Process Automation Manager 发行版配置的用户角色,请导航到 ~/$SERVER_HOME/standalone/configuration/application-roles.properties~/application-users.properties

要添加具有 kie-server 角色的用户,请导航到 ~/$SERVER_HOME/bin 并运行以下命令:

$ ./add-user.sh -a --user <USERNAME> --password <PASSWORD> --role kie-server

有关用户角色和 Red Hat Process Automation Manager 安装选项的更多信息,请参阅 规划 Red Hat Process Automation Manager 安装

HTTP 标头

KIE Server REST API 需要以下 HTTP 标头用于 API 请求:

  • 接受 :您请求的客户端接受的数据格式:

    • application/json (JSON)
    • application/xml (用于 JAXB 或 XSTREAM)
  • Content-TypePOSTPUT API 请求数据的数据格式:

    • application/json (JSON)
    • application/xml (用于 JAXB 或 XSTREAM)
  • x-KIE-ContentType: 应用程序/xml XSTREAM API 请求和响应所需的标头:

    • XSTREAM
HTTP 方法

KIE Server REST API 支持以下 HTTP 方法进行 API 请求:

  • GET :从指定的资源端点检索指定的信息
  • POST :更新资源或资源实例
  • PUT :更新或创建资源或资源实例
  • DELETE :删除资源或资源实例
基本 URL
KIE 服务器 REST API 请求的基本 URL 是 http://SERVER:PORT/kie-server/services/rest/,如 http://localhost:8080/kie-server/services/rest/。
Endpoints

KIE Server REST API 端点(如指定 KIE 容器的 /server/containers/{containerId} )是您附加到 KIE Server REST API 基本 URL 的 URI,以访问 Red Hat Process Automation Manager 中的相应资源或资源类型。

/server/containers/{containerId} 端点的请求 URL 示例

http://localhost:8080/kie-server/services/rest/server/containers/MyContainer

请求参数和请求数据

许多 KIE Server REST API 请求需要请求 URL 路径中的特定参数来识别或过滤特定资源并执行特定操作。您可以将 URL 参数附加到端点,格式为 ?<PARAM>=<VALUE>&<PARAM>=<VALUE >。

带有参数的 GET 请求 URL 示例

http://localhost:8080/kie-server/services/rest/server/containers?groupId=com.redhat&artifactId=Project1&version=1.0&status=STARTED

HTTP POSTPUT 请求可能还需要请求正文或带有数据的文件来附带请求。

POST 请求 URL 和 JSON 请求正文数据示例

http://localhost:8080/kie-server/services/rest/server/containers/MyContainer/release-id

{
  "release-id": {
    "artifact-id": "Project1",
    "group-id": "com.redhat",
    "version": "1.1"
  }
}

21.1. 使用 REST 客户端或 curl 工具通过 KIE Server REST API 发送请求

KIE Server REST API 可让您在不使用 Business Central 用户界面的情况下与 Red Hat Process Automation Manager 中的 KIE 容器和业务资产交互。您可以使用任何 REST 客户端或 curl 工具发送 KIE Server REST API 请求。

先决条件

  • KIE 服务器已安装并运行。
  • 您有对 KIE 服务器的 kie-server 用户角色访问权限。

流程

  1. 识别您要发送请求的相关 API 端点,如 [GET] /server/containers,以从 KIE 服务器检索 KIE 容器。
  2. 在 REST 客户端或 curl 工具中,为对 /server/containersGET 请求输入以下组件。根据您的用例调整任何请求详情。

    对于 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-idartifact-idversion (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
      }
    }

21.2. 使用 Swagger 接口通过 KIE Server REST API 发送请求

KIE Server REST API 支持使用 Swagger Web 界面,而不是独立 REST 客户端或 curl 工具与 Red Hat Process Automation Manager 中的 KIE 容器和业务资产(如规则、流程和程序)交互,而无需使用 Business Central 用户界面。

注意

默认情况下,KIE 服务器的 Swagger Web 界面由 org.kie.swagger.server.ext.disabled=false 系统属性启用。要在 KIE 服务器中禁用 Swagger Web 界面,请将此系统属性设置为 true

先决条件

  • KIE 服务器已安装并运行。
  • 您有对 KIE 服务器的 kie-server 用户角色访问权限。

流程

  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-idartifact-idversion (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
      }
    }

21.3. 支持的 KIE Server REST API 端点

KIE Server REST API 为 Red Hat Process Automation Manager 中的以下资源类型提供端点:

  • KIE 服务器和 KIE 容器
  • KIE 会话资产(用于运行时命令)
  • DMN 资产
  • 规划程序
  • Process
  • 进程镜像
  • 进程和任务表单
  • 任务
  • 问题单
  • 文档
  • Jobs
  • 查询进程、任务和问题单
  • 自定义查询

KIE Server REST API 基本 URL 是 http://SERVER:PORT/kie-server/services/rest/。所有请求都需要对 kie-server 用户角色进行 HTTP 基本身份验证或基于令牌的身份验证。

有关 KIE Server REST API 端点和描述的完整列表,请使用以下资源之一:

  • 在 jBPM 文档页面的 Execution Server REST API(静态)
  • http://SERVER:PORT/kie-server/docs (动态,需要运行 KIE Server REST)的 KIE Server REST API 的 Swagger UI

    注意

    默认情况下,KIE 服务器的 Swagger Web 界面由 org.kie.swagger.server.ext.disabled=false 系统属性启用。要在 KIE 服务器中禁用 Swagger Web 界面,请将此系统属性设置为 true

端点要求

请注意,以下对 KIE Server REST API 端点的要求:

  • Process images: 为了对处理镜像的 API 访问,必须为 $SERVER_HOME/standalone/deployments /business-central.war/org.kie.workbench.KIEWebapp/profiles/jbpm.xml 项目配置系统属性 <storesvgonsave enabled="true" />。默认情况下,此属性设置为 true。如果 API 没有使用进程镜像,在文件中将其设置为 true,重启您的 KIE 服务器,修改相关进程并保存它,然后构建和部署项目。此属性允许存储 SVG 镜像,以便由 KIE Server REST API 检索它们。
  • 自定义查询: 一些带有 KIE Server REST API 的自定义查询请求需要查询 映射器 定义来将查询结果映射到协调对象。您可以实施自己的查询结果映射程序,或使用 Red Hat Process Automation Manager 提供的映射程序。Red Hat Process Automation Manager 中的查询映射器与其他对象关系映射(ORM)供应商类似,后者将表映射到实体。例如,您可以在自定义查询端点中使用 org.jbpm.kie.services.impl.query.mapper.ProcessInstanceQueryMapper,也可注册为 ProcessInstances,以返回进程实例数据。

    带有 ProcessInstances mapper 参数的 POST 端点示例:

    http://localhost:8080/kie-server/services/rest/server/queries/definitions/jbpmProcessInstances?mapper=ProcessInstances

    如需 Red Hat Process Automation Manager 中可用的查询映射器列表,请从红帽客户门户网站下载并提取 Red Hat Process Automation Manager 7.11 源分发,并进入 ~/jbpm-$VERSION/jbpm-services/jbpm-kie-services/src/main/java/org/jbpm/kie/services/impl/query/mapperhttps://access.redhat.com/jbossnetwork/restricted/listSoftware.html

21.3.1. 特定 DMN 模型的 REST 端点

Red Hat Process Automation Manager 提供特定于模型的 DMN KIE Server 端点,您可以在不使用 Business Central 用户界面的情况下与特定的 DMN 模型交互。

对于 Red Hat Process Automation Manager 中的容器中的每个 DMN 模型,KIE 服务器的以下 REST 端点会根据 DMN 模型的内容自动生成:

  • POST /server/containers/{containerId}/dmn/models/{modelname}: 一个用于评估容器中的指定 DMN 模型的业务域端点
  • POST /server/containers/{containerId}/dmn/models/{modelname}/{decisionServiceName}: 一个用于评估容器中可用特定 DMN 模型中指定的决策服务组件的业务域端点
  • POST /server/containers/{containerId}/dmn/models/{modelname}/dmnresult: 一个端点来评估包含自定义正文有效负载并返回 DMNResult 响应,包括业务域上下文、帮助程序消息和帮助程序决策指针
  • POST /server/containers/{containerId}/dmn/models/{modelname}/{decisionServiceName}/dmnresult: 一个端点来评估特定 DMN 模型中的指定决策服务组件,并返回 DMNResult 响应,包括业务域上下文、帮助程序消息和帮助决策方向服务
  • GET /server/containers/{containerId}/dmn/models/{modelname}: 一个端点,用于在没有决策逻辑的情况下返回标准 DMN XML,并包含指定 DMN 模型的输入和输出
  • GET /server/containers/{containerId}/dmn/openapi.json (|.yaml): 一个端点,用于在指定容器中为 DMN 模型检索 Swagger 或 OAS

您可以使用这些端点与 DMN 模型或模型中的特定决策服务交互。当您决定使用这些 REST 端点的 Business-domain 和 dmnresult 变体,请查看以下注意事项:

  • REST Business-domain 端点 :如果客户端应用程序只关注正评估结果,请使用此端点类型,不负责解析 InfoWarn 消息,且只需要 HTTP 5xx 响应来进行任何错误。由于单一的决策服务结果与 DMN 模型行为类似,这种类型的端点对单页应用程序的客户端也很有用。
  • REST dmnresult 端点 :如果客户端需要解析 InfoWarnError 消息,请使用此端点类型。

对于每个端点,请使用 REST 客户端或 curl 工具来发送带有以下组件的请求:

  • 基本 URLhttp://HOST:PORT/kie-server/services/rest/
  • 路径参数

    • {containerID} :容器的字符串标识符,如 mykjar-project
    • {modelName} : DMN 模型的字符串标识符,如 流量冲突
    • {decisionServiceName} : DMN DRG 中决策服务组件的字符串标识符,如 TrafficViolationDecisionService
    • dmnresult :字符串标识符,使端点返回一个更加详细的 DMNResult 响应,它带有更详细的 Info, Warn, 和 Error 信息。
  • HTTP 标头: 只适用对于 POST 请求:

    • 接受:application/json
    • Content-type:application/json
  • HTTP 方法GETPOST

以下端点中的示例基于 mykjar-project 容器,其中包含 流量 Violation DMN 模型,其中包含 流量ViolationDecisionService 决策服务组件。

对于所有这些端点,如果出现 DMN 评估 Error 消息,则返回 DMNResult 响应并带有 HTTP 5xx 错误。如果发生 DMN InfoWarn 消息,则会在 X-Kogito-decision-messages 扩展 HTTP 标头中返回相关响应以及业务域 REST 正文,以用于客户端侧的业务逻辑。当需要更多优化的客户端业务逻辑的要求时,客户端可以使用端点的 dmnresult 变体。

在指定容器中检索 DMN 模型的 Swagger 或 OAS

GET /server/containers/{containerId}/dmn/openapi.json (|.yaml)

REST 端点示例

http://localhost:8080/kie-server/services/rest/server/containers/mykjar-project/dmn/openapi.json(|.yaml)

返回没有决策逻辑的 DMN XML

GET /server/containers/{containerId}/dmn/models/{modelname}

REST 端点示例

http://localhost:8080/kie-server/services/rest/server/containers/mykjar-project/dmn/models/Traffic 违反

curl 请求示例

curl -u wbadmin:wbadmin -X GET "http://localhost:8080/kie-server/services/rest/server/containers/mykjar-project/dmn/models/Traffic%20Violation" -H  "accept: application/xml"

响应示例(XML)

<?xml version='1.0' encoding='UTF-8'?>
<dmn:definitions xmlns:dmn="http://www.omg.org/spec/DMN/20180521/MODEL/" xmlns="https://github.com/kiegroup/drools/kie-dmn/_A4BCA8B8-CF08-433F-93B2-A2598F19ECFF" xmlns:di="http://www.omg.org/spec/DMN/20180521/DI/" xmlns:kie="http://www.drools.org/kie/dmn/1.2" xmlns:feel="http://www.omg.org/spec/DMN/20180521/FEEL/" xmlns:dmndi="http://www.omg.org/spec/DMN/20180521/DMNDI/" xmlns:dc="http://www.omg.org/spec/DMN/20180521/DC/" id="_1C792953-80DB-4B32-99EB-25FBE32BAF9E" name="Traffic Violation" expressionLanguage="http://www.omg.org/spec/DMN/20180521/FEEL/" typeLanguage="http://www.omg.org/spec/DMN/20180521/FEEL/" namespace="https://github.com/kiegroup/drools/kie-dmn/_A4BCA8B8-CF08-433F-93B2-A2598F19ECFF">
  <dmn:extensionElements/>
  <dmn:itemDefinition id="_63824D3F-9173-446D-A940-6A7F0FA056BB" name="tDriver" isCollection="false">
    <dmn:itemComponent id="_9DAB5DAA-3B44-4F6D-87F2-95125FB2FEE4" name="Name" isCollection="false">
      <dmn:typeRef>string</dmn:typeRef>
    </dmn:itemComponent>
    <dmn:itemComponent id="_856BA8FA-EF7B-4DF9-A1EE-E28263CE9955" name="Age" isCollection="false">
      <dmn:typeRef>number</dmn:typeRef>
    </dmn:itemComponent>
    <dmn:itemComponent id="_FDC2CE03-D465-47C2-A311-98944E8CC23F" name="State" isCollection="false">
      <dmn:typeRef>string</dmn:typeRef>
    </dmn:itemComponent>
    <dmn:itemComponent id="_D6FD34C4-00DC-4C79-B1BF-BBCF6FC9B6D7" name="City" isCollection="false">
      <dmn:typeRef>string</dmn:typeRef>
    </dmn:itemComponent>
    <dmn:itemComponent id="_7110FE7E-1A38-4C39-B0EB-AEEF06BA37F4" name="Points" isCollection="false">
      <dmn:typeRef>number</dmn:typeRef>
    </dmn:itemComponent>
  </dmn:itemDefinition>
  <dmn:itemDefinition id="_40731093-0642-4588-9183-1660FC55053B" name="tViolation" isCollection="false">
    <dmn:itemComponent id="_39E88D9F-AE53-47AD-B3DE-8AB38D4F50B3" name="Code" isCollection="false">
      <dmn:typeRef>string</dmn:typeRef>
    </dmn:itemComponent>
    <dmn:itemComponent id="_1648EA0A-2463-4B54-A12A-D743A3E3EE7B" name="Date" isCollection="false">
      <dmn:typeRef>date</dmn:typeRef>
    </dmn:itemComponent>
    <dmn:itemComponent id="_9F129EAA-4E71-4D99-B6D0-84EEC3AC43CC" name="Type" isCollection="false">
      <dmn:typeRef>string</dmn:typeRef>
      <dmn:allowedValues kie:constraintType="enumeration" id="_626A8F9C-9DD1-44E0-9568-0F6F8F8BA228">
        <dmn:text>"speed", "parking", "driving under the influence"</dmn:text>
      </dmn:allowedValues>
    </dmn:itemComponent>
    <dmn:itemComponent id="_DDD10D6E-BD38-4C79-9E2F-8155E3A4B438" name="Speed Limit" isCollection="false">
      <dmn:typeRef>number</dmn:typeRef>
    </dmn:itemComponent>
    <dmn:itemComponent id="_229F80E4-2892-494C-B70D-683ABF2345F6" name="Actual Speed" isCollection="false">
      <dmn:typeRef>number</dmn:typeRef>
    </dmn:itemComponent>
  </dmn:itemDefinition>
  <dmn:itemDefinition id="_2D4F30EE-21A6-4A78-A524-A5C238D433AE" name="tFine" isCollection="false">
    <dmn:itemComponent id="_B9F70BC7-1995-4F51-B949-1AB65538B405" name="Amount" isCollection="false">
      <dmn:typeRef>number</dmn:typeRef>
    </dmn:itemComponent>
    <dmn:itemComponent id="_F49085D6-8F08-4463-9A1A-EF6B57635DBD" name="Points" isCollection="false">
      <dmn:typeRef>number</dmn:typeRef>
    </dmn:itemComponent>
  </dmn:itemDefinition>
  <dmn:inputData id="_1929CBD5-40E0-442D-B909-49CEDE0101DC" name="Violation">
    <dmn:variable id="_C16CF9B1-5FAB-48A0-95E0-5FCD661E0406" name="Violation" typeRef="tViolation"/>
  </dmn:inputData>
  <dmn:decision id="_4055D956-1C47-479C-B3F4-BAEB61F1C929" name="Fine">
    <dmn:variable id="_8C1EAC83-F251-4D94-8A9E-B03ACF6849CD" name="Fine" typeRef="tFine"/>
    <dmn:informationRequirement id="_800A3BBB-90A3-4D9D-BA5E-A311DED0134F">
      <dmn:requiredInput href="#_1929CBD5-40E0-442D-B909-49CEDE0101DC"/>
    </dmn:informationRequirement>
  </dmn:decision>
  <dmn:inputData id="_1F9350D7-146D-46F1-85D8-15B5B68AF22A" name="Driver">
    <dmn:variable id="_A80F16DF-0DB4-43A2-B041-32900B1A3F3D" name="Driver" typeRef="tDriver"/>
  </dmn:inputData>
  <dmn:decision id="_8A408366-D8E9-4626-ABF3-5F69AA01F880" name="Should the driver be suspended?">
    <dmn:question>Should the driver be suspended due to points on his license?</dmn:question>
    <dmn:allowedAnswers>"Yes", "No"</dmn:allowedAnswers>
    <dmn:variable id="_40387B66-5D00-48C8-BB90-E83EE3332C72" name="Should the driver be suspended?" typeRef="string"/>
    <dmn:informationRequirement id="_982211B1-5246-49CD-BE85-3211F71253CF">
      <dmn:requiredInput href="#_1F9350D7-146D-46F1-85D8-15B5B68AF22A"/>
    </dmn:informationRequirement>
    <dmn:informationRequirement id="_AEC4AA5F-50C3-4FED-A0C2-261F90290731">
      <dmn:requiredDecision href="#_4055D956-1C47-479C-B3F4-BAEB61F1C929"/>
    </dmn:informationRequirement>
  </dmn:decision>
  <dmndi:DMNDI>
    <dmndi:DMNDiagram>
      <di:extension/>
      <dmndi:DMNShape id="dmnshape-_1929CBD5-40E0-442D-B909-49CEDE0101DC" dmnElementRef="_1929CBD5-40E0-442D-B909-49CEDE0101DC" isCollapsed="false">
        <dmndi:DMNStyle>
          <dmndi:FillColor red="255" green="255" blue="255"/>
          <dmndi:StrokeColor red="0" green="0" blue="0"/>
          <dmndi:FontColor red="0" green="0" blue="0"/>
        </dmndi:DMNStyle>
        <dc:Bounds x="708" y="350" width="100" height="50"/>
        <dmndi:DMNLabel/>
      </dmndi:DMNShape>
      <dmndi:DMNShape id="dmnshape-_4055D956-1C47-479C-B3F4-BAEB61F1C929" dmnElementRef="_4055D956-1C47-479C-B3F4-BAEB61F1C929" isCollapsed="false">
        <dmndi:DMNStyle>
          <dmndi:FillColor red="255" green="255" blue="255"/>
          <dmndi:StrokeColor red="0" green="0" blue="0"/>
          <dmndi:FontColor red="0" green="0" blue="0"/>
        </dmndi:DMNStyle>
        <dc:Bounds x="709" y="210" width="100" height="50"/>
        <dmndi:DMNLabel/>
      </dmndi:DMNShape>
      <dmndi:DMNShape id="dmnshape-_1F9350D7-146D-46F1-85D8-15B5B68AF22A" dmnElementRef="_1F9350D7-146D-46F1-85D8-15B5B68AF22A" isCollapsed="false">
        <dmndi:DMNStyle>
          <dmndi:FillColor red="255" green="255" blue="255"/>
          <dmndi:StrokeColor red="0" green="0" blue="0"/>
          <dmndi:FontColor red="0" green="0" blue="0"/>
        </dmndi:DMNStyle>
        <dc:Bounds x="369" y="344" width="100" height="50"/>
        <dmndi:DMNLabel/>
      </dmndi:DMNShape>
      <dmndi:DMNShape id="dmnshape-_8A408366-D8E9-4626-ABF3-5F69AA01F880" dmnElementRef="_8A408366-D8E9-4626-ABF3-5F69AA01F880" isCollapsed="false">
        <dmndi:DMNStyle>
          <dmndi:FillColor red="255" green="255" blue="255"/>
          <dmndi:StrokeColor red="0" green="0" blue="0"/>
          <dmndi:FontColor red="0" green="0" blue="0"/>
        </dmndi:DMNStyle>
        <dc:Bounds x="534" y="83" width="133" height="63"/>
        <dmndi:DMNLabel/>
      </dmndi:DMNShape>
      <dmndi:DMNEdge id="dmnedge-_800A3BBB-90A3-4D9D-BA5E-A311DED0134F" dmnElementRef="_800A3BBB-90A3-4D9D-BA5E-A311DED0134F">
        <di:waypoint x="758" y="375"/>
        <di:waypoint x="759" y="235"/>
      </dmndi:DMNEdge>
      <dmndi:DMNEdge id="dmnedge-_982211B1-5246-49CD-BE85-3211F71253CF" dmnElementRef="_982211B1-5246-49CD-BE85-3211F71253CF">
        <di:waypoint x="419" y="369"/>
        <di:waypoint x="600.5" y="114.5"/>
      </dmndi:DMNEdge>
      <dmndi:DMNEdge id="dmnedge-_AEC4AA5F-50C3-4FED-A0C2-261F90290731" dmnElementRef="_AEC4AA5F-50C3-4FED-A0C2-261F90290731">
        <di:waypoint x="759" y="235"/>
        <di:waypoint x="600.5" y="114.5"/>
      </dmndi:DMNEdge>
    </dmndi:DMNDiagram>
  </dmndi:DMNDI>

评估指定容器中的指定 DMN 模型

POST /server/containers/{containerId}/dmn/models/{modelname}

REST 端点示例

http://localhost:8080/kie-server/services/rest/server/containers/mykjar-project/dmn/models/Traffic 违反

curl 请求示例

curl -u wbadmin:wbadmin-X POST "http://localhost:8080/kie-server/services/rest/server/containers/mykjar-project/dmn/models/Traffic Violation" -H  "accept: application/json" -H  "Content-Type: application/json" -d "{\"Driver\":{\"Points\":15},\"Violation\":{\"Date\":\"2021-04-08\",\"Type\":\"speed\",\"Actual Speed\":135,\"Speed Limit\":100}}"

带有输入数据的 POST 请求正文示例

{
  "Driver": {
    "Points": 15
  },
  "Violation": {
    "Date": "2021-04-08",
    "Type": "speed",
    "Actual Speed": 135,
    "Speed Limit": 100
  }
}

响应示例(JSON)

{
  "Violation": {
    "Type": "speed",
    "Speed Limit": 100,
    "Actual Speed": 135,
    "Code": null,
    "Date": "2021-04-08"
  },
  "Driver": {
    "Points": 15,
    "State": null,
    "City": null,
    "Age": null,
    "Name": null
  },
  "Fine": {
    "Points": 7,
    "Amount": 1000
  },
  "Should the driver be suspended?": "Yes"
}

评估容器中指定的 DMN 模型中指定的决策服务

POST /server/containers/{containerId}/dmn/models/{modelname}/{decisionServiceName}

对于此端点,请求正文必须包含决策服务的所有要求。响应是决策服务生成的 DMN 上下文,包括决策值、原始输入值以及所有其他 parametric DRG 组件(序列化形式)。例如,业务知识模型以字符串序列化形式提供。

如果决定服务由单输出决定组成,则响应是该特定决策的结果值。在模型本身调用决策服务时,此行为在规格功能的 API 级别上提供等效的值。例如,您可以从单页 Web 应用程序与 DMN 决策服务交互。

图 21.1. 带有单输出决策的 TrafficViolationDecisionService 决策服务示例

流量 Violation DMN 模型中的决策服务镜像

图 21.2. 带有多输出决定的 TrafficViolationDecisionService 决策服务示例

流量 Violation DMN 模型中的决策服务镜像

REST 端点示例

http://localhost:8080/kie-server/services/rest/server/containers/mykjar-project/dmn/models/Traffic violation/TrafficViolationDecisionService

带有输入数据的 POST 请求正文示例

{
  "Driver": {
    "Points": 2
  },
  "Violation": {
    "Type": "speed",
    "Actual Speed": 120,
    "Speed Limit": 100
  }
}

curl 请求示例

curl -X POST http://localhost:8080/kie-server/services/rest/server/containers/mykjar-project/dmn/models/Traffic Violation/TrafficViolationDecisionService -H 'content-type: application/json' -H 'accept: application/json' -d '{"Driver": {"Points": 2}, "Violation": {"Type": "speed", "Actual Speed": 120, "Speed Limit": 100}}'

单输出决策(JSON)的响应示例

"No"

多输出决策(JSON)的响应示例

{
  "Violation": {
    "Type": "speed",
    "Speed Limit": 100,
    "Actual Speed": 120
  },
  "Driver": {
    "Points": 2
  },
  "Fine": {
    "Points": 3,
    "Amount": 500
  },
  "Should the driver be suspended?": "No"
}

评估指定容器中的指定 DMN 模型,并返回 DMNResult 响应

POST /server/containers/{containerId}/dmn/models/{modelname}/dmnresult

REST 端点示例

http://localhost:8080/kie-server/services/rest/server/containers/mykjar-project/dmn/models/Traffic违反/密钥结果

带有输入数据的 POST 请求正文示例

{
  "Driver": {
    "Points": 2
  },
  "Violation": {
    "Type": "speed",
    "Actual Speed": 120,
    "Speed Limit": 100
  }
}

curl 请求示例

curl -X POST http://localhost:8080/kie-server/services/rest/server/containers/mykjar-project/dmn/models/Traffic Violation/dmnresult -H 'content-type: application/json' -H 'accept: application/json' -d '{"Driver": {"Points": 2}, "Violation": {"Type": "speed", "Actual Speed": 120, "Speed Limit": 100}}'

响应示例(JSON)

{
  "namespace": "https://github.com/kiegroup/drools/kie-dmn/_A4BCA8B8-CF08-433F-93B2-A2598F19ECFF",
  "modelName": "Traffic Violation",
  "dmnContext": {
    "Violation": {
      "Type": "speed",
      "Speed Limit": 100,
      "Actual Speed": 120,
      "Code": null,
      "Date": null
    },
    "Driver": {
      "Points": 2,
      "State": null,
      "City": null,
      "Age": null,
      "Name": null
    },
    "Fine": {
      "Points": 3,
      "Amount": 500
    },
    "Should the driver be suspended?": "No"
  },
  "messages": [],
  "decisionResults": [
    {
      "decisionId": "_4055D956-1C47-479C-B3F4-BAEB61F1C929",
      "decisionName": "Fine",
      "result": {
        "Points": 3,
        "Amount": 500
      },
      "messages": [],
      "evaluationStatus": "SUCCEEDED"
    },
    {
      "decisionId": "_8A408366-D8E9-4626-ABF3-5F69AA01F880",
      "decisionName": "Should the driver be suspended?",
      "result": "No",
      "messages": [],
      "evaluationStatus": "SUCCEEDED"
    }
  ]
}

在指定容器中的 DMN 模型中评估指定的决策服务,并返回 DMNResult 响应

POST /server/containers/{containerId}/dmn/models/{modelname}/{decisionServiceName}/dmnresult

REST 端点示例

http://localhost:8080/kie-server/services/rest/server/containers/mykjar-project/dmn/models/Traffic violation/TrafficViolationDecisionService/dmnresult

带有输入数据的 POST 请求正文示例

{
  "Driver": {
    "Points": 2
  },
  "Violation": {
    "Type": "speed",
    "Actual Speed": 120,
    "Speed Limit": 100
  }
}

curl 请求示例

curl -X POST http://localhost:8080/kie-server/services/rest/server/containers/mykjar-project/dmn/models/Traffic Violation/TrafficViolationDecisionService/dmnresult -H 'content-type: application/json' -H 'accept: application/json' -d '{"Driver": {"Points": 2}, "Violation": {"Type": "speed", "Actual Speed": 120, "Speed Limit": 100}}'

响应示例(JSON)

{
  "namespace": "https://github.com/kiegroup/drools/kie-dmn/_A4BCA8B8-CF08-433F-93B2-A2598F19ECFF",
  "modelName": "Traffic Violation",
  "dmnContext": {
    "Violation": {
      "Type": "speed",
      "Speed Limit": 100,
      "Actual Speed": 120,
      "Code": null,
      "Date": null
    },
    "Driver": {
      "Points": 2,
      "State": null,
      "City": null,
      "Age": null,
      "Name": null
    },
    "Should the driver be suspended?": "No"
  },
  "messages": [],
  "decisionResults": [
    {
      "decisionId": "_8A408366-D8E9-4626-ABF3-5F69AA01F880",
      "decisionName": "Should the driver be suspended?",
      "result": "No",
      "messages": [],
      "evaluationStatus": "SUCCEEDED"
    }
  ]
}

第 22 章 KIE Server Java 客户端 API 用于 KIE 容器和业务资产

Red Hat Process Automation Manager 提供了一个 KIE Server Java 客户端 API,可让您使用来自 Java 客户端应用程序的 REST 协议连接到 KIE 服务器。您可以使用 KIE Server Java 客户端 API 作为 KIE Server REST API 的替代选择,以便在不使用 Business Central 用户界面的情况下与红帽 Process Automation Manager 中的 KIE 容器和业务资产(如自定义规则、流程和程序)交互。通过这个 API 支持,您可以更有效地维护 Red Hat Process Automation Manager 资源,并使用 Red Hat Process Automation Manager 优化您的集成和开发。

使用 KIE Server Java 客户端 API,您还可以由 KIE Server REST API 执行以下操作:

  • 部署或取消 KIE 容器
  • 检索和更新 KIE 容器信息
  • 返回 KIE 服务器状态和基本信息
  • 检索和更新业务资产信息
  • 执行业务资产(如规则和流程)

KIE Server Java 客户端 API 请求需要以下组件:

身份验证

KIE Server Java 客户端 API 需要用户角色 kie-server 的 HTTP 基本身份验证。要查看 Red Hat Process Automation Manager 发行版配置的用户角色,请导航到 ~/$SERVER_HOME/standalone/configuration/application-roles.properties~/application-users.properties

要添加具有 kie-server 角色的用户,请导航到 ~/$SERVER_HOME/bin 并运行以下命令:

$ ./add-user.sh -a --user <USERNAME> --password <PASSWORD> --role kie-server

有关用户角色和 Red Hat Process Automation Manager 安装选项的更多信息,请参阅 规划 Red Hat Process Automation Manager 安装

项目依赖项

KIE Server Java 客户端 API 需要以下依赖 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>

Red Hat Process Automation Manager 依赖项的 <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 的更多信息,请参阅 RHPAM 产品和 maven 库版本之间的映射是什么?

客户端请求配置

具有 KIE 服务器 Java 客户端 API 的所有 Java 客户端请求必须至少定义以下服务器通信组件:

  • kie-server 用户的凭证
  • KIE 服务器位置,如 http://localhost:8080/kie-server/services/rest/server
  • API 请求和响应的 Marshalling 格式(JSON、JAXB 或 XSTREAM)
  • KieServicesConfiguration 对象和一个 KieServicesClient 对象,用作使用 Java 客户端 API 启动服务器通信的入口点
  • 定义 REST 协议和用户访问的 KieServicesFactory 对象
  • 任何使用的其他客户端服务,如 RuleServicesClientProcessServicesClientQueryServicesClient

以下是带有这些组件的基本和高级客户端配置示例:

基本客户端配置示例

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;

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

    //If you use custom classes, such as Obj.class, add them to the configuration.
    Set<Class<?>> extraClassList = new HashSet<Class<?>>();
    extraClassList.add(Obj.class);
    conf.addExtraClasses(extraClassList);

    conf.setMarshallingFormat(FORMAT);
    kieServicesClient = KieServicesFactory.newKieServicesClient(conf);
  }
}

带有额外客户端服务的高级客户端配置示例

import org.kie.server.api.marshalling.MarshallingFormat;
import org.kie.server.client.CaseServicesClient;
import org.kie.server.client.DMNServicesClient;
import org.kie.server.client.DocumentServicesClient;
import org.kie.server.client.JobServicesClient;
import org.kie.server.client.KieServicesClient;
import org.kie.server.client.KieServicesConfiguration;
import org.kie.server.client.KieServicesFactory;
import org.kie.server.client.ProcessServicesClient;
import org.kie.server.client.QueryServicesClient;
import org.kie.server.client.RuleServicesClient;
import org.kie.server.client.SolverServicesClient;
import org.kie.server.client.UIServicesClient;
import org.kie.server.client.UserTaskServicesClient;
import org.kie.server.api.model.instance.ProcessInstance;
import org.kie.server.api.model.KieContainerResource;
import org.kie.server.api.model.ReleaseId;

public class MyAdvancedConfigurationObject {

    // REST API base URL, credentials, and marshalling format
    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;

    // KIE client for common operations
    private static KieServicesClient kieServicesClient;

    // Rules client
    private static RuleServicesClient ruleClient;

    // Process automation clients
    private static CaseServicesClient caseClient;
    private static DocumentServicesClient documentClient;
    private static JobServicesClient jobClient;
    private static ProcessServicesClient processClient;
    private static QueryServicesClient queryClient;
    private static UIServicesClient uiClient;
    private static UserTaskServicesClient userTaskClient;

    // DMN client
    private static DMNServicesClient dmnClient;

    // Planning client
    private static SolverServicesClient solverClient;

    public static void main(String[] args) {
        initializeKieServerClient();
        initializeDroolsServiceClients();
        initializeJbpmServiceClients();
        initializeSolverServiceClients();
    }

    public static void initializeKieServerClient() {
        conf = KieServicesFactory.newRestConfiguration(URL, USER, PASSWORD);
        conf.setMarshallingFormat(FORMAT);
        kieServicesClient = KieServicesFactory.newKieServicesClient(conf);
    }

    public static void initializeDroolsServiceClients() {
        ruleClient = kieServicesClient.getServicesClient(RuleServicesClient.class);
        dmnClient = kieServicesClient.getServicesClient(DMNServicesClient.class);
    }

    public static void initializeJbpmServiceClients() {
        caseClient = kieServicesClient.getServicesClient(CaseServicesClient.class);
        documentClient = kieServicesClient.getServicesClient(DocumentServicesClient.class);
        jobClient = kieServicesClient.getServicesClient(JobServicesClient.class);
        processClient = kieServicesClient.getServicesClient(ProcessServicesClient.class);
        queryClient = kieServicesClient.getServicesClient(QueryServicesClient.class);
        uiClient = kieServicesClient.getServicesClient(UIServicesClient.class);
        userTaskClient = kieServicesClient.getServicesClient(UserTaskServicesClient.class);
    }

    public static void initializeSolverServiceClients() {
        solverClient = kieServicesClient.getServicesClient(SolverServicesClient.class);
    }
}

22.1. 使用 KIE Server Java 客户端 API 发送请求

KIE Server Java 客户端 API 可让您使用 Java 客户端应用程序中的 REST 协议连接到 KIE 服务器。您可以使用 KIE Server Java 客户端 API 作为 KIE Server REST API 的替代选择,以便在不使用 Business Central 用户界面的情况下与红帽 Process Automation Manager 中的 KIE 容器和业务资产(如自定义规则、流程和程序)交互。

先决条件

  • KIE 服务器已安装并运行。
  • 您有对 KIE 服务器的 kie-server 用户角色访问权限。
  • 您有一个带有 Red Hat Process Automation Manager 资源的 Java 项目。

流程

  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 客户端的 createContainerdisposeContainer。根据您的用例调整任何配置详情。

    创建并分离容器

    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 类型 :返回 SUCCESSFAILURE
    • 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 配置。

22.2. 支持的 KIE Server Java 客户端

以下是 Red Hat Process Automation Manager 发行版本的 org.kie.server.client 软件包中的一些 Java 客户端服务。您可以使用这些服务与 KIE 服务器中的相关资源交互,类似于 KIE Server REST API。

  • KieServicesClient :用作其他 KIE Server Java 客户端的入口点,用于与 KIE 容器交互
  • JobServicesClient :用于调度、取消、重新队列和获取作业请求
  • RuleServicesClient :用于将命令发送到服务器来执行与规则相关的操作,如执行规则或将对象插入到 KIE 会话
  • SolverServicesClient :用于执行所有 Red Hat build of OptaPlanner 操作,如获得 solver 状态和最佳解决方案,或忽略一个临时解决方案
  • ProcessServicesClient :用于启动、信号和中止进程或工作项目
  • QueryServicesClient :用于查询进程、进程节点和进程变量
  • UserTaskServicesClient :用于执行所有用户任务操作,如启动、声明或取消任务,以及通过指定字段(如由用户或进程实例 ID)查询任务
  • UIServicesClient :用于获取表单(XML 或 JSON)和进程镜像(SVG)的字符串表示
  • ProcessAdminServicesClient :为处理实例的操作提供一个接口(在 ~/org/kie/server/client/admin中找到)
  • UserTaskAdminServicesClient :为带有用户任务的操作提供一个接口(位于 ~/org/kie/server/client/admin中)

getServicesClient 方法提供对这些客户端的访问权限:

RuleServicesClient rulesClient = kieServicesClient.getServicesClient(RuleServicesClient.class);

有关可用 KIE Server Java 客户端的完整列表,请从红帽客户门户网站下载 Red Hat Process Automation Manager 7.11.0 源分发,并进入 ~/rhpam-7.11.0-sources/src/droolsjbpm-integration-$VERSION/kie-server-parent/kie-server-remote/kie-server-client/src/main/java/java/org/kie/server/clienthttps://access.redhat.com/jbossnetwork/restricted/listSoftware.html

22.3. 带有 KIE 服务器 Java 客户端 API 的请求示例

以下是 KIE 服务器 Java 客户端 API 请求示例,用于与 KIE 服务器基本交互。有关可用 KIE Server Java 客户端的完整列表,请从红帽客户门户网站下载 Red Hat Process Automation Manager 7.11.0 源分发,并进入 ~/rhpam-7.11.0-sources/src/droolsjbpm-integration-$VERSION/kie-server-parent/kie-server-remote/kie-server-client/src/main/java/java/org/kie/server/clienthttps://access.redhat.com/jbossnetwork/restricted/listSoftware.html

列出 KIE 服务器功能

您可以使用 org.kie.server.api.model.KieServerInfo 对象来识别服务器功能。KieServicesClient 客户端需要服务器功能信息才能正确生成服务客户端。您可以在 KieServicesConfiguration 中全局指定功能;否则会自动从 KIE 服务器检索它们。

返回 KIE 服务器功能的请求示例

public void listCapabilities() {

  KieServerInfo serverInfo = kieServicesClient.getServerInfo().getResult();
  System.out.print("Server capabilities:");

  for (String capability : serverInfo.getCapabilities()) {
    System.out.print(" " + capability);
  }

  System.out.println();
}

列出 KIE 服务器中的 KIE 容器

KIE 容器由 org.kie.server.api.model.KieContainerResource 对象表示。资源列表由 org.kie.server.api.model.KieContainerResourceList 对象表示。

从 KIE 服务器返回 KIE 容器的请求示例

public void listContainers() {
    KieContainerResourceList containersList = kieServicesClient.listContainers().getResult();
    List<KieContainerResource> kieContainers = containersList.getContainers();
    System.out.println("Available containers: ");
    for (KieContainerResource container : kieContainers) {
        System.out.println("\t" + container.getContainerId() + " (" + container.getReleaseId() + ")");
    }
}

您可以使用 org.kie.server.api.model.KieContainerResourceFilter 类的实例过滤 KIE 容器结果,该实例传递给 org.kie.server.client.KieServicesClient.listContainers () 方法。

按发行版本 ID 和状态返回 KIE 容器的请求示例

public void listContainersWithFilter() {

    // Filter containers by releaseId "org.example:container:1.0.0.Final" and status FAILED
    KieContainerResourceFilter filter = new KieContainerResourceFilter.Builder()
            .releaseId("org.example", "container", "1.0.0.Final")
            .status(KieContainerStatus.FAILED)
            .build();

    // Using previously created KieServicesClient
    KieContainerResourceList containersList = kieServicesClient.listContainers(filter).getResult();
    List<KieContainerResource> kieContainers = containersList.getContainers();

    System.out.println("Available containers: ");

    for (KieContainerResource container : kieContainers) {
        System.out.println("\t" + container.getContainerId() + " (" + container.getReleaseId() + ")");
    }
}

在 KIE 服务器中创建并分离 KIE 容器

您可以使用 KieServicesClient 客户端中的 createContainerdisposeContainer 方法来忽略并创建 KIE 容器。在本例中,当您分离容器时,ServiceResponse 会返回 Void 响应。在创建容器时,ServiceResponse 会返回 KieContainerResource 对象。

取消和重新创建 KIE 容器的请求示例

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

在 KIE 服务器中执行运行时命令

Red Hat Process Automation Manager 支持您可以发送到 KIE 服务器的运行时命令,以获取与资产相关的操作,如在 KIE 会话中插入或重新遍历对象或触发所有规则。支持的运行时命令的完整列表位于 Red Hat Process Automation Manager 实例的 org.drools.core.command.runtime 软件包中。

您可以使用 org.kie.api.command.KieCommands 类插入命令,并使用 org.kie.api.KieServices.get ().getCommands () 来实例化 KieCommands 类。如果要添加多个命令,请使用 BatchExecutionCommand 打包程序。

插入对象并触发所有规则的请求示例

import org.kie.api.command.Command;
import org.kie.api.command.KieCommands;
import org.kie.server.api.model.ServiceResponse;
import org.kie.server.client.RuleServicesClient;
import org.kie.server.client.KieServicesClient;
import org.kie.api.KieServices;

import java.util.Arrays;

...

public void executeCommands() {

  String containerId = "hello";
  System.out.println("== Sending commands to the server ==");
  RuleServicesClient rulesClient = kieServicesClient.getServicesClient(RuleServicesClient.class);
  KieCommands commandsFactory = KieServices.Factory.get().getCommands();

  Command<?> insert = commandsFactory.newInsert("Some String OBJ");
  Command<?> fireAllRules = commandsFactory.newFireAllRules();
  Command<?> batchCommand = commandsFactory.newBatchExecution(Arrays.asList(insert, fireAllRules));

  ServiceResponse<String> executeResponse = rulesClient.executeCommands(containerId, batchCommand);

  if(executeResponse.getType() == ResponseType.SUCCESS) {
    System.out.println("Commands executed with success! Response: ");
    System.out.println(executeResponse.getResult());
  } else {
    System.out.println("Error executing rules. Message: ");
    System.out.println(executeResponse.getMsg());
  }
}

注意

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

列出 KIE 容器中可用的进程

您可以使用 QueryServicesClient 客户端列出可用的进程定义。QueryServicesClient 方法使用分页,因此除了您进行的查询外,还必须提供当前页面和每个页面的结果数。在本例中,查询从页面 0 开始,并列出前 1000 个结果。

列出 KIE 服务器中处理进程的请求示例

public void listProcesses() {
    System.out.println("== Listing Business Processes ==");
    QueryServicesClient queryClient = kieServicesClient.getServicesClient(QueryServicesClient.class);
    List<ProcessDefinition> findProcessesByContainerId = queryClient.findProcessesByContainerId("rewards", 0, 1000);
    for (ProcessDefinition def : findProcessesByContainerId) {
        System.out.println(def.getName() + " - " + def.getId() + " v" + def.getVersion());
    }
}

在 KIE 容器中启动批准过程

您可以使用 ProcessServicesClient 客户端启动启动过程。使用 addExtraClasses () 方法,确保您需要的任何自定义类添加到 KieServicesConfiguration 对象中。

启动业务进程的请求示例

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;

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.client.ProcessServicesClient;
...

public static void startProcess() {

  //Client configuration setup
  KieServicesConfiguration config = KieServicesFactory.newRestConfiguration(SERVER_URL, LOGIN, PASSWORD);

  //Add custom classes, such as Obj.class, to the configuration
  Set<Class<?>> extraClassList = new HashSet<Class<?>>();
  extraClassList.add(Obj.class);
  config.addExtraClasses(extraClassList);
  config.setMarshallingFormat(MarshallingFormat.JSON);

  // ProcessServicesClient setup
  KieServicesClient client = KieServicesFactory.newKieServicesClient(config);
  ProcessServicesClient processServicesClient = client.getServicesClient(ProcessServicesClient.class);

  // Create an instance of the custom class
  Obj obj = new Obj();
  obj.setOk("ok");

  Map<String, Object> variables = new HashMap<String, Object>();
  variables.put("test", obj);

  // Start the process with custom class
  processServicesClient.startProcess(CONTAINER, processId, variables);
}

运行自定义查询

您可以使用 QueryServicesClient 客户端的 QueryDefinition 对象在 KIE 服务器中注册和执行自定义查询。

在 KIE 服务器中注册和执行自定义查询的请求示例

// Client setup
KieServicesConfiguration conf = KieServicesFactory.newRestConfiguration(SERVER_URL, LOGIN, PASSWORD);
KieServicesClient client = KieServicesFactory.newKieServicesClient(conf);

// Get the QueryServicesClient
QueryServicesClient queryClient = client.getServicesClient(QueryServicesClient.class);

// Build the query
QueryDefinition queryDefinition = QueryDefinition.builder().name(QUERY_NAME)
        .expression("select * from Task t")
        .source("java:jboss/datasources/ExampleDS")
        .target("TASK").build();

// Specify that two queries cannot have the same name
queryClient.unregisterQuery(QUERY_NAME);

// Register the query
queryClient.registerQuery(queryDefinition);

// Execute the query with parameters: query name, mapping type (to map the fields to an object), page number, page size, and return type
List<TaskInstance> query = queryClient.query(QUERY_NAME, QueryServicesClient.QUERY_MAP_TASK, 0, 100, TaskInstance.class);

// Read the result
for (TaskInstance taskInstance : query) {
    System.out.println(taskInstance);
}

在本例中,目标 指示查询服务应用默认过滤器。或者,您可以手动设置过滤器参数。Target 类支持以下值:

public enum Target {
    PROCESS,
    TASK,
    BA_TASK,
    PO_TASK,
    JOBS,
    CUSTOM;
}

第 23 章 Red Hat Process Automation Manager 中的 KIE 服务器和 KIE 容器命令

Red Hat Process Automation Manager 支持您可以发送到 KIE 服务器的服务器命令,以获取与服务器相关的或容器相关的操作,如检索服务器信息或创建和删除容器。支持的 KIE 服务器配置命令的完整列表位于 Red Hat Process Automation Manager 实例的 org.kie.server.api.commands 软件包中。

在 KIE Server REST API 中,您可以使用 org.kie.server.api.commands 命令作为向 http://SERVER:PORT/kie-server/services/rest/server/configPOST 请求的请求正文。有关使用 KIE 服务器 REST API 的更多信息,请参阅 第 21 章 KIE 服务器 REST API 用于 KIE 容器和业务资产

在 KIE Server Java 客户端 API 中,您可以使用父 KieServicesClient Java 客户端中的相应方法作为 Java 应用中的嵌入式 API 请求。所有 KIE Server 命令都由 Java 客户端 API 中提供的方法执行,因此您不需要在 Java 应用程序中嵌入实际的 KIE Server 命令。有关使用 KIE Server Java 客户端 API 的更多信息,请参阅 第 22 章 KIE Server Java 客户端 API 用于 KIE 容器和业务资产

23.1. KIE 服务器和 KIE 容器命令示例

以下是与 KIE Server REST API 或 Java 客户端 API 搭配使用的 KIE Server 命令示例,用于 KIE 服务器中与服务器相关的或与容器相关的操作:

  • GetServerInfoCommand
  • GetServerStateCommand
  • CreateContainerCommand
  • GetContainerInfoCommand
  • ListContainersCommand
  • CallContainerCommand
  • DisposeContainerCommand
  • GetScannerInfoCommand
  • UpdateScannerCommand
  • UpdateReleaseIdCommand

有关支持的 KIE 服务器配置和管理命令的完整列表,请查看 Red Hat Process Automation Manager 实例中的 org.kie.server.api.commands 软件包。

您可以单独运行 KIE Server 命令,也可以作为批处理 REST API 请求或批处理 Java API 请求一起运行:

批处理 REST API 请求,以创建、调用和取消一个 KIE 容器(JSON)

{
  "commands": [
    {
      "create-container": {
        "container": {
          "status": "STARTED",
          "container-id": "command-script-container",
          "release-id": {
            "version": "1.0",
            "group-id": "com.redhat",
            "artifact-id": "Project1"
          }
        }
      }
    },
    {
      "call-container": {
        "payload": "{\n  \"commands\" : [ {\n    \"fire-all-rules\" : {\n      \"max\" : -1,\n      \"out-identifier\" : null\n    }\n  } ]\n}",
        "container-id": "command-script-container"
      }
    },
    {
      "dispose-container": {
        "container-id": "command-script-container"
      }
    }
  ]
}

检索、取消和重新创建 KIE 容器的批处理 Java API 请求

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

本节中的每个命令都包含 KIE 服务器 REST API 的 REST 请求正文示例(JSON),以及 KIE Server Java 客户端 API 的 KieServicesClient Java 客户端中的嵌入式方法示例。

GetServerInfoCommand

返回有关 KIE 服务器的信息。

REST 请求正文示例(JSON)

{
  "commands" : [ {
    "get-server-info" : { }
  } ]
}

Java 客户端方法示例

KieServerInfo serverInfo = kieServicesClient.getServerInfo();

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Kie Server info",
      "result": {
        "kie-server-info": {
          "id": "default-kieserver",
          "version": "7.11.0.Final-redhat-00001",
          "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": 1538502533321
              },
              "content": [
                "Server KieServerInfo{serverId='default-kieserver', version='7.11.0.Final-redhat-00001', 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 Tue Oct 02 13:48:53 EDT 2018"
              ]
            }
          ]
        }
      }
    }
  ]
}

GetServerStateCommand

返回有关 KIE 服务器当前状态和配置的信息。

REST 请求正文示例(JSON)

{
  "commands" : [ {
    "get-server-state" : { }
  } ]
}

Java 客户端方法示例

KieServerStateInfo serverStateInfo = kieServicesClient.getServerState();

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Successfully loaded server state for server id default-kieserver",
      "result": {
        "kie-server-state-info": {
          "controller": [
            "http://localhost:8080/business-central/rest/controller"
          ],
          "config": {
            "config-items": [
              {
                "itemName": "org.kie.server.location",
                "itemValue": "http://localhost:8080/kie-server/services/rest/server",
                "itemType": "java.lang.String"
              },
              {
                "itemName": "org.kie.server.controller.user",
                "itemValue": "controllerUser",
                "itemType": "java.lang.String"
              },
              {
                "itemName": "org.kie.server.controller",
                "itemValue": "http://localhost:8080/business-central/rest/controller",
                "itemType": "java.lang.String"
              }
            ]
          },
          "containers": [
            {
              "container-id": "employee-rostering",
              "release-id": {
                "group-id": "employeerostering",
                "artifact-id": "employeerostering",
                "version": "1.0.0-SNAPSHOT"
              },
              "resolved-release-id": null,
              "status": "STARTED",
              "scanner": {
                "status": "STOPPED",
                "poll-interval": null
              },
              "config-items": [
                {
                  "itemName": "KBase",
                  "itemValue": "",
                  "itemType": "BPM"
                },
                {
                  "itemName": "KSession",
                  "itemValue": "",
                  "itemType": "BPM"
                },
                {
                  "itemName": "MergeMode",
                  "itemValue": "MERGE_COLLECTIONS",
                  "itemType": "BPM"
                },
                {
                  "itemName": "RuntimeStrategy",
                  "itemValue": "SINGLETON",
                  "itemType": "BPM"
                }
              ],
              "messages": [],
              "container-alias": "employeerostering"
            }
          ]
        }
      }
    }
  ]
}

CreateContainerCommand

在 KIE 服务器中创建一个 KIE 容器。

表 23.1. 命令属性

名称描述要求

container

包含 container-idrelease-id 数据(组 ID、工件 ID、版本)、状态 以及新 KIE 容器的其他组件的映射

必填

REST 请求正文示例(JSON)

{
  "commands" : [ {
    "create-container" : {
      "container" : {
        "status" : null,
        "messages" : [ ],
        "container-id" : "command-script-container",
        "release-id" : {
          "version" : "1.0",
          "group-id" : "com.redhat",
          "artifact-id" : "Project1"
        },
        "config-items" : [ ]
      }
    }
  } ]
}

Java 客户端方法示例

ServiceResponse<KieContainerResource> response = kieServicesClient.createContainer("command-script-container", resource);

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container command-script-container successfully deployed with module com.redhat:Project1:1.0.",
      "result": {
        "kie-container": {
          "container-id": "command-script-container",
          "release-id": {
            "version" : "1.0",
            "group-id" : "com.redhat",
            "artifact-id" : "Project1"
          },
          "resolved-release-id": {
            "version" : "1.0",
            "group-id" : "com.redhat",
            "artifact-id" : "Project1"
          },
          "status": "STARTED",
          "scanner": {
            "status": "DISPOSED",
            "poll-interval": null
          },
          "config-items": [],
          "messages": [
            {
              "severity": "INFO",
              "timestamp": {
                "java.util.Date": 1538762455510
              },
              "content": [
                "Container command-script-container successfully created with module com.redhat:Project1:1.0."
              ]
            }
          ],
          "container-alias": null
        }
      }
    }
  ]
}

GetContainerInfoCommand

返回 KIE 服务器中指定 KIE 容器的信息。

表 23.2. 命令属性

名称描述要求

container-id

KIE 容器的 ID

必填

REST 请求正文示例(JSON)

{
  "commands" : [ {
    "get-container-info" : {
      "container-id" : "command-script-container"
    }
  } ]
}

Java 客户端方法示例

ServiceResponse<KieContainerResource> response = kieServicesClient.getContainerInfo("command-script-container");

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Info for container command-script-container",
      "result": {
        "kie-container": {
          "container-id": "command-script-container",
          "release-id": {
            "group-id": "com.redhat",
            "artifact-id": "Project1",
            "version": "1.0"
          },
          "resolved-release-id": {
            "group-id": "com.redhat",
            "artifact-id": "Project1",
            "version": "1.0"
          },
          "status": "STARTED",
          "scanner": {
            "status": "DISPOSED",
            "poll-interval": null
          },
          "config-items": [

          ],
          "container-alias": null
        }
      }
    }
  ]
}

ListContainersCommand

返回在 KIE 服务器中创建的 KIE 容器列表。

表 23.3. 命令属性

名称描述要求

kie-container-filter

包含 release-id-filtercontainer-status-filter 以及您要过滤结果的任何其他 KIE 容器属性的可选映射

选填

REST 请求正文示例(JSON)

{
  "commands" : [ {
    "list-containers" : {
      "kie-container-filter" : {
        "release-id-filter" : { },
        "container-status-filter" : {
          "accepted-status" : ["FAILED"]
        }
      }
    }
  } ]
}

Java 客户端方法示例

KieContainerResourceFilter filter = new KieContainerResourceFilter.Builder()
        .status(KieContainerStatus.FAILED)
        .build();

KieContainerResourceList containersList = kieServicesClient.listContainers(filter);

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "List of created containers",
      "result": {
        "kie-containers": {
          "kie-container": [
            {
              "container-id": "command-script-container",
              "release-id": {
                "group-id": "com.redhat",
                "artifact-id": "Project1",
                "version": "1.0"
              },
              "resolved-release-id": {
                "group-id": "com.redhat",
                "artifact-id": "Project1",
                "version": "1.0"
              },
              "status": "STARTED",
              "scanner": {
                "status": "STARTED",
                "poll-interval": 5000
              },
              "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"
                }
              ],
              "messages": [
                {
                  "severity": "INFO",
                  "timestamp": {
                    "java.util.Date": 1538504619749
                  },
                  "content": [
                    "Container command-script-container successfully created with module com.redhat:Project1:1.0."
                  ]
                }
              ],
              "container-alias": null
            }
          ]
        }
      }
    }
  ]
}

CallContainerCommand

调用 KIE 容器并执行一个或多个运行时命令。有关 Red Hat Process Automation Manager 运行时命令的详情,请参考 第 24 章 Red Hat Process Automation Manager 中的运行时命令

表 23.4. 命令属性

名称描述要求

container-id

要调用的 KIE 容器的 ID

必填

payload

要对 KIE 容器执行的 BatchExecutionCommand 打包程序中的一个或多个命令

必填

REST 请求正文示例(JSON)

{
  "commands" : [ {
    "call-container" : {
      "payload" : "{\n  \"lookup\" : \"defaultKieSession\",\n  \"commands\" : [ {\n    \"fire-all-rules\" : {\n      \"max\" : -1,\n      \"out-identifier\" : null\n    }\n  } ]\n}",
      "container-id" : "command-script-container"
    }
  } ]
}

Java 客户端方法示例

List<Command<?>> commands = new ArrayList<Command<?>>();
      BatchExecutionCommand batchExecution1 = commandsFactory.newBatchExecution(commands, "defaultKieSession");
      commands.add(commandsFactory.newFireAllRules());

      ServiceResponse<ExecutionResults> response1 = ruleClient.executeCommandsWithResults("command-script-container", batchExecution1);

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container command-script-container successfully called.",
      "result": "{\n  \"results\" : [ ],\n  \"facts\" : [ ]\n}"
    }
  ]
}

DisposeContainerCommand

在 KIE 服务器中分离指定的 KIE 容器。

表 23.5. 命令属性

名称描述要求

container-id

要处理的 KIE 容器的 ID

必填

REST 请求正文示例(JSON)

{
  "commands" : [ {
    "dispose-container" : {
      "container-id" : "command-script-container"
    }
  } ]
}

Java 客户端方法示例

ServiceResponse<Void> response = kieServicesClient.disposeContainer("command-script-container");

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container command-script-container successfully disposed.",
      "result": null
    }
  ]
}

GetScannerInfoCommand

返回有关用于指定 KIE 容器中用于自动更新的 KIE 扫描程序的信息(如果适用)。

表 23.6. 命令属性

名称描述要求

container-id

使用 KIE 扫描程序的 KIE 容器的 ID

必填

REST 请求正文示例(JSON)

{
  "commands" : [ {
    "get-scanner-info" : {
      "container-id" : "command-script-container"
    }
  } ]
}

Java 客户端方法示例

ServiceResponse<KieScannerResource> response = kieServicesClient.getScannerInfo("command-script-container");

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Scanner info successfully retrieved",
      "result": {
        "kie-scanner": {
          "status": "DISPOSED",
          "poll-interval": null
        }
      }
    }
  ]
}

UpdateScannerCommand

启动或停止控制更新 KIE 容器部署的轮询的 KIE 扫描程序。

注意

避免使用带有业务进程的 KIE 扫描程序。将 KIE 扫描程序与进程搭配使用可能会导致无法预计的更新,然后在更改与正在运行的进程实例不兼容时导致长时间运行的进程出现错误。

表 23.7. 命令属性

名称描述要求

container-id

使用 KIE 扫描程序的 KIE 容器的 ID

必填

status

在 KIE 扫描程序上设置的状态(STARTEDSTOPPED)

必填

poll-interval

允许轮询持续时间(毫秒)

仅在启动扫描程序时才需要

REST 请求正文示例(JSON)

{
  "commands" : [ {
    "update-scanner" : {
      "scanner" : {
        "status" : "STARTED",
        "poll-interval" : 10000
      },
      "container-id" : "command-script-container"
    }
  } ]
}

Java 客户端方法示例

KieScannerResource scannerResource = new KieScannerResource();
scannerResource.setPollInterval(10000);
scannerResource.setStatus(KieScannerStatus. STARTED);

ServiceResponse<KieScannerResource> response = kieServicesClient.updateScanner("command-script-container", scannerResource);

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Kie scanner successfully created.",
      "result": {
        "kie-scanner": {
          "status": "STARTED",
          "poll-interval": 10000
        }
      }
    }
  ]
}

UpdateReleaseIdCommand

更新指定 KIE 容器的发行版本 ID 数据(组 ID、工件 ID、版本)。

表 23.8. 命令属性

名称描述要求

container-id

要更新的 KIE 容器的 ID

必填

releaseId

更新了 GAV (组 ID、工件 ID、版本)数据,以应用到 KIE 容器

必填

REST 请求正文示例(JSON)

{
  "commands" : [ {
    "update-release-id" : {
      "releaseId" : {
        "version" : "1.1",
        "group-id" : "com.redhat",
        "artifact-id" : "Project1"
      },
      "container-id" : "command-script-container"
    }
  } ]
}

Java 客户端方法示例

ServiceResponse<ReleaseId> response = kieServicesClient.updateReleaseId("command-script-container", "com.redhat:Project1:1.1");

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Release id successfully updated",
      "result": {
        "release-id": {
          "group-id": "com.redhat",
          "artifact-id": "Project1",
          "version": "1.1"
        }
      }
    }
  ]
}

第 24 章 Red Hat Process Automation Manager 中的运行时命令

Red Hat Process Automation Manager 支持您可以发送到 KIE 服务器的运行时命令,以获取与资产相关的操作,例如在 KIE 会话中执行所有规则或插入或重新遍历对象。支持的运行时命令的完整列表位于 Red Hat Process Automation Manager 实例的 org.drools.core.command.runtime 软件包中。

在 KIE Server REST API 中,您可以使用全局 org.drools.core.command.runtime 命令或特定于规则的 org.drools.core.command.runtime.rule 命令作为对 http://SERVER:PORT/kie-server/services/rest/server/containers/instances/{containerId}POST 请求的请求正文。有关使用 KIE 服务器 REST API 的更多信息,请参阅 第 21 章 KIE 服务器 REST API 用于 KIE 容器和业务资产

在 KIE Server Java 客户端 API 中,您可以将这些命令嵌入到 Java 应用程序中,以及相关的 Java 客户端。例如,对于与规则相关的命令,您可以使用 RuleServicesClient Java 客户端及嵌入式命令。有关使用 KIE Server Java 客户端 API 的更多信息,请参阅 第 22 章 KIE Server Java 客户端 API 用于 KIE 容器和业务资产

24.1. Red Hat Process Automation Manager 中的运行时命令示例

以下是您可以与 KIE Server REST API 或 Java 客户端 API 搭配使用的运行时命令示例,用于 KIE Server 中的与资产相关的操作:

  • BatchExecutionCommand
  • InsertObjectCommand
  • RetractCommand
  • ModifyCommand
  • GetObjectCommand
  • GetObjectsCommand
  • InsertElementsCommand
  • FireAllRulesCommand
  • StartProcessCommand
  • SignalEventCommand
  • CompleteWorkItemCommand
  • AbortWorkItemCommand
  • QueryCommand
  • SetGlobalCommand
  • GetGlobalCommand

有关支持的运行时命令的完整列表,请参阅 Red Hat Process Automation Manager 实例中的 org.drools.core.command.runtime 软件包。

本节中的每个命令都包含 KIE Server REST API 的 REST 请求正文示例(JSON),以及 KIE Server Java 客户端 API 的嵌入式 Java 命令示例。Java 示例使用对象 org.drools.compiler.test.Person,其 字段名称 (字符串) 和年龄 (Integer)。

BatchExecutionCommand

包含要一起执行的多个命令。

表 24.1. 命令属性

名称描述要求

commands

要执行的命令列表。

必填

lookup

设置要在其上执行命令的 KIE 会话 ID。对于无状态 KIE 会话,需要此属性。对于有状态 KIE 会话,此属性是可选的,如果没有指定,则使用默认的 KIE 会话。

对于无状态 KIE 会话是必需的,对于有状态 KIE 会话是可选的

注意

KIE 会话 ID 位于 Red Hat Process Automation Manager 项目的 kmodule.xml 文件中。要在 Business Central 中查看或添加 KIE 会话 ID,以用于 lookup 命令属性,进入到 Business Central 中的相关项目,并转至 SettingsKIE basesKIE 会话。如果不存在 KIE 基础,请点击 Add KIE baseKIE 会话 来定义新的 KIE 基础和 KIE 会话。

JSON 请求正文示例

{
  "lookup": "ksession1",
  "commands": [ {
      "insert": {
        "object": {
          "org.drools.compiler.test.Person": {
            "name": "john",
            "age": 25
          }
        }
      }
    },
    {
      "fire-all-rules": {
        "max": 10,
        "out-identifier": "firedActivations"
      }
    }
  ]
}

Java 命令示例

InsertObjectCommand insertCommand = new InsertObjectCommand(new Person("john", 25));
FireAllRulesCommand fireCommand = new FireAllRulesCommand();

BatchExecutionCommand batch = new BatchExecutionCommandImpl(Arrays.asList(insertCommand, fireCommand), "ksession1");

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container command-script-container successfully called.",
      "result": {
        "execution-results": {
          "results": [
            {
              "value": 0,
              "key": "firedActivations"
            }
          ],
          "facts": []
        }
      }
    }
  ]
}

InsertObjectCommand

将对象插入到 KIE 会话中。

表 24.2. 命令属性

名称描述要求

对象

要插入的对象

必填

out-identifier

从对象插入创建的 factHandle 的 ID,并添加到执行结果中

选填

return-object

确定对象是否必须在执行结果中返回的布尔值(默认值: true

选填

entry-point

插入的入口点

选填

JSON 请求正文示例

{
  "commands": [ {
      "insert": {
        "entry-point": "my stream",
        "object": {
          "org.drools.compiler.test.Person": {
            "age": 25,
            "name": "john"
          }
        },
        "out-identifier": "john",
        "return-object": false
      }
    }
  ]
}

Java 命令示例

Command insertObjectCommand =
  CommandFactory.newInsert(new Person("john", 25), "john", false, null);

ksession.execute(insertObjectCommand);

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container command-script-container successfully called.",
      "result": {
        "execution-results": {
          "results": [],
          "facts": [
            {
              "value": {
                "org.drools.core.common.DefaultFactHandle": {
                  "external-form": "0:4:436792766:-2127720265:4:DEFAULT:NON_TRAIT:java.util.LinkedHashMap"
                }
              },
              "key": "john"
            }
          ]
        }
      }
    }
  ]
}

RetractCommand

从 KIE 会话中重新传递对象。

表 24.3. 命令属性

名称描述要求

fact-handle

与要重新遍历的对象关联的 factHandle

必填

JSON 请求正文示例

{
  "commands": [ {
      "retract": {
        "fact-handle": "0:4:436792766:-2127720265:4:DEFAULT:NON_TRAIT:java.util.LinkedHashMap"
      }
    }
  ]
}

示例 Java 命令: 使用 factHandleFromString

RetractCommand retractCommand = new RetractCommand();
retractCommand.setFactHandleFromString("123:234:345:456:567");

示例 Java 命令: 使用插入对象的 factHandle

RetractCommand retractCommand = new RetractCommand(factHandle);

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container employee-rostering successfully called.",
      "result": {
        "execution-results": {
          "results": [],
          "facts": []
        }
      }
    }
  ]
}

ModifyCommand

修改 KIE 会话中之前插入的对象。

表 24.4. 命令属性

名称描述要求

fact-handle

与要修改的对象关联的 factHandle

必填

setters

对象修改的 setters 列表

必填

JSON 请求正文示例

{
  "commands": [ {
      "modify": {
        "fact-handle": "0:4:436792766:-2127720265:4:DEFAULT:NON_TRAIT:java.util.LinkedHashMap",
        "setters": {
          "accessor": "age",
          "value": 25
        }
      }
    }
  ]
}

Java 命令示例

ModifyCommand modifyCommand = new ModifyCommand(factHandle);

List<Setter> setters = new ArrayList<Setter>();
setters.add(new SetterImpl("age", "25"));

modifyCommand.setSetters(setters);

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container employee-rostering successfully called.",
      "result": {
        "execution-results": {
          "results": [],
          "facts": []
        }
      }
    }
  ]
}

GetObjectCommand

从 KIE 会话检索对象。

表 24.5. 命令属性

名称描述要求

fact-handle

与要检索的对象关联的 factHandle

必填

out-identifier

从对象插入创建的 factHandle 的 ID,并添加到执行结果中

选填

JSON 请求正文示例

{
  "commands": [ {
      "get-object": {
        "fact-handle": "0:4:436792766:-2127720265:4:DEFAULT:NON_TRAIT:java.util.LinkedHashMap",
        "out-identifier": "john"
      }
    }
  ]
}

Java 命令示例

GetObjectCommand getObjectCommand = new GetObjectCommand();
getObjectCommand.setFactHandleFromString("123:234:345:456:567");
getObjectCommand.setOutIdentifier("john");

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container command-script-container successfully called.",
      "result": {
        "execution-results": {
          "results": [
            {
              "value": null,
              "key": "john"
            }
          ],
          "facts": []
        }
      }
    }
  ]
}

GetObjectsCommand

从 KIE 会话检索所有对象作为一个集合。

表 24.6. 命令属性

名称描述要求

object-filter

从 KIE 会话返回的对象过滤

选填

out-identifier

执行结果中使用的标识符

选填

JSON 请求正文示例

{
  "commands": [ {
      "get-objects": {
        "out-identifier": "objects"
      }
    }
  ]
}

Java 命令示例

GetObjectsCommand getObjectsCommand = new GetObjectsCommand();
getObjectsCommand.setOutIdentifier("objects");

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container command-script-container successfully called.",
      "result": {
        "execution-results": {
          "results": [
            {
              "value": [
                {
                  "org.apache.xerces.dom.ElementNSImpl": "<?xml version=\"1.0\" encoding=\"UTF-16\"?>\n<object xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"person\"><age>25</age><name>john</name>\n <\/object>"
                },
                {
                  "org.drools.compiler.test.Person": {
                    "name": "john",
                    "age": 25
                  }
                }
              ],
              "key": "objects"
            }
          ],
          "facts": []
        }
      }
    }
  ]
}

InsertElementsCommand

将对象列表插入到 KIE 会话中。

表 24.7. 命令属性

名称描述要求

对象

要插入到 KIE 会话中的对象列表

必填

out-identifier

从对象插入创建的 factHandle 的 ID,并添加到执行结果中

选填

return-object

确定在执行结果中是否必须返回对象的布尔值。默认值: true

选填

entry-point

插入的入口点

选填

JSON 请求正文示例

{
  "commands": [ {
    "insert-elements": {
        "objects": [
            {
                "containedObject": {
                    "@class": "org.drools.compiler.test.Person",
                    "age": 25,
                    "name": "john"
                }
            },
            {
                "containedObject": {
                    "@class": "Person",
                    "age": 35,
                    "name": "sarah"
                }
            }
        ]
    }
  }
]
}

Java 命令示例

List<Object> objects = new ArrayList<Object>();
objects.add(new Person("john", 25));
objects.add(new Person("sarah", 35));

Command insertElementsCommand = CommandFactory.newInsertElements(objects);

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container command-script-container successfully called.",
      "result": {
        "execution-results": {
          "results": [],
          "facts": [
            {
              "value": {
                "org.drools.core.common.DefaultFactHandle": {
                  "external-form": "0:4:436792766:-2127720265:4:DEFAULT:NON_TRAIT:java.util.LinkedHashMap"
                }
              },
              "key": "john"
            },
            {
              "value": {
                "org.drools.core.common.DefaultFactHandle": {
                  "external-form": "0:4:436792766:-2127720266:4:DEFAULT:NON_TRAIT:java.util.LinkedHashMap"
                }
              },
              "key": "sarah"
            }
          ]
        }
      }
    }
  ]
}

FireAllRulesCommand

执行 KIE 会话中的所有规则。

表 24.8. 命令属性

名称描述要求

max

要执行的规则的最大数量。默认值为 -1, 在执行时不会产生任何限制。

选填

out-identifier

用于在执行结果中检索触发的规则数的 ID。

选填

agenda-filter

用于规则执行的议程过滤。

选填

JSON 请求正文示例

{
  "commands" : [ {
    "fire-all-rules": {
        "max": 10,
        "out-identifier": "firedActivations"
    }
  } ]
}

Java 命令示例

FireAllRulesCommand fireAllRulesCommand = new FireAllRulesCommand();
fireAllRulesCommand.setMax(10);
fireAllRulesCommand.setOutIdentifier("firedActivations");

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container command-script-container successfully called.",
      "result": {
        "execution-results": {
          "results": [
            {
              "value": 0,
              "key": "firedActivations"
            }
          ],
          "facts": []
        }
      }
    }
  ]
}

StartProcessCommand

使用进程 ID 启动进程。您还可以传递要插入的参数和初始数据。

表 24.9. 命令属性

名称描述要求

processId

要启动的进程 ID

必填

parameters

Map <String,Object&gt; 参数,用于在进程启动中传递参数

选填

data

在进程启动前要插入到 KIE 会话中的对象列表

选填

JSON 请求正文示例

{
  "commands": [
    {
      "start-process": {
        "processId": "myProject.myProcess",
        "data": null,
        "parameter": [],
        "out-identifier": null
      }
    }
  ]
}

Java 命令示例

StartProcessCommand startProcessCommand = new StartProcessCommand();
startProcessCommand.setProcessId("org.drools.task.processOne");

服务器响应示例(JSON)

{
  "type": "SUCCESS",
  "msg": "Container stateful-session successfully called.",
  "result": {
    "execution-results": {
      "results": [],
      "facts": []
    }
  }
}

SignalEventCommand

向 KIE 会话发送一个信号事件。

表 24.10. 命令属性

名称描述要求

event-type

传入事件的类型

必填

process-instance-id

要信号的进程实例的 ID

选填

event

传入事件的数据

选填

JSON 请求正文示例

{
  "commands": [
    {
      "signal-event": {
        "process-instance-id": 1001,
        "correlation-key": null,
        "event-type": "start",
        "event": {
          "org.kie.server.testing.Person": {
            "fullname": "john",
            "age": 25
          }
        }
      }
    }
  ]
}

Java 命令示例

SignalEventCommand signalEventCommand = new SignalEventCommand();
signalEventCommand.setProcessInstanceId(1001);
signalEventCommand.setEventType("start");
signalEventCommand.setEvent(new Person("john", 25));

服务器响应示例(JSON)

{
  "type": "SUCCESS",
  "msg": "Container stateful-session successfully called.",
  "result": {
    "execution-results": {
      "results": [],
      "facts": []
    }
  }
}

CompleteWorkItemCommand

在 KIE 会话中完成一个工作项目。

表 24.11. 命令属性

名称描述要求

workItemId

要完成的工作项目的 ID

必填

results

工作项目的结果

选填

JSON 请求正文示例

{
  "commands": [ {
    "complete-work-item": {
        "id": 1001
    }
  }
]
}

Java 命令示例

CompleteWorkItemCommand completeWorkItemCommand = new CompleteWorkItemCommand();
completeWorkItemCommand.setWorkItemId(1001);

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container employee-rostering successfully called.",
      "result": {
        "execution-results": {
          "results": [],
          "facts": []
        }
      }
    }
  ]
}

AbortWorkItemCommand

中止 KIE 会话中的工作项,其方式与 ksession.getWorkItemManager ().abortWorkItem (workItemId) 相同。

表 24.12. 命令属性

名称描述要求

workItemId

要中止的工作项目的 ID

必填

JSON 请求正文示例

{
  "commands": [ {
      "abort-work-item": {
        "id": 1001
      }
    }
  ]
}

Java 命令示例

AbortWorkItemCommand abortWorkItemCommand = new AbortWorkItemCommand();
abortWorkItemCommand.setWorkItemId(1001);

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container employee-rostering successfully called.",
      "result": {
        "execution-results": {
          "results": [],
          "facts": []
        }
      }
    }
  ]
}

QueryCommand

执行 KIE 基础中定义的查询。

表 24.13. 命令属性

名称描述要求

name

查询名称。

必填

out-identifier

查询结果的 ID。查询结果将添加到带有此标识符的执行结果中。

选填

参数

要作为参数传递的对象列表。

选填

JSON 请求正文示例

{
  "commands": [
    {
      "query": {
        "name": "persons",
        "arguments": [],
        "out-identifier": "persons"
      }
    }
  ]
}

Java 命令示例

QueryCommand queryCommand = new QueryCommand();
queryCommand.setName("persons");
queryCommand.setOutIdentifier("persons");

服务器响应示例(JSON)

{
  "type": "SUCCESS",
  "msg": "Container stateful-session successfully called.",
  "result": {
    "execution-results": {
      "results": [
        {
          "value": {
            "org.drools.core.runtime.rule.impl.FlatQueryResults": {
              "idFactHandleMaps": {
                "type": "LIST",
                "componentType": null,
                "element": [
                  {
                    "type": "MAP",
                    "componentType": null,
                    "element": [
                      {
                        "value": {
                          "org.drools.core.common.DisconnectedFactHandle": {
                            "id": 1,
                            "identityHashCode": 1809949690,
                            "objectHashCode": 1809949690,
                            "recency": 1,
                            "object": {
                              "org.kie.server.testing.Person": {
                                "fullname": "John Doe",
                                "age": 47
                              }
                            },
                            "entryPointId": "DEFAULT",
                            "traitType": "NON_TRAIT",
                            "external-form": "0:1:1809949690:1809949690:1:DEFAULT:NON_TRAIT:org.kie.server.testing.Person"
                          }
                        },
                        "key": "$person"
                      }
                    ]
                  }
                ]
              },
              "idResultMaps": {
                "type": "LIST",
                "componentType": null,
                "element": [
                  {
                    "type": "MAP",
                    "componentType": null,
                    "element": [
                      {
                        "value": {
                          "org.kie.server.testing.Person": {
                            "fullname": "John Doe",
                            "age": 47
                          }
                        },
                        "key": "$person"
                      }
                    ]
                  }
                ]
              },
              "identifiers": {
                "type": "SET",
                "componentType": null,
                "element": [
                  "$person"
                ]
              }
            }
          },
          "key": "persons"
        }
      ],
      "facts": []
    }
  }
}

SetGlobalCommand

将对象设置为全局状态。

表 24.14. 命令属性

名称描述要求

identifier

KIE 基础中定义的全局变量 ID

必填

对象

要设置为全局变量的对象

选填

out

布尔值从执行结果中排除您设置的全局变量

选填

out-identifier

全局执行结果的 ID

选填

JSON 请求正文示例

{
  "commands": [
    {
      "set-global": {
        "identifier": "helper",
        "object": {
          "org.kie.server.testing.Person": {
            "fullname": "kyle",
            "age": 30
          }
        },
        "out-identifier": "output"
      }
    }
  ]
}

Java 命令示例

SetGlobalCommand setGlobalCommand = new SetGlobalCommand();
setGlobalCommand.setIdentifier("helper");
setGlobalCommand.setObject(new Person("kyle", 30));
setGlobalCommand.setOut(true);
setGlobalCommand.setOutIdentifier("output");

服务器响应示例(JSON)

{
  "type": "SUCCESS",
  "msg": "Container stateful-session successfully called.",
  "result": {
    "execution-results": {
      "results": [
        {
          "value": {
            "org.kie.server.testing.Person": {
              "fullname": "kyle",
              "age": 30
            }
          },
          "key": "output"
        }
      ],
      "facts": []
    }
  }
}

GetGlobalCommand

检索之前定义的全局对象。

表 24.15. 命令属性

名称描述要求

identifier

KIE 基础中定义的全局变量 ID

必填

out-identifier

执行结果中使用的 ID

选填

JSON 请求正文示例

{
  "commands": [ {
      "get-global": {
        "identifier": "helper",
        "out-identifier": "helperOutput"
      }
    }
  ]
}

Java 命令示例

GetGlobalCommand getGlobalCommand = new GetGlobalCommand();
getGlobalCommand.setIdentifier("helper");
getGlobalCommand.setOutIdentifier("helperOutput");

服务器响应示例(JSON)

{
  "response": [
    {
      "type": "SUCCESS",
      "msg": "Container command-script-container successfully called.",
      "result": {
        "execution-results": {
          "results": [
            {
              "value": null,
              "key": "helperOutput"
            }
          ],
          "facts": []
        }
      }
    }
  ]
}

第 25 章 为 KIE 服务器模板和实例处理自动化管理器控制器 REST API

Red Hat Process Automation Manager 提供了一个 Process Automation Manager 控制器 REST API,可用于与 KIE 服务器模板(配置)、KIE 服务器实例(远程服务器)以及 Red Hat Process Automation Manager 中的关联 KIE 容器(部署单元)交互,而无需使用 Business Central 用户界面。通过这个 API 支持,您可以更有效地维护 Red Hat Process Automation Manager 服务器和资源,并使用 Red Hat Process Automation Manager 优化集成和开发。

使用 Process Automation Manager 控制器 REST API,您可以执行以下操作:

  • 检索 KIE Server 模板、实例和相关 KIE 容器的信息
  • 更新、启动或停止与 KIE Server 模板和实例关联的 KIE 容器
  • 创建、更新或删除 KIE 服务器模板
  • 创建、更新或删除 KIE 服务器实例

对 Process Automation Manager 控制器 REST API 的请求需要以下组件:

身份验证

Process Automation Manager 控制器 REST API 需要以下用户角色的 HTTP 基本身份验证或基于令牌的身份验证,具体取决于控制器类型:

  • 如果您安装了 Business Central 且希望使用内置 Process Automation Manager 控制器,则 REST -all 用户角色
  • 如果您独立于 Business Central 安装无头 Process Automation Manager 控制器,则 kie-server 用户角色

要查看 Red Hat Process Automation Manager 发行版配置的用户角色,请导航到 ~/$SERVER_HOME/standalone/configuration/application-roles.properties~/application-users.properties

要添加具有 kie-server 角色或 rest-all 角色或两者的用户,请导航到 ~/$SERVER_HOME/bin,并使用指定的角色运行以下命令:

$ ./add-user.sh -a --user <USERNAME> --password <PASSWORD> --role kie-server,rest-all

要配置带有 Process Automation Manager 控制器访问权限的 kie-serverrest-all 用户,请导航到 ~/$SERVER_HOME/standalone/configuration/standalone-full.xml,取消注释 org.kie.server 属性(如果适用),并添加控制器用户登录凭证和控制器位置(如果需要):

<property name="org.kie.server.location" value="http://localhost:8080/kie-server/services/rest/server"/>
<property name="org.kie.server.controller" value="http://localhost:8080/business-central/rest/controller"/>
<property name="org.kie.server.controller.user" value="baAdmin"/>
<property name="org.kie.server.controller.pwd" value="password@1"/>
<property name="org.kie.server.id" value="default-kieserver"/>

有关用户角色和 Red Hat Process Automation Manager 安装选项的更多信息,请参阅 规划 Red Hat Process Automation Manager 安装

HTTP 标头

Process Automation Manager 控制器 REST API 需要以下 HTTP 标头用于 API 请求:

  • 接受 :您请求的客户端接受的数据格式:

    • application/json (JSON)
    • application/xml (用于 JAXB 的XML)
  • Content-TypePOSTPUT API 请求数据的数据格式:

    • application/json (JSON)
    • application/xml (用于 JAXB 的XML)
HTTP 方法

Process Automation Manager 控制器 REST API 支持以下 API 请求的方法:

  • GET :从指定的资源端点检索指定的信息
  • POST :更新资源或资源实例
  • PUT :创建资源或资源实例
  • DELETE :删除资源或资源实例
基本 URL
Process Automation Manager 控制器 REST API 请求的基本 URL 是 http://SERVER:PORT/CONTROLLER/rest/,例如,如果您使用内置于 Business Central 的 Process Automation Manager,则为 http://localhost:8080/business-central/rest/
Endpoints

处理 Automation Manager 控制器 REST API 端点(如指定 KIE Server 模板的 /controller/management/servers/{serverTemplateId} )是您附加到 Process Automation Manager 控制器 REST API 基本 URL 中的 URI,以访问 Red Hat Process Automation Manager 中的对应服务器资源或服务器资源类型。

/controller/management/servers/{serverTemplateId} 端点的请求 URL 示例

http://localhost:8080/business-central/rest/controller/management/servers/default-kieserver

请求参数和请求数据

有些流程自动化管理器控制器 REST API 请求需要请求 URL 路径中的特定参数来识别或过滤特定资源并执行特定操作。您可以将 URL 参数附加到端点,格式为 ?<PARAM>=<VALUE>&<PARAM>=<VALUE >。

带有参数的 DELETE 请求 URL 示例

http://localhost:8080/business-central/rest/controller/server/new-kieserver-instance?location=http://localhost:8080/kie-server/services/rest/server

HTTP POSTPUT 请求可能还需要请求正文或带有数据的文件来附带请求。

PUT 请求 URL 和 JSON 请求正文数据示例

http://localhost:8080/business-central/rest/controller/management/servers/new-kieserver

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

25.1. 使用 REST 客户端或 curl 工具通过 Process Automation Manager 控制器 REST API 发送请求

Process Automation Manager 控制器 REST API 可让您在不使用 Business Central 用户界面的情况下与 KIE 服务器模板(配置)、KIE 服务器实例(远程服务器)和相关 KIE 容器(部署单元)交互。您可以使用任何 REST 客户端或 curl 工具发送 Process Automation Manager 控制器 REST API 请求。

先决条件

  • KIE 服务器已安装并运行。
  • Process Automation Manager 控制器或无头 Process Automation Manager 控制器已安装并运行。
  • 如果您安装了 Business Central,或 kie-server 用户角色可以访问与 Business Central 单独安装的无头 Process Automation Manager 控制器,则您具有对 Process Automation Manager 控制器的 rest-all 用户角色访问。

流程

  1. 识别您要发送请求的相关 API 端点,如 [GET] /controller/management/servers,以从 Process Automation Manager 控制器检索 KIE Server 模板。
  2. 在 REST 客户端或 curl 工具中,为对 controller/management/serversGET 请求输入以下组件。根据您的用例调整任何请求详情。

    对于 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. 执行请求,并确认过程自动化管理器控制器响应成功。

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

25.2. 使用 Swagger 接口通过 Process Automation Manager 控制器 REST API 发送请求

Process Automation Manager 控制器 REST API 支持 Swagger Web 界面,您可以使用它而不是独立 REST 客户端或 curl 实用程序与 Red Hat Process Automation Manager 中的 KIE 服务器模板、实例和相关 KIE 容器进行交互,而无需使用 Business Central 用户界面。

注意

默认情况下,Process Automation Manager 控制器的 Swagger Web 界面由 org.kie.workbench.swagger.disabled=false 系统属性启用。要禁用 Process Automation Manager 控制器的 Swagger Web 界面,请将此系统属性设置为 true

先决条件

  • Process Automation Manager 控制器已安装并运行。
  • 如果您安装了 Business Central,或 kie-server 用户角色可以访问与 Business Central 单独安装的无头 Process Automation Manager 控制器,则您具有对 Process Automation Manager 控制器的 rest-all 用户角色访问。

流程

  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 控制器响应成功。

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

25.3. 支持的流程自动化管理器控制器 REST API 端点

Process Automation Manager 控制器 REST API 提供与 KIE 服务器模板(配置)、KIE 服务器实例(远程服务器)和相关 KIE 容器(部署单元)交互的端点。Process Automation Manager 控制器 REST API 基本 URL 是 http://SERVER:PORT/CONTROLLER/rest/。所有请求都需要 HTTP 基本身份验证,如果您安装了 Business Central 并希望使用内置的 Process Automation Manager控制器则为 rest-all 用户使用基于令牌的验证;如果安装了独立于 Business Central 的无头 Process Automation Manager 控制器,则为 kie-server 使用基于令牌的身份验证。

如需流程 Automation Manager 控制器 REST API 端点和描述的完整列表,请使用以下资源之一:

  • 用户界面文档页面上的控制器 REST API (静态)
  • http://SERVER:PORT/CONTROLLER/docs 中的 Process Automation Manager 控制器 REST API 的 Swagger UI (动态,需要运行 Process Automation Manager 控制器)

    注意

    默认情况下,Process Automation Manager 控制器的 Swagger Web 界面由 org.kie.workbench.swagger.disabled=false 系统属性启用。要禁用 Process Automation Manager 控制器的 Swagger Web 界面,请将此系统属性设置为 true

    如果您使用内置于 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 端点都是相同的。

第 26 章 为 KIE 服务器模板和实例处理自动化管理器控制器 Java 客户端 API

Red Hat Process Automation Manager 提供了一个 Process Automation Manager 控制器 Java 客户端 API,可让您使用 Java 客户端应用程序中的 REST 或 WebSocket 协议连接到 Process Automation Manager 控制器。您可以使用 Process Automation Manager 控制器 Java 客户端 API 作为 Process Automation Manager 控制器 REST API 的替代选择,以与 KIE Server 模板(配置)、KIE 服务器实例(远程服务器)以及 Red Hat Process Automation Manager 中的关联的 KIE 容器(部署单元)进行交互,而无需使用 Business Central 用户界面。通过这个 API 支持,您可以更有效地维护 Red Hat Process Automation Manager 服务器和资源,并使用 Red Hat Process Automation Manager 优化集成和开发。

使用 Process Automation Manager 控制器 Java 客户端 API,您还可以执行以下操作,并被 Process Automation Manager 控制器 REST API 支持:

  • 检索 KIE Server 模板、实例和相关 KIE 容器的信息
  • 更新、启动或停止与 KIE Server 模板和实例关联的 KIE 容器
  • 创建、更新或删除 KIE 服务器模板
  • 创建、更新或删除 KIE 服务器实例

处理 Automation Manager 控制器 Java 客户端 API 请求需要以下组件:

身份验证

Process Automation Manager 控制器 Java 客户端 API 需要以下用户角色的 HTTP 基本身份验证,具体取决于控制器类型:

  • 如果您安装了 Business Central 且希望使用内置 Process Automation Manager 控制器,则 REST -all 用户角色
  • 如果您独立于 Business Central 安装无头 Process Automation Manager 控制器,则 kie-server 用户角色

要查看 Red Hat Process Automation Manager 发行版配置的用户角色,请导航到 ~/$SERVER_HOME/standalone/configuration/application-roles.properties~/application-users.properties

要添加具有 kie-server 角色或 rest-all 角色或(假设已设置了 Keystore)的用户,请导航到 ~/$SERVER_HOME/bin,并使用指定的角色运行以下命令:

$ ./add-user.sh -a --user <USERNAME> --password <PASSWORD> --role kie-server,rest-all

如果没有设置 Keystore,则执行以下命令来创建密钥存储:

$ keytool -importpassword -keystore $SERVER_HOME/standalone/configuration/kie_keystore.jceks -keypass <SECRETKEYPASSWORD> -alias kieserver -storepass <SECRETSTOREPASSWORD> -storetype JCEKS

另外,在 ~/$SERVER_HOME/standalone/configuration/standalone-full.xml 中添加以下属性:

    <property name="kie.keystore.keyStoreURL" value="file:///data/jboss/rhpam780/standalone/configuration/kie_keystore.jceks"/>
    <property name="kie.keystore.keyStorePwd" value="<SECRETSTOREPASSWORD>"/>
    <property name="kie.keystore.key.server.alias" value="kieserver"/>
    <property name="kie.keystore.key.server.pwd" value="<SECRETKEYPASSWORD>"/>
    <property name="kie.keystore.key.ctrl.alias" value="kieserver"/>
    <property name="kie.keystore.key.ctrl.pwd" value="<SECRETKEYPASSWORD>"/>

要配置带有 Process Automation Manager 控制器访问权限的 kie-serverrest-all 用户,请导航到 ~/$SERVER_HOME/standalone/configuration/standalone-full.xml,取消注释 org.kie.server 属性(如果适用),并添加控制器用户登录凭证和控制器位置(如果需要):

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

有关用户角色和 Red Hat Process Automation Manager 安装选项的更多信息,请参阅 规划 Red Hat Process Automation Manager 安装

项目依赖项

Process Automation Manager 控制器 Java 客户端 API 需要以下依赖 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>

Red Hat Process Automation Manager 依赖项的 <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 的更多信息,请参阅 RHPAM 产品和 maven 库版本之间的映射是什么?

客户端请求配置

所有带有 Process Automation Manager 控制器 Java 客户端 API 的 Java 客户端请求必须至少定义以下控制器通信组件:

  • 如果安装了 Business Central,则为 rest-all 用户的凭证,如果您安装了无头进程 Automation Manager 控制器,则由 kie-server 用户分开。
  • 为 REST 或 WebSocket 协议处理自动化管理器控制器位置:

    • REST URL 示例: http://localhost:8080/business-central/rest/controller
    • WebSocket URL 示例: ws://localhost:8080/headless-controller/websocket/controller
  • API 请求和响应的 Marshalling 格式(JSON 或 JAXB)
  • KieServerControllerClient 对象,用作使用 Java 客户端 API 启动服务器通信的入口点
  • KieServerControllerClientFactory 定义 REST 或 WebSocket 协议和用户访问
  • Process Automation Manager 控制器客户端服务或使用的服务,如 listServerTemplatesgetServerTemplategetServerInstances

以下是带有以下组件的 REST 和 WebSocket 客户端配置示例:

使用 REST 的客户端配置示例

import org.kie.server.api.marshalling.MarshallingFormat;
import org.kie.server.controller.api.model.spec.ServerTemplateList;
import org.kie.server.controller.client.KieServerControllerClient;
import org.kie.server.controller.client.KieServerControllerClientFactory;

public class ListServerTemplatesExample {

    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 final MarshallingFormat FORMAT = MarshallingFormat.JSON;

    public static void main(String[] args) {
        KieServerControllerClient client = KieServerControllerClientFactory.newRestClient(URL,
                                                                                          USER,
                                                                                          PASSWORD);

        final ServerTemplateList serverTemplateList = client.listServerTemplates();
        System.out.println(String.format("Found %s server template(s) at controller url: %s",
                                         serverTemplateList.getServerTemplates().length,
                                         URL));
    }
}

使用 WebSocket 的客户端配置示例

import org.kie.server.api.marshalling.MarshallingFormat;
import org.kie.server.controller.api.model.spec.ServerTemplateList;
import org.kie.server.controller.client.KieServerControllerClient;
import org.kie.server.controller.client.KieServerControllerClientFactory;

public class ListServerTemplatesExample {

    private static final String URL = "ws://localhost:8080/my-controller/websocket/controller";
    private static final String USER = "baAdmin";
    private static final String PASSWORD = "password@1";

    private static final MarshallingFormat FORMAT = MarshallingFormat.JSON;

    public static void main(String[] args) {
        KieServerControllerClient client = KieServerControllerClientFactory.newWebSocketClient(URL,
                                                                                               USER,
                                                                                               PASSWORD);

        final ServerTemplateList serverTemplateList = client.listServerTemplates();
        System.out.println(String.format("Found %s server template(s) at controller url: %s",
                                         serverTemplateList.getServerTemplates().length,
                                         URL));
    }
}

26.1. 使用 Process Automation Manager 控制器 Java 客户端 API 发送请求

Process Automation Manager 控制器 Java 客户端 API 可让您使用来自 Java 客户端应用程序的 REST 或 WebSocket 协议连接到 Process Automation Manager 控制器。您可以使用 Process Automation Manager 控制器 Java 客户端 API 作为 Process Automation Manager 控制器 REST API 的替代选择,以与 KIE Server 模板(配置)、KIE 服务器实例(远程服务器)以及 Red Hat Process Automation Manager 中的关联的 KIE 容器(部署单元)进行交互,而无需使用 Business Central 用户界面。

先决条件

  • KIE 服务器已安装并运行。
  • Process Automation Manager 控制器或无头 Process Automation Manager 控制器已安装并运行。
  • 如果您安装了 Business Central,或 kie-server 用户角色可以访问与 Business Central 单独安装的无头 Process Automation Manager 控制器,则您具有对 Process Automation Manager 控制器的 rest-all 用户角色访问。
  • 您有一个带有 Red Hat Process Automation Manager 资源的 Java 项目。

流程

  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 对象和要执行的客户端方法,如 createServerTemplatecreateContainerRestKieServerControllerClient 实施中创建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 配置。

26.2. 支持的流程自动化管理器控制器 Java 客户端

以下是 Red Hat Process Automation Manager 发行版本的 org.kie.server.controller.client 软件包中的一些 Java 客户端服务。您可以使用这些服务与 Process Automation Manager 控制器中的相关资源交互,类似于 Process Automation Manager 控制器 REST API。

  • KieServerControllerClient :用作与 Process Automation Manager 控制器通信的入口点
  • RestKieServerControllerClient :用于与 KIE 服务器模板和 REST 协议中的 KIE 容器交互的实施(包括在 ~/org/kie/server/controller/client/rest中)
  • WebSocketKieServerControllerClient :用于与 WebSocket 协议中的 KIE 服务器模板和 KIE 容器交互的实施(在 ~/org/kie/server/controller/client/websocket中)

有关可用 Process Automation Manager 控制器 Java 客户端的完整列表,请从红帽客户门户网站下载 Red Hat Process Automation Manager 7.11.0 源分发,并进入 ~/rhpam-7.11.0-sources/src/droolsjbpm-integration-$VERSION/kie-server-parent/kie-server-controller/kie-server-controller-client/src/main/java/org/kie/server/controller/clienthttps://access.redhat.com/jbossnetwork/restricted/listSoftware.html

26.3. 使用 Process Automation Manager 控制器 Java 客户端 API 的请求示例

以下是与 Process Automation Manager 控制器基本交互的 Process Automation Manager 控制器 Java 客户端 API 请求示例。有关可用 Process Automation Manager 控制器 Java 客户端的完整列表,请从红帽客户门户网站下载 Red Hat Process Automation Manager 7.11.0 源分发,并进入 ~/rhpam-7.11.0-sources/src/droolsjbpm-integration-$VERSION/kie-server-parent/kie-server-controller/kie-server-controller-client/src/main/java/org/kie/server/controller/clienthttps://access.redhat.com/jbossnetwork/restricted/listSoftware.html

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

您可以使用 REST 或 WebSocket Process Automation Manager 控制器客户端中的 ServerTemplateContainerSpec 服务来创建、取消和更新 KIE Server 模板和 KIE 容器,以及启动和停止 KIE 容器,如下例所示。

创建并与 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;
    }
}

列出 KIE 服务器模板并指定连接超时(REST)

当您对 Process Automation Manager 控制器 Java 客户端 API 请求使用 REST 协议时,您可以提供自己的 javax.ws.rs.core.Configuration 规格来修改底层 REST 客户端 API,如连接超时。

返回服务器模板的 REST 请求示例并指定连接超时

import java.util.concurrent.TimeUnit;
import javax.ws.rs.core.Configuration;
import org.jboss.resteasy.client.jaxrs.ResteasyClientBuilder;

import org.kie.server.api.marshalling.MarshallingFormat;
import org.kie.server.controller.api.model.spec.ServerTemplateList;
import org.kie.server.controller.client.KieServerControllerClient;
import org.kie.server.controller.client.KieServerControllerClientFactory;

public class RESTTimeoutExample {

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

  public static void main(String[] args) {

      // Specify connection timeout
      final Configuration configuration =
              new ResteasyClientBuilder()
                      .establishConnectionTimeout(10,
                                                    TimeUnit.SECONDS)
                      .socketTimeout(60,
                                       TimeUnit.SECONDS)
                        .getConfiguration();
        KieServerControllerClient client = KieServerControllerClientFactory.newRestClient(URL,
                                                                                          USER,
                                                                                          PASSWORD,
                                                                                          MarshallingFormat.JSON,
                                                                                          configuration);

        // Retrieve list of server templates
        final ServerTemplateList serverTemplateList = client.listServerTemplates();
        System.out.println(String.format("Found %s server template(s) at controller url: %s",
                                         serverTemplateList.getServerTemplates().length,
                                         URL));
    }
}

列出 KIE 服务器模板并指定事件通知(WebSocket)

当您为 Process Automation Manager 控制器 Java 客户端 API 请求使用 WebSocket 协议时,您可以根据客户端 API 连接到的特定 Process Automation Manager 控制器中启用事件通知。例如,当 KIE Server 模板或实例连接到或更新 Process Automation Manager 控制器时,您可以收到通知。

返回服务器模板的 WebSocket 请求示例并指定事件通知

import org.kie.server.api.marshalling.MarshallingFormat;
import org.kie.server.controller.api.model.events.*;
import org.kie.server.controller.api.model.spec.ServerTemplateList;
import org.kie.server.controller.client.KieServerControllerClient;
import org.kie.server.controller.client.KieServerControllerClientFactory;
import org.kie.server.controller.client.event.EventHandler;

public class WebSocketEventsExample {

    private static final String URL = "ws://localhost:8080/my-controller/websocket/controller";
    private static final String USER = "baAdmin";
    private static final String PASSWORD = "password@1";

    public static void main(String[] args) {
        KieServerControllerClient client = KieServerControllerClientFactory.newWebSocketClient(URL,
                                                                                               USER,
                                                                                               PASSWORD,
                                                                                               MarshallingFormat.JSON,
                                                                                               new TestEventHandler());

        // Retrieve list of server templates
        final ServerTemplateList serverTemplateList = client.listServerTemplates();
        System.out.println(String.format("Found %s server template(s) at controller url: %s",
                                         serverTemplateList.getServerTemplates().length,
                                         URL));
        try {
            Thread.sleep(60 * 1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // Set up event notifications
    static class TestEventHandler implements EventHandler {

        @Override
        public void onServerInstanceConnected(ServerInstanceConnected serverInstanceConnected) {
            System.out.println("serverInstanceConnected = " + serverInstanceConnected);
        }

        @Override
        public void onServerInstanceDeleted(ServerInstanceDeleted serverInstanceDeleted) {
            System.out.println("serverInstanceDeleted = " + serverInstanceDeleted);
        }

        @Override
        public void onServerInstanceDisconnected(ServerInstanceDisconnected serverInstanceDisconnected) {
            System.out.println("serverInstanceDisconnected = " + serverInstanceDisconnected);
        }

        @Override
        public void onServerTemplateDeleted(ServerTemplateDeleted serverTemplateDeleted) {
            System.out.println("serverTemplateDeleted = " + serverTemplateDeleted);
        }

        @Override
        public void onServerTemplateUpdated(ServerTemplateUpdated serverTemplateUpdated) {
            System.out.println("serverTemplateUpdated = " + serverTemplateUpdated);
        }

        @Override
        public void onServerInstanceUpdated(ServerInstanceUpdated serverInstanceUpdated) {
            System.out.println("serverInstanceUpdated = " + serverInstanceUpdated);
        }

        @Override
        public void onContainerSpecUpdated(ContainerSpecUpdated containerSpecUpdated) {
            System.out.println("onContainerSpecUpdated = " + containerSpecUpdated);
        }
    }
}

第 27 章 Business Central 进程的 FDO 流程流畅 API

Red Hat Process Automation Manager 提供了一个可组合的 API,可让您使用工厂创建业务流程。您还可以手动验证您使用流程流畅的 API 创建的进程。过程流畅的 API 在 org.kie.api.fluent 软件包中定义。

因此,您可以使用流程流畅的 API 在几行代码中创建业务进程,而不必使用 slirp2 XML 标准。

27.1. 带有 fluent 进程流畅 API 的请求示例

以下示例包括与流程基本交互的 fluent 进程流畅 API 请求。如需更多示例,请从红帽客户门户网站下载 Red Hat Process Automation Manager 7.11.0 Source Distribution,并导航到 ~/rhpam-7.11.0-sources/src/droolsjbpm-knowledge-$VERSION/kie-api/src/main/java/org/kie/api/fluenthttps://access.redhat.com/jbossnetwork/restricted/listSoftware.html

创建与 Business Central 业务流程交互

以下示例显示了带有脚本任务、异常处理程序和变量的基本进程:

创建并与 Business Central 批准过程交互的请求示例

Process process =
                // Create process builder
                factory.processBuilder(processId)
                       // package and name
                       .packageName("org.jbpm")
                       .name("My process")
                       // start node
                       .startNode(1).name("Start").done()
                       // Add variable of type string
                       .variable(var("pepe", String.class))
                       // Add exception handler
                       .exceptionHandler(IllegalArgumentException.class, Dialect.JAVA, "System.out.println(\"Exception\");")
                       // script node in Java language that prints "action"
                       .actionNode(2).name("Action")
                       .action(Dialect.JAVA,
                               "System.out.println(\"Action\");").done()
                       // end node
                       .endNode(3).name("End").done()
                       // connections
                       .connection(1,
                                   2)
                       .connection(2,
                                   3)
                       .build();

在本例中,获取 ProcessBuilderFactory 引用,然后使用 processBuilder (String processId) 方法创建一个 ProcessBuilder 实例,它与给定进程 Id 关联。ProcessBuilder 实例允许您使用 fluent API 构建创建进程的定义。

迁移过程由三个组件组成:

  • header : header 部分包含全局元素,如进程的名称、导入和变量。

    在上例中,标头包含进程的名称和软件包名称。

  • Nodes: nodes 部分包含属于进程的所有不同节点。

    在上例中,通过调用 startNode(), actionNode(), 和 endNode() 方法,将节点添加到进程中。这些方法会返回特定的 NodeBuilder,允许您设置该节点的属性。在代码完成配置该节点后,maked () 方法会返回 NodeContainerBuilder 以添加更多节点。

  • 连接 :连接部分链接节点以创建流图。

    在上例中,添加所有节点后,必须通过在它们之间创建连接来连接这些节点。您可以调用 connection () 方法,该方法链接节点。

最后,您可以调用 build () 方法并获取生成的进程定义。build () 方法还验证进程定义,并在进程定义无效时抛出异常。

27.2. 执行批准过程的请求示例

创建有效进程定义实例后,您可以使用公共和内部 KIE API 的组合来执行它。要执行进程,请创建一个资源,用于创建 KieBase。通过使用 KieBase,您可以创建一个 KieSession 来执行进程。

以下示例使用 ProcessBuilderFactory.toBytes 进程来创建 ByteArrayResource 资源。

执行进程的请求示例

// Build resource from Process
KieResources resources = ServiceRegistry.getInstance().get(KieResources.class);
Resource res = resources
                        .newByteArrayResource(factory.toBytes(process))
                        ​.setSourcePath("/tmp/processFactory.bpmn2"); // source path or target path must be set to be added into kbase
​// Build kie base from this resource using KIE API
​KieServices ks = KieServices.Factory.get();
​KieRepository kr = ks.getRepository();
​KieFileSystem kfs = ks.newKieFileSystem();
​kfs.write(res);
​KieBuilder kb = ks.newKieBuilder(kfs);
​kb.buildAll(); // kieModule is automatically deployed to KieRepository if successfully built.
​KieContainer kContainer = ks.newKieContainer(kr.getDefaultReleaseId());
​KieBase kbase = kContainer.getKieBase();
​// Create kie session using KieBase
​KieSessionConfiguration conf = ...;
​Environment env = ....;
​KieSession ksession = kbase.newKieSession(conf,env);
​// execute process using same process Id that is used to obtain ProcessBuilder instance
​ksession.startProcess(processId)

第 28 章 知识存储用于 Business Central 空格和项目的 REST API

Red Hat Process Automation Manager 提供了一个 知识库存储 REST API,您可以使用它与 Red Hat Process Automation Manager 中的项目和空格交互,而无需使用 Business Central 用户界面。知识库存储是 Red Hat Process Automation Manager 中资产的工件存储库。通过这个 API 支持,您可以促进并自动维护 Business Central 项目和空格。

使用 知识库 REST API,您可以执行以下操作:

  • 检索有关所有项目和空格的信息
  • 创建、更新或删除项目和空格
  • 构建、部署和测试项目
  • 检索有关之前关于存储 REST API 请求或作业的信息

知识存储 REST API 请求需要以下组件:

身份验证

知识库存储 REST API 需要 HTTP 基本身份验证或基于令牌的身份验证用于用户角色 rest-all。要查看 Red Hat Process Automation Manager 发行版配置的用户角色,请导航到 ~/$SERVER_HOME/standalone/configuration/application-roles.properties~/application-users.properties

要添加具有 rest-all 角色的用户,请导航到 ~/$SERVER_HOME/bin 并运行以下命令:

$ ./add-user.sh -a --user <USERNAME> --password <PASSWORD> --role rest-all

有关用户角色和 Red Hat Process Automation Manager 安装选项的更多信息,请参阅 规划 Red Hat Process Automation Manager 安装

HTTP 标头

知识库存储 REST API 需要以下 HTTP 标头用于 API 请求:

  • 接受 :您请求的客户端接受的数据格式:

    • application/json (JSON)
  • Content-TypePOSTPUT API 请求数据的数据格式:

    • application/json (JSON)
HTTP 方法

知识库存储 REST API 支持以下 HTTP 方法进行 API 请求:

  • GET :从指定的资源端点检索指定的信息
  • POST :创建或更新资源
  • PUT :更新资源
  • DELETE :删除资源
基本 URL

知识库 REST API 请求的基本 URL 是 http://SERVER:PORT/business-central/rest/,如 http://localhost:8080/business-central/rest/。

注意

知识库存储的 REST API 基本 URL 以及内置于 Business Central 的 Process Automation Manager 控制器的 REST API 基本 URL 相同,因为它们都被视为 Business Central REST 服务的一部分。

Endpoints

知识存储 REST API 端点(如指定空间的 /spaces/{spaceName} )是您附加到知识库 REST API 基本 URL 的 URI,以访问 Red Hat Process Automation Manager 中的相应资源或资源类型。

/spaces/{spaceName} 端点的请求 URL 示例

http://localhost:8080/business-central/rest/spaces/MySpace

请求数据

知识库存储 REST API 中的 HTTP POST 请求可能需要带有数据的 JSON 请求正文来附带请求。

POST 请求 URL 和 JSON 请求正文数据示例

http://localhost:8080/business-central/rest/spaces/MySpace/projects

{
  "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."
}

28.1. 使用 REST 客户端或 curl 工具通过 知识库 REST API 发送请求

知识库存储 REST API 可让您在不使用 Business Central 用户界面的情况下与 Red Hat Process Automation Manager 中的项目和空格交互。您可以使用任何 REST 客户端或 curl 工具发送知识库 REST API 请求。

先决条件

  • Business Central 已安装并运行。
  • 您有对 Business Central 的 rest-all 用户角色访问权限。

流程

  1. 识别您要发送请求的相关 API 端点,如 [GET] /spaces 以检索 Business Central 中的空格。
  2. 在 REST 客户端或 curl 工具中,为对 /spaceGET 请求输入以下组件。根据您的用例调整任何请求详情。

    对于 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."
    }

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

28.2. 支持的知识库存储 REST API 端点

知识库存储 REST API 提供了在 Red Hat Process Automation Manager 中管理空格和项目的端点,以及检索之前关于 REST API 请求的信息,或 作业

28.2.1. 空格

知识库存储 REST API 支持以下端点来管理 Business Central 中的空格。知识库存储 REST API 基本 URL 是 http://SERVER:PORT/business-central/rest/。所有请求都需要 HTTP 基本身份验证或基于令牌的验证用于 rest-all 用户角色。

[GET] /spaces

返回 Business Central 中的所有空格。

服务器响应示例(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"
  }
]

[GET] /spaces/{spaceName}

返回有关指定空间的信息。

表 28.1. 请求参数

名称描述类型要求

spaceName

要检索的空间的名称

字符串

必填

服务器响应示例(JSON)

{
  "name": "MySpace",
  "description": null,
  "projects": [
    {
      "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"
        }
      ]
    },
    {
      "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": "Evaluation_Process",
      "spaceName": "MySpace",
      "groupId": "evaluation",
      "version": "1.0.0-SNAPSHOT",
      "description": "Getting started Business Process for evaluating employees",
      "publicURIs": [
        {
          "protocol": "git",
          "uri": "git://localhost:9418/MySpace/example-Evaluation_Process"
        },
        {
          "protocol": "ssh",
          "uri": "ssh://localhost:8001/MySpace/example-Evaluation_Process"
        }
      ]
    },
    {
      "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"
        },
        {
          "protocol": "ssh",
          "uri": "ssh://localhost:8001/MySpace/example-IT_Orders"
        }
      ]
    }
  ],
  "owner": "admin",
  "defaultGroupId": "com.myspace"
}

[POST] /spaces

在 Business Central 中创建空间。

表 28.2. 请求参数

名称描述类型要求

正文(body)

名称描述所有者defaultGroupId 以及新空间的任何其他组件

请求正文

必填

请求正文示例(JSON)

{
  "name": "NewSpace",
  "description": "My new space.",
  "owner": "admin",
  "defaultGroupId": "com.newspace"
}

服务器响应示例(JSON)

{
  "jobId": "1541016978154-3",
  "status": "APPROVED",
  "spaceName": "NewSpace",
  "owner": "admin",
  "defaultGroupId": "com.newspace",
  "description": "My new space."
}

[PUT] /spaces

更新 Business Central 中空间 的描述所有者和 defaultGroupId

请求正文示例(JSON)

{
  "name": "MySpace",
  "description": "This is updated description",
  "owner": "admin",
  "defaultGroupId": "com.updatedGroupId"
}

服务器响应示例(JSON)

{
  "jobId": "1592214574454-1",
  "status": "APPROVED",
  "spaceName": "MySpace",
  "owner": "admin",
  "defaultGroupId": "com.updatedGroupId",
  "description": "This is updated description"
}

[DELETE] /spaces/{spaceName}

从 Business Central 中删除指定空间。

表 28.3. 请求参数

名称描述类型要求

spaceName

要删除的空间的名称

字符串

必填

服务器响应示例(JSON)

{
  "jobId": "1541127032997-8",
  "status": "APPROVED",
  "spaceName": "MySpace",
  "owner": "admin",
  "description": "My deleted space.",
  "repositories": null
}

28.2.2. 项目

知识库存储 REST API 支持以下端点,以便在 Business Central 中管理、构建和部署项目。知识库存储 REST API 基本 URL 是 http://SERVER:PORT/business-central/rest/。所有请求都需要 HTTP 基本身份验证或基于令牌的验证用于 rest-all 用户角色。

[GET] /spaces/{spaceName}/projects

返回指定空间中的项目。

表 28.4. 请求参数

名称描述类型要求

spaceName

检索项目的空间名称

字符串

必填

服务器响应示例(JSON)

[
  {
    "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"
      }
    ]
  },
  {
    "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": "Evaluation_Process",
    "spaceName": "MySpace",
    "groupId": "evaluation",
    "version": "1.0.0-SNAPSHOT",
    "description": "Getting started Business Process for evaluating employees",
    "publicURIs": [
      {
        "protocol": "git",
        "uri": "git://localhost:9418/MySpace/example-Evaluation_Process"
      },
      {
        "protocol": "ssh",
        "uri": "ssh://localhost:8001/MySpace/example-Evaluation_Process"
      }
    ]
  },
  {
    "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"
      },
      {
        "protocol": "ssh",
        "uri": "ssh://localhost:8001/MySpace/example-IT_Orders"
      }
    ]
  }
]

[GET] /spaces/{spaceName}/projects/{projectName}

返回指定空间中指定项目的信息。

表 28.5. 请求参数

名称描述类型要求

spaceName

项目所在的空间名称

字符串

必填

projectName

要检索的项目的名称

字符串

必填

服务器响应示例(JSON)

{
  "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"
    }
  ]
}

[POST] /spaces/{spaceName}/projects

在指定空间中创建项目。

表 28.6. 请求参数

名称描述类型要求

spaceName

创建新项目的空间名称

字符串

必填

正文(body)

新项目 的其他组件、groupId版本描述 和任何其他组件

请求正文

必填

请求正文示例(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."
}

服务器响应示例(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."
}

[DELETE] /spaces/{spaceName}/projects/{projectName}

从指定空间中删除指定项目。

表 28.7. 请求参数

名称描述类型要求

spaceName

项目所在的空间名称

字符串

必填

projectName

要删除的项目的名称

字符串

必填

服务器响应示例(JSON)

{
  "jobId": "1541128617727-10",
  "status": "APPROVED",
  "projectName": "Employee_Rostering",
  "spaceName": "MySpace"
}

[POST] /spaces/{spaceName}/git/clone

将项目从指定的 Git 地址克隆到指定空间中。

表 28.8. 请求参数

名称描述类型要求

spaceName

克隆项目的空间名称

字符串

必填

正文(body)

要克隆的项目的名称描述 和 Git 存储库 userNamepasswordgitURL

请求正文

必填

请求正文示例(JSON)

{
  "name": "Employee_Rostering",
  "description": "Employee rostering problem optimisation using Planner. Assigns employees to shifts based on their skill.",
  "userName": "baAdmin",
  "password": "password@1",
  "gitURL": "git://localhost:9418/MySpace/example-Employee_Rostering"
}

服务器响应示例(JSON)

{
  "jobId": "1541129488547-13",
  "status": "APPROVED",
  "cloneProjectRequest": {
    "name": "Employee_Rostering",
    "description": "Employee rostering problem optimisation using Planner. Assigns employees to shifts based on their skill.",
    "userName": "baAdmin",
    "password": "password@1",
    "gitURL": "git://localhost:9418/MySpace/example-Employee_Rostering"
  },
  "spaceName": "MySpace2"
}

[POST] /spaces/{spaceName}/projects/{projectName}/maven/compile

在指定空间中编译指定项目(等同于 mvn 编译)。

表 28.9. 请求参数

名称描述类型要求

spaceName

项目所在的空间名称

字符串

必填

projectName

要编译的项目的名称

字符串

必填

服务器响应示例(JSON)

{
  "jobId": "1541128617727-10",
  "status": "APPROVED",
  "projectName": "Employee_Rostering",
  "spaceName": "MySpace"
}

[POST] /spaces/{spaceName}/projects/{projectName}/maven/test

在指定空间中测试指定项目(等同于 mvn 测试)。

表 28.10. 请求参数

名称描述类型要求

spaceName

项目所在的空间名称

字符串

必填

projectName

要测试的项目的名称

字符串

必填

服务器响应示例(JSON)

{
  "jobId": "1541132591595-19",
  "status": "APPROVED",
  "projectName": "Employee_Rostering",
  "spaceName": "MySpace"
}

[POST] /spaces/{spaceName}/projects/{projectName}/maven/install

在指定空间中安装指定项目(等同于 mvn install)。

表 28.11. 请求参数

名称描述类型要求

spaceName

项目所在的空间名称

字符串

必填

projectName

要安装的项目名称

字符串

必填

服务器响应示例(JSON)

{
  "jobId": "1541132668987-20",
  "status": "APPROVED",
  "projectName": "Employee_Rostering",
  "spaceName": "MySpace"
}

[POST] /spaces/{spaceName}/projects/{projectName}/maven/deploy

以指定空间(等同于 mvn deploy)部署指定项目。

表 28.12. 请求参数

名称描述类型要求

spaceName

项目所在的空间名称

字符串

必填

projectName

要部署的项目的名称

字符串

必填

服务器响应示例(JSON)

{
  "jobId": "1541132816435-21",
  "status": "APPROVED",
  "projectName": "Employee_Rostering",
  "spaceName": "MySpace"
}

28.2.3. 作业(API 请求)

除返回的请求详情外,知识库存储 REST API 中的所有 POSTDELETE 请求都会返回与每个请求关联的作业 ID。您可以使用作业 ID 查看请求状态或删除发送的请求。

知识存储 REST API 请求或作业可以具有以下状态:

表 28.13. 作业状态(API 请求状态)

状态描述

已接受

请求已被接受,正在处理。

BAD_REQUEST

请求包含不正确的内容,且不接受。

RESOURCE_NOT_EXIST

请求的资源(路径)不存在。

DUPLICATE_RESOURCE

资源已存在。

SERVER_ERROR

KIE 服务器中出现错误。

SUCCESS

请求成功完成。

FAIL

请求失败。

已批准

请求已批准。

已拒绝

请求被拒绝。

停用

因为以下原因之一,无法找到请求的作业 ID:

  • 请求被明确删除。
  • 请求已完成,已从状态缓存中删除。缓存达到其最大容量后,会从状态缓存中删除请求。
  • 请求永不存在。

知识库存储 REST API 支持以下端点来检索或删除发送的 API 请求。知识库存储 REST API 基本 URL 是 http://SERVER:PORT/business-central/rest/。所有请求都需要 HTTP 基本身份验证或基于令牌的验证用于 rest-all 用户角色。

[GET] /jobs/{jobId}

返回指定作业的状态(之前发送的 API 请求)。

表 28.14. 请求参数

名称描述类型要求

jobId

要检索的作业 ID (例如:1541010216919-1

字符串

必填

服务器响应示例(JSON)

{
  "status": "SUCCESS",
  "jobId": "1541010216919-1",
  "result": null,
  "lastModified": 1541010218352,
  "detailedResult": [
    "level:INFO, path:null, text:Build of module 'Mortgage_Process' (requested by system) completed.\n Build: SUCCESSFUL"
  ]
}

[DELETE] /jobs/{jobId}

删除指定的作业(之前发送的 API 请求)。如果还没有处理作业,此请求会从作业队列中删除作业。此请求不会取消或停止持续的作业。

表 28.15. 请求参数

名称描述类型要求

jobId

要删除的作业的 ID (例如:1541010216919-1

字符串

必填

服务器响应示例(JSON)

{
  "status": "GONE",
  "jobId": "1541010216919-1",
  "result": null,
  "lastModified": 1541132054916,
  "detailedResult": [
    "level:INFO, path:null, text:Build of module 'Mortgage_Process' (requested by system) completed.\n Build: SUCCESSFUL"
  ]
}

28.2.4. 分支

知识库存储 REST API 支持以下端点来管理 Business Central 中的分支。知识库存储 REST API 基本 URL 是 http://SERVER:PORT/business-central/rest/。所有请求都需要 HTTP 基本身份验证或基于令牌的验证用于 rest-all 用户角色。

[GET] /spaces/{spaceName}/projects/{projectName}/branches

返回指定项目和空间中的所有分支。

表 28.16. 请求参数

名称描述类型要求

spaceName

检索项目的空间名称

字符串

必填

projectName

您要检索分支的项目的名称

字符串

必填

服务器响应示例(JSON)

[
  {
    "name":"master"
  }
]

[POST] /spaces/{spaceName}/projects/{projectName}/branches

在指定的项目和空间中添加指定的分支。

表 28.17. 请求参数

名称描述类型要求

spaceName

项目所在的空间名称

字符串

必填

projectName

需要在其中创建新分支的项目的名称

字符串

必填

正文(body)

项目的 newBranchNamebaseBranchName

请求正文

必填

请求正文示例(JSON)

{
   "newBranchName":  "branch01",
   "baseBranchName": "master"
}

服务器响应示例(JSON)

{
    "jobId":          "1576175811141-3",
    "status":         "APPROVED",
    "spaceName":      "Space123",
    "projectName":    "ProjABC",
    "newBranchName":  "b1",
    "baseBranchName": "master",
    "userIdentifier": "bc"
}

[DELETE] /spaces/{spaceName}/projects/{projectName}/branches/{branchName}

删除指定项目和空间中的指定分支。

表 28.18. 请求参数

名称描述类型要求

spaceName

项目所在的空间名称

字符串

必填

projectName

分支所在的项目名称

字符串

必填

branchName

要删除的分支名称

字符串

必填

服务器响应示例(JSON)

{
    "jobId":          "1576175811421-5",
    "status":         "APPROVED",
    "spaceName":      "Space123",
    "projectName":    "ProjABC",
    "branchName":     "b1",
    "userIdentifier": "bc"
}

[POST] /spaces/{spaceName}/projects/{projectName}/branches/{branchName}/maven/compile

在指定项目和空间中编译指定的分支。如果没有指定 branchName,则请求将应用到 master 分支。

表 28.19. 请求参数

名称描述类型要求

spaceName

项目所在的空间名称

字符串

必填

projectName

分支所在的项目名称

字符串

必填

branchName

要编译的分支的名称

字符串

必填

服务器响应示例(JSON)

{
    "jobId":       "1576175811233-4",
    "status":      "APPROVED",
    "spaceName":   "Space123",
    "projectName": "ProjABC",
    "branchName":  "b1",
}

[POST] /spaces/{spaceName}/projects/{projectName}/branches/{branchName}/maven/install

在指定的项目和空格中安装指定的分支。如果没有指定 branchName,则请求将应用到 master 分支。

表 28.20. 请求参数

名称描述类型要求

spaceName

项目所在的空间名称

字符串

必填

projectName

分支所在的项目名称

字符串

必填

branchName

要安装的分支名称

字符串

必填

服务器响应示例(JSON)

{
    "jobId":       "1576175811233-4",
    "status":      "APPROVED",
    "spaceName":   "Space123",
    "projectName": "ProjABC",
    "branchName":  "b1",
}

[POST] /spaces/{spaceName}/projects/{projectName}/branches/{branchName}/maven/test

在指定项目和空间中测试指定的分支。如果没有指定 branchName,则请求将应用到 master 分支。

表 28.21. 请求参数

名称描述类型要求

spaceName

项目所在的空间名称

字符串

必填

projectName

分支所在的项目名称

字符串

必填

branchName

要测试的分支的名称

字符串

必填

服务器响应示例(JSON)

{
    "jobId":       "1576175811233-4",
    "status":      "APPROVED",
    "spaceName":   "Space123",
    "projectName": "ProjABC",
    "branchName":  "b1",
}

[POST] /spaces/{spaceName}/projects/{projectName}/branches/{branchName}/maven/deploy

在指定的项目和空间中部署指定的分支。如果没有指定 branchName,则请求将应用到 master 分支。

表 28.22. 请求参数

名称描述类型要求

spaceName

项目所在的空间名称

字符串

必填

projectName

分支所在的项目名称

字符串

必填

branchName

要部署的分支的名称

字符串

必填

服务器响应示例(JSON)

{
    "jobId":       "1576175811233-4",
    "status":      "APPROVED",
    "spaceName":   "Space123",
    "projectName": "ProjABC",
    "branchName":  "b1",
}

第 29 章 Business Central 组、角色和用户的安全管理 REST API

Red Hat Process Automation Manager 提供了一个安全管理 REST API,可用于在不使用 Business Central 用户界面的情况下管理 Red Hat Process Automation Manager 中的组、角色和用户。通过这个 API 支持,您可以促进和自动管理 Business Central 组、角色、用户和授予权限。

使用 Security Management REST API,您可以执行以下操作:

  • 检索所有组、角色、用户及其授予权限的信息
  • 创建、更新或删除组和用户
  • 更新组、角色和用户的授予权限
  • 检索分配给用户的组和角色的信息

安全管理 REST API 请求需要以下组件:

身份验证

安全管理 REST API 需要 HTTP 基本身份验证或基于令牌的身份验证 管理员。要查看 Red Hat Process Automation Manager 发行版配置的用户角色,请导航到 ~/$SERVER_HOME/standalone/configuration/application-roles.properties~/application-users.properties

要添加具有 admin 角色的用户,请导航到 ~/$SERVER_HOME/bin 并运行以下命令:

$ ./add-user.sh -a --user <USERNAME> --password <PASSWORD> --role admin

有关用户角色和 Red Hat Process Automation Manager 安装选项的更多信息,请参阅 规划 Red Hat Process Automation Manager 安装

HTTP 标头

Security Management REST API 需要以下 HTTP 标头用于 API 请求:

  • 接受 :您请求的客户端接受的数据格式:

    • application/json (JSON)
  • Content-TypePOSTPUT API 请求数据的数据格式:

    • application/json (JSON)
HTTP 方法

Security Management REST API 支持以下 HTTP 方法进行 API 请求:

  • GET :从指定的资源端点检索指定的信息
  • POST :创建或更新资源
  • PUT :更新资源
  • DELETE :删除资源
基本 URL

安全管理 REST API 请求的基本 URL 是 http://SERVER:PORT/business-central/rest/,如 http://localhost:8080/business-central/rest/。

注意

内置在 Business Central 中的安全管理、知识存储和流程自动化管理器控制器的 REST API 基本 URL 相同,因为所有都被视为 Business Central REST 服务的一部分。

Endpoints

安全管理 REST API 端点(如指定用户的 /users/{userName} )是您附加到安全管理 REST API 基本 URL 的 URI,以访问 Red Hat Process Automation Manager 中的相应资源或资源类型。

/users/{userName} 端点的请求 URL 示例

http://localhost:8080/business-central/rest/users/newUser

请求数据

安全管理 REST API 中的 HTTP POST 请求可能需要带有数据的 JSON 请求正文来附带请求。

POST 请求 URL 和 JSON 请求正文数据示例

http://localhost:8080/business-central/rest/users/newUser/groups

[
  "newGroup"
]

29.1. 使用 REST 客户端或 curl 工具通过安全管理 REST API 发送请求

通过 Security Management REST API,您可以在不使用 Business Central 用户界面的情况下管理 Red Hat Process Automation Manager 中的组、角色和用户。您可以使用任何 REST 客户端或 curl 工具发送安全管理 REST API 请求。

先决条件

  • Business Central 已安装并运行。
  • 您有对 Business Central 的 admin 用户角色访问权限。

流程

  1. 识别您要发送请求的相关 API 端点,如 [GET] /groups 以检索 Business Central 中的组。
  2. 在 REST 客户端或 curl 工具中,为对 /groupsGET 请求输入以下组件。根据您的用例调整任何请求详情。

    对于 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"
    }

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

29.2. 支持的安全管理 REST API 端点

Security Management REST API 提供了在 Business Central 中管理组、角色、用户和权限的端点。它包括使用 Business Central 中的 Security Management 页面执行的安全性和权限管理任务。

29.2.1. 组

安全管理 REST API 支持以下端点来管理 Business Central 中的组。安全管理 REST API 基本 URL 是 http://SERVER:PORT/business-central/rest/。所有请求都需要对 admin 用户角色进行 HTTP 基本身份验证或基于令牌的身份验证。

[GET] /groups

返回 Business Central 中的所有组。

服务器响应示例(JSON)

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

[POST] /groups

在 Business Central 中创建组。组必须至少分配一个用户。

表 29.1. 请求参数

名称描述类型要求

正文(body)

分配给新组的组名称和用户

请求正文

必填

请求正文示例(JSON)

{
  "name": "groupName",
  "users": [
    "userNames"
  ]
}

服务器响应示例(JSON)

{
  "status": "OK",
  "message": "Group newGroup is created successfully."
}

[DELETE] /groups/{groupName}

从 Business Central 中删除指定的组。

表 29.2. 请求参数

名称描述类型要求

groupName

要删除的组名称

字符串

必填

服务器响应示例(JSON)

{
  "status": "OK",
  "message": "Group newGroup is deleted successfully."
}

29.2.2. 角色

安全管理 REST API 支持以下端点来管理 Business Central 中的角色。安全管理 REST API 基本 URL 是 http://SERVER:PORT/business-central/rest/。所有请求都需要对 admin 用户角色进行 HTTP 基本身份验证或基于令牌的身份验证。

[GET] /roles

返回 Business Central 中的所有角色。

服务器响应示例(JSON)

[
  {
    "name": "process-admin"
  },
  {
    "name": "manager"
  },
  {
    "name": "admin"
  }
]

29.2.3. 用户

安全管理 REST API 支持以下端点来管理 Business Central 中的用户。安全管理 REST API 基本 URL 是 http://SERVER:PORT/business-central/rest/。所有请求都需要对 admin 用户角色进行 HTTP 基本身份验证或基于令牌的身份验证。

[GET] /users

返回 Business Central 中的所有用户。

服务器响应示例(JSON)

[
    "newUser",
    "user1",
    "user2",
]

[GET] /users/{userName}/groups

返回分配给指定用户的所有组。

表 29.3. 请求参数

名称描述类型要求

userName

您要检索分配组的用户名称

字符串

必填

服务器响应示例(JSON)

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

[GET] /users/{userName}/roles

返回分配给指定用户的所有角色。

表 29.4. 请求参数

名称描述类型要求

userName

您要检索分配的角色的用户名称

字符串

必填

服务器响应示例(JSON)

[
  {
    "name": "process-admin"
  },
  {
    "name": "manager"
  },
  {
    "name": "admin"
  }
]

[POST] /users

创建具有指定角色和组的指定用户。

请求正文示例(JSON)

{
  "name": "newUser",
  "roles": [
    "admin",
    "developer"
  ],
  "groups": [
    "group1",
    "group2"
  ]
}

服务器响应示例(JSON)

{
  "status": "OK",
  "message": "User newUser is created successfully."
}

[Post] /users/{userName}/changePassword

更改指定用户的密码。

表 29.5. 请求参数

名称描述类型要求

userName

您更改密码的用户名称

字符串

必填

request 命令示例

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

服务器响应示例(JSON)

{
  "status": "OK",
  "message": "Password for newUser has been updated successfully."
}

[DELETE] /users/{userName}

从 Business Central 中删除指定用户。

表 29.6. 请求参数

名称描述类型要求

userName

要删除的用户名称

字符串

必填

服务器响应示例(JSON)

{
  "status": "OK",
  "message": "User newUser is deleted successfully."
}

[POST] /users/{userName}/groups

覆盖分配给具有新组的指定用户的现有组。

表 29.7. 请求参数

名称描述类型要求

userName

您要更新组的用户名称

字符串

必填

请求正文示例(JSON)

[
  "newGroup"
]

服务器响应示例(JSON)

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

[POST] /users/{userName}/roles

覆盖分配给具有新角色的指定用户的现有角色。

表 29.8. 请求参数

名称描述类型要求

userName

您要更新角色的用户名称

字符串

必填

请求正文示例(JSON)

[
  "admin"
]

服务器响应示例(JSON)

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

29.2.4. 权限

Security Management REST API 支持以下端点来管理对 Business Central 中的组、角色和用户授予权限。安全管理 REST API 基本 URL 是 http://SERVER:PORT/business-central/rest/。所有请求都需要对 admin 用户角色进行 HTTP 基本身份验证或基于令牌的身份验证。

[GET] /groups/{groupName}/permissions

返回授予指定组的所有权限。

表 29.9. 请求参数

名称描述类型要求

groupName

您要检索权限的组名称

字符串

必填

服务器响应示例(JSON)

{
	"homePage": "HomePerspective",
	"priority": -10,
	"project": {
		"read": {
			"access": false,
			"exceptions": []
		},

	},
	"spaces": {
		"read": {
			"access": true,
			"exceptions": [
				"MySpace"
			]
		},
	},
	"editor": {
		"read": {
			"access": false,
			"exceptions": [
				"GuidedDecisionTreeEditorPresenter"
			]
		},
		"create": null,
		"update": null,
		"delete": null,
		"build": null
	},
	"pages": {
		"read": {
			"access": true,
			"exceptions": []
		},
		"build": null
	},
	"workbench": {
		"editDataObject": false,
		"plannerAvailable": false,
		"editGlobalPreferences": false,
		"editProfilePreferences": false,
		"accessDataTransfer": false,
		"jarDownload": true,
		"editGuidedDecisionTableColumns": true
	}
}

[GET] /roles/{roleName}/permissions

返回授予指定角色的所有权限。

表 29.10. 请求参数

名称描述类型要求

roleName

您要检索权限的角色名称

字符串

必填

服务器响应示例(JSON)

{
	"homePage": "HomePerspective",
	"priority": -10,
	"project": {
		"read": {
			"access": false,
			"exceptions": []
		},

	},
	"spaces": {
		"read": {
			"access": true,
			"exceptions": [
				"MySpace"
			]
		},
	},
	"editor": {
		"read": {
			"access": false,
			"exceptions": [
				"GuidedDecisionTreeEditorPresenter"
			]
		},
		"create": null,
		"update": null,
		"delete": null,
		"build": null
	},
	"pages": {
		"read": {
			"access": true,
			"exceptions": []
		},
		"build": null
	},
	"workbench": {
		"editDataObject": false,
		"plannerAvailable": false,
		"editGlobalPreferences": false,
		"editProfilePreferences": false,
		"accessDataTransfer": false,
		"jarDownload": true,
		"editGuidedDecisionTableColumns": true
	}
}

[GET] /users/{userName}/permissions

返回授予指定用户的所有权限。

表 29.11. 请求参数

名称描述类型要求

userName

您要检索权限的用户名称

字符串

必填

服务器响应示例(JSON)

{
	"homePage": null,
	"priority": null,
	"project": {
		"read": {
			"access": false,
			"exceptions": []
		},

	},
	"spaces": {
		"read": {
			"access": true,
			"exceptions": [
				"MySpace"
			]
		},
	},
	"editor": {
		"read": {
			"access": false,
			"exceptions": [
				"GuidedDecisionTreeEditorPresenter"
			]
		},
		"create": null,
		"update": null,
		"delete": null,
		"build": null
	},
	"pages": {
		"read": {
			"access": true,
			"exceptions": []
		},
		"build": null
	},
	"workbench": {
		"editDataObject": false,
		"plannerAvailable": false,
		"editGlobalPreferences": false,
		"editProfilePreferences": false,
		"accessDataTransfer": false,
		"jarDownload": true,
		"editGuidedDecisionTableColumns": true
	}
}

[post] /groups/{groupName}/permissions

更新指定组的权限。

表 29.12. 请求参数

名称描述类型要求

groupName

您要更新权限的组名称

字符串

必填

请求正文示例(JSON)

{
  "homepage": "HomePerspective",
  "priority": 10,
  "pages": {
    "create": true,
    "read": false,
    "delete": false,
    "update": false,
    "exceptions": [
      {
        "name": "HomePerspective",
        "permissions": {
          "read": true
        }
      }
    ]
  },
  "project": {
    "create": true,
    "read": true,
    "delete": false,
    "update": false,
    "Build": false
  },
  "spaces": {
    "create": true,
    "read": true,
    "delete": false,
    "update": false
  },
  "editor": {
    "read": true
  },
  "workbench": {
    "editDataObject": true,
    "plannerAvailable": true,
    "editGlobalPreferences": true,
    "editProfilePreferences": true,
    "accessDataTransfer": true,
    "jarDownload": true,
    "editGuidedDecisionTableColumns": true
  }
}

服务器响应示例(JSON)

{
  "status": "OK",
  "message": "Group newGroup permissions are updated successfully."
}

[post] /roles/{roleName}/permissions

更新指定角色的权限。

表 29.13. 请求参数

名称描述类型要求

roleName

您要更新权限的角色名称

字符串

必填

请求正文示例(JSON)

{
	"homepage": "HomePerspective",
	"priority": 10,
	"pages": {
		"create": true,
		"read": false,
		"delete": false,
		"update": false,
		"exceptions": [{
			"name": "HomePerspective",
			"permissions": {
				"read": true
			}
		}]
	},
	"project": {
		"create": true,
		"read": true,
		"delete": false,
		"update": false,
		"Build": false
	},
	"spaces": {
		"create": true,
		"read": true,
		"delete": false,
		"update": false
	},
	"editor": {
		"read": true
	},
	"workbench": {
		"editDataObject": true,
		"plannerAvailable": true,
		"editGlobalPreferences": true,
		"editProfilePreferences": true,
		"accessDataTransfer": true,
		"jarDownload": true,
		"editGuidedDecisionTableColumns": true
	}
}

服务器响应示例(JSON)

{
  "status": "OK",
  "message": "Role newRole permissions are updated successfully."
}

29.2.4.1. Business Central 支持的权限

以下是 Red Hat Process Automation Manager 中可用的权限。管理员使用这些权限来允许在 Business Central 中对组、角色或用户进行特定操作。

优先级

优先级是一个整数,用于定义分配多个角色或组的用户的优先级。新组的默认值为 -100。在 Business Central 中,您可以将整数值设置为优先级,这使用以下规则解析:

表 29.14. 优先级值表

整数值优先级

小于 -5

非常低

-5 到 0

等于 0

NORMAL

0 到 5 之间

HIGH

大于 5

非常高

主页
主页表示用户的默认登录页面。
workbench

工作台由以下定义的权限组成:

{
  "editDataObject": true,
  "plannerAvailable": true,
  "editGlobalPreferences": true,
  "editProfilePreferences": true,
  "accessDataTransfer": true,
  "jarDownload": true,
  "editGuidedDecisionTableColumns": true
}
页面、编辑器、Spaces 和项目

以下是根据资源类型的权限可能的值:

  • PAGES: read,create,update,delete
  • EDITOR: read
  • SPACES: read,create,update,delete
  • PROJECT: read,create,update,delete,build

您可以使用以下代码在 PagesEditorSpacesProjects 权限中添加例外:

{
  "pages": {
    "read": false,
    "exceptions": [
      {
        "resourceName": "ProcessInstances",
        "permissions": {
          "read": false
        }
      },
      {
        "resourceName": "ProcessDefinitions",
        "permissions": {
          "read": false
        }
      }
    ]
  }
}

name 属性是您添加为异常的资源的标识符。使用以下 REST API 端点获取可能标识符列表。REST API 基本 URL 是 http://SERVER:PORT/business-central/rest/

  • [GET] /perspectives: 返回 Business Central 中所有页面的视角名称
  • [GET] /editors :返回 Business Central 中的所有编辑器
  • [GET] /spaces :返回 Business Central 中的所有空格
  • [GET] /spaces/{spaceName}/projects: 返回指定空间的项目

页面的服务器响应示例(JSON)

"pages": {
	"create": true,
	"read": false,
	"exceptions": [
    {
		"name": "HomePerspective",
		"permissions": {
			"read": true
		}
	}
]
}

第 30 章 KIE 会话和任务服务的 EJB API

Red Hat Process Automation Manager 提供了一个 Enterprise 3.0.0 (EJB) API,可用于嵌入式用例从应用程序远程访问 KieSessionTaskService 对象。EJB API 启用 Red Hat Process Automation Manager 和远程客户应用程序中的进程引擎之间的关闭事务集成。

虽然 KIE 服务器不支持 EJB,但您可以使用 EJB 作为进程引擎的远程协议,类似于使用 KIE 服务器的远程 REST 或 JMS 操作。

EJB 接口的实施是单一独立于框架且与容器无关的 API,可用于特定于框架的代码。EJB 服务通过 Red Hat Process Automation Manager 中的 org.jbpm.services.apiorg.jbpm.services.ejb 软件包公开。该实施不支持 RuleService 类,但 ProcessService 类会公开一个 execute 方法,供您使用各种与规则相关的命令,如 InsertCommandFireAllRulesCommand

注意

Red Hat Process Automation Manager 中的 org.jbpm.services.cdi 软件包也支持上下文和依赖注入(CDI)。但是,为了避免 EJB 集成中的冲突,请不要将 EJB 和 CDI 一起使用。

30.1. 支持的 EJB 服务

如需 Red Hat Process Automation Manager 中的可用企业站(ejb)服务的完整列表,请从红帽客户门户网站下载 Red Hat Process Automation Manager 7.11.0 Maven 存储库,并进入 ~/jboss-rhba-7.11.0.GA-maven-repository/org/jbpm/jbpm-services-ejbhttps://access.redhat.com/jbossnetwork/restricted/listSoftware.html

为 venv 服务提供 EJB 接口的工件位于以下软件包中:

  • org.jbpm.services.ejb.api :包含 EJB 接口的 jBPM 服务 API 的扩展
  • org.jbpm.services.ejb.impl :在核心服务实施之上包含 EJB 打包程序
  • org.jbpm.services.ejb.client :包含 EJB 远程客户端实施,仅在 Red Hat JBoss EAP 上被支持

org.jbpm.services.ejb.api 软件包包含以下可与远程 EJB 客户端一起使用的服务接口:

  • DefinitionServiceejbRemote :使用此接口收集有关进程(ID、名称和版本)、进程变量(名称和类型)、定义的可重复使用的子进程、域特定服务、用户任务和用户任务输入和输出的信息。
  • DeploymentServiceejbRemote :使用此接口来启动部署和未部署。接口包括方法 deploy, undeploy, getRuntimeManager, getDeployedUnits, isDeployed, activate, deactivate, 和 getDeployedUnit。通过构建 RuntimeManager 实例,通过 DeploymentUnit 实例调用部署方法,将单元部署到运行时引擎中。成功部署后,会创建一个 DeployedUnit 实例并缓存给以后使用。(为了使用这些方法,您必须在 Maven 存储库中安装项目的工件。)
  • ProcessServiceejbRemote :使用此接口来控制一个或多个进程和工作项目的生命周期。
  • RuntimeDataServiceejbRemote :使用此接口检索与运行时间相关的数据,如进程实例、进程定义、节点实例信息和变量信息。这个界面包括几个方便的方法,用于根据所有者、状态和时间收集任务信息。
  • UserTaskServiceejbRemote :使用此接口来控制用户任务的生命周期。界面包括几个方便的方法,用于与用户任务交互,如 激活启动停止并执行
  • QueryServiceejbRemote :使用此接口进行高级查询。
  • ProcessInstanceMigrationServiceejbRemote :部署新版本的进程定义时,使用此接口来迁移进程实例。

如果您在同一 KIE 服务器实例上运行 EJB 应用程序和 Business Central,您可以通过设置 org.jbpm.deploy.sync.int 系统属性来同步 EJB 和 Business Central 之间的信息。在服务完成同步后,您可以使用 REST 操作访问更新的信息。

注意

Red Hat Process Automation Manager 中的 EJB 服务适用于嵌入式用例。如果在同一 KIE 服务器实例上运行 EJB 应用程序和 Business Central,还必须在 EJB 应用程序的类路径中添加 kie-services 软件包。

30.2. 部署 EJB 服务 WAR 文件

您可以使用 Enterprise MRG (ejb)接口创建和部署您要用作 Red Hat Process Automation Manager 发行版一部分的 EJB 服务 WAR 文件。

流程

  1. 使用启动 Java 类注册人任务回调,如下例所示:

    @Singleton
    @Startup
    public class StartupBean {
    
      @PostConstruct
      public void init()
      { System.setProperty("org.jbpm.ht.callback", "jaas"); }
    
    }
  2. 构建 EJB 项目,以根据您的项目配置生成 WAR 文件。
  3. 在运行 Red Hat Process Automation Manager 的 Red Hat JBoss EAP 实例上部署生成的文件。

    避免使用 Singleton 策略进行运行时会话。Singleton 策略可能会导致应用程序从底层文件系统多次加载相同的 ksession 实例,并导致选择性锁定异常。

    如果要在与运行 Red Hat Process Automation Manager 的 Red Hat JBoss EAP 实例上部署 EJB WAR 文件,请配置应用程序或应用服务器来调用远程 EJB 并传播安全上下文。

    如果您使用 Hibernate 为 Red Hat Process Automation Manager 创建数据库模式,请更新 Business Central 中的 persistence.xml 文件,并设置 hibernate.hbm2ddl.auto 属性的值,而不是 创建

  4. 通过创建基本 web 应用程序并注入 EJB 服务在本地测试部署,如下例所示:

    @EJB(lookup = "ejb:/sample-war-ejb-app/ProcessServiceEJBImpl!org.jbpm.services.ejb.api.ProcessServiceEJBRemote")
    private ProcessServiceEJBRemote processService;
    
    @EJB(lookup = "ejb:/sample-war-ejb-app/UserTaskServiceEJBImpl!org.jbpm.services.ejb.api.UserTaskServiceEJBRemote")
    private UserTaskServiceEJBRemote userTaskService;
    
    @EJB(lookup = "ejb:/sample-war-ejb-app/RuntimeDataServiceEJBImpl!org.jbpm.services.ejb.api.RuntimeDataServiceEJBRemote")
    private RuntimeDataServiceEJBRemote runtimeDataService;

有关使用 Red Hat JBoss EAP 开发和部署 EJB 应用程序的更多信息,请参阅 EJB 应用程序

第 31 章 其他资源

附录 A. 版本信息

文档最后在 2022 年 3 月 8 日更新。

附录 B. 联系信息

Red Hat Process Automation Manager 文档团队: brms-docs@redhat.com

法律通告

Copyright © 2023 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.