16.3. 使用自定义客户端 API 扩展 KIE 服务器客户端

流程

1. 创建一个空的 Maven 项目，并在项目的 pom.xml 文件中定义以下打包类型和依赖项：

   示例项目中的 pom.xml 文件示例

   <packaging>jar</packaging>
   
   <properties>
      <version.org.kie>7.59.0.Final-redhat-00006</version.org.kie>
    </properties>
   
    <dependencies>
      <dependency>
        <groupId>org.kie.server</groupId>
        <artifactId>kie-server-api</artifactId>
        <version>${version.org.kie}</version>
      </dependency>
      <dependency>
         <groupId>org.kie.server</groupId>
         <artifactId>kie-server-client</artifactId>
         <version>${version.org.kie}</version>
       </dependency>
      <dependency>
        <groupId>org.drools</groupId>
        <artifactId>drools-compiler</artifactId>
        <version>${version.org.kie}</version>
      </dependency>
    </dependencies>

   Copy to Clipboard Toggle word wrap

2. 在项目中的 Java 类中实施相关的 ServicesClient 接口，如下例所示：

   RulesMinaServicesClient 接口示例

   public interface RulesMinaServicesClient extends RuleServicesClient {
   
   }

   Copy to Clipboard Toggle word wrap

   需要一个特定的接口，因为您必须根据接口注册客户端实现，且对于给定接口只能有一个实施。

   在本例中，自定义基于 MINA 的数据传输使用 Drools 扩展，因此本例 RulesMinaServicesClient 接口会扩展 Drools 扩展的现有 RuleServicesClient 客户端 API。

