如何使用RDF4J获取OWL/RDF schema中的所有OWL类及属性

问题概述 #

原使用Jena开发OWL/RDF本体展示库，因Jena对部分Schema读取存在局限，转用RDF4J。已成功加载模型，但无法像Jena那样便捷获取OWL类、子类、数据属性及对象属性，遍历Statement仅得到SimpleIRI无法判断类型。

Jena中原实现参考：

// 获取OWL类
OntModel model = createModel("OWL_MEM");
FileManager.get().readModel(model, uri.toString());
Model _model = model.getRawModel();
model = new OntModelImpl(OntModelSpec.OWL_MEM, _model);
ExtendedIterator classes = model.listClasses();
while (classes.hasNext()) {
    OntClass theOwlClass = (OntClass) classes.next();
    if (thisClass.getNameSpace() == null && thisClass.getLocalName() == null) {
       continue;
    }
    // 处理类逻辑
}

// 获取属性
ExtendedIterator properties = model.listAllOntProperties();
while (properties.hasNext()) {
   OntProperty thisProperty = (OntProperty) properties.next();
   // 处理属性逻辑
}

解决方案 #

1. 简化模型加载（可选优化） #

原加载代码可简化为RDF4J标准写法，无需使用DynamicModelFactory：

URL url = file.toURI().toURL();
try (InputStream inputStream = url.openStream()) {
    Model model = ModelFactory.createDefaultModel();
    RDFFormat format = Rio.getParserFormatForFileName(url.toString()).orElse(RDFFormat.RDFXML);
    // 直接用Rio.parse加载模型，更简洁
    Rio.parse(inputStream, url.toString(), format, model);
} catch (IOException e) {
    e.printStackTrace();
}

2. 获取OWL类及子类关系 #

RDF4J没有Jena那样的OntModel高阶封装，但可以通过模型过滤或SPARQL查询实现相同效果：

方式一：模型过滤（直接操作RDF语句）

利用RDF4J内置的OWL和RDFS词汇表筛选资源：

import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Resource;
import org.eclipse.rdf4j.model.vocabulary.OWL;
import org.eclipse.rdf4j.model.vocabulary.RDF;
import org.eclipse.rdf4j.model.vocabulary.RDFS;
import java.util.*;

// 1. 获取所有OWL类
Set<Resource> owlClasses = new HashSet<>();
model.filter(null, RDF.TYPE, OWL.CLASS).forEach(statement -> {
    owlClasses.add(statement.getSubject());
});

// 2. 整理子类关系（构建父类到子类的映射）
Map<Resource, Set<Resource>> subClassHierarchy = new HashMap<>();
model.filter(null, RDFS.SUBCLASSOF, null).forEach(statement -> {
    Resource subClass = statement.getSubject();
    Resource superClass = (Resource) statement.getObject();
    subClassHierarchy.computeIfAbsent(superClass, k -> new HashSet<>()).add(subClass);
});

// 遍历输出类及子类
for (Resource cls : owlClasses) {
    if (cls instanceof IRI) {
        IRI classIri = (IRI) cls;
        System.out.printf("OWL类: %s (%s)%n", classIri.getLocalName(), classIri);
        
        // 输出子类
        Set<Resource> subClasses = subClassHierarchy.getOrDefault(cls, Collections.emptySet());
        if (!subClasses.isEmpty()) {
            System.out.println("  子类:");
            subClasses.forEach(subCls -> 
                System.out.printf("    - %s%n", ((IRI) subCls).getLocalName())
            );
        }
    }
}

方式二：SPARQL查询（更灵活，适合复杂需求）

通过SPARQL一次性查询类及子类关系：

import org.eclipse.rdf4j.query.QueryResults;
import org.eclipse.rdf4j.query.TupleQuery;
import org.eclipse.rdf4j.query.TupleQueryResult;
import org.eclipse.rdf4j.model.IRI;

String classQuerySparql = """
    PREFIX owl: <http://www.w3.org/2002/07/owl#>
    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
    SELECT ?class ?subClass
    WHERE {
        ?class a owl:Class .
        OPTIONAL { ?subClass rdfs:subClassOf ?class }
    }
""";

TupleQuery query = model.getConnection().prepareTupleQuery(classQuerySparql);
try (TupleQueryResult result = query.evaluate()) {
    while (result.hasNext()) {
        var bindings = result.next();
        IRI cls = bindings.getValue("class").asIRI();
        System.out.printf("OWL类: %s%n", cls.getLocalName());
        
        var subClassVal = bindings.getValue("subClass");
        if (subClassVal != null) {
            IRI subClass = subClassVal.asIRI();
            System.out.printf("  子类: %s%n", subClass.getLocalName());
        }
    }
}

3. 获取数据属性与对象属性 #

同样通过模型过滤或SPARQL查询筛选对应类型的属性：

方式一：模型过滤

import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.vocabulary.OWL;
import org.eclipse.rdf4j.model.vocabulary.RDF;
import java.util.HashSet;
import java.util.Set;

// 获取数据属性（owl:DatatypeProperty）
Set<IRI> dataProperties = new HashSet<>();
model.filter(null, RDF.TYPE, OWL.DATATYPEPROPERTY).forEach(st -> {
    if (st.getSubject() instanceof IRI) {
        dataProperties.add((IRI) st.getSubject());
    }
});

// 获取对象属性（owl:ObjectProperty）
Set<IRI> objectProperties = new HashSet<>();
model.filter(null, RDF.TYPE, OWL.OBJECTPROPERTY).forEach(st -> {
    if (st.getSubject() instanceof IRI) {
        objectProperties.add((IRI) st.getSubject());
    }
});

// 输出结果
System.out.println("=== 数据属性 ===");
dataProperties.forEach(prop -> 
    System.out.printf("%s (%s)%n", prop.getLocalName(), prop)
);

System.out.println("=== 对象属性 ===");
objectProperties.forEach(prop -> 
    System.out.printf("%s (%s)%n", prop.getLocalName(), prop)
);

方式二：SPARQL查询

String propertyQuerySparql = """
    PREFIX owl: <http://www.w3.org/2002/07/owl#>
    SELECT ?property ?propertyType
    WHERE {
        ?property a ?propertyType .
        FILTER (?propertyType IN (owl:DatatypeProperty, owl:ObjectProperty))
    }
""";

TupleQuery propQuery = model.getConnection().prepareTupleQuery(propertyQuerySparql);
try (TupleQueryResult propResult = propQuery.evaluate()) {
    while (propResult.hasNext()) {
        var bindings = propResult.next();
        IRI prop = bindings.getValue("property").asIRI();
        IRI type = bindings.getValue("propertyType").asIRI();
        String typeLabel = type.getLocalName().equals("DatatypeProperty") ? "数据属性" : "对象属性";
        System.out.printf("%s: %s%n", typeLabel, prop.getLocalName());
    }
}

内容的提问来源于stack exchange，提问作者Hervé Girod