如何使用JENA创建owl文件？ 我被困在本体创造的中间。我想用Java创建一个OWL文件，这是我的目标。我已经创建了分层集群，但现在我必须在本体创建中使用这些集群

提前谢谢

到目前为止我已经试过了。我明白狄金森的意思。现在这是我的代码，我得到了一个异常 线程“main”com.hp.hpl.jena.shared.BadURIException中的异常：RDF/XML输出中只能包含格式良好的绝对URIREF：代码：57/方案中缺少必需的组件：方案中缺少必需的组件

JenaOwl.java

public class JenaOwl {

    static OntModel jenaModel = null;

    public static void main(String[] args) throws IOException {
        JenaOwl jo = new JenaOwl();
        FileWriter fw = null;
        try {
            jenaModel = createModel();
        } catch (Exception ex) {
            Logger.getLogger(JenaOwl.class.getName()).log(Level.SEVERE, null, ex);
        }
        OutputStream output = null;
        try {
            fw = new FileWriter("D:/mymodel.owl");
            jenaModel.write( fw, "RDF/XML-ABBREV" );
            fw.close();
  // OR Turtle format - compact and more readable
  // use this variant if you're not sure which to use!
            fw = new FileWriter("D:/mymodel.ttl");
            jenaModel.write( fw, "Turtle" );
//            output = new FileOutputStream(new File("D:/Sample.owl"));
//            jenaModel.write(output);
            //jo.write(output);
        } finally {
         if (fw != null) {
                try {
                    fw.close();
                }
          catch (IOException ignore) {
         }
         }


}
    }
        //jenaModel.write(output)}

    public static OntModel createModel() throws Exception {
        jenaModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM);
        jenaModel.setNsPrefix("ot", OT.NS);
        jenaModel.setNsPrefix("owl", OWL.NS);
        jenaModel.setNsPrefix("dc", DC.NS);
//        OT ot = new OT();
//        OT.OTClass otc;
        System.out.println("jenaModel.getOntClass(OT.OTClass.Dataset.getNS()) : "+jenaModel.getOntClass(OT.OTClass.Dataset.getNS()));
        Individual dataset = jenaModel.createIndividual("Dataset URI", jenaModel.getOntClass(OT.OTClass.Dataset.getNS()));

        OT.OTClass.Dataset.createOntClass(jenaModel);

        OT.OTClass.DataEntry.createOntClass(jenaModel);

        OT.OTClass.Feature.createOntClass(jenaModel);

        OT.OTClass.FeatureValue.createOntClass(jenaModel);

        OT.OTClass.Compound.createOntClass(jenaModel);

        Individual dataEntry = jenaModel.createIndividual(OT.OTClass.DataEntry.getOntClass(jenaModel));
        dataset.addProperty(OT.dataEntry, dataEntry);

        Individual compound = jenaModel.createIndividual("compoundURI", OT.OTClass.Compound.getOntClass(jenaModel));
        dataEntry.addProperty(OT.compound, compound);

        //  First
        Individual feature1 = jenaModel.createIndividual("featureURI1", OT.OTClass.Feature.getOntClass(jenaModel));
        Individual featureValue1 = jenaModel.createIndividual(OT.OTClass.FeatureValue.getOntClass(jenaModel));
        featureValue1.addProperty(OT.feature, feature1);
        featureValue1.addLiteral(OT.value, jenaModel.createTypedLiteral("formaldehyde", XSDDatatype.XSDstring));

//Second value
        Individual feature2 = jenaModel.createIndividual("featureURI2", OT.OTClass.Feature.getOntClass(jenaModel));
        Individual featureValue2 = jenaModel.createIndividual(OT.OTClass.FeatureValue.getOntClass(jenaModel));
        featureValue2.addProperty(OT.feature, feature2);
        featureValue2.addLiteral(OT.value, jenaModel.createTypedLiteral(3.14, XSDDatatype.XSDdouble));

//and finally add values to the data entry
        dataEntry.addProperty(OT.values, featureValue1);
        dataEntry.addProperty(OT.values, featureValue2);



        return jenaModel;
    }

    public void write(OutputStream output) {
        MediaType mediaType = new MediaType(null);
        if (mediaType.equals(MediaType.APPLICATION_RDF_XML)) //jenaModel.write(output,"RDF/XML");  //this is faster
        {
            jenaModel.write(output, "RDF/XML-ABBREV");   //this is more readable
        } else if (mediaType.equals(MediaType.APPLICATION_RDF_XML)) {
            jenaModel.write(output, "TURTLE");
        } else if (mediaType.equals(MediaType.TEXT_RDF_N3)) {
            jenaModel.write(output, "N3");
        } else if (mediaType.equals(MediaType.TEXT_RDF_N3)) {
            jenaModel.write(output, "N-TRIPLE");
        } else {
            jenaModel.write(output, "RDF/XML-ABBREV");
        }
    }

    ;
}

