drools kie框架测试工程

最新推荐文章于 2024-04-29 23:54:10 发布
最新推荐文章于 2024-04-29 23:54:10 发布
阅读量459 收藏
点赞数
分类专栏： kie 工程 文章标签： drools 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qb200903527/article/details/100549336
版权

drools kie框架测试工程

目录

│ .gitignore
│ pom.xml
│ README.md
│
├─.idea
│ workspace.xml
│
├─src
│ ├─main
│ │ ├─java
│ │ │ └─cn
│ │ │ └─org
│ │ │ └─zhixiang
│ │ │ │ DroolsApplication.java
│ │ │ │
│ │ │ ├─config
│ │ │ │ DroolsAutoConfiguration.java
│ │ │ │
│ │ │ └─entity
│ │ │ BookInfo.java
│ │ │ Dog.java
│ │ │ User.java
│ │ │
│ │ └─resources
│ │ │ application.yml
│ │ │
│ │ └─rules
│ │ Function.drl
│ │ HelloWord.drl
│ │ Property.drl
│ │
│ └─test
│ └─java
│ └─cn
│ └─org
│ └─zhixiang
│ BlogsUrlOutputTest.java
│ DroolsApplicationFunctionTests.java
│ DroolsApplicationHelloWordTests.java
│ DroolsApplicationKieServerTest.java
│ DroolsApplicationPropertyTests.java
│ DroolsApplicationWorkBenchTests.java
│
└─target
├─classes
│ │ application.yml
│ │
│ ├─cn
│ │ └─org
│ │ └─zhixiang
│ │ │ DroolsApplication.class
│ │ │
│ │ ├─config
│ │ │ DroolsAutoConfiguration$1.class
│ │ │ DroolsAutoConfiguration.class
│ │ │
│ │ └─entity
│ │ BookInfo.class
│ │ Dog.class
│ │ User.class
│ │
│ └─rules
│ Function.drl
│ HelloWord.drl
│ Property.drl
│
├─generated-sources
│ └─annotations
├─generated-test-sources
│ └─test-annotations
└─test-classes
└─cn
└─org
└─zhixiang
BlogsUrlOutputTest.class
DroolsApplicationFunctionTests.class
DroolsApplicationHelloWordTests.class
DroolsApplicationKieServerTest.class
DroolsApplicationPropertyTests.class
DroolsApplicationWorkBenchTests.class

工程配置文件

pom.xml：

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.org.zhixiang</groupId>
    <artifactId>drools</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>drools</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <drools.version>7.14.0.Final</drools.version>

    </properties>
    <repositories>
        <repository>
            <id>guvnor-m2-repo</id>
            <name>Guvnor M2 Repo</name>
            <!--<url>http://localhost:8080/kie-drools/maven2/</url>-->
            <url>http://118.25.197.252:8080/drools-wb/maven2/</url>
        </repository>
        <repository>
            <id>Central-Repository</id>
            <name>Central Repository</name>
            <!--<url>http://localhost:8080/kie-drools/maven2/</url>-->
            <url>	https://repo1.maven.org/maven2/</url>
        </repository>
    </repositories>

    <dependencies>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-core</artifactId>
            <version>${drools.version}</version>
        </dependency>
        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-spring</artifactId>
            <version>${drools.version}</version>
        </dependency>
        <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.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.eclipse.jdt</groupId>
            <artifactId>org.eclipse.jdt.core</artifactId>
            <version>3.15.0</version>
        </dependency>
       <!-- kieServer依赖-->
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-core</artifactId>
            <version>7.14.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>7.14.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.kie.server</groupId>
            <artifactId>kie-server</artifactId>
            <version>7.14.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.22</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.51</version>
        </dependency>
        <dependency>
            <groupId>com.qchery</groupId>
            <artifactId>harper</artifactId>
            <version>1.0.0</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version><!--$NO-MVN-MAN-VER$-->
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

application.yml:

server:
  port: 8081

Function.drl:

package rules;
import cn.org.zhixiang.entity.User

rule "test1"
    when

    then
      insert(new User("赵六",12));
      System.err.println("创造赵六");
end

rule "test2"
    when
       $u:User(name=="赵六")
    then
        $u.setName("王五");
        update($u);
        System.err.println("赵六");
