如何在 camunda DMN 建模器中制作动态规则？

问：

我创建了一个DMN建模器，我在spring boot中运行它。现在我不想硬核规则，而是想使用一些表达式，以便我可以在运行时传递所有值。

这是 DMN 建模器

下面的 POM 文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>camunda-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>camunda-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.camunda.bpm.dmn</groupId>
                <artifactId>camunda-engine-dmn-bom</artifactId>
                <version>7.19.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

        </dependencies>
    </dependencyManagement>



    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.camunda.bpm.dmn</groupId>
            <artifactId>camunda-engine-dmn</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

DmnConfig 类：

package com.example.camundademo.config;


import org.camunda.bpm.dmn.engine.DmnDecision;
import org.camunda.bpm.dmn.engine.DmnEngine;
import org.camunda.bpm.dmn.engine.DmnEngineConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import java.io.IOException;
import java.io.InputStream;

@Configuration
public class DmnConfiguration {

    @Bean
    public DmnEngine createDmnEngine() {
        DmnEngineConfiguration configuration = DmnEngineConfiguration.createDefaultDmnEngineConfiguration();
        return configuration.buildEngine();
    }

    @Bean
    public DmnDecision transactionLimit(DmnEngine dmnEngine) {
        return getDmnDecision(dmnEngine, "dmn/transactionLimit.dmn", "transactionLimit");
    }


    private DmnDecision getDmnDecision(DmnEngine dmnEngine, String dmnFilePath, String decisionId) {

        Resource resource = new ClassPathResource(dmnFilePath);

        InputStream inputStream = null;
        try {
            inputStream = resource.getInputStream();
        }
        catch (IOException exception) {
            exception.printStackTrace();
        }
        return dmnEngine.parseDecision(decisionId, inputStream);
    }
}

TransactionLimitService 类：

package com.example.camundademo.service;


import org.camunda.bpm.dmn.engine.DmnDecision;
import org.camunda.bpm.dmn.engine.DmnDecisionTableResult;
import org.camunda.bpm.dmn.engine.DmnEngine;
import org.camunda.bpm.engine.variable.VariableMap;
import org.camunda.bpm.engine.variable.Variables;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class TransactionLimitService {

    private final DmnEngine engine;

    private final DmnDecision decision;

    public TransactionLimitService(DmnEngine engine, @Qualifier("transactionLimit") DmnDecision decision) {
        this.engine = engine;
        this.decision = decision;
    }

    public String validateRule(int amount, int limit) {
        VariableMap variables = Variables.putValue("amount", amount)
                .putValue("limit", limit);
        DmnDecisionTableResult result = engine.evaluateDecisionTable(decision, variables);
        return (String) result.getSingleResult().get("transactionLimit");
    }
}

任何人都可以建议我如何使规则动态化？