import org.kie.api.builder.Results; //导入依赖的package包/类
public static void logResults(Results results) {
    for (Message result : results.getMessages()) {
        switch (result.getLevel()) {
            case ERROR:
                LOGGER.error(result.toString());
                break;
            case WARNING:
                LOGGER.warn(result.toString());
                break;
            case INFO:
                LOGGER.info(result.toString());
                break;
            default:
                LOGGER.warn(result.toString());
        }
    }
}
 

import org.kie.api.builder.Results; //导入依赖的package包/类
public boolean updateToVersion(String version) {
    checkStatus();
    if (StringUtils.isEmpty(version)) {
        throw new IllegalArgumentException("Update to version cannot accept an empty version");
    }
    ReleaseId releaseId = kieServices.newReleaseId(
            rulesConfiguration.getGroupId(),
            rulesConfiguration.getArtifactId(),
            version);
    Results results = kieContainer.updateToVersion(releaseId);
    this.releaseId = kieContainer.getReleaseId();
    KieSessionUtils.logResults(results);
    if (results.hasMessages(Message.Level.ERROR)) {
        LOGGER.error("Update to version {} aborted due to errors", version);
        return false;
    }
    LOGGER.info("Update to version {} completed", version);
    return true;
}
 

import org.kie.api.builder.Results; //导入依赖的package包/类
@Before
public void setup() {
    KieServices kieServices = KieServices.Factory.get();

    KieContainer kContainer = kieServices.getKieClasspathContainer();
    Results verifyResults = kContainer.verify();
    for (Message m : verifyResults.getMessages()) {
        LOG.debug("Kie container message: {}", m);
    }

    KieBase kieBase = kContainer.getKieBase();
    LOG.debug("Created kieBase");

    for ( KiePackage kp : kieBase.getKiePackages() ) {
        for (Rule rule : kp.getRules()) {
            LOG.debug("kp " + kp + " rule " + rule.getName());
        }
    }

    session = kieBase.newKieSession();
    LOG.info(session.getGlobals().toString());
    Logger kieLogger = LoggerFactory.getLogger(this.getClass());
   // session.setGlobal("logger",kieLogger);
}
 

import org.kie.api.builder.Results; //导入依赖的package包/类
/**
 * Load all .drl files
 *
 * if a rule does not compile an exception will be thrown indicating the problem
 *
 * @param path
 * @return - session containing all loaded rules
 * @throws Exception
 */
public KieSession buildSession() throws Exception {
  kieServices = KieServices.Factory.get();
  KieRepository kr = kieServices.getRepository();
  kfs = kieServices.newKieFileSystem();
  if(rules != null){
    loadFromList();
  }
  else{
    loadFromFiles();
  }
  kieBuilder = kieServices.newKieBuilder( kfs ).buildAll();
  Results results = kieBuilder.getResults();
  if( results.hasMessages( Message.Level.ERROR ) ){
      System.out.println( results.getMessages() );
      throw new IllegalStateException( results.getMessages() + "" );
  }
  kieContainer =
      kieServices.newKieContainer( kr.getDefaultReleaseId() );
  ksession = kieContainer.newKieSession();
  ksession.addEventListener(new RuleTracker());
  return ksession;
}
 

import org.kie.api.builder.Results; //导入依赖的package包/类
@Test
public void drlSyntaxTest()
{
	  String str = "";
	    str += "package org.kie.test\n";
	    str += "global java.util.List list\n";
	    str += "rule rule1\n";
	    str += "when\n";
	    str += "  Integer(intValue > 0)\n";
	    str += "then\n";
	    str += "  list.add( 1 );\n";
	    str += "end\n";
	    str += "\n";
	    
	    Map<String,String> drls = new HashMap<String,String>();
	    drls.put("rule1", str);
	    
	KieHelper kieHelper = new KieHelper();
	for (String ruleId : drls.keySet()) {
	    kieHelper.addContent(drls.get(ruleId), ResourceType.DRL);
	}
	Results results = kieHelper.verify();
	for (Message message : results.getMessages()) {
	    log.error(">> Message ({}): {}", message.getLevel(), message.getText());
	}

	if (results.hasMessages(Message.Level.ERROR)) {
	    throw new IllegalStateException("There are errors in the KB.");
	}

	KieSession ksession = kieHelper.build().newKieSession();
}
 

import org.kie.api.builder.Results; //导入依赖的package包/类
private Boolean readFilenamesFromDirectory(String rootFilePath) {
	Boolean compileOk = true;
	final File folder = new File(rootFilePath);
	final File[] listOfFiles = folder.listFiles();

	for (int i = 0; i < listOfFiles.length; i++) {
		if (listOfFiles[i].isFile()) {
			System.out.println("File " + listOfFiles[i].getName());
			try {
				String ruleText = getFileAsText(listOfFiles[i]);
				KieHelper kieHelper = new KieHelper();
				kieHelper.addContent(ruleText, ResourceType.DRL);
				Results results = kieHelper.verify();
				for (Message message : results.getMessages()) {
					log.error(">> Message ({}): {}", message.getLevel(), message.getText());
					compileOk = false;
					assertTrue("Drools Compile Error in "+listOfFiles[i].getName(),false);
				}

			} catch (final IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		} else if (listOfFiles[i].isDirectory()) {
			System.out.println("Directory " + listOfFiles[i].getName());
			readFilenamesFromDirectory(rootFilePath+"/"+listOfFiles[i].getName());
		}
	}
	return compileOk;
}
 

import org.kie.api.builder.Results; //导入依赖的package包/类
private void assertBuildResults(Results results) {
    if (results.hasMessages(Message.Level.WARNING, Message.Level.ERROR)) {
        List<Message> messages = results.getMessages(Message.Level.WARNING, Message.Level.ERROR);
        for (Message message : messages) {
            System.out.printf("[%s] - %s[%s,%s]: %s", message.getLevel(), message.getPath(), message.getLine(), message.getColumn(), message.getText());
        }

        throw new IllegalStateException("Compilation errors were found. Check the logs.");
    }
}
 

import org.kie.api.builder.Results; //导入依赖的package包/类
public static void hasErrors(Results results) {
    if (results.hasMessages(Message.Level.ERROR)) {
        throw new RuntimeException("Build errors\n" + results.toString());
    }
}
 

import org.kie.api.builder.Results; //导入依赖的package包/类
@Override
public Results verify() {
    return kieContainer.verify();
}
 

import org.kie.api.builder.Results; //导入依赖的package包/类
@Override
public Results updateToVersion(ReleaseId version) {
    return kieContainer.updateToVersion(version);
}