end

rule "test3"
    when
         $u:User(name=="王五")
    then
        System.err.println("王五");
        retract($u);
end

rule "test4"
    when
         $u:User(name=="王五")
    then
        System.err.println("王五删除删除之后"+$u.getName());
end

HelloWord.drl

package rules;
import cn.org.zhixiang.entity.User;
import java.lang.String;
import java.util.List;

rule "hello,word"
    when
        eval(true)
    then
        System.err.println("hello,word!");
end

rule "user"
    when
      $u:User(name=="张三",age==18)//连接符： && || ,
    then
        $u.setName("李四");
        System.err.println("hello,word："+$u.getName());
end

rule "contains"
    when
      $s:String()
      $u:User(name contains $s)
    then
        System.err.println("用户张三存在");
end

rule "memberOf"
    when
      $list:List()
      $u:User(name memberOf $list)
    then
        System.err.println("用户李四存在");
end

rule "matches"
    when
      $u:User(name matches "张.*")
    then
        System.err.println("用户张xx存在");
end

Property.drl

package rules;
import cn.org.zhixiang.entity.User;

rule "salience2"
salience 2
    when
        eval(true)
    then
        System.err.println("salience2");
end

rule "salience1"
salience 1
    when
        eval(true)
    then
        System.err.println("salience1");
end

rule "dateEffective"
date-effective "2018-11-24"
    when
    then
        System.err.println("2018-11-24被执行");
end

rule "dateEffectiveTomorrow"
date-effective "2018-11-25"
    when
    then
        System.err.println("2018-11-25被执行");
end

rule "enabled"
enabled false
    when
    then
        System.err.println("被禁用的规则");
end

测试代码

BlogsUrlOutputTest

package cn.org.zhixiang;

import cn.org.zhixiang.entity.BookInfo;
import org.junit.Test;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class BlogsUrlOutputTest {
    private static List<BookInfo> books;
    static{
        books=new ArrayList<>();
        books.add(new BookInfo(0,"weixin_40078053","79869321"));
        books.add(new BookInfo(1,"free-wings","10281198.html"));
        books.add(new BookInfo(0,"X5fnncxzq4","82919860"));
        books.add(new BookInfo(1,"loveyou","cuckoo.html"));
        books.add(new BookInfo(1,"loveyou","cuckoo.html"));
    }

    @Test
    public void testRule2() throws Exception {
        genUrlText();
    }

    private void genUrlText() throws IOException {
        BufferedReader buf=new BufferedReader(new FileReader(new File("D://example.txt")));
        String line  = null;
        books=new ArrayList<>();
        while((line = buf.readLine()) != null) {
            String[] meta=line.split(" ");
            books.add(new BookInfo(Integer.valueOf(meta[0]),meta[1],meta[2]));
        }
        File f=new File("D://books.txt");
        f.delete();
        f.createNewFile();
        FileWriter w=new FileWriter(new File("D://books.txt"),true);
        for(BookInfo b:books){
            String bookUrl="";
            if(b.getType()==0){
                bookUrl="https://blog.youkuaiyun.com/"+b.getAuthorName()+"/article/details/"+b.getSuffix();
            }else{
                bookUrl="https://www.cnblogs.com/"+b.getAuthorName()+"/p/"+b.getSuffix();
            }
            w.write(bookUrl);
            w.write("\r\n");
        }
        w.flush();
        w.close();

    }
}

DroolsApplicationFunctionTests

package cn.org.zhixiang;

import org.drools.core.base.RuleNameEndsWithAgendaFilter;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.kie.api.runtime.KieSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;


@RunWith(SpringRunner.class)
@SpringBootTest
public class DroolsApplicationFunctionTests {

    @Autowired
    KieSession kieSession;


    @Test
    public void testFunction() {
        kieSession.fireAllRules();
    }



}

DroolsApplicationHelloWordTests

package cn.org.zhixiang;