OT.java

public class OT {

    public enum OTClass {

        Compound,
        Conformer,
        Dataset,
        DataEntry,
        Feature,
        FeatureValue,
        Algorithm,
        Model,
        Validation,
        ValidationInfo;

        public String getNS() {
            System.out.println("String.format(_NS, toString()) : " + String.format(_NS, toString()));
            return String.format(_NS, toString());
        }

        public OntClass getOntClass(OntModel model) {
            return model.getOntClass(getNS());
        }

        public OntClass createOntClass(OntModel model) {
            return model.createClass(getNS());
        }

        public Property createProperty(OntModel model) {
            return model.createProperty(getNS());
        }
    };
    /** <p>The RDF model that holds the vocabulary terms</p> */
    private static Model m_model = ModelFactory.createDefaultModel();
    /** <p>The namespace of the vocabalary as a string ({@value})</p> */
    protected static final String _NS = "http://www.opentox.org/api/1.1#%s";
    public static final String NS = String.format(_NS, "");

    public static String getURI() {
        return NS;
    }
    /** <p>The namespace of the vocabalary as a resource</p> */
    public static final Resource NAMESPACE = m_model.createResource(NS);
    /**
     * Object properties
     */
    public static final Property dataEntry = m_model.createProperty(String.format(_NS, "dataEntry"));
    public static final Property compound = m_model.createProperty(String.format(_NS, "compound"));
    public static final Property feature = m_model.createProperty(String.format(_NS, "feature"));
    public static final Property values = m_model.createProperty(String.format(_NS, "values"));
    public static final Property hasSource = m_model.createProperty(String.format(_NS, "hasSource"));
    public static final Property conformer = m_model.createProperty(String.format(_NS, "conformer"));
    public static final Property isA = m_model.createProperty(String.format(_NS, "isA"));
    public static final Property model = m_model.createProperty(String.format(_NS, "model"));
    public static final Property report = m_model.createProperty(String.format(_NS, "report"));
    public static final Property algorithm = m_model.createProperty(String.format(_NS, "algorithm"));
    public static final Property dependentVariables = m_model.createProperty(String.format(_NS, "dependentVariables"));
    public static final Property independentVariables = m_model.createProperty(String.format(_NS, "independentVariables"));
    public static final Property predictedVariables = m_model.createProperty(String.format(_NS, "predictedVariables"));
    public static final Property trainingDataset = m_model.createProperty(String.format(_NS, "trainingDataset"));
    public static final Property validationReport = m_model.createProperty(String.format(_NS, "validationReport"));
    public static final Property validation = m_model.createProperty(String.format(_NS, "validation"));
    public static final Property hasValidationInfo = m_model.createProperty(String.format(_NS, "hasValidationInfo"));
    public static final Property validationModel = m_model.createProperty(String.format(_NS, "validationModel"));
    public static final Property validationPredictionDataset = m_model.createProperty(String.format(_NS, "validationPredictionDataset"));
    public static final Property validationTestDataset = m_model.createProperty(String.format(_NS, "validationTestDataset"));
    /**
     * Data properties
     */
    public static final Property value = m_model.createProperty(String.format(_NS, "value"));
    public static final Property units = m_model.createProperty(String.format(_NS, "units"));
    public static final Property has3Dstructure = m_model.createProperty(String.format(_NS, "has3Dstructure"));
    public static final Property hasStatus = m_model.createProperty(String.format(_NS, "hasStatus"));
    public static final Property paramScope = m_model.createProperty(String.format(_NS, "paramScope"));
    public static final Property paramValue = m_model.createProperty(String.format(_NS, "paramValue"));
    public static final Property statisticsSupported = m_model.createProperty(String.format(_NS, "statisticsSupported"));
}

