Fatal编程技术网
  • java/
  • Java 耶拿定制内置

Java 耶拿定制内置

java eclipse

Java 耶拿定制内置,java,eclipse,jena,built-in,jena-rules,Java,Eclipse,Jena,Built In,Jena Rules,这是我编写的代码，但新的内置代码似乎不起作用。我得到一个错误： 线程“main”com.hp.hpl.jena.reasoner.rulesys.impl.LPRuleSyntaxException中的异常：反向规则中的语法错误：matematica未知内置操作mysum 谁能告诉我错误在哪里吗？这是我的密码： package JenaRules; import java.io.BufferedReader; import java.io.ByteArrayInputStream; impor

这是我编写的代码，但新的内置代码似乎不起作用。我得到一个错误：

线程“main”com.hp.hpl.jena.reasoner.rulesys.impl.LPRuleSyntaxException中的异常：反向规则中的语法错误：matematica未知内置操作mysum

谁能告诉我错误在哪里吗？这是我的密码：

package JenaRules;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.List;

import org.semanticweb.owlapi.model.OWLOntologyCreationException;
import org.semanticweb.owlapi.model.OWLOntologyStorageException;

import com.hp.hpl.jena.graph.Node;
import com.hp.hpl.jena.query.Query;
import com.hp.hpl.jena.query.QueryExecution;
import com.hp.hpl.jena.query.QueryExecutionFactory;
import com.hp.hpl.jena.query.QueryFactory;
import com.hp.hpl.jena.query.ResultSet;
import com.hp.hpl.jena.query.ResultSetFormatter;
import com.hp.hpl.jena.rdf.model.InfModel;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.reasoner.Reasoner;
import com.hp.hpl.jena.reasoner.rulesys.*;
import com.hp.hpl.jena.reasoner.rulesys.builtins.BaseBuiltin;
import com.hp.hpl.jena.util.FileManager;
import com.hp.hpl.jena.vocabulary.RDFS;
import com.hp.hpl.jena.vocabulary.ReasonerVocabulary;

public class RulesOntology_MT {

    public static void main(String[] args) throws OWLOntologyStorageException,
    OWLOntologyCreationException, IOException  {

        BuiltinRegistry.theRegistry.register(new BaseBuiltin() {
             @Override
             public String getName() {
                    return "mysum";
                }
             @Override
                public int getArgLength() {
                    return 2;
                }
             @Override
                public boolean bodyCall(Node[] args, int length, RuleContext context) {
                    checkArgs(length, context);
                    BindingEnvironment env = context.getEnv();
                    Node n1 = getArg(0, args, context);
                    Node n2 = getArg(1, args, context);
                    if (n1.isLiteral() && n2.isLiteral()) {
                        Object v1 = n1.getLiteralValue();
                        Object v2 = n2.getLiteralValue();
                        Node sum = null;
                        if (v1 instanceof Number && v2 instanceof Number) {
                            Number nv1 = (Number)v1;
                            Number nv2 = (Number)v2;
                            int sumInt = nv1.intValue()+nv2.intValue();
                            sum = Util.makeIntNode(sumInt);
                            return env.bind(args[2], sum);
                        }
                    }
                    return false;
                }

        });

        // NON SERVE

        //      final String exampleRuleString2 =
        //              "[mat1: equal(?s ?p )\n\t-> print(?s ?p ?o),\n\t   (?s ?p ?o)\n]"+
        //                      "";

        final String exampleRuleString =    
                "[matematica:"+
                        "(?p http://www.semanticweb.org/prova_rules_M#totale_crediti ?x)"+
                        " -> " +
                        "(?p rdf:type  http://www.semanticweb.org/prova_rules_M#:Persona)"+
                        "(?e rdf:type  http://www.semanticweb.org/prova_rules_M#:Esame)"+
                        "(?p  http://www.semanticweb.org/prova_rules_M#:haSostenutoEsameDi ?e)"+
                        "(?e http://www.semanticweb.org/prova_rules_M/persona#crediti_esame ?cr)"+
                        "mysum(?cr,2)"+
                        "]";

        System.out.println(exampleRuleString);

        /* I tend to use a fairly verbose syntax for parsing out my rules when I construct them
         * from a string. You can read them from whatever other sources.
         */
        final List<Rule> rules;
        try( final BufferedReader src = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(exampleRuleString.getBytes()))) ) {
            rules = Rule.parseRules(Rule.rulesParserFromReader(src));
        }


        /* Construct a reasoner and associate the rules with it  */
        // create an empty non-inferencing model

        GenericRuleReasoner reasoner = (GenericRuleReasoner) GenericRuleReasonerFactory.theInstance().create(null);
        reasoner.setRules(rules);


        /* Create & Prepare the InfModel. If you don't call prepare, then
         * rule firings and inference may be deferred until you query the
         * model rather than happening at insertion. This can make you think
         * that your Builtin is not working, when it is.
         */

        InfModel infModel = ModelFactory.createInfModel(reasoner, ModelFactory.createDefaultModel());
        infModel.prepare();
        infModel.createResource(RDFS.Class);

        //write down the result in RDFXML form
        infModel.write(System.out);

    }
}

包装JenaRules；
导入java.io.BufferedReader；
导入java.io.ByteArrayInputStream；
导入java.io.IOException；
导入java.io.InputStreamReader；
导入java.util.array；
导入java.util.List；
导入org.semanticweb.owlapi.model.owletologyCreationException；
导入org.semanticweb.owlapi.model.owletologyStorageException；
导入com.hp.hpl.jena.graph.Node；
导入com.hp.hpl.jena.query.query；
导入com.hp.hpl.jena.query.QueryExecution；
导入com.hp.hpl.jena.query.QueryExecutionFactory；
导入com.hp.hpl.jena.query.QueryFactory；
导入com.hp.hpl.jena.query.ResultSet；
导入com.hp.hpl.jena.query.ResultSetFormatter；
导入com.hp.hpl.jena.rdf.model.InfModel；
导入com.hp.hpl.jena.rdf.model.model；
导入com.hp.hpl.jena.rdf.model.ModelFactory；
导入com.hp.hpl.jena.rdf.model.Resource；
导入com.hp.hpl.jena.reasoner.reasoner；
导入com.hp.hpl.jena.reasoner.rulesys.*；
导入com.hp.hpl.jena.reasoner.rulesys.builtins.BaseBuiltin；
导入com.hp.hpl.jena.util.FileManager；
导入com.hp.hpl.jena.词汇表.RDFS；
导入com.hp.hpl.jena.词汇表.reasonervaculary；
公共类规则{
publicstaticvoidmain（字符串[]args）抛出owletologyStorageException，
OWLOntologyCreationException，IOException{
BuiltinRegistry.theRegistry.register（新的BaseBuiltin（）{
@凌驾
公共字符串getName（）{
返回“mysum”；
}
@凌驾
public int getArgLength（）{
返回2；
}
@凌驾
公共布尔bodyCall（节点[]参数，整数长度，RuleContext上下文）{
checkArgs（长度、上下文）；
BindingEnvironment env=context.getEnv（）；
节点n1=getArg（0，args，上下文）；
节点n2=getArg（1，args，上下文）；
如果（n1.isLiteral（）&&n2.isLiteral（））{
对象v1=n1.getLiteralValue（）；
对象v2=n2.getLiteralValue（）；
节点和=空；
if（v1实例编号和v2实例编号）{
编号nv1=（编号）v1；
编号nv2=（编号）v2；
int sumInt=nv1.intValue（）+nv2.intValue（）；
sum=Util.makeIntNode（sumInt）；
返回环境绑定（参数[2]，总和）；
}
}
返回false；
}
});
//不发球
//最后一个字符串示例RuleString2=
//[mat1:equal（？s？p）\n\t->print（？s？p？o），\n\t（？s？p？o）\n]+
//                      "";
最终字符串示例RuleString=
“[matematica：”+
“（？phttp://www.semanticweb.org/prova_rules_M#totale_crediti ？x“+
" -> " +
“（？p rdf:类型http://www.semanticweb.org/prova_rules_M#:Persona)"+
“（？e rdf:类型http://www.semanticweb.org/prova_rules_M#:Esame)"+
“（？phttp://www.semanticweb.org/prova_rules_M#:haSostenutoEsameDi ？e）“+
“（？ehttp://www.semanticweb.org/prova_rules_M/persona#crediti_esame “cr”）+
糠秕（？cr，2）+
"]";
System.out.println（exampleRuleString）；
/*在构造规则时，我倾向于使用相当详细的语法来解析规则
*你可以从任何其他来源读取它们。
*/
最后清单规则；
try（final BufferedReader src=new BufferedReader（new InputStreamReader（new ByteArrayInputStream）（exampleRuleString.getBytes（）））{
rules=Rule.parseRules（Rule.rulesParserFromReader（src））；
}
/*构造一个推理器并将规则与之关联*/
//创建一个空的非推断模型
GenericRuleReasoner reasoner=（GenericRuleReasoner）GenericRuleReasonerFactory.theInstance（）.create（null）；
推理机。设置规则（规则）；
/*创建并准备InfModel。如果不调用Prepare，则
*规则触发和推断可能会推迟到您查询
*模型而不是在插入时发生。这会让你思考
*你的内置设备不工作，当它工作时。
*/
InfModel InfModel=ModelFactory.createInfModel（推理机，ModelFactory.createDefaultModel（））；
infModel.prepare（）；
infModel.createResource（RDFS.Class）；
//将结果写在RDFXML表格中
infModel.write（系统输出）；
}
}
使用您提供的代码和Apache Jena
2.11.1
，我无法复制您得到的异常。请注意，当您调用
内置注册表.theRegistry.register（…）
时，您是在告诉推理机内置的存在