import cn.org.zhixiang.entity.User;
import org.drools.core.base.RuleNameEndsWithAgendaFilter;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.kie.api.runtime.KieSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class DroolsApplicationHelloWordTests {

    @Autowired
    KieSession kieSession;


    @Test
    public void testHelloWord() {
        kieSession.fireAllRules();
    }
    @Test
    public void testUser() {
        User user=new User("张三",18);
        kieSession.insert(user);
        kieSession.fireAllRules();
        System.err.println("规则执行完毕后张三变为了："+user.getName());
    }
    @Test
    public void testOneRule() {
        User user=new User("张三",18);
        kieSession.insert(user);
        kieSession.fireAllRules(new RuleNameEndsWithAgendaFilter("user"));
    }

    @Test
    public void testContains() {
       String name="张三";
        User user=new User("张三",18);
        kieSession.insert(name);
        kieSession.insert(user);
        kieSession.fireAllRules(new RuleNameEndsWithAgendaFilter("contains"));
    }
    @Test
    public void testMemberOf() {
        List list=new ArrayList();
        list.add("张三");
        list.add("李四");
        User user=new User("李四",18);
        kieSession.insert(list);
        kieSession.insert(user);
        kieSession.fireAllRules(new RuleNameEndsWithAgendaFilter("memberOf"));
    }
    @Test
    public void testMatches() {
        User user=new User("张三",18);
        kieSession.insert(user);
        kieSession.fireAllRules(new RuleNameEndsWithAgendaFilter("matches"));
    }



}

testKieServer

package cn.org.zhixiang;

import com.alibaba.fastjson.JSONObject;
import com.qchery.harper.fact.Address;
import com.qchery.harper.fact.ApplyInfo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.kie.api.KieServices;
import org.kie.api.command.Command;
import org.kie.api.command.KieCommands;
import org.kie.api.runtime.ExecutionResults;
import org.kie.server.api.marshalling.MarshallingFormat;
import org.kie.server.api.model.ServiceResponse;
import org.kie.server.client.KieServicesClient;
import org.kie.server.client.KieServicesConfiguration;
import org.kie.server.client.KieServicesFactory;
import org.kie.server.client.RuleServicesClient;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.LinkedList;
import java.util.List;

@RunWith(SpringRunner.class)
public class DroolsApplicationKieServerTest {
    public static final String SERVER_URL = "http://118.25.197.252:8180/kie-server/services/rest/server";
    public static final String PASSWORD = "kieserver1!";
    public static final String USERNAME = "kieserver";
    public static final String KIE_CONTAINER_ID = "com.qchery:harper:1.0.0";//"kie-server-80835beb889a";
    @Test
    public void testKieServer() {

            // KisService 配置信息设置
            KieServicesConfiguration kieServicesConfiguration =
                    KieServicesFactory.newRestConfiguration(SERVER_URL, USERNAME, PASSWORD, 10000L);
            kieServicesConfiguration.setMarshallingFormat(MarshallingFormat.JSON);

            // 创建规则服务客户端
            KieServicesClient kieServicesClient = KieServicesFactory.newKieServicesClient(kieServicesConfiguration);
            RuleServicesClient ruleServicesClient = kieServicesClient.getServicesClient(RuleServicesClient.class);

            // 规则输入条件
            ApplyInfo applyInfo = new ApplyInfo();
            applyInfo.setAge(19);
            Address familyAddress = new Address();
            familyAddress.setProvince("aa");
            applyInfo.setFamilyAddress(familyAddress);

            // 命令定义，包含插入数据，执行规则
            KieCommands kieCommands = KieServices.Factory.get().getCommands();
            List<Command<?>> commands = new LinkedList<>();
            commands.add(kieCommands.newInsert(applyInfo, "applyInfo"));
            commands.add(kieCommands.newFireAllRules());
            String payload="{\"lookup\": \"ksessionId1\", 	\"commands\": [{ 		\"insert\": { 			\"return-object\": true, 			\"out-identifier\": \"applyInfo\", 			\"object\": { 				\"com.qchery.harper.fact.ApplyInfo\": { 					\"name\": null, 					\"age\": 19, 					\"familyAddress\": { 						\"city\": null, 						\"detail\": null, 						\"distract\": null, 						\"province\": \"aa\" 					} 				} 			} 		} 	}, { 		\"fire-all-rules\": \"\" 	}] }";
            System.err.println(payload);
            System.err.println(JSONObject.toJSON(kieCommands.newBatchExecution(commands, "ksessionId1")).toString());
            ServiceResponse<ExecutionResults> results = ruleServicesClient.executeCommandsWithResults(KIE_CONTAINER_ID,
                    /*kieCommands.newBatchExecution(commands, "ksessionId1")*/payload);

            // 返回值读取
            ApplyInfo value = (ApplyInfo) results.getResult().getValue("applyInfo");
            System.out.println(JSONObject.toJSON(value).toString());

    }
}

