import org.kie.api.command.BatchExecutionCommand; //导入依赖的package包/类
public Measure processRules(@Body Measure measure) {
	
	KieServicesConfiguration config = KieServicesFactory.newRestConfiguration(
			kieHost, kieUser,
			kiePassword);
	
	Set<Class<?>> jaxBClasses = new HashSet<Class<?>>();
	jaxBClasses.add(Measure.class);
	
	config.addJaxbClasses(jaxBClasses);
	config.setMarshallingFormat(MarshallingFormat.JAXB);
	RuleServicesClient client = KieServicesFactory.newKieServicesClient(config)
			.getServicesClient(RuleServicesClient.class);

       List<Command<?>> cmds = new ArrayList<Command<?>>();
	KieCommands commands = KieServices.Factory.get().getCommands();
	cmds.add(commands.newInsert(measure));
	
    GetObjectsCommand getObjectsCommand = new GetObjectsCommand();
    getObjectsCommand.setOutIdentifier("objects");

	
	cmds.add(commands.newFireAllRules());
	cmds.add(getObjectsCommand);
	BatchExecutionCommand myCommands = CommandFactory.newBatchExecution(cmds,
			"DecisionTableKS");
	ServiceResponse<ExecutionResults> response = client.executeCommandsWithResults("iot-ocp-businessrules-service", myCommands);
			
	List responseList = (List) response.getResult().getValue("objects");
	
	Measure responseMeasure = (Measure) responseList.get(0);
	
	return responseMeasure;

}
 

import org.kie.api.command.BatchExecutionCommand; //导入依赖的package包/类
public static void main(String[] args) {

    Drug seldane = new Drug();
    seldane.setDrugName("Seldane");
    Drug biaxin = new Drug();
    biaxin.setDrugName("Biaxin");

    Patient patient = new Patient();

    patient.setfName("Goku");
    patient.setPerscription(seldane);
    patient.getDrugList().add(biaxin);

    List<GenericCommand<?>> commands = new ArrayList<>();

    commands.add(new InsertObjectCommand(patient));
    commands.add(new FireAllRulesCommand());

    BatchExecutionCommand command = (BatchExecutionCommand) new BatchExecutionCommandImpl(commands);
    String json = BatchExecutionHelper.newJSonMarshaller().toXML(command);

    System.out.println(json);
  }
 

import org.kie.api.command.BatchExecutionCommand; //导入依赖的package包/类
@Override
public Meal recommendMeal(Person person) throws BusinessException {
    StatelessKieSession kieSession = kContainer.newStatelessKieSession();

    InsertObjectCommand insertObjectCommand = new InsertObjectCommand(person);
    FireAllRulesCommand fireAllRulesCommand = new FireAllRulesCommand();
    QueryCommand queryCommand = new QueryCommand("results", "getMeal", (Object[]) null);
    List<GenericCommand<?>> commands = new ArrayList<GenericCommand<?>>();
    commands.add(insertObjectCommand);
    commands.add(fireAllRulesCommand);
    commands.add(queryCommand);
    BatchExecutionCommand batch = new BatchExecutionCommandImpl(commands);

    ExecutionResults results = kieSession.execute(batch);
    QueryResults queryResults = (QueryResults) results.getValue("results");
    Iterator<QueryResultsRow> iterator = queryResults.iterator();
    while (iterator.hasNext()) {
        Meal meal = (Meal) iterator.next().get("$m");
        if (meal != null) {
            System.out.println("Meal : " + meal);
            return meal;
        }
    }

    return null;
}
 

import org.kie.api.command.BatchExecutionCommand; //导入依赖的package包/类
public BatchExecutionCommand createRandomCommand() {
    Person person = new Person();
    String name = NAMES[random.nextInt(NAMES.length)];
    person.setName(name);

    List<Command<?>> cmds = new ArrayList<Command<?>>();
    KieCommands commands = KieServices.Factory.get().getCommands();
    cmds.add(commands.newInsert(person));
    cmds.add(commands.newFireAllRules());
    cmds.add(commands.newQuery("greetings", "get greeting"));
    BatchExecutionCommand command = commands.newBatchExecution(cmds, "HelloRulesSession");
    return command;
}
 