解决方案

您得到的异常可能是因为在实际代码中，在调用
Rule.parseRules（Rule.rulesParserFromReader（src））之前，您没有调用
BuiltinRegistry.theRegistry.register（…）
，就规则解析器而言，您使用的是一个不存在的
内置
。要修复它，只需在解析规则之前调用
register
。提供的玩具示例没有此问题

使用提供的示例

我还注意到，所提供的代码示例没有包含任何实际上会导致错误的内容 
final Resource s = infModel.createResource();
final Property p = infModel.createProperty("http://www.semanticweb.org/prova_rules_M#totale_crediti");
final Resource o = infModel.createResource();
infModel.add(s,p,o);

com.hp.hpl.jena.reasoner.rulesys.BuiltinException: Error in clause of rule (matematica) mysum: builtin mysum not usable in rule heads
    at com.hp.hpl.jena.reasoner.rulesys.builtins.BaseBuiltin.headAction(BaseBuiltin.java:86)
    at com.hp.hpl.jena.reasoner.rulesys.impl.RETEConflictSet.execute(RETEConflictSet.java:184)
    at com.hp.hpl.jena.reasoner.rulesys.impl.RETEConflictSet.add(RETEConflictSet.java:81)
    at com.hp.hpl.jena.reasoner.rulesys.impl.RETEEngine.requestRuleFiring(RETEEngine.java:249)
    at com.hp.hpl.jena.reasoner.rulesys.impl.RETETerminal.fire(RETETerminal.java:80)
    at com.hp.hpl.jena.reasoner.rulesys.impl.RETEClauseFilter.fire(RETEClauseFilter.java:227)
    at com.hp.hpl.jena.reasoner.rulesys.impl.RETEEngine.inject(RETEEngine.java:469)
    at com.hp.hpl.jena.reasoner.rulesys.impl.RETEEngine.runAll(RETEEngine.java:451)
    at com.hp.hpl.jena.reasoner.rulesys.impl.RETEEngine.add(RETEEngine.java:174)
    at com.hp.hpl.jena.reasoner.rulesys.FBRuleInfGraph.performAdd(FBRuleInfGraph.java:654)
    at com.hp.hpl.jena.graph.impl.GraphBase.add(GraphBase.java:202)
    at com.hp.hpl.jena.rdf.model.impl.ModelCom.add(ModelCom.java:1138)
    at SO.test(SO.java:108)