DroolsApplicationPropertyTests

package cn.org.zhixiang;

import org.drools.core.base.RuleNameEndsWithAgendaFilter;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.kie.api.runtime.KieSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;


@RunWith(SpringRunner.class)
@SpringBootTest
public class DroolsApplicationPropertyTests {

    @Autowired
    KieSession kieSession;


    @Test
    public void testSalience() {
        kieSession.fireAllRules();
    }

    @Test
    public void testDateEffective() {
        kieSession.fireAllRules(new RuleNameEndsWithAgendaFilter("dateEffective"));
    }

    @Test
    public void testDateEffectiveTomorrow() {
        kieSession.fireAllRules(new RuleNameEndsWithAgendaFilter("dateEffectiveTomorrow"));
    }
    @Test
    public void testEnabled() {
        kieSession.fireAllRules(new RuleNameEndsWithAgendaFilter("enabled"));
    }

}

DroolsApplicationWorkBenchTests

package cn.org.zhixiang;


import cn.org.zhixiang.entity.Dog;
import org.drools.compiler.kproject.ReleaseIdImpl;
import org.drools.core.io.impl.UrlResource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.kie.api.KieServices;
import org.kie.api.builder.KieModule;
import org.kie.api.builder.KieRepository;

import org.kie.api.builder.KieScanner;
import org.kie.api.builder.ReleaseId;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.springframework.test.context.junit4.SpringRunner;

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

@RunWith(SpringRunner.class)
public class DroolsApplicationWorkBenchTests {
    @Test
    public void testWorkbench() {
        String url = "http://118.25.197.252:8080/drools-wb/maven2/cn/org/zhixiang/drools-test1/0.0.1/drools-test1-0.0.1.jar";
        KieServices kieServices = KieServices.Factory.get();
        KieRepository kieRepository = kieServices.getRepository();
        UrlResource resource = (UrlResource) kieServices.getResources().newUrlResource(url);
        resource.setBasicAuthentication("enabled");
        resource.setPassword("admin");
        resource.setUsername("admin");
        InputStream is = null;
        try {
            is = resource.getInputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }
        KieModule kieModule = kieRepository.addKieModule(kieServices.getResources().newInputStreamResource(is));
        KieContainer kieContainer = kieServices.newKieContainer(kieModule.getReleaseId());
        KieSession kieSession = kieContainer.newKieSession();
        Dog dog = new Dog();
        dog.setName("大黄");
        kieSession.insert(dog);
        kieSession.fireAllRules();
    }
}

源码

DroolsApplication.java

package cn.org.zhixiang;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DroolsApplication {

	public static void main(String[] args) {
		SpringApplication.run(DroolsApplication.class, args);
	}

}

DroolsAutoConfiguration.java

package cn.org.zhixiang.config;

import org.kie.api.KieBase;
import org.kie.api.KieServices;
import org.kie.api.builder.*;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.kie.internal.io.ResourceFactory;
import org.kie.spring.KModuleBeanFactoryPostProcessor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

import java.io.IOException;


/**
 * d
 *
 * @author syj
 * CreateTime 2018/11/23
 * describe:
 */
@Configuration
public class DroolsAutoConfiguration {
    private static final String RULES_PATH = "rules/";

    @Bean
    @ConditionalOnMissingBean(KieFileSystem.class)
    public KieFileSystem kieFileSystem() throws IOException {
        KieFileSystem kieFileSystem = getKieServices().newKieFileSystem();
        for (Resource file : getRuleFiles()) {
            kieFileSystem.write(ResourceFactory.newClassPathResource(RULES_PATH + file.getFilename(), "UTF-8"));
        }
        return kieFileSystem;
    }

    private Resource[] getRuleFiles() throws IOException {
        ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
        return resourcePatternResolver.getResources("classpath*:" + RULES_PATH + "**/*.*");
    }

