1. 项目文件结构

2. maven 依赖

<!-- https://mvnrepository.com/artifact/org.drools/drools-core -->
	<dependency>
		<groupId>org.drools</groupId>
		<artifactId>drools-core</artifactId>
		<version>7.0.0.Final</version>
	</dependency>
	<!-- https://mvnrepository.com/artifact/org.kie/kie-spring -->
	 <dependency>
	    <groupId>org.kie</groupId>
	    <artifactId>kie-spring</artifactId>
	    <version>7.0.0.Final</version>
	</dependency> 
		<!-- https://mvnrepository.com/artifact/org.drools/drools-compiler -->
	<dependency>
	    <groupId>org.drools</groupId>
	    <artifactId>drools-compiler</artifactId>
	    <version>7.0.0.Final</version>
	</dependency>
		<!-- https://mvnrepository.com/artifact/org.kie/kie-internal -->
	<dependency>
	    <groupId>org.kie</groupId>
	    <artifactId>kie-internal</artifactId>
	    <version>7.0.0.Final</version>
	</dependency>

 3. 在src/main/resources下添加两个目录： META-INF和rules

 3.1 META-INF下添加kmodule.xml，内容如下：

<kmodule xmlns="http://jboss.org/kie/6.0.0/kmodule">
   <kbase name="rules" packages="rules">
       <ksession name="ksession-rules"/>
   </kbase>
</kmodule>

注意： DroolsService 中 KieSession kSession = kContainer.newKieSession("ksession-rules");

kmodule.xml 中 ksession name 要唯一

3.2 规则文件

package com.haoyi
import com.haoyi.common.pojo.Message
dialect  "mvel"

rule "HelloWorld"
    dialect "mvel"
    when
        m : Message(status.equals(Message.HELLO), message : message )
    then
        System.out.println( message);
    modify ( m ) { message = "Goodbye cruel world",status = Message.GOODBYE };
end

rule "GoodBye"
    dialect "java"
    when
       Message( status == Message.GOODBYE, message : message )
    then
        System.out.println( message );
end

drl 文件的整体结构如下：

package package-name

imports

globals

functions

queries

rules

// package部分
// 这个是用来管理包的，跟java的package概念类似，多个rule文件时，可以按包来管理rule代码。
// import
// drl 规则文件中，可以直接使用java定义好的类，只需要import进来就好。
// global
// 相当于全局变量声明，多个规则文件中可共享该变量（后面会演示这一用法），要注意的是：共享全局变量建议不要用Integer这种"简单"类型，这样无法在规则文件中修改变量的"值"，建议用复杂类型（比如上面的AtomicInteger）
// function
// 即：函数，可以定义一些共用函数，在本drl文件被其它规则共用。

// rule ... when ... then ... end
//rule 就是三大块中的规则体，以rule开头，以end 结尾，每个规则文件可以包含多个rule。规则体分为三个部分，LHS RHS 属性 三大部分
//LHS：条件部分又被称之为 LeftHand Side，简称为 LHS，在一个规则当中 when 与 then 中间的部分就是 LHS 部分。
//在 LHS 当中，可以包含 0~n 个条件，如果 LHS 部分没空的话，那么引擎会自动添加一个eval(true)的条件，由于该条件总是返回 true，所以 LHS 为空的规则总是返回 true。
//RHS：结果部分又被称之为 RightHand Side，简称为 RHS，在一个规则当中 then后面部分就是 RHS，只有在 LHS 的所有条件都满足时 RHS 部分才会执行。


// rule ... when ... then ... end
// 这个就是真正的规则了，rule后面的"say-hi"为规则名称，
// when后面的相当于判断条件（注：声明条件的同时，
// 还能声明所谓fact"变量"-[不太准确，暂且这样叫吧]，
// message:Message(...)这里就相当于把后面一串东西，保存在message这个fact"变量中）

 

 

4. pojo 层

定义一个 Drools 中需要使用到的 Model。

package com.haoyi.common.pojo;

import lombok.Data;

@Data
public class Message {
	public static final Integer HELLO = 0;
    public static final Integer GOODBYE = 1;

    private String messageType;

    private Integer status;
}

5. service 层

package com.haoyi.demo.service;

import org.kie.api.KieServices;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.springframework.stereotype.Service;

import com.haoyi.common.pojo.Message;

@Service
public class DroolsService  {
	public String fireRule(String messageType) {
        // load up the knowledge base
        KieServices ks = KieServices.Factory.get();
        KieContainer kContainer = ks.getKieClasspathContainer();
        KieSession kSession = kContainer.newKieSession("ksession-rules");

        // go !
        Message message = new Message();
        // Hello World / Good Bye
        message.setMessageType(messageType);
        message.setStatus(Message.HELLO);
        kSession.insert(message);//插入
        kSession.fireAllRules();//执行规则
        kSession.dispose();
        return message.getMessageType();
    }
}

 

6. controller 层

package com.haoyi.demo.controller;

import java.text.SimpleDateFormat;
import java.util.Calendar;

import org.kie.api.runtime.KieSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;

import com.haoyi.common.pojo.Address;
import com.haoyi.common.pojo.AddressCheckResult;
import com.haoyi.demo.service.DroolsService;

@RestController
@RequestMapping(value = "hello")
public class HelloWorldController {

  Logger logger =LoggerFactory.getLogger(HelloWorldController.class);
 
//  @Autowired
//  private KieSession kieSession;
  
  @Autowired
  private DroolsService droolsServiceImpl;
  
  /**
   * 实现Hello World输出
   * @return
   */
  @RequestMapping(value = "helloWorld")
  public String helloWorld(){
    logger.debug("进入helloWorld处理方法.....");
   return "Hello World Java";
  }

  
  @RequestMapping("/fireRuleDemo")
  public String fireRuleDemo(String messageType){
      return droolsServiceImpl.fireRule(messageType);
  }
    
}

 

通过访问： http://localhost:8080/hello/fireRuleDemo?messageType=HelloWorld 显示如下：

 

http://localhost:8080/hello/fireRuleDemo?messageType=GodBye