import org.kie.api.command.BatchExecutionCommand; //导入依赖的package包/类
@Test
public void testModifyFact() {
	GetObjectsCommand getObjectCommand = new GetObjectsCommand(new ClassObjectFilter(this.getClass()));
	getObjectCommand.setOutIdentifier("test");
	List<GenericCommand<?>> commands = new ArrayList<GenericCommand<?>>();
       commands.add(getObjectCommand);
       BatchExecutionCommand command = new BatchExecutionCommandImpl(commands);
       System.out.println(BatchExecutionHelper.newXStreamMarshaller().toXML(command));		
}
 

import org.kie.api.command.BatchExecutionCommand; //导入依赖的package包/类
public void insertAndFireAll(Exchange exchange) {
    final Message in = exchange.getIn();
    final Object body = in.getBody();

    final KieCommands kieCommands = KieServices.Factory.get().getCommands();

    final List<Command> commands = new ArrayList<Command>();
    // since KIE commands are JAXB-annotated, the body has to be JAXB annotated class as well
    commands.add(kieCommands.newInsert(body, "person"));
    commands.add(kieCommands.newFireAllRules());

    BatchExecutionCommand command = kieCommands.newBatchExecution(commands);
    in.setBody(command);
}
 

import org.kie.api.command.BatchExecutionCommand; //导入依赖的package包/类
@Test
public void testSessionBatchExecutionCommand() throws Exception {
    Person john = new Person();
    john.setName("John Smith");

    List<Command> commands = new ArrayList<Command>();
    commands.add(CommandFactory.newInsert(john, "john"));
    BatchExecutionCommand batchExecutionCommand = CommandFactory.newBatchExecution(commands);

    ExecutionResults response = (ExecutionResults)template.requestBody("direct:test-with-session", batchExecutionCommand);
    assertTrue("Expected valid ExecutionResults object", response != null);
    assertTrue("ExecutionResults missing expected fact", response.getFactHandle("john") != null);
    assertTrue("ExecutionResults missing expected fact", response.getFactHandle("john") instanceof FactHandle);
}
 

import org.kie.api.command.BatchExecutionCommand; //导入依赖的package包/类
@Test
public void testSessionBatchExecutionCommandWithHeader() throws Exception {

    MockEndpoint mockResult = context.getEndpoint("mock:resultWithHeader", MockEndpoint.class);

    String headerName = "testHeaderName";
    String headerValue = "testHeaderValue";

    Person john = new Person();
    john.setName("John Smith");

    List<Command> commands = new ArrayList<Command>();
    commands.add(CommandFactory.newInsert(john, "john"));
    BatchExecutionCommand batchExecutionCommand = CommandFactory.newBatchExecution(commands);

    Map<String, Object> headers = new HashMap<String, Object>();
    headers.put(headerName, headerValue);

    // set mock expectations
    mockResult.expectedMessageCount(1);
    mockResult.expectedHeaderReceived(headerName, headerValue);

    // do test
    template.requestBodyAndHeaders("direct:test-with-session-withHeader", batchExecutionCommand, headers);

    ExecutionResults response = mockResult.getReceivedExchanges().get(0).getIn().getBody(ExecutionResults.class);

    assertTrue("Expected valid ExecutionResults object", response != null);
    assertTrue("ExecutionResults missing expected fact", response.getFactHandle("john") != null);
    assertTrue("ExecutionResults missing expected fact", response.getFactHandle("john") instanceof FactHandle);

    mockResult.assertIsSatisfied();
}
 

import org.kie.api.command.BatchExecutionCommand; //导入依赖的package包/类
/** bz771203
 * creates batch-execution command with insert. Marshalls it to XML
 * and send to drools */
@Test
public void testInsert() throws Exception {
    Person p = new Person("Alice", "spicy meals", 30);
    List<Command> commands = new ArrayList<Command>();
    commands.add(CommandFactory.newInsert(p, "tempPerson"));
    BatchExecutionCommand command = CommandFactory.newBatchExecution(commands);
    String xmlCommand = template.requestBody("direct:marshall", command, String.class);

    String xml = template.requestBody("direct:test-session", xmlCommand, String.class);
    ExecutionResults res = (ExecutionResults)template.requestBody("direct:unmarshall", xml);

    Object o = res.getFactHandle("tempPerson");
    assertTrue("returned String instead of FactHandle instance", o instanceof FactHandle);
}