    @Bean
    @ConditionalOnMissingBean(KieContainer.class)
    public KieContainer kieContainer() throws IOException {
        final KieRepository kieRepository = getKieServices().getRepository();
        kieRepository.addKieModule(new KieModule() {
            public ReleaseId getReleaseId() {
                return kieRepository.getDefaultReleaseId();
            }
        });
        KieBuilder kieBuilder = getKieServices().newKieBuilder(kieFileSystem());
        kieBuilder.buildAll();
        return getKieServices().newKieContainer(kieRepository.getDefaultReleaseId());
    }


    @Bean
    @ConditionalOnMissingBean(KieBase.class)
    public KieBase kieBase() throws IOException {
        return kieContainer().getKieBase();
    }

    @Bean
    @ConditionalOnMissingBean(KieSession.class)
    public KieSession kieSession() throws IOException {
        KieSession kieSession = kieContainer().newKieSession();
        return kieSession;
    }

    @Bean
    @ConditionalOnMissingBean(KModuleBeanFactoryPostProcessor.class)
    public KModuleBeanFactoryPostProcessor kiePostProcessor() {
        return new KModuleBeanFactoryPostProcessor();
    }
    public KieServices getKieServices() {
        System.setProperty("drools.dateformat","yyyy-MM-dd");
        return KieServices.Factory.get();
    }
}

BookInfo.java

package cn.org.zhixiang.entity;

public class BookInfo {
    private int type;//0;csdn; 1:cnblogs
    private String authorName;
    private String suffix;

    public BookInfo(int type, String authorName, String suffix) {
        this.type = type;
        this.authorName = authorName;
        this.suffix = suffix;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }

    public String getAuthorName() {
        return authorName;
    }

    public void setAuthorName(String authorName) {
        this.authorName = authorName;
    }

    public String getSuffix() {
        return suffix;
    }

    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }
}

Dog.java

package cn.org.zhixiang.entity;

/**
 * d
 *
 * @author syj
 * CreateTime 2018/11/26
 * describe:
 */
public class Dog  {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

User.java

package cn.org.zhixiang.entity;

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
drools 7.11.0.Final使用
九师兄
09-27 1644
1.前提 入门java程序：https://blog.youkuaiyun.com/qq_21383435/article/details/82860461 界面配置：https://blog.youkuaiyun.com/qq_21383435/article/details/82867495 2. 新建一个项目 3. 添加一个规则 选择DRL 填写文件名 创建成功后就会到如下的页面上,在这个页面上，我们要填...
drools-test:测试drools中的一些特性
05-21
drools-test 测试drools中的一些特性
Drools与Spring集成 登录测试
caomiao2006的专栏
06-11 2071
Drools5.2.0.Final与Spring3集成测试 在drools5.2，有一个jar包：drools-spring-5.2.0.Final.jar，其中定义了在spring中应用的drools的扩展。通过这些扩展，可以直接在spring的配置文件中，配置knowledgebase、session等bean，从而在spring配置的程序中直接应用。 drools-spring-
基于 Jboss Drools 规则引擎开发框架
深度磨练
11-22 2757
                                                       规则引擎  框架 –by struct1、框架概述a)         CTU系统分为3部分：1、事件注册器。 2、事件分析引擎。 3、风险处理系统。b)        事件注册器：收集服务器信息、事件触发人员信息、以及事件相关的数据，将这些数据组合成一个Event 。
