13.代碼中(zhōng)調用(yòng)規則
概述
在URule Pro當中(zhōng),是不能(néng)直接調用(yòng)具(jù)體(tǐ)的規則文(wén)件的,我們需要先将定義好的規則文(wén)件放到知識包中(zhōng),然後才可(kě)以對規則文(wén)件進行測試和調用(yòng)。
在代碼中(zhōng)調用(yòng)知識包,需要先通過KnowledgeService接口可(kě)獲取指定的知識包ID對應的構建好的資源包信息,然後通過知識包來創建具(jù)體(tǐ)的KnowledgeSession對象,接下來插入相關業務(wù)對象,最後執行具(jù)體(tǐ)的規則調用(yòng)。
KnowledgeService接口源碼如下:
package com.bstek.urule.runtime.service;
import java.io.IOException;
import com.bstek.urule.runtime.KnowledgePackage;
/**
* @author Jacky.gao
* @since 2015年1月28日
*/
public interface KnowledgeService {
public static final String BEAN_ID="urule.knowledgeService";
/**
* 根據給定的資源包ID獲取對應的KnowledgePackage對象
* @param packageId 項目名(míng)稱加資源包ID,格式為(wèi):projectName/packageId
* @return 返回與給定的資源包ID獲取對應的KnowledgePackage對象
* @throws IOException
*/
KnowledgePackage getKnowledge(String packageId) throws IOException;
/**
* 根據給定的一個或多(duō)個資源包ID獲取對應的KnowledgePackage對象的集合
* @param packageIds 資源包ID數組
* @return 返回與給定的一個或多(duō)個資源包ID獲取對應的KnowledgePackage對象集合
* @throws IOException
*/
KnowledgePackage[] getKnowledges(String[] packageIds) throws IOException;
}
可(kě)以看到,這個接口中(zhōng)有(yǒu)兩個方法可(kě)供使用(yòng),一個是給一個知識包ID(格式為(wèi):projectName/packageId)返回一個對應的KnowledgePackage對象;另一個是給一個或多(duō)個知識包ID,返回一個集合類型的KnowledgePackage對象。在URule Pro當中(zhōng),對于一個知識包,在使用(yòng)時引擎會将其構建成KnowledgePackage對象,在這個KnowledgePackage對象中(zhōng)包含了所有(yǒu)由向決策集、決策表、交叉決策表、決策樹、評分(fēn)卡、複雜評分(fēn)卡以及決策流等文(wén)件構建的RuleSet對象,以及由規則流構成的FlowDefinition對象。
在使用(yòng)getKnowledge方法獲取某個指定的package時,要給一個資源包ID,需要注意的是資源包的ID在定義要要包含資源包所在項目名(míng)稱,格式為(wèi):projectName/packageId
通過KnowledgeService接口獲取到KnowledgePackage對象後,接下來就可(kě)通過KnowledgePackage對象創建com.bstek.urule.runtime.KnowledgeSession對象,這個對象就是引擎提供的與業務(wù)數據交互的接口,通過這個接口,可(kě)将需要的業務(wù)數據對象插入到引擎當中(zhōng),最後根據需要執行規則或規則流。
package com.bstek.urule.runtime;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import com.bstek.urule.runtime.agenda.AgendaFilter;
import com.bstek.urule.runtime.response.FlowExecutionResponse;
import com.bstek.urule.runtime.response.RuleExecutionResponse;
import com.bstek.urule.runtime.rete.ReteInstance;
public interface KnowledgeSession extends WorkingMemory{
/**
* 執行當前WorkMemory中(zhōng)所有(yǒu)滿足條件的規則
* @return 返回一個ExecutionResponse對象,其中(zhōng)包含規則執行耗時,滿足條件的規則,執行的規則等信息
*/
RuleExecutionResponse fireRules();
/**
* 對當前WorkMemory中(zhōng)所有(yǒu)滿足條件的規則進行過濾執行
* @param filter 對滿足條件的規則進行過濾
* @return 返回一個ExecutionResponse對象,其中(zhōng)包含規則執行耗時,滿足條件的規則,執行的規則等信息
*/
RuleExecutionResponse fireRules(AgendaFilter filter);
/**
* 對當前WorkMemory中(zhōng)所有(yǒu)滿足條件的規則進行過濾執行,并向WorkingMemory中(zhōng)設置一個Map的參數對象
* @param parameters 向WorkingMemory中(zhōng)設置一個Map的參數對象
* @param filter 對滿足條件的規則進行過濾
* @return 返回一個ExecutionResponse對象,其中(zhōng)包含規則執行耗時,滿足條件的規則,執行的規則等信息
*/
RuleExecutionResponse fireRules(Map<String,Object> parameters,AgendaFilter filter);
/**
* 對當前WorkMemory中(zhōng)所有(yǒu)滿足條件的規則進行執行,并定義執行的最大數目,超出後就不再執行
* @param max 執行規則的最大數目
* @return 返回一個ExecutionResponse對象,其中(zhōng)包含規則執行耗時,滿足條件的規則,執行的規則等信息
*/
RuleExecutionResponse fireRules(int max);
/**
* 對當前WorkMemory中(zhōng)所有(yǒu)滿足條件的規則進行執行,并定義執行的最大數目,超出後就不再執行,<br>
* 并向WorkingMemory中(zhōng)設置一個Map的參數對象
* @param parameters 向WorkingMemory中(zhōng)設置一個Map的參數對象
* @param max 執行規則的最大數目
* @return 返回一個ExecutionResponse對象,其中(zhōng)包含規則執行耗時,滿足條件的規則,執行的規則等信息
*/
RuleExecutionResponse fireRules(Map<String,Object> parameters,int max);
/**
* 對當前WorkMemory中(zhōng)所有(yǒu)滿足條件的規則進行過濾執行,并定義執行數目的最大值
* @param filter 對滿足條件的規則進行過濾
* @param max 執行規則的最大數目
* @return 返回一個ExecutionResponse對象,其中(zhōng)包含規則執行耗時,滿足條件的規則,執行的規則等信息
*/
RuleExecutionResponse fireRules(AgendaFilter filter,int max);
/**
* 對當前WorkMemory中(zhōng)所有(yǒu)滿足條件的規則進行過濾執行,并定義執行數目的最大值,<br>
* 并向WorkingMemory中(zhōng)設置一個Map的參數對象
* @param parameters 向WorkingMemory中(zhōng)設置一個Map的參數對象
* @param filter 對滿足條件的規則進行過濾
* @param max 執行規則的最大數目
* @return 返回一個ExecutionResponse對象,其中(zhōng)包含規則執行耗時,滿足條件的規則,執行的規則等信息
*/
RuleExecutionResponse fireRules(Map<String,Object> parameters,AgendaFilter filter,int max);
/**
* 對當前WorkMemory中(zhōng)所有(yǒu)滿足條件的規則進行執行,并向WorkingMemory中(zhōng)設置一個Map的參數對象
* @param parameters 向WorkingMemory中(zhōng)設置一個Map的參數對象
* @return 返回一個ExecutionResponse對象,其中(zhōng)包含規則執行耗時,滿足條件的規則,執行的規則等信息
*/
RuleExecutionResponse fireRules(Map<String,Object> parameters);
/**
* 根據規則流ID,執行目标規則流
* @param processId 要執行的規則流ID
* @return 返回一個ExecutionResponse對象,其中(zhōng)包含規則流執行耗時信息
*/
FlowExecutionResponse startProcess(String processId);
/**
* 根據規則流ID,執行目标規則流,并向WorkingMemory中(zhōng)設置一個Map的參數對象
* @param processId 要執行的規則流ID
* @param parameters 向WorkingMemory中(zhōng)設置一個Map的參數對象
* @return 返回一個ExecutionResponse對象,其中(zhōng)包含規則流執行耗時信息
*/
FlowExecutionResponse startProcess(String processId,Map<String,Object> parameters);
/**
* 執行将日志(zhì)信息寫入到日志(zhì)文(wén)件操作(zuò),要看到日志(zhì)文(wén)件我們需要設置urule.debugToFile屬性值為(wèi)true,<br>
* 同時定義輸出文(wén)件目錄屬性urule.defaultHtmlFileDebugPath,這樣在urule.debug屬性為(wèi)true情況下就會向這個目錄下寫入日志(zhì)文(wén)件,<br>
* 需要的時候,可(kě)以通過實現com.bstek.urule.debug.DebugWriter接口定義自己的日志(zhì)輸出文(wén)件,這樣就可(kě)以将日志(zhì)輸出到任何地方
* @throws IOException 抛出IO異常
*/
void writeLogFile() throws IOException;
/**
* @return 返回對應的知識包集合
*/
List<KnowledgePackage> getKnowledgePackageList();
/**
* @return 返回Rete實例對象集合
*/
List<ReteInstance> getReteInstanceList();
/**
* @return 返回當前緩存的KnowledgeSession Map對象
*/
Map<String,KnowledgeSession> getKnowledgeSessionMap();
/**
* @return 返回當前KnowledgeSession的父,如果不存在則返回null
*/
KnowledgeSession getParentSession();
}
可(kě)以看到KnowledgeSession接口擴展自WorkingMemory接口,WorkingMemory接口源碼如下:
package com.bstek.urule.runtime;
import java.util.List;
import java.util.Map;
import com.bstek.urule.runtime.log.LogManager;
import com.bstek.urule.runtime.rete.Context;
public interface WorkingMemory{
/**
* 插入一個業務(wù)數據對象,對應到規則當中(zhōng)就是一個變量對象
* @param fact 目标業務(wù)數據對象
* @return 插入是否成功
*/
boolean insert(Object fact);
/**
* 更新(xīn)一個在當前WorkingMemory中(zhōng)已存在的業務(wù)對象,如果對象存在,那麽WorkingMemory會重新(xīn)評估這個對象
* @param fact 要更新(xīn)的對象
* @return 更新(xīn)是否成功,如果對象不在WorkingMemory中(zhōng),則返回false
*/
boolean update(Object fact);
/**
* 獲取當前WorkingMemory中(zhōng)的某個參數值
* @param key 參數對應的key值
* @return 返回具(jù)體(tǐ)的值
*/
Object getParameter(String key);
/**
* @return 返回所有(yǒu)的參數對象
*/
Map<String,Object> getParameters();
/**
* @return 返回當前WorkingMemory中(zhōng)所有(yǒu)類型的業務(wù)數據對象
*/
Map<String,Object> getAllFactsMap();
/**
* @return 返回插入到當前WorkingMemory中(zhōng)所有(yǒu)業務(wù)對象
*/
List<Object> getFactList();
/**
* 根據knowledgePackageWrapper的id返回對應的KnowledgeSession對象
* @param id knowledgePackageWrapper的id
* @return 對應的KnowledgeSession對象
*/
KnowledgeSession getKnowledgeSession(String id);
/**
* 将KnowledgeSession對象放入緩存以備下次調用(yòng)時使用(yòng)
* @param id knowledgePackageWrapper的id
* @param session 對應的KnowledgeSession對象
*/
void putKnowledgeSession(String id,KnowledgeSession session);
/**
* 向當前Session中(zhōng)放入變量
* @param key 變量Key
* @param value 變量值
*/
void setSessionValue(String key,Object value);
/**
* 取出當前Session中(zhōng)對應的變量
* @param key 變量key
* @return 變量值
*/
Object getSessionValue(String key);
/**
* @return 返回當前SessionValueMap對象
*/
Map<String,Object> getSessionValueMap();
/**
* 激活某個設置了互斥組屬性的具(jù)體(tǐ)的規則
* @param activationGroupName 互斥組屬性值
* @param ruleName 規則名(míng)
*/
void activeRule(String activationGroupName,String ruleName);
/**
* 激活指定名(míng)稱的執行組
* @param groupName 執行組名(míng)稱
*/
void activePendedGroup(String groupName);
/**
* 激活指定名(míng)稱的執行組并立即執行執行組規則對應的動作(zuò)部分(fēn)
* @param groupName 執行組名(míng)稱
*/
void activePendedGroupAndExecute(String groupName);
/**
* 返回當前上下文(wén)對象
* @return 返回當前上下文(wén)對象
*/
Context getContext();
/**
* @return 返回當前LogManager對象
*/
LogManager getLogManager();
/**
* @return 返回當前FactManager對象
*/
FactManager getFactManager();
}
要通過KnowledgePackage對象或這個對象的數組創建一個KnowledgeSession對象,可(kě)以通過com.bstek.urule.runtime.KnowledgeSessionFactory類中(zhōng)下面兩個靜态方法實現:
/**
* 創建一個普通的KnowledgeSession對象
* @param knowledgePackage 創建KnowledgeSession對象所需要的KnowledgePackage對象
* @return 返回一個新(xīn)的KnowledgeSession對象
*/
public static KnowledgeSession newKnowledgeSession(KnowledgePackage knowledgePackage){
return new KnowledgeSessionImpl(knowledgePackage);
}
/**
* 創建一個普通的KnowledgeSession對象
* @param knowledgePackage 創建KnowledgeSession對象所需要的KnowledgePackage集合對象
* @return 返回一個新(xīn)的KnowledgeSession對象
*/
public static KnowledgeSession newKnowledgeSession(KnowledgePackage[] knowledgePackages){
return new KnowledgeSessionImpl(knowledgePackages);
}
單次調用(yòng)
由于這兩個方法都是靜态方法,所以可(kě)以直接調用(yòng),下面的代碼中(zhōng)演示了完整的調用(yòng)過程:
package tt;
import rete.test.Dept;
import rete.test.Employee;
import com.bstek.urule.Utils;
import com.bstek.urule.runtime.KnowledgePackage;
import com.bstek.urule.runtime.KnowledgeSession;
import com.bstek.urule.runtime.KnowledgeSessionFactory;
import com.bstek.urule.runtime.service.KnowledgeService;
/**
* @author Jacky.gao
* @since 2015年3月5日
*/
public class Invoke {
public void doTest() throws Exception{
//從Spring中(zhōng)獲取KnowledgeService接口實例
KnowledgeService service=(KnowledgeService)Utils.getApplicationContext().getBean(KnowledgeService.BEAN_ID);
//通過KnowledgeService接口獲取指定的資源包"projectName/test123"
KnowledgePackage knowledgePackage=service.getKnowledge("projectName/test123");
//通過取到的KnowledgePackage對象創建KnowledgeSession對象
KnowledgeSession session=KnowledgeSessionFactory.newKnowledgeSession(knowledgePackage);
Employee employee=new Employee();
Dept dept=new Dept();
dept.setLevel(12);
employee.setDept(dept);
employee.setSalary(111000);
//将業務(wù)數據對象Employee插入到KnowledgeSession中(zhōng)
session.insert(employee);
//執行所有(yǒu)滿足條件的規則
session.fireRules();
}
}
在上面的示例當中(zhōng),獲取到KnowledgeSession對象後,向其中(zhōng)插入一個名(míng)為(wèi)Employee業務(wù)數據對象,這樣引擎在計算時,會直接采用(yòng)Employee中(zhōng)相關數據,如有(yǒu)條件滿足,同時有(yǒu)對Employee中(zhōng)相關數據賦值,那麽會直接反映到當前插入的這個Employee對象當中(zhōng)。
在實際使用(yòng)中(zhōng),可(kě)能(néng)還會向KnowledgeSession中(zhōng)添加參數數據(以Map形式添加),對應URule中(zhōng)的參數庫文(wén)件中(zhōng)定義的信息,引擎計算完成後,我們要通KnowledgeSession中(zhōng)的getParameter來獲取具(jù)體(tǐ)的參數對象,而不 能(néng)通過原添加的Map中(zhōng)獲取,如下代碼:
package tt;
import java.util.HashMap;
import java.util.Map;
import rete.test.Dept;
import rete.test.Employee;
import com.bstek.urule.Utils;
import com.bstek.urule.runtime.KnowledgePackage;
import com.bstek.urule.runtime.KnowledgeSession;
import com.bstek.urule.runtime.KnowledgeSessionFactory;
import com.bstek.urule.runtime.service.KnowledgeService;
/**
* @author Jacky.gao
* @since 2015年3月5日
*/
public class Invoke {
public void doTest() throws Exception{
//從Spring中(zhōng)獲取KnowledgeService接口實例
KnowledgeService service=(KnowledgeService)Utils.getApplicationContext().getBean(KnowledgeService.BEAN_ID);
//通過KnowledgeService接口獲取指定的資源包"test123"
KnowledgePackage knowledgePackage=service.getKnowledge("projectName/test123");
//通過取到的KnowledgePackage對象創建KnowledgeSession對象
KnowledgeSession session=KnowledgeSessionFactory.newKnowledgeSession(knowledgePackage);
Employee employee=new Employee();
Dept dept=new Dept();
dept.setLevel(12);
employee.setDept(dept);
employee.setSalary(111000);
//将業務(wù)數據對象Employee插入到KnowledgeSession中(zhōng)
session.insert(employee);
//執行所有(yǒu)滿足條件的規則
Map<String,Object> parameter=new HashMap<String,Object>();
parameter.put("count", 10);
parameter.put("result", true);
//觸發規則時并設置參數
session.fireRules(parameter);
//獲取計算後的result值,要通過KnowledgeSession,而不能(néng)通過原來的parameter對象
boolean result=(Boolean)session.getParameter("result");
System.out.println(result);
}
}
從上面的代碼中(zhōng)可(kě)以看到,在規則計算完成後,在獲取計算後的參數中(zhōng)的result值時,我們并沒有(yǒu)用(yòng)提供參數的parameter,而是通過KnowledgeSession的getParameter來實現,這是因為(wèi)在向KnowledgeSession設置參數時,引擎會将參數中(zhōng)所有(yǒu)的值取出并放入到引擎中(zhōng)内置的一個Map中(zhōng),以避免影響原參數的值。所以計算完成後,我們要通過KnowledgeSession的getParameter來獲取計算後的參數值。
如果我們的資源包中(zhōng)包含有(yǒu)規則流,那麽在插入好相關業務(wù)數據對象後,可(kě)以通過KnowledgeSession中(zhōng)提供的startProcess來實現規則流的調用(yòng),如下面的代碼所示:
package tt;
import java.util.HashMap;
import java.util.Map;
import rete.test.Dept;
import rete.test.Employee;
import com.bstek.urule.Utils;
import com.bstek.urule.runtime.KnowledgePackage;
import com.bstek.urule.runtime.KnowledgeSession;
import com.bstek.urule.runtime.KnowledgeSessionFactory;
import com.bstek.urule.runtime.service.KnowledgeService;
/**
* @author Jacky.gao
* @since 2015年3月5日
*/
public class Invoke {
public void doTest() throws Exception{
//從Spring中(zhōng)獲取KnowledgeService接口實例
KnowledgeService service=(KnowledgeService)Utils.getApplicationContext().getBean(KnowledgeService.BEAN_ID);
//通過KnowledgeService接口獲取指定的資源包"test123"
KnowledgePackage knowledgePackage=service.getKnowledge("projectName/test123");
//通過取到的KnowledgePackage對象創建KnowledgeSession對象
KnowledgeSession session=KnowledgeSessionFactory.newKnowledgeSession(knowledgePackage);
Employee employee=new Employee();
Dept dept=new Dept();
dept.setLevel(12);
employee.setDept(dept);
employee.setSalary(111000);
//将業務(wù)數據對象Employee插入到KnowledgeSession中(zhōng)
session.insert(employee);
//執行所有(yǒu)滿足條件的規則
Map<String,Object> parameter=new HashMap<String,Object>();
parameter.put("count", 10);
parameter.put("result", true);
//開始規則流并設置參數
session.startProcess("flow-test",parameter);
//獲取計算後的result值,要通過KnowledgeSession,而不能(néng)通過原來的parameter對象
boolean result=(Boolean)session.getParameter("result");
System.out.println(result);
}
}
在URule Pro當中(zhōng),規則流中(zhōng)是不存在人工(gōng)任務(wù)的,也就是說規則流的執行是一次性完成的,這點與包含人工(gōng)任務(wù)的工(gōng)作(zuò)流引擎不同,比如UFLO,在UFLO中(zhōng)有(yǒu)人工(gōng)任務(wù),所以開啓流程實例後可(kě)能(néng)需要多(duō)次完成人工(gōng)任務(wù)才能(néng)完成一個流程實例。
使用(yòng)GeneralEntity傳遞值
在代碼中(zhōng)調用(yòng)知識包,對于需要插入到規則中(zhōng)的變量對象,可(kě)能(néng)當前環境裏并不存在,或者說這種變量的屬性是動态可(kě)變的,對于這兩種我們可(kě)以使用(yòng)URule Pro中(zhōng)提供的GeneralEntity來代替實際的業務(wù)對象。
GeneralEntity擴展自HashMap,所以可(kě)以通過Map的put方法将目标對象的屬性及其值在代碼中(zhōng)逐個填入,同時GeneralEntity實例化時要求必須要提供一個String類型的構造參數,這個String類型的值表示的就是目标業務(wù)對象的完整類名(míng)。 上面的通過startProcess來實現規則流的調用(yòng)代碼示例,通過使用(yòng)GeneralEntity來代替實際業務(wù)對象,代碼就是下面的樣子:
package tt;
import java.util.HashMap;
import java.util.Map;
import com.bstek.urule.Utils;
import com.bstek.urule.model.GeneralEntity;
import com.bstek.urule.runtime.KnowledgePackage;
import com.bstek.urule.runtime.KnowledgeSession;
import com.bstek.urule.runtime.KnowledgeSessionFactory;
import com.bstek.urule.runtime.service.KnowledgeService;
/**
* @author Jacky.gao
* @since 2015年3月5日
*/
public class Invoke {
public void doTest() throws Exception{
//從Spring中(zhōng)獲取KnowledgeService接口實例
KnowledgeService service=(KnowledgeService)Utils.getApplicationContext().getBean(KnowledgeService.BEAN_ID);
//通過KnowledgeService接口獲取指定的資源包"test123"
KnowledgePackage knowledgePackage=service.getKnowledge("projectName/test123");
//通過取到的KnowledgePackage對象創建KnowledgeSession對象
KnowledgeSession session=KnowledgeSessionFactory.newKnowledgeSession(knowledgePackage);
GeneralEntity employee=new GeneralEntity("rete.test.Employee");
GeneralEntity dept=new GeneralEntity("rete.test.Dept");
dept.setLevel(12);
employee.setDept(dept);
employee.setSalary(111000);
//将業務(wù)數據對象Employee插入到KnowledgeSession中(zhōng)
session.insert(employee);
//執行所有(yǒu)滿足條件的規則
Map<String,Object> parameter=new HashMap<String,Object>();
parameter.put("count", 10);
parameter.put("result", true);
//開始規則流并設置參數
session.startProcess("flow-test",parameter);
//獲取計算後的result值,要通過KnowledgeSession,而不能(néng)通過原來的parameter對象
boolean result=(Boolean)session.getParameter("result");
System.out.println(result);
}
}
在上面的代碼當中(zhōng),我們就通過GeneralEntity來代替實際的Employee和Dept對象插入到規則當中(zhōng),運行後我們發現其結果與實際的Employee和Dept對象插入到規則當中(zhōng)運行結果完全一緻。
實際上,在URule Pro提供的快速測試、基于JSON的快速測試、防真測試三種測試工(gōng)具(jù)中(zhōng)以及Rest服務(wù)裏,實際在調用(yòng)規則傳遞變量時采用(yòng)的都是GeneralEntity來代替實際的業務(wù)對象, 所以如果我們在代碼中(zhōng)調用(yòng)業務(wù)規則實際業務(wù)對象不存在時,也可(kě)以采用(yòng)GeneralEntity實現業務(wù)數據的傳遞。
批處理(lǐ)支持
實際業務(wù)當中(zhōng),我們除了會做單條規則計算外,還有(yǒu)可(kě)能(néng)需要運行規則引擎來處理(lǐ)一大批數據,這些數據可(kě)能(néng)有(yǒu)幾萬條,幾十萬條,甚至更多(duō)。在這種情況下,如果我們還是采用(yòng)普通的KnowledgeSession在一個線(xiàn)程裏處理(lǐ)大批量數據的話,那麽引擎還是隻能(néng)在當前線(xiàn)程裏運行,這樣就會需要很(hěn)長(cháng)的時間才能(néng)可(kě)能(néng)将這幾十萬條甚至更多(duō)的數據處理(lǐ)完成,在這個時候,為(wèi)了充分(fēn)利用(yòng)服務(wù)器較強的CPU性能(néng),我們可(kě)以使用(yòng)BatchSession利用(yòng)多(duō)線(xiàn)程并行處理(lǐ)這些數據。顧名(míng)思義BatchSession是用(yòng)來做批處理(lǐ)任務(wù)的會話對象,它是 URule Pro當中(zhōng)提供的多(duō)線(xiàn)程并行處理(lǐ)大批量業務(wù)數據的規則會話對象。
要得到一個BatchSession對象,我們也需要提供一個或多(duō)個KnowledgePackage對象,獲取KnowledgePackage對象的方法與上面介紹的方法相同,有(yǒu)了KnowledgePackage對象後,就可(kě)以利用(yòng)KnowledgeSessionFactory類創建一個BatchSession對象。
在com.bstek.urule.runtime.KnowledgeSessionFactory類中(zhōng)除上面提到的兩個構建KnowledgeSession的靜态方法外,還提供了另外八個可(kě)用(yòng)于構建BatchSession的靜态方法,其源碼如下:
/**
* 創建一個用(yòng)于批處理(lǐ)的BatchSession對象,這裏默認将開啓10個普通的線(xiàn)程池來運行提交的批處理(lǐ)任務(wù),默認将每100個任務(wù)放在一個線(xiàn)程裏處理(lǐ)
* @param knowledgePackage 創建BatchSession對象所需要的KnowledgePackage對象
* @return 返回一個新(xīn)的BatchSession對象
*/
public static BatchSession newBatchSession(KnowledgePackage knowledgePackage){
return new BatchSessionImpl(knowledgePackage,BatchSession.DEFAULT_THREAD_SIZE,BatchSession.DEFAULT_BATCH_SIZE);
}
/**
* 創建一個用(yòng)于批處理(lǐ)的BatchSession對象,第二個參數來指定線(xiàn)程池中(zhōng)可(kě)用(yòng)線(xiàn)程個數,默認将每100個任務(wù)放在一個線(xiàn)程裏處理(lǐ)
* @param knowledgePackage 創建BatchSession對象所需要的KnowledgePackage對象
* @param threadSize 線(xiàn)程池中(zhōng)可(kě)用(yòng)的線(xiàn)程個數
* @return 返回一個新(xīn)的BatchSession對象
*/
public static BatchSession newBatchSessionByThreadSize(KnowledgePackage knowledgePackage,int threadSize){
return new BatchSessionImpl(knowledgePackage,threadSize,BatchSession.DEFAULT_BATCH_SIZE);
}
/**
* 創建一個用(yòng)于批處理(lǐ)的BatchSession對象,這裏默認将開啓10個普通的線(xiàn)程池來運行提交的批處理(lǐ)任務(wù),第二個參數用(yòng)來決定單個線(xiàn)程處理(lǐ)的任務(wù)數
* @param knowledgePackage 創建BatchSession對象所需要的KnowledgePackage對象
* @param batchSize 單個線(xiàn)程處理(lǐ)的任務(wù)數
* @return 返回一個新(xīn)的BatchSession對象
*/
public static BatchSession newBatchSessionByBatchSize(KnowledgePackage knowledgePackage,int batchSize){
return new BatchSessionImpl(knowledgePackage,BatchSession.DEFAULT_THREAD_SIZE,batchSize);
}
/**
* 創建一個用(yòng)于批處理(lǐ)的BatchSession對象,第二個參數來指定線(xiàn)程池中(zhōng)可(kě)用(yòng)線(xiàn)程個數,第三個參數用(yòng)來決定單個線(xiàn)程處理(lǐ)的任務(wù)數
* @param knowledgePackage 創建BatchSession對象所需要的KnowledgePackage對象
* @param threadSize 線(xiàn)程池中(zhōng)可(kě)用(yòng)的線(xiàn)程個數
* @param batchSize 單個線(xiàn)程處理(lǐ)的任務(wù)數
* @return 返回一個新(xīn)的BatchSession對象
*/
public static BatchSession newBatchSession(KnowledgePackage knowledgePackage,int threadSize,int batchSize){
return new BatchSessionImpl(knowledgePackage,threadSize,batchSize);
}
/**
* 創建一個用(yòng)于批處理(lǐ)的BatchSession對象,這裏默認将開啓10個普通的線(xiàn)程池來運行提交的批處理(lǐ)任務(wù),默認将每100個任務(wù)放在一個線(xiàn)程裏處理(lǐ)
* @param knowledgePackage 創建BatchSession對象所需要的KnowledgePackage集合對象
* @return 返回一個新(xīn)的BatchSession對象
*/
public static BatchSession newBatchSession(KnowledgePackage[] knowledgePackages){
return new BatchSessionImpl(knowledgePackages,BatchSession.DEFAULT_THREAD_SIZE,BatchSession.DEFAULT_BATCH_SIZE);
}
/**
* 創建一個用(yòng)于批處理(lǐ)的BatchSession對象,第二個參數來指定線(xiàn)程池中(zhōng)可(kě)用(yòng)線(xiàn)程個數,默認将每100個任務(wù)放在一個線(xiàn)程裏處理(lǐ)
* @param knowledgePackages 創建BatchSession對象所需要的KnowledgePackage集合對象
* @param threadSize 線(xiàn)程池中(zhōng)可(kě)用(yòng)的線(xiàn)程個數
* @return 返回一個新(xīn)的BatchSession對象
*/
public static BatchSession newBatchSessionByThreadSize(KnowledgePackage[] knowledgePackages,int threadSize){
return new BatchSessionImpl(knowledgePackages,threadSize,BatchSession.DEFAULT_BATCH_SIZE);
}
/**
* 創建一個用(yòng)于批處理(lǐ)的BatchSession對象,這裏默認将開啓10個普通的線(xiàn)程池來運行提交的批處理(lǐ)任務(wù),第二個參數用(yòng)來決定單個線(xiàn)程處理(lǐ)的任務(wù)數
* @param knowledgePackages 創建BatchSession對象所需要的KnowledgePackage集合對象
* @param batchSize 單個線(xiàn)程處理(lǐ)的任務(wù)數
* @return 返回一個新(xīn)的BatchSession對象
*/
public static BatchSession newBatchSessionByBatchSize(KnowledgePackage[] knowledgePackages,int batchSize){
return new BatchSessionImpl(knowledgePackages,BatchSession.DEFAULT_THREAD_SIZE,batchSize);
}
/**
* 創建一個用(yòng)于批處理(lǐ)的BatchSession對象,第二個參數來指定線(xiàn)程池中(zhōng)可(kě)用(yòng)線(xiàn)程個數,第三個參數用(yòng)來決定單個線(xiàn)程處理(lǐ)的任務(wù)數
* @param knowledgePackages 創建BatchSession對象所需要的KnowledgePackage集合對象
* @param threadSize 線(xiàn)程池中(zhōng)可(kě)用(yòng)的線(xiàn)程個數
* @param batchSize 單個線(xiàn)程處理(lǐ)的任務(wù)數
* @return 返回一個新(xīn)的BatchSession對象
*/
public static BatchSession newBatchSession(KnowledgePackage[] knowledgePackages,int threadSize,int batchSize){
return new BatchSessionImpl(knowledgePackages,threadSize,batchSize);
}
前面介紹規則流中(zhōng)的決策節點時,了解到決策節點中(zhōng)支持百分(fēn)比分(fēn)流,這種百分(fēn)比分(fēn)流就要求必須是在使用(yòng)BatchSession處理(lǐ)一批數據的時候,或者是一個用(yòng)一個普通的KnowledgeSession一次性處理(lǐ)多(duō)條數據才有(yǒu)效,否則規則流隻會走比例最高的那個分(fēn)支。
BatchSession接口比較簡單,它隻定義了兩個方法:
/**
* 添加一個具(jù)體(tǐ)要執行Business對象
* @param business Business對象實例
*/
void addBusiness(Business business);
/**
* 等待線(xiàn)程池中(zhōng)所有(yǒu)業務(wù)線(xiàn)程執行完成,在進行批處理(lǐ)操作(zuò)時一定要以此方法作(zuò)為(wèi)方法調用(yòng)結尾
*/
void waitForCompletion();
可(kě)以看到,它可(kě)以接收若幹個名(míng)為(wèi)com.bstek.urule.runtime.Business接口實例,Business接口比較簡單,它隻有(yǒu)一個方法:
package com.bstek.urule.runtime;
/**
* @author Jacky.gao
* @since 2015年9月29日
*/
public interface Business {
void execute(KnowledgeSession session);
}
在Business實現類中(zhōng),我們的業務(wù)寫在execute方法當中(zhōng),在這個方法中(zhōng),隻有(yǒu)一個KnowledgeSession對象,這個session對象就是我們與規則引擎操作(zuò)的對象,示例代碼如下:
//從Spring中(zhōng)獲取KnowledgeService接口實例
KnowledgeService service=(KnowledgeService)Utils.getApplicationContext().getBean(KnowledgeService.BEAN_ID);
//通過KnowledgeService接口獲取指定的資源包"aaa"
KnowledgePackage knowledgePackage=service.getKnowledge("projectName/aaa");
//通過取的KnowledgePackage對象創建BatchSession對象,在這個對象中(zhōng),我們将開啓5個線(xiàn)程,每個線(xiàn)程最多(duō)放置10個Bussiness接口實例運行
BatchSession batchSession=KnowledgeSessionFactory.newBatchSession(knowledgePackage, 5, 10);
for(int i=0;i<100;i++){
batchSession.addBusiness(new Business(){
@Override
public void execute(KnowledgeSession session) {
Employee employee=new Employee();
employee.setSalary(11080);
//将業務(wù)數據對象Employee插入到KnowledgeSession中(zhōng)
session.insert(employee);
session.startProcess("demo");
}
});
}
//等待所有(yǒu)的線(xiàn)程執行完成,對于BatchSession調用(yòng)來說,此行代碼必不可(kě)少,否則将導緻錯誤
batchSession.waitForCompletion();
其它API
這裏羅列了幾個非常用(yòng)的api,這些api涉及到操作(zuò)知識庫裏的文(wén)件、操作(zuò)知識包、查看文(wén)件引用(yòng)等相關api,這裏羅列出來,我們可(kě)以根據業務(wù)需要,通過調用(yòng)這些api可(kě)實現在業務(wù)系統中(zhōng)操作(zuò)知識包或知識庫裏的文(wén)件等。
這些接口實現都配置在Spring當中(zhōng),如果我們需要在業務(wù)代碼中(zhōng)調用(yòng)這些接口方法,那麽可(kě)以通過Spring的ApplicationContext引用(yòng)它們,比如要使用(yòng)RepositoryService接口,那麽可(kě)以通過下面的代碼獲取RepositoryService接口 在Spring中(zhōng)的對象實例引用(yòng):
KnowledgeService service=(KnowledgeService)Utils.getApplicationContext().getBean(RepositoryService.BEAN_ID);
上面的代碼中(zhōng)的RepositoryService.BEAN_ID是一個定義在RepositoryService接口中(zhōng)的靜态常量,用(yòng)于表示它在Spring中(zhōng)定義的Bean的ID。其實不僅是RepositoryService接口, 後面要介紹除了RefactorService(RefactorService對象實例要通過RepositoryService接口中(zhōng)getRefactorService()方法獲取)外, ReferenceService、KnowledgePackageRepositoryService等都有(yǒu)一個名(míng)為(wèi)BEAN_ID的靜态常量,也都可(kě)以通過它來獲取它們在Spring中(zhōng)定義的Bean的ID值。
RepositoryService
RepositoryService接口中(zhōng)定義了針對知識庫文(wén)件操作(zuò)的大部分(fēn)方法,其源碼如下:
package com.bstek.urule.console.repository;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.List;
import com.bstek.urule.console.Principal;
import com.bstek.urule.console.repository.model.FileType;
import com.bstek.urule.console.repository.model.RepositoryFile;
import com.bstek.urule.console.repository.refactor.Item;
import com.bstek.urule.console.repository.refactor.RefactorService;
public interface RepositoryService extends RepositoryReader{
public static final String BEAN_ID="urule.repositoryService";
/**
* @param filePath 文(wén)件路徑
* @return 返回文(wén)件是否存在
* @throws Exception 抛出異常
*/
boolean fileExistCheck(String filePath) throws Exception;
/**
* @param projectName 項目名(míng)稱
* @param user 創建人
* @param classify 是否采用(yòng)分(fēn)類方式返回創建好的項目結果
* @return 返回創建好的項目結果對象RepositoryFile
* @throws Exception 抛出異常
*/
RepositoryFile createProject(String projectName,Principal user,boolean classify) throws Exception;
/**
* 創建目錄
* @param path 新(xīn)目錄的路徑
* @param user 創建人
* @throws Exception 抛出異常
*/
void createDir(String path,Principal user) throws Exception;
/**
* 創建文(wén)件
* @param path 文(wén)件路徑
* @param content 文(wén)件内容
* @param user 創建人
* @throws Exception 抛出異常
*/
void createFile(String path,String content,Principal user) throws Exception;
/**
* 保存文(wén)件
* @param path 文(wén)件路徑
* @param content 文(wén)件内容
* @param newVersion 是否以版本形式保存
* @param versionComment 版本内容,如果不是以版本形式保存,這裏給null即可(kě)
* @param user 保存文(wén)件的用(yòng)戶
* @throws Exception 抛出異常
*/
void saveFile(String path,String content,boolean newVersion,String versionComment,Principal user) throws Exception;
/**
* 删除文(wén)件
* @param path 要删除的文(wén)件路徑
* @param user 操作(zuò)的用(yòng)戶
* @throws Exception 抛出異常
*/
void deleteFile(String path,Principal user)throws Exception;
/**
* 鎖定指定文(wén)件
* @param path 文(wén)件路徑
* @param user 操作(zuò)的用(yòng)戶
* @throws Exception 抛出異常
*/
void lockPath(String path,Principal user) throws Exception;
/**
* 解鎖文(wén)件
* @param path 文(wén)件路徑
* @param user 操作(zuò)的用(yòng)戶
* @throws Exception 抛出異常
*/
void unlockPath(String path,Principal user) throws Exception;
/**
* 加載項目
* @param project 項目名(míng)
* @param user 操作(zuò)的用(yòng)戶,會根據這個用(yòng)戶權限過濾加載後的文(wén)件
* @param classify 返回的項目是否以分(fēn)類形式展示
* @param types 要加載的文(wén)件類型
* @param searchFileName 要搜索的文(wén)件文(wén)件名(míng)
* @return 返回項目的Repository對象
* @throws Exception 抛出異常
*/
Repository loadRepository(String project,Principal user,boolean classify,FileType[] types,String searchFileName) throws Exception;
/**
* 文(wén)件重命名(míng)
* @param path 文(wén)件原路徑
* @param newPath 新(xīn)路徑
* @throws Exception 抛出異常
*/
void fileRename(String path, String newPath) throws Exception;
/**
* 将指定項目以xml形式導出
* @param projectPath 要導出項目
* @param outputStream 導入後的項目要輸出的目的地
* @throws Exception 抛出異常
*/
void exportXml(String projectPath,OutputStream outputStream)throws Exception;
/**
* 導出所有(yǒu)項目
* @param outputStream 導入後要輸出的目的地
* @throws Exception 抛出異常
*/
void exportXml(OutputStream outputStream)throws Exception;
/**
* 導入xml文(wén)件
* @param inputStream要導入的xml的數據源
* @param overwrite 是否覆蓋已存在的項目
* @throws Exception 抛出異常
*/
void importXml(InputStream inputStream,boolean overwrite)throws Exception;
/**
* @param project 項目名(míng)稱
* @return 返回指定項目的目錄信息
* @throws Exception 抛出異常
*/
List<RepositoryFile> getDirectories(String project) throws Exception;
/**
* @param project 項目名(míng)
* @param all 是否返回所有(yǒu)的客戶端配置信息,包含<b>禁用(yòng)</b>狀态的客戶信息
* @return 返回客戶端信息列表
* @throws Exception 抛出異常
*/
List<ClientConfig> loadClientConfigs(String project,boolean all)throws Exception;
/**
* @param path 項目路徑
* @return 返回項目名(míng),會去除項目名(míng)前可(kě)能(néng)存在的/
*/
String getProject(String path);
/**
* @return 返回項目中(zhōng)配置的ClientProvider接口實現,如果有(yǒu)的話
*/
ClientProvider getClientProvider();
/**
* 重構庫文(wén)件内容
* @param path 是重構的庫文(wén)件路徑
* @param item 要重構的内容
* @throws Exception 抛出異常
*/
void refactorContent(String path,Item item) throws Exception;
/**
* @param path 文(wén)件路徑
* @return 返回文(wén)件是否存在
* @throws Exception 抛出異常
*/
boolean fileExist(String path) throws Exception;
/**
* @param project 指定的項目
* @param principal 操作(zuò)人
* @return 返回指定項目中(zhōng)所有(yǒu)的變量庫文(wén)件内容信息列表
* @throws Exception 抛出異常
*/
List<ProjectVariable> loadProjectLibraries(String project,Principal principal) throws Exception;
/**
* @return 返回當前的RefactorService實例對象
*/
RefactorService getRefactorService();
}
RepositoryService接口擴展自RepositoryReader,在RepositoryReader接口中(zhōng)定義了一些用(yòng)于讀取知識庫文(wén)件的相關操作(zuò),其源碼如下:
package com.bstek.urule.console.repository;
import java.io.InputStream;
import java.util.List;
import com.bstek.urule.console.repository.model.RepositoryFile;
import com.bstek.urule.console.repository.model.VersionFile;
public interface RepositoryReader {
/**
* 加載指定的companyId下創建的所有(yǒu)的項目信息
* @param companyId 指定的公(gōng)司ID
* @return 返回所有(yǒu)的項目信息
* @throws Exception 抛出異常
*/
List<RepositoryFile> loadProjects(String companyId) throws Exception;
/**
* 讀取指定的最新(xīn)版本的文(wén)件
* @param path 文(wén)件考路徑
* @return 返回文(wén)件内容
* @throws Exception 抛出異常
*/
InputStream readFile(String path) throws Exception;
/**
* 獲取指定路徑文(wén)件的所有(yǒu)版本信息
* @param path 文(wén)件路徑
* @return 返回版本信息列表
* @throws Exception 抛出異常
*/
List<VersionFile> getVersionFiles(String path) throws Exception;
/**
* 讀取指定版本文(wén)件
* @param path 文(wén)件路徑
* @param version 文(wén)件版本号
* @return 返回文(wén)件内容
* @throws Exception 抛出異常
*/
InputStream readFile(String path, String version) throws Exception;
}
RefactorService
RefactorService的作(zuò)用(yòng)是用(yòng)于實現對規則文(wén)件名(míng)以及庫文(wén)件中(zhōng)定義的信息值的重命名(míng)操作(zuò),也就是我們通常說的重構操作(zuò)。RefactorService接口比較特殊, 它的實例要通過RepositoryService接口中(zhōng)提供的getRefactorService()方法獲取,RefactorService接口源碼如下:
package com.bstek.urule.console.repository.refactor;
import com.bstek.urule.console.repository.Repository;
public interface RefactorService {
/**
* 重構文(wén)件名(míng)操作(zuò),路徑要以jcr:開頭
* @param oldPath 舊路徑
* @param newPath 新(xīn)路徑
* @throws Exception 抛出異常
*/
void refactorFile(String oldPath,String newPath) throws Exception;
/**
* 重構指定Repository下所有(yǒu)文(wén)件,路徑要以jcr:開頭
* @param oldPath 舊路徑
* @param newPath 新(xīn)路徑
* @param repo 指定的Repository
* @throws Exception 抛出異常
*/
void refactorFile(String oldPath,String newPath,Repository repo) throws Exception;
/**
* 重構某個變量庫文(wén)件或常量庫文(wén)件或參數庫文(wén)件或動作(zuò)庫文(wén)件下某具(jù)體(tǐ)值
* @param path 具(jù)體(tǐ)值所在庫文(wén)件路徑,路徑要以jcr:開頭
* @param item 要重構的庫文(wén)件内容的具(jù)體(tǐ)值
* @throws Exception 抛出異常
*/
void refactorItem(String path,Item item) throws Exception;
}
ReferenceService
顧名(míng)思義,ReferenceService接口作(zuò)用(yòng)是用(yòng)于查看庫文(wén)件以及庫文(wén)件定義在其它文(wén)件中(zhōng)引用(yòng)的接口,基實例定義在Spring中(zhōng),在Spring中(zhōng)的Bean的ID為(wèi)ReferenceService.BEAN_ID, ReferenceService接口源碼如下:
package com.bstek.urule.console.repository.reference;
import java.util.List;
public interface ReferenceService {
public static final String BEAN_ID="urule.referenceService";
/**
* @param path 被引用(yòng)的文(wén)件路徑
* @param item 包含的内容對象
* @return 返回引用(yòng)了當前庫文(wén)件指定内容的其它文(wén)件列表
* @throws Exception 抛出異常
*/
List<RefFile> loadReferenceFiles(String path,SearchItem item) throws Exception;
/**
* @param path 被引用(yòng)的文(wén)件路徑
* @return 返回引用(yòng)了當前文(wén)件的其它文(wén)件列表
* @throws Exception 抛出異常
*/
List<RefFile> loadReferenceFiles(String path) throws Exception;
}
KnowledgePackageRepositoryService
KnowledgePackageRepositoryService操作(zuò)的對象是定義在項目中(zhōng)的知識包對象,基實例定義在Spring中(zhōng),在Spring中(zhōng)的Bean的ID為(wèi)KnowledgePackageRepositoryService.BEAN_ID,其源碼如下:
package com.bstek.urule.console.repository;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
import com.bstek.urule.console.repository.model.ResourcePackage;
import com.bstek.urule.console.repository.model.VersionFile;
import com.bstek.urule.model.library.variable.VariableCategory;
import com.bstek.urule.runtime.KnowledgePackage;
public interface KnowledgePackageRepositoryService {
/**
* 根據指定格式的知識包信息,獲取當前知識包的所有(yǒu)已發布的版本信息
* @param packageInfo 知識包信息,格式為(wèi):項目名(míng)/知識包ID,如:testProject/testPackage
* @return 返回所有(yǒu)已發布的知識包版本集合信息
*/
List<VersionFile> getKnowledgePackges(String packageInfo);
/**
* 返回已發布的知識包指定版本對應的文(wén)件信息
* @param packageInfo 知識包信息,格式為(wèi):項目名(míng)/知識包ID,如:testProject/testPackage
* @param version 指定的已發布的知識包版本
* @return 返回對應的文(wén)件信息Map
*/
Map<String,Object> loadKnowledgePackageFiles(String packageInfo,String version);
/**
* @param packageInfo 知識包信息,格式為(wèi):項目名(míng)/知識包ID,如:testProject/testPackage
* @return 返回已發布的當前處于激活狀态下的知識包的版本信息
*/
VersionFile getActivedKnowledgePackge(String packageInfo);
/**
* @param packageInfo 知識包信息,格式為(wèi):項目名(míng)/知識包ID,如:testProject/testPackage
* @param version 指定的已發布的版本
* @return 返回對應版本的已發布的知識包編譯後的byte信息
*/
byte[] getKnowledgePackgeBytes(String packageInfo,String version);
/**
* @param packageInfo 知識包信息,格式為(wèi):項目名(míng)/知識包ID,如:testProject/testPackage
* @param version 指定的已發布的版本
* @return 返回對應版本的已發布的知識包編譯後的KnowledgePackage對象信息
*/
KnowledgePackage getKnowledgePackge(String packageInfo,String version);
/**
* @param packageInfo 知識包信息,格式為(wèi):項目名(míng)/知識包ID,如:testProject/testPackage
* @param version 指定的已發布的版本
* @return 返回對應版本的已發布的知識包中(zhōng)包含的變量庫信息集合
*/
List<VariableCategory> getKnowledgePackgeLib(String packageInfo,String version);
/**
* @param packageInfo 知識包信息,格式為(wèi):項目名(míng)/知識包ID,如:testProject/testPackage
* @param version 指定的已發布的版本
* @return 返回對應版本的已發布的知識包編譯後的InputStream對象信息
*/
InputStream getKnowledgePackgeData(String packageInfo,String version);
/**
* 删除指定版本已發布的知識包信息
* @param packageInfo 知識包信息,格式為(wèi):項目名(míng)/知識包ID,如:testProject/testPackage
* @param version 指定的已發布的版本
*/
void removeKnowledgePackge(String packageInfo,String version);
/**
* 删除指定知識所有(yǒu)已發布的知識包信息
* @param packageInfo 知識包信息,格式為(wèi):項目名(míng)/知識包ID,如:testProject/testPackage
*/
void removeDeployKnowledgePackge(String packageInfo);
/**
* 将指定版本的已發布的知識包定義為(wèi)處于激活狀态的知識包
* @param packageInfo 知識包信息,格式為(wèi):項目名(míng)/知識包ID,如:testProject/testPackage
* @param version 指定的已發布的版本
*/
void activeKnowledgePackage(String packageInfo,String version);
/**
* 修改指定知識的狀态,将狀态改為(wèi)<b>停用(yòng)</b>或<b>啓用(yòng)</b>
* @param packageInfo 知識包信息,格式為(wèi):項目名(míng)/知識包ID,如:testProject/testPackage
* @param state true表示<b>啓用(yòng)</b>,false表示<b>停用(yòng)</b
*/
void knowledgePackageStateChange(String packageInfo,boolean state);
/**
* 項目重命名(míng)時觸發修改當前項目下知識包的存儲路徑
* @param oldName 舊項目名(míng)
* @param newName 新(xīn)項目名(míng)
*/
void projectRename(String oldName,String newName);
/**
* 重置知識包時間戳
* @param project 項目名(míng)稱
*/
void resetProjectResourcePackagesTag(String project);
/**
* @param project 項目名(míng)稱
* @return 返回指定項目的知識包時間戳
*/
String getProjectResourcePackagesTag(String project);
/**
* @param project 項目名(míng)稱
* @return 返回指定項目的知識包信息集合
*/
List<ResourcePackage> loadProjectResourcePackages(String project);
/**
* @param file 要查找的文(wén)件
* @return 返回包含當前文(wén)件的知識包列表
*/
List<ResourcePackage> loadResourcePackagesByFile(String file);
/**
* 發布一個新(xīn)的知識包版本
* @param packageInfo 知識包信息,格式為(wèi):項目名(míng)/知識包ID,如:testProject/testPackage
* @param knowledgePackage 發布的編譯後知識包對象
* @param comment 知識包版本備注
* @param createUser 發布人
* @param active 是否激活
*/
void saveKnowledgePackage(String packageInfo,KnowledgePackage knowledgePackage,String comment,String createUser,boolean active);
}
AuthorityRepositoryService
AuthorityRepositoryService接口實現針對規則項目及文(wén)件的權限配置操作(zuò),基實例定義在Spring中(zhōng),在Spring中(zhōng)的Bean的ID為(wèi)AuthorityRepositoryService.BEAN_ID,其源碼如下:
package com.bstek.urule.console.repository.authority;
import java.util.List;
import com.bstek.urule.console.Principal;
import com.bstek.urule.console.repository.OperateType;
public interface AuthorityRepositoryService {
/**
* 保存授權信息
* @param p 當前操作(zuò)的登錄對象信息
* @param user 要授權的對象的用(yòng)戶名(míng)
* @param authority 要授權的信息
* @param type 操作(zuò)類型
* @throws Exception 抛出異常
*/
void saveAuthority(Principal p,String user,Authority authority,OperateType type) throws Exception;
/**
* 加載指定companyId下所有(yǒu)的權限信息
* @param companyId 指定的companyId,應與當前登錄用(yòng)戶的companyId保持一緻
* @return 返回權限信息集合
* @throws Exception 抛出異常
*/
List<AuthorityUnit> loadAuthorityUnits(String companyId) throws Exception;
/**
* 重置某個companyId下對應的權限信息的時間戳,系統内部調用(yòng)
* @param companyId 指定的companyId
* @return 返回新(xīn)的重置後的時間戳
* @throws Exception 抛出異常
*/
long resetAuthorityTag(String companyId) throws Exception;
/**
* 檢查指定companyId下權限信息有(yǒu)沒有(yǒu)變化,系統内部調用(yòng)
* @param companyId 指定的companyId
* @param timestamp 給定的時間戳
* @return 如果有(yǒu)變化返回新(xīn)的時間戳,沒變化則返回0
* @throws Exception 抛出異常
*/
long check(String companyId,long timestamp) throws Exception;
/**
* 保存權限信息文(wén)件,系統内部調用(yòng)
* @param content 文(wén)件xml格式内容
* @param user 保存操作(zuò)的調用(yòng)人
* @return 返回保存後的時間戳
* @throws Exception 抛出異常
*/
long saveAuthoritiesFile(String content,Principal user) throws Exception;
}
RepositoryInteceptor
RepositoryInteceptor接口的作(zuò)用(yòng)是攔截對所有(yǒu)規則文(wén)件的的添加、修改、删除操作(zuò),實現好該接口後配置到spring中(zhōng)即可(kě)生效,其源碼内容如下:
package com.bstek.urule.console;
public interface RepositoryInteceptor {
void readFile(String file);
void saveFile(String file,String content);
void createFile(String file,String content);
void deleteFile(String file);
void renameFile(String oldFileName,String newFileName);
void createDir(String dir);
void createProject(String project);
}
KnowledgePackagePublishListener
KnowledgePackagePublishListener接口是用(yòng)來攔截發布知識包操作(zuò),實現好該接口後配置到spring中(zhōng)即可(kě)生效,其源碼内容如下:
package com.bstek.urule.console.servlet.respackage;
import com.bstek.urule.runtime.KnowledgePackage;
public interface KnowledgePackagePublishListener {
void beforePublish(String packageId,String comment,boolean active);
void afterPublish(KnowledgePackage knowledgePackage,String comment,boolean active);
void beforeActive(String packageId,String version);
void afterActive(KnowledgePackage knowledgePackage,String version);
}