3. 实施 KIE 服务器可以用来为新的 MINA 传输提供额外的客户端功能的 RulesMinaServicesClient 接口，如下例所示：

   RulesMinaServicesClient 接口的实现示例

   public class RulesMinaServicesClientImpl implements RulesMinaServicesClient {
   
       private String host;
       private Integer port;
   
       private Marshaller marshaller;
   
       public RulesMinaServicesClientImpl(KieServicesConfiguration configuration, ClassLoader classloader) {
           String[] serverDetails = configuration.getServerUrl().split(":");
   
           this.host = serverDetails[0];
           this.port = Integer.parseInt(serverDetails[1]);
   
           this.marshaller = MarshallerFactory.getMarshaller(configuration.getExtraJaxbClasses(), MarshallingFormat.JSON, classloader);
       }
   
       public ServiceResponse<String> executeCommands(String id, String payload) {
   
           try {
               String response = sendReceive(id, payload);
               if (response.startsWith("{")) {
                   return new ServiceResponse<String>(ResponseType.SUCCESS, null, response);
               } else {
                   return new ServiceResponse<String>(ResponseType.FAILURE, response);
               }
           } catch (Exception e) {
               throw new KieServicesException("Unable to send request to KIE Server", e);
           }
       }
   
       public ServiceResponse<String> executeCommands(String id, Command<?> cmd) {
           try {
               String response = sendReceive(id, marshaller.marshall(cmd));
               if (response.startsWith("{")) {
                   return new ServiceResponse<String>(ResponseType.SUCCESS, null, response);
               } else {
                   return new ServiceResponse<String>(ResponseType.FAILURE, response);
               }
           } catch (Exception e) {
               throw new KieServicesException("Unable to send request to KIE Server", e);
           }
       }
   
       protected String sendReceive(String containerId, String content) throws Exception {
   
           // Flatten the content to be single line:
           content = content.replaceAll("\\n", "");
   
           Socket minaSocket = null;
           PrintWriter out = null;
           BufferedReader in = null;
   
           StringBuffer data = new StringBuffer();
           try {
               minaSocket = new Socket(host, port);
               out = new PrintWriter(minaSocket.getOutputStream(), true);
               in = new BufferedReader(new InputStreamReader(minaSocket.getInputStream()));
   
               // Prepare and send data:
               out.println(containerId + "|" + content);
               // Wait for the first line:
               data.append(in.readLine());
               // Continue as long as data is available:
               while (in.ready()) {
                   data.append(in.readLine());
               }
   
               return data.toString();
           } finally {
               out.close();
               in.close();
               minaSocket.close();
           }
       }
   }

   Copy to Clipboard Toggle word wrap

   这个示例实现指定了以下数据和行为：

   • 使用基于套接字的通信以简化性
   • 依赖于 KIE Server 客户端的默认配置，并使用 ServerUrl 提供 MINA 服务器的主机和端口
   • 将 JSON 指定为 marshalling 格式
   • 需要收到的消息是以打开的 bracket {开头的 JSON 对象。
   • 在等待响应的第一行时，使用与阻塞 API 的直接套接字通信，然后读取所有可用的行
   • 不使用流模式，因此在调用命令后断开 KIE 服务器会话

4. 在项目中的 Java 类中实施 org.kie.server.client.helper.KieServicesClientBuilder 接口，如下例所示：

   KieServicesClientBuilder 接口实施示例

   public class MinaClientBuilderImpl implements KieServicesClientBuilder {  

   1

   
   
       public String getImplementedCapability() {  

   2

   
           return "BRM-Mina";
       }
   
       public Map<Class<?>, Object> build(KieServicesConfiguration configuration, ClassLoader classLoader) {  

   3

   
           Map<Class<?>, Object> services = new HashMap<Class<?>, Object>();
   
           services.put(RulesMinaServicesClient.class, new RulesMinaServicesClientImpl(configuration, classLoader));
   
           return services;
       }
   
   }

   Copy to Clipboard Toggle word wrap

   1

   可让您为通用 KIE 服务器客户端基础架构提供额外的客户端 API

   2

   定义客户端使用的 KIE 服务器功能（分机）

   3

   提供客户端实施的映射，其中键是接口，值是完全初始化的实施

5. 要使新的客户端 API 发现 KIE 服务器客户端，请在 Maven 项目中创建一个 META-INF/services/org.kie.server.client.helper.KieServicesClientBuilder 文件，并在文件中添加 KieServicesClientBuilder 实施类的完全限定名称。在本例中，文件包含一行 org.kie.server.ext.mina.client.MinaClientBuilderImpl。
6. 构建项目并将生成的 JAR 文件复制到项目的 ~/kie-server.war/WEB-INF/lib 目录中。例如，在红帽 JBoss EAP 上，此目录的路径为 EAP_HOME/standalone/deployments/kie-server.war/WEB-INF/lib。

7. 启动 KIE 服务器，并将构建的项目部署到正在运行的 KIE 服务器。您可以使用 Business Central 接口或 KIE 服务器 REST API 部署项目( PUT 请求 http://SERVER:PORT/kie-server/services/rest/server/containers/{containerId})。

   在运行的 KIE Server 上部署项目后，您可以开始与新的 KIE Server 客户端交互。您可以通过创建客户端配置和客户端实例、按类型检索服务客户端并调用客户端方法，按照标准 KIE 服务器客户端使用新客户端。

   在本例中，您可以创建一个 RulesMinaServiceClient 客户端实例，并通过 MINA 传输在 KIE 服务器上调用操作：

   创建 RulesMinaServiceClient 客户端的示例实施

   protected RulesMinaServicesClient buildClient() {
       KieServicesConfiguration configuration = KieServicesFactory.newRestConfiguration("localhost:9123", null, null);
       List<String> capabilities = new ArrayList<String>();
       // Explicitly add capabilities (the MINA client does not respond to `get-server-info` requests):
       capabilities.add("BRM-Mina");
   
       configuration.setCapabilities(capabilities);
       configuration.setMarshallingFormat(MarshallingFormat.JSON);
   
       configuration.addJaxbClasses(extraClasses);
   
       KieServicesClient kieServicesClient =  KieServicesFactory.newKieServicesClient(configuration);
   
       RulesMinaServicesClient rulesClient = kieServicesClient.getServicesClient(RulesMinaServicesClient.class);
   
       return rulesClient;
   }

   Copy to Clipboard Toggle word wrap

   通过 MINA 传输调用操作的示例配置

   RulesMinaServicesClient rulesClient = buildClient();
   
   List<Command<?>> commands = new ArrayList<Command<?>>();
   BatchExecutionCommand executionCommand = commandsFactory.newBatchExecution(commands, "defaultKieSession");
   
   Person person = new Person();
   person.setName("mary");
   commands.add(commandsFactory.newInsert(person, "person"));
   commands.add(commandsFactory.newFireAllRules("fired"));
   
   ServiceResponse<String> response = rulesClient.executeCommands(containerId, executionCommand);
   Assert.assertNotNull(response);
   
   Assert.assertEquals(ResponseType.SUCCESS, response.getType());
   
   String data = response.getResult();
   
   Marshaller marshaller = MarshallerFactory.getMarshaller(extraClasses, MarshallingFormat.JSON, this.getClass().getClassLoader());
   
   ExecutionResultImpl results = marshaller.unmarshall(data, ExecutionResultImpl.class);
   Assert.assertNotNull(results);
   
   Object personResult = results.getValue("person");
   Assert.assertTrue(personResult instanceof Person);
   
   Assert.assertEquals("mary", ((Person) personResult).getName());
   Assert.assertEquals("JBoss Community", ((Person) personResult).getAddress());
   Assert.assertEquals(true, ((Person) personResult).isRegistered());

   Copy to Clipboard Toggle word wrap