jena
Apache Jena, A free and open source Java framework for building Semantic Web and Linked Data applications.
Top Related Projects
SPARQL graph database
Quick Overview
Apache Jena is an open-source Java framework for building Semantic Web and Linked Data applications. It provides a comprehensive set of tools and libraries for working with RDF, SPARQL, and OWL, enabling developers to create, manipulate, and query semantic data models.
Pros
- Comprehensive toolkit for Semantic Web development
- Strong community support and regular updates
- Excellent documentation and extensive examples
- Supports various data storage options (in-memory, TDB, and database backends)
Cons
- Steep learning curve for newcomers to Semantic Web technologies
- Performance can be an issue with large datasets
- Limited support for non-Java programming languages
Code Examples
- Creating and querying an RDF model:
Model model = ModelFactory.createDefaultModel();
model.read("data.ttl");
String queryString = "SELECT ?subject ?predicate ?object WHERE { ?subject ?predicate ?object }";
Query query = QueryFactory.create(queryString);
QueryExecution qexec = QueryExecutionFactory.create(query, model);
ResultSet results = qexec.execSelect();
while (results.hasNext()) {
QuerySolution solution = results.nextSolution();
System.out.println(solution);
}
- Creating and writing an OWL ontology:
OntModel ontModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
String ns = "http://example.org/ontology#";
OntClass personClass = ontModel.createClass(ns + "Person");
OntClass employeeClass = ontModel.createClass(ns + "Employee");
employeeClass.addSuperClass(personClass);
ObjectProperty worksFor = ontModel.createObjectProperty(ns + "worksFor");
worksFor.addDomain(employeeClass);
worksFor.addRange(ontModel.createClass(ns + "Company"));
ontModel.write(System.out, "RDF/XML");
- Performing SPARQL updates:
Dataset dataset = TDBFactory.createDataset("path/to/tdb");
String updateString = "PREFIX dc: <http://purl.org/dc/elements/1.1/> " +
"INSERT DATA { <http://example/book1> dc:title \"A new book\" ; dc:creator \"A.N.Author\" . }";
UpdateRequest update = UpdateFactory.create(updateString);
UpdateProcessor processor = UpdateExecutionFactory.create(update, dataset);
processor.execute();
Getting Started
To start using Apache Jena in your Java project, add the following dependencies to your Maven pom.xml
file:
<dependencies>
<dependency>
<groupId>org.apache.jena</groupId>
<artifactId>apache-jena-libs</artifactId>
<version>4.6.1</version>
<type>pom</type>
</dependency>
</dependencies>
Then, you can create a simple RDF model and add a triple:
import org.apache.jena.rdf.model.*;
Model model = ModelFactory.createDefaultModel();
String ns = "http://example.org/";
Resource subject = model.createResource(ns + "subject");
Property predicate = model.createProperty(ns + "predicate");
RDFNode object = model.createLiteral("object");
model.add(subject, predicate, object);
model.write(System.out, "TURTLE");
This will create an RDF model, add a triple, and print it in Turtle format.
Competitor Comparisons
SPARQL graph database
Pros of Oxigraph
- Written in Rust, offering potential performance benefits and memory safety
- Lightweight and designed for easy embedding in other applications
- Supports SPARQL 1.1 Query and Update languages
Cons of Oxigraph
- Smaller community and ecosystem compared to Jena
- Less comprehensive documentation and fewer examples available
- Limited support for advanced RDF features and extensions
Code Comparison
Oxigraph (Rust):
use oxigraph::model::*;
use oxigraph::store::Store;
let store = Store::new()?;
store.insert(&Triple::new(
NamedNode::new("http://example.com/s")?,
NamedNode::new("http://example.com/p")?,
NamedNode::new("http://example.com/o")?,
));
Jena (Java):
import org.apache.jena.rdf.model.*;
Model model = ModelFactory.createDefaultModel();
Resource subject = model.createResource("http://example.com/s");
Property predicate = model.createProperty("http://example.com/p");
RDFNode object = model.createResource("http://example.com/o");
model.add(subject, predicate, object);
Both examples demonstrate creating a simple RDF triple and adding it to a store or model. Oxigraph uses a more compact syntax, while Jena provides a more verbose but potentially more readable approach.
Convert
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Jena README
Welcome to Apache Jena, a Java framework for writing Semantic Web applications.
See https://jena.apache.org/ for the project website, including documentation.
The codebase for the active modules is in git:
Top Related Projects
SPARQL graph database
Convert
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot