Here's what I do: We inject KnowledgeBases into our app using Spring. It was a simple matter of just implementing a builder class that takes a bunch of drools Resources and adding a build() method to create the KnowledgeBase and then creating a class that implements Spring FactoryBean and InitializingBean to construct the builder and convert Spring resources to Drools ones and calling the builder.build() method in the afterPropertiesSet(). There is one currently open bug in drools that means we have to cast to a class from the old api to add accumulate functions. cheers Steve 2009/4/3 Abu Rasheed <aburasheed(a)studentmasjid.com&gt; > Are there any plans to have Spring support in drools-api? The last mail > that I saw in searching the topic is dated last year, and there are no > new > postings related to this. > > Does anyone have any success in injecting KnowledgeBase into their apps > using Spring? Is there any examples out there that I can refer to? > > Thanks > > > _______________________________________________ > rules-dev mailing list > rules-dev(a)lists.jboss.org > https://lists.jboss.org/mailman/listinfo/rules-dev > > package xxxxx; import java.io.IOException; import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.drools.KnowledgeBase; import org.drools.KnowledgeBaseFactory; import org.drools.builder.KnowledgeBuilder; import org.drools.builder.KnowledgeBuilderConfiguration; import org.drools.builder.KnowledgeBuilderError; import org.drools.builder.KnowledgeBuilderErrors; import org.drools.builder.KnowledgeBuilderFactory; import org.drools.builder.ResourceType; import org.drools.compiler.PackageBuilderConfiguration; import org.drools.io.Resource; /** * Given the appropriate resources builds the rule base. Expected usage: <code> * RuleBaseBuilder builder = new RuleBaseBuilder(); * builder.set*List(arg); * RuleBase b = builder.build(); * </code> Since the build() method creates a new RuleBase each invocation, the builder instance can be reused as long * as the lists are set/reset. */ public class KnowledgeBaseBuilder { private static final Log LOG = LogFactory.getLog(KnowledgeBaseBuilder.class); private Map<Resource, ResourceType> resourceList; private Map<String, String> accumulateFunctionMap; /** * List of rule resources that should be used in the Rule Base. * * @param aResourceList */ public void setResourceList(final Map<Resource, ResourceType> aResourceList) { this.resourceList = aResourceList; } /** * Builds the rule base. * * @return the configured RuleBase object. * @throws Exception * on error, e.g. no rule lists configured, or bad lists. */ public KnowledgeBase build() throws Exception { // create default configuration. KnowledgeBuilderConfiguration configuration = KnowledgeBuilderFactory.newKnowledgeBuilderConfiguration(); // config.setJavaLanguageLevel("1.5"); // config.setCompiler(PackageBuilderConfiguration.ECLIPSE); return build(configuration); } /** * Builds the rule base with the provided configuration for the builder. * * @return the configured RuleBase object. * @throws Exception * on error, e.g. no rule lists configured, or bad lists. if config is null */ public KnowledgeBase build(final KnowledgeBuilderConfiguration config) throws Exception { verifyBuilder(); addAccumulateFunctions(config); KnowledgeBuilder builder = KnowledgeBuilderFactory.newKnowledgeBuilder(config); addPackagesFromList(builder); KnowledgeBuilderErrors errors = builder.getErrors(); if (errors.size() > 0) { for (KnowledgeBuilderError error : errors) { LOG.error(error); } throw new IllegalArgumentException("Could not parse knowledge."); } KnowledgeBase knowledgeBase = KnowledgeBaseFactory.newKnowledgeBase(); knowledgeBase.addKnowledgePackages(builder.getKnowledgePackages()); return knowledgeBase; } private void verifyBuilder() { if (!rulesExist()) { throw new IllegalStateException("No rule lists provided!"); } } private void addAccumulateFunctions(final KnowledgeBuilderConfiguration config) { if (accumulateFunctionMap != null) { for (Map.Entry<String, String> entry : accumulateFunctionMap.entrySet()) { // TODO: uncomment code below when adding of accumlate function bug is fixed in drools // config.setProperty("drools.accumulate.function." + entry.getKey(), entry.getValue()); ((PackageBuilderConfiguration) config).addAccumulateFunction(entry.getKey(), entry.getValue()); } } } private void addPackagesFromList(final KnowledgeBuilder builder) throws IOException { for (Map.Entry<Resource, ResourceType> entry : resourceList.entrySet()) { builder.add(entry.getKey(), entry.getValue()); } } /** * Checks that at least one rule resource list is not empty. * * @return true if at least one rule list is populated, false if all empty. */ public boolean rulesExist() { return (this.resourceList != null && !this.resourceList.isEmpty()); } public void setAccumulateFunctionMap(Map<String, String> aAccumulateFunctionMap) { this.accumulateFunctionMap = aAccumulateFunctionMap; } } package xxxxx; import java.util.LinkedHashMap; import java.util.Map; import org.drools.KnowledgeBase; import org.drools.builder.ResourceType; import org.drools.io.ResourceFactory; import org.springframework.beans.factory.FactoryBean; import org.springframework.beans.factory.InitializingBean; import org.springframework.core.io.Resource; /** * Factory for Drools KnowledgeBase. * @author Steve * */ public class KnowledgeBaseFactoryBean implements FactoryBean, InitializingBean { private KnowledgeBaseBuilder builder = new KnowledgeBaseBuilder(); private KnowledgeBase knowledgeBase; /** * List of DRL rules to include in the rule base. * @param drlResourceList */ public void setResourceList(Map<Resource, ResourceType> resourceList) throws Exception { Map<org.drools.io.Resource, ResourceType> resources = new LinkedHashMap<org.drools.io.Resource, ResourceType>(); for (Map.Entry<Resource, ResourceType> entry : resourceList.entrySet()) { resources.put(ResourceFactory.newInputStreamResource(entry.getKey().getInputStream()), entry.getValue()); } builder.setResourceList(resources); } /** * @param accumulateFunctionMap */ public void setAccumulateFunctionMap(Map<String, String> accumulateFunctionMap) { builder.setAccumulateFunctionMap(accumulateFunctionMap); } /** * @{inheritDoc} */ @Override public Object getObject() throws Exception { return knowledgeBase; } /** * @{inheritDoc} */ @Override public Class<?> getObjectType() { return KnowledgeBase.class; } /** * @{inheritDoc} */ @Override public boolean isSingleton() { return true; } /** * @{inheritDoc} */ @Override public void afterPropertiesSet() throws Exception { knowledgeBase = builder.build(); } } _______________________________________________ rules-dev mailing list rules-dev(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/rules-dev