drools入门-02
qq_36291682的博客
10-30 521
规则引擎 drools
Drools 5.1.1(一)
走马观花
12-27 4007
http://shikonglaike.iteye.com/blog/1236354 第一章欢迎 我总是和终端业务用户争论不休，理解规则和流程、最新规则和事件处理的区别。对此，在他们的意识中有这样的问题，并且他们希望使用某些软件模拟它。使用两个供应商提供的传统方式，强迫业务用户与一个刚刚获得方式的面向流程或面向规则的方法一起工作，他们将使用该工具模拟这点，往往整体是极为混乱的。 PegaS
kie drools war
05-25
在这个"kie drools war"项目中，我们看到的是一个基于kie drools构建的Web工程。WAR（Web Application Archive）文件是Java Web应用的标准打包格式，通常包含了Web应用的所有必需组件，如Servlets、JSP、静态HTML、...
KIE-Drools Workbench运行时jar包压缩教程
Drools Workbench则是Drools的一个集成开发环境（IDE），它允许开发者以图形化的方式定义、管理和测试业务规则。Drools Workbench运行时所需的jar包，是运行Drools规则引擎和Workbench所必需的组件集合。 了解...
Drools6 基本使用 -- 1
热门推荐
cloud的技术积累
05-25 1万+
drools6 基本使用1
Drools WorkBench最佳实践：构建企业级规则管理系统的10个关键点
本文对Drools Workbench进行了全面的介绍，探讨了规则管理系统的基础理论，包括规则引擎的原理、Drools规则的语法结构以及规则的生命周期管理。文章进一步详细阐述了Drools Workbench的配置与安装步骤，并对用户界面...
org.kie.navigator:Droolsjbpm-tools的扩展，为DroolsjBPM服务器安装定义了专门的查看器
05-20
org.kie.navigator droolsjbpm-tools的扩展，为Drools / jBPM服务器安装定义了专门的查看器。
规则引擎----drools
jim_007的博客
11-16 143
一、流程过程 过程描述： pom.xml引入依赖----》【 构建规则模型--》编写DroolTest.drl规则文件--》把.drl编织入配置类--》生成kieSession 】----》执行规则----》查看执行结果 二、drool配置类配置 ...
Drools深入学习之KIE
echo_decode的博客
03-07 2463
初步接触Drools，肯定会看到KieContainer、KieSession之类的带有kie标识的方法类名词，kie作为Drools和JBPM的共享核心，它的主要作用在于提供了一体化的方法模型去供给应用中的部署生成环节。KIE（Knowledge is everything），从官方给出的文档上看出它的生态圈包含以下内容：OptaPlanner:一个规划引擎，注意，
kie－api介绍和使用
weixin_30508241的博客
08-13 466
参考：KIE kie在drools jbpm uberfire里广泛被使用，下面对kie－api中的几个重要组件做下简单介绍 maven依赖 <dependency> <groupId>org.kie</groupId> <artifactId>kie-api</artifactId> <version&gt...
流程引擎之KIE项目简介
苦行僧
02-15 2119
KIE 是“Knowledge Is Everything”的简称，KIE 名称也被用于系统的共享方面，比如统一构建、部署和使用。jBoss 公司通过 KIE 将 jBPM 和 Drools 等相关项目进行了一个整合，统一了他们的使用方式
java: 无法访问org.kie.internal.io.ResourceFactory
assenone的博客
02-06 230
java: 无法访问org.kie.internal.io.ResourceFactory
规则引擎drools Part4
最新发布
快乐江小鱼的博客
04-29 331
【代码】规则引擎drools Part4。
Springboot Drools kie 规则重新加载
赵英超的博客
08-01 7363
前言   目前世面上中文的KIE DROOLS Workbench（JBOSS BRMS）的教程几乎没有，有的也只有灵灵碎碎的使用机器来翻译的（翻的不知所云）或者是基于老版本的JBOSS Guvnor即5.x的一些教程，而且这些教程都是”缺胳膊少腿“的，初学者看后不知道它到底在干吗？能干吗？能够解决自己系统中什么问题。   什么是规则引擎     规则是让业务人士驱动整个企业...
使用drools workbench，在tomcat中部署,在下图
lazyCoder
09-29 398
使用drools workbench，在tomcat中部署,在下图 此中url取自kieIDE的 在IDEA中运行程序，加载部署到maven2中的jar包，出现Unable to fetch module from resource: null 调试发现 打印接收的inputstream中的内容，发现接收的数据为kieIDE的登录界面，我们的用户名密码设置并没有生效 UrlResource resource = (UrlResource) ks.getResources().newU
KIE Drools Workbench运行时Jar包压缩包
标题和描述中提到的“kie-drools-wb”指的是与KIE平台相关的一个组件，Drools Workbench。Drools Workbench是基于KIE（Knowledge Is Everything）平台的业务规则管理工具，它提供了一个用户友好的界面，让开发者能够...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值