CODEWITHSUNDEEP
javardfjenaontology
Smajl
Smajl

Reputation: 7995

Jena - how to use ontology + rdf together

I have a RDF file that I am able to read using

Model model = ModelFactory.createDefaultModel();

// use the FileManager to find the input file
InputStream in = FileManager.get().open(args[0]);
if (in == null) {
    throw new IllegalArgumentException(
     "File: " + args[0] + " not found");
}

// read the RDF/XML file
model.read(in, null);

I also have OWL file which contains the description of the ontology which is used for creating my models. My question is: do I need to read this file (and how?) in order to work with my RDF model correctly?

To make myself clear, I will give ou an example: I need to know whether one resource has some relationship with other resource (for example Station1 has predicate "isResponsibleFor" Workorder1). How can I do this with Jena?

If I try to use something like resource.hasProperty(ResourceFactory.createProperty("isResponsibleFor")), it returns false (but the property is there!).

Can you direct me to some advanced tutorial on this topic perhaps? I found many tutorials on Papache site etc. but they do not provide me with the information I am looking for. Sorry if the question is not clear, I am quite new to Jena

EDIT: currently, I am searching whether my model contains given statement using this:

public static boolean containsStatement(Model model, String sub,
            String pred, String obj) {
        // list the statements in the Model
        StmtIterator iter = model.listStatements();

        // print out the predicate, subject and object of each statement
        while (iter.hasNext()) {
            Statement stmt = iter.nextStatement(); // get next statement
            Resource subject = stmt.getSubject(); // get the subject
            Property predicate = stmt.getPredicate(); // get the predicate
            RDFNode object = stmt.getObject(); // get the object

            if (subject.toString().contains(sub)
                    && predicate.toString().contains(pred)
                    && object.toString().contains(obj)) {
                return true;
            }
        }

        return false;
    }

but I am pretty sure that this is highly ineffective approach.. could you suggest me something more elegant and fast? Thanks!

Upvotes: 1

Views: 1890

Answers (1)

Ian Dickinson
Ian Dickinson

Reputation: 13285

Short answer: no, you don't need the ontology to work with your RDF file, but in many cases it can help your application.

First, you can shorten loading your file:

Model model = FileManager.get().loadModel( args[0] );

Now, in order to work with the relationship between resources, as given by the URI of the property connecting the subject resource to the object, you need the full URI of the predicate. Typically, this will be something like http://example.com/foo#isResponsibleFor. If you just use the short-name of predicate, it won't work - which is what you are finding.

You don't show any examples of your actual RDF data, so I'm going to use a fake namespace. Use your actual namespace in your code. In the meantime:

String NS = "http://example.com/example#";
Property isResponsibleFor = model.getProperty( NS + "isResponsibleFor" );

Resource station = model.getResource( NS + "station1" );

for (StmtIterator i = station.listProperties( isResponsibleFor ); i.hasNext(); ) {
  Statement s = i.next();
  Resource workorder = s.getResource();
  // now you can do something with the work-order resource
}

In your code, you had:

public static boolean containsStatement(Model model, String sub, String pred, String obj)

There are a number of things wrong here. First, it's better if you can write your code in a more object-oriented style, which tends not to use static methods if that can be avoided. Second, don't use strings when you refer to things in a model. Jena has the Resource class to denote resources in a model, and many other RDF-specific classes as well. Use strings for handling input from your user, otherwise convert strings to resources or other RDF objects as soon as you can. Thirdly, I'd advise against exposing the details of your representation via your object's API. containsStatement makes it clear in the API that you are using RDF triples; that's not a detail that callers of the API need to know and it breaks encapsulation. A better API would have methods such as listWorkItems - that relates to the domain, and hides details of the implementation.

Regarding the use of your ontology, there are two specific ways your application can benefit from using your ontology. First, you can automatically generate statements such as:

Property isResponsibleFor = model.getProperty( NS + "isResponsibleFor" );

by using Jena's schemagen vocabulary generator tool. You can use schemagen as part of your build process to ensure that your vocabulary class automatically stays up-to-date as your ontology changes.

Secondly, by using Jena's inference engines, you can use the ontology to infer additional statements about your domain. For example, suppose you have class WidgetOrder, which is a type of WorkItem. Without inference, and without your ontology, if you ask the model object to list all of the WorkItems, it won't list the WidgetOrder resources. However, with the ontology and the reasoner, listing resources of type WorkItem will also return the resources that only have a declared type of WidgetOrder, because the other types can be inferred.

Upvotes: 3

Related Questions