公共类OT{
公共枚举类{
复合物
顺从者，
数据集，
数据输入，
特色
特征值，
算法，
模型
验证，
验证信息；
公共字符串getNS（）{
System.out.println（“String.format（_NS，toString（））：”+String.format（_NS，toString（）））；
返回String.format（_NS，toString（））；
}
公共OntClass getOntClass（OntModel）{
返回model.getOntClass（getNS（））；
}
公共OntClass createOntClass（OntModel模型）{
返回model.createClass（getNS（））；
}
公共属性createProperty（OntModel模型）{
返回model.createProperty（getNS（））；
}
};
/**保存词汇表术语的RDF模型
*/
私有静态模型m_Model=ModelFactory.createDefaultModel（）；
/**作为字符串（{@value}）的词汇名称空间
*/
受保护的静态最终字符串\u NS=”http://www.opentox.org/api/1.1#%s";
公共静态最终字符串NS=String.format（_NS，“”）；
公共静态字符串getURI（）{
返回NS；
}
/**作为资源的词汇表的名称空间
*/
公共静态最终资源名称空间=m_model.createResource（NS）；
/**
*对象属性
*/
公共静态最终属性dataEntry=m_model.createProperty（String.format（_NS，“dataEntry”）；
公共静态最终属性composite=m_model.createProperty（String.format（_NS，“composite”）；
公共静态最终属性feature=m_model.createProperty（String.format（_NS，“feature”））；
公共静态最终属性值=m_model.createProperty（String.format（_NS，“values”）；
公共静态最终属性hasSource=m_model.createProperty（String.format（_NS，“hasSource”）；
公共静态最终属性conformer=m_model.createProperty（String.format（_NS，“conformer”）；
公共静态最终属性isA=m_model.createProperty（String.format（_NS，“isA”））；
公共静态最终属性模型=m_model.createProperty（String.format（_NS，“model”））；
公共静态最终属性报告=m_model.createProperty（String.format（_NS，“报告”））；
公共静态最终属性算法=m_model.createProperty（String.format（_NS，“algorithm”）；
公共静态最终属性dependentVariables=m_model.createProperty（String.format（_NS，“dependentVariables”）；
公共静态最终属性independentVariables=m_model.createProperty（String.format（_NS，“independentVariables”）；
公共静态最终属性predictedVariables=m_model.createProperty（String.format（_NS，“predictedVariables”）；
公共静态最终属性trainingDataset=m_model.createProperty（String.format（_NS，“trainingDataset”）；
公共静态最终属性validationReport=m_model.createProperty（String.format（_NS，“validationReport”）；
公共静态最终属性验证=m_model.createProperty（String.format（_NS，“validation”）；
公共静态最终属性hasValidationInfo=m_model.createProperty（String.format（_NS，“hasValidationInfo”）；
公共静态最终属性validationModel=m_model.createProperty（String.format（_NS，“validationModel”）；
公共静态最终属性validationPredictionDataset=m_model.createProperty（String.format（_NS，“validationPredictionDataset”）；
公共静态最终属性validationTestDataset=m_model.createProperty（String.format（_NS，“validationTestDataset”）；
/**
*数据属性
*/
公共静态最终属性值=m_model.createProperty（String.format（_NS，“value”））；
公共静态最终属性单位=m_model.createProperty（String.format（_NS，“units”））；
公共静态最终属性has3Dstructure=m_model.createProperty（String.format（_NS，“has3Dstructure”）；
公共静态最终属性hasStatus=m_model.createProperty（String.format（_NS，“hasStatus”）；
公共静态最终属性paramScope=m_model.createProperty（String.format（_NS，“paramScope”）；
公共静态最终属性paramValue=m_model.createProperty（String.format（_NS，“paramValue”）；
公共静态最终属性statisticsSupported=m_model.createProperty（String.format（_NS，“statisticsSupported”）；
}

---

你能帮忙吗？

你的问题不是很清楚。如果您询问如何保存已创建的模型，则需要将其写入文件：

OntModel m = .... your model .... ;
FileWriter out = null;
try {
  // XML format - long and verbose
  out = new FileWriter( "mymodel.xml" );
  m.write( out, "RDF/XML-ABBREV" );

  // OR Turtle format - compact and more readable
  // use this variant if you're not sure which to use!
  out = new FileWriter( "mymodel.ttl" );
  m.write( out, "Turtle" );
}
finally {
  if (out != null) {
    try {out.close()} catch (IOException ignore) {}
  }
}

有关编写RDF的更多详细信息，请参阅

或者，如果您的问题是关于如何添加本体实例，请参阅中的示例。作为提示，粗略地说，您希望获得一个与要创建其实例的OWL类相对应的

OntClass

对象：

OntModel m = ... your model ... ;
String ns = "http://example.com/example#";
OntClass foo = m.getOntClass( ns + "Foo" );
Individual fubar = foo.createInstance( ns + "fubar" );

如果这不能解决您的问题，请更新您的问题，提供更多详细信息，最好是您已经尝试过的代码示例

更新

好的，我看到了你的更新代码。对于Protégé，您只需要用XML编写文件，这样就可以删除行来编写Turtle格式。但你真正的问题是这样的台词：

jenaModel.createIndividual("compoundURI" )

“compoundURI”

不是有效的URI-这是错误消息告诉您的。您需要一个符合有效URI之一的完整URI

jenaModel.createIndividual( OT.NS + compoundURI );