如何通过Jena或SPARQL列出N-triple文件中所有的类与实例

你需要的提取操作既可以通过Jena原生API实现，也可以通过SPARQL查询完成，以下是具体实现逻辑：

核心概念提前明确 #

避免不同定义导致的结果偏差，先统一本次提取的三类对象定义：

• 实体：RDF三元组中所有非字面量的节点，包含IRI节点和空白节点，覆盖所有主语和非字面量宾语
• 类：通过rdf:type关联的宾语中，属于rdfs:Class或owl:Class的资源，若数据集无显式类声明，可直接将所有rdf:type的宾语视为类
• 实例：通过rdf:type关联到任意类的主语资源

基于你已经加载完成的model对象，可直接调用内置API遍历提取：

1.1 提取所有实体 #

import org.apache.jena.rdf.model.*;
import java.util.HashSet;
import java.util.Set;

// 提取所有实体（排除字面量）
Set<RDFNode> entities = new HashSet<>();
StmtIterator stmtIter = model.listStatements();
while (stmtIter.hasNext()) {
    Statement stmt = stmtIter.next();
    // 主语默认是资源，直接加入
    entities.add(stmt.getSubject());
    RDFNode object = stmt.getObject();
    // 宾语非字面量则加入
    if (!object.isLiteral()) {
        entities.add(object);
    }
}
// 遍历输出实体
for (RDFNode entity : entities) {
    if (entity.isURIResource()) {
        System.out.println("IRI实体：" + entity.asResource().getURI());
    } else if (entity.isAnon()) {
        System.out.println("空白节点实体：" + entity.asResource().getId());
    }
}

1.2 提取所有类 #

import org.apache.jena.vocabulary.RDF;
import org.apache.jena.vocabulary.RDFS;
import org.apache.jena.vocabulary.OWL;

Set<Resource> classes = new HashSet<>();
// 先获取所有rdf:type的宾语
NodeIterator typeObjs = model.listObjectsOfProperty(RDF.type);
while (typeObjs.hasNext()) {
    RDFNode obj = typeObjs.next();
    if (obj.isResource()) {
        Resource clsCandidate = obj.asResource();
        // 确认是类的实例，无显式类声明的数据集可直接去掉这个判断
        if (clsCandidate.hasProperty(RDF.type, RDFS.Class) || clsCandidate.hasProperty(RDF.type, OWL.Class)) {
            classes.add(clsCandidate);
        }
    }
}
// 输出类
for (Resource cls : classes) {
    System.out.println("类：" + cls.getURI());
}

1.3 提取所有实例 #

Set<Resource> instances = new HashSet<>();
// 所有带rdf:type属性的主语都是实例
ResIterator insIter = model.listSubjectsWithProperty(RDF.type);
while (insIter.hasNext()) {
    instances.add(insIter.next());
}
// 输出实例
for (Resource ins : instances) {
    if (ins.isURIResource()) {
        System.out.println("实例IRI：" + ins.getURI());
    } else {
        System.out.println("空白节点实例：" + ins.getId());
    }
}

SPARQL更适合需要复杂过滤、关联查询的场景，以下是三类查询的语句和Jena执行逻辑：

2.1 公共执行代码模板 #

所有SPARQL查询都可以通过以下模板执行，替换其中的sparqlStr即可：

import org.apache.jena.query.*;

String sparqlStr = "替换为对应SPARQL语句";
Query query = QueryFactory.create(sparqlStr);
try (QueryExecution qexec = QueryExecutionFactory.create(query, model)) {
    ResultSet results = qexec.execSelect();
    while (results.hasNext()) {
        QuerySolution soln = results.next();
        // 从soln中取出对应变量处理即可
    }
}

2.2 查询所有实体的SPARQL #

SELECT DISTINCT ?entity WHERE {
    {?entity ?p ?o}
    UNION
    {?s ?p ?entity FILTER (!isLiteral(?entity))}
}

2.3 查询所有类的SPARQL #

PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX owl: <http://www.w3.org/2002/07/owl#>
SELECT DISTINCT ?class WHERE {
    ?s rdf:type ?class .
    {?class rdf:type rdfs:Class} UNION {?class rdf:type owl:Class}
}

无显式类声明的数据集可去掉大括号的判断条件，直接保留?s rdf:type ?class即可。

2.4 查询所有实例的SPARQL #

PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT DISTINCT ?instance WHERE {
    ?instance rdf:type ?class .
}

内容的提问来源于stack exchange，提问作者khd