bean

package com.sample;

public class Person {
	private String name;
	private int age;
	private Gender gender;
	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;
	}
	public Gender getGender() {
		return gender;
	}
	public void setGender(Gender gender) {
		this.gender = gender;
	}
}

条件筛选

package com.sample
 
import com.sample.Person;
import com.sample.Gender;
rule "find"
    when
    	// 注释
    	// 1. 支持//注释
		/*  
		   2. 支持多行注释
		*/
		// 3. #注释能用，但是有些不能用，版本问题？设置问题？这个不太清楚，反正java注释通用
        
        // 筛选
        /*
           1. 空条件筛选:表示无筛选条件，全量接收
           		Person()
           2. 单条件筛选:通过属性名直接进行值判断，筛选属性值满足条件的对象
           		Person(name == "godme")
           3. 多条件筛选:多条件筛选即多属性限定，用逗号进行分隔，多个筛选条件同时存在，同时满足才符合筛选条件
           		Person(name == "godme" , age < 25)
        */
        
        // 筛选操作符说明
        /*	
        	 0. 基本的框架其实就是指定类，在括号中进行属性值的筛选
        	 1. 多属性之间的筛选通过逗号进行分隔
       	 	 2. 属性判断支持一般的判定符，大于，小于，等于，不等 ... 等系列操作
       		 3. 操作符针对类型，不能使用不适合的条件判定符操作不对应的数据
        */

        Person(name == "godme") 
       	// 单对象的多属性关联筛选要严格区别于其他条件关联，后续的慢慢学习
       	/*
       		1. 单一对象筛选
       		2. 对象联合筛选
       		3. 条件联动组合
       	*/
    then
        System.out.println("is him");
end

对象获取

package com.sample
 
import com.sample.Person;
rule "find"
    when
    	/*
    		规则文件当中也可以存在变量，通过变量来存储值，可以有很多用途
    		1. 关联筛选：通过用变量进行筛选，可以进行一个动态过滤，不必那么死板
    			Person(name == $name)
    		2. 操作传递
    			通过$person:Person()提取对象
    			可以再then的操作语句中进行操作，针对对象进行处理
    	*/
    	
    	/*
    		替换办法
    		1. 变量名
    			无限定，不重复即可，不必类型声明，自动判别
    		2. 赋值符
    			:冒号，不再是等号=
    	*/
    	/*
    		作用对象
    		1. 对象
    		2. 属性
    	*/
    	/*
    		命名
    		一般可以用$开头，同名来进行值记录，类似于this，便于区分，也 不会混淆
    		但是没有硬性规定，还是可以随便自定义
    	*/
        $person:Person($name:name == "godme") 
    then
        System.out.println($person.getName());
end

数据插入

package com.sample;

import org.drools.KnowledgeBase;
import org.drools.KnowledgeBaseFactory;
import org.drools.builder.KnowledgeBuilder;
import org.drools.builder.KnowledgeBuilderError;
import org.drools.builder.KnowledgeBuilderErrors;
import org.drools.builder.KnowledgeBuilderFactory;
import org.drools.builder.ResourceType;
import org.drools.io.ResourceFactory;
import org.drools.logger.KnowledgeRuntimeLogger;
import org.drools.logger.KnowledgeRuntimeLoggerFactory;
import org.drools.runtime.StatefulKnowledgeSession;

public class DroolsTest {

    public static final void main(String[] args) {
        try {
            KnowledgeBase kbase = readKnowledgeBase();
            StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
            KnowledgeRuntimeLogger logger = KnowledgeRuntimeLoggerFactory.newFileLogger(ksession, "test");
            // 数据生成
            Person person = new Person();
            // 属性填充
            person.setName("godme");
            // 数据插入
            ksession.insert(person);
            // 规则执行
            ksession.fireAllRules();
            logger.close();
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }

    private static KnowledgeBase readKnowledgeBase() throws Exception {
        KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
        kbuilder.add(ResourceFactory.newClassPathResource("Sample.drl"), ResourceType.DRL);
        KnowledgeBuilderErrors errors = kbuilder.getErrors();
        if (errors.size() > 0) {
            for (KnowledgeBuilderError error: errors) {
                System.err.println(error);
            }
            throw new IllegalArgumentException("Could not parse knowledge.");
        }
        KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
        kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());
        return kbase;
    }
}

代码部分，可以万年不变的

1. 创建对象
2. 属性填充
3. 对象插入
4. 规则执行

主体的逻辑都在规则文件中定义，至于规则文件中的更高级操作，目前不得而知。

现在只能专注于逻辑的编辑。