Mobile RDF

RDF Resource Description Framework Icon
A Java implementation of Resource Description Framework

Author:Michael Hedenus

Table of Contents


This is a free and open source Java implementation of Resource Description Framework. The design goals are:

Actually I stick to Java ME Personal Profile because I want to use the collection framework of java.util and have at least some UI (AWT).

The current implementation provides following features:

The XML parser has support for character encoding detection, UTF-8, UTF-16 (big and little endian), xml:base, xml:lang, xml:id, xml:space, general internal parsed entities.

This is an early release but I hope you find it useful. I am looking forward to any kind of feedback - criticism is welcome, too.

The download contains all source including the code examples, binaries, Java-docs and a ready-to-install jar.


Instead of bothering you with long text I present some code examples to show how Mobile RDF works.

Example 1: Parsing a RDF-XML file

Let's start with parsing. A simple example a RDF-XML file is loaded into a graph and the new statements are printed out.

	// an new RDF graph
	RDFGraph graph = new RDFGraph();
	// an RDF event listener which translates RDF events
	// to add new statements to the graph
	GraphBuilder graphBuilder = new GraphBuilder(graph);
	// an RDF XML parser
	RDFXMLParser rdfXmlParser = new RDFXMLParser();
	rdfXmlParser.parse(graphBuilder, new URL("")); 
	// print the statements to System.out

The output is in form of N-Triples:

<> <> "An example file."@en .
<> <> <> .
<> <> "2008-07-13"^^<> .

Example 2: Manipulating the RDF model

Of course the graph can also be manipulated directly:

	// new graph
	RDFGraph graph = new RDFGraph();
	// the subject resource
	URIRefNode subject = graph.createURIRefNode("");
	// the property URI
	String predicate = Namespaces.DUBLINCORE11+"description";
	// the object literal
	// the second argument is the datatype
	Literal object = graph.createLiteral("Hello World.", null, "en");
	// create statement
	Statement statement = graph.createStatement(subject, predicate, object);

The output is then:

<> <> "Hello World."@en .

Example 3: Serialization

Currently the graph can be serialized as RDF-XML or in form of Graph Modelling Language. Append following lines to the code of Example 1:

	new RDFXMLSerializer().serialize(graph, new File("example3_output.rdf"));
	new GMLSerializer().serialize(graph, new File("example3_output.gml"));

The resulting RDF-XML output is like:

<?xml version="1.0" encoding="US-ASCII"?>
<!-- created Sun Jul 13 22:28:47 CEST 2008-->
	<!ENTITY dc "">
	<!ENTITY rdfs "">
	<!ENTITY geo "">
	<!ENTITY xsd "">
	<!ENTITY owl "">
	<!ENTITY rss "">
	<!ENTITY mh "">
	<!ENTITY rdf "">

	<rdf:Description rdf:about="">
		<dc:creator rdf:resource=""/>
		<dc:date rdf:datatype="">2008-07-13</dc:date>
		<dc:description xml:lang="en">An example file.</dc:description>

The GML output can be loaded and rendered by a suitable application, e.g. yEd. yEd really makes beautiful graph renderings:

Example 4: RDF-Schema

So far so good, these examples were the basics. If you want to work with RDF, the next step is RDF-Schema. RDF-Schema provides the notation of classes, so a databinding framework which maps rdfs:Class resources to Java objects suggests itself.

The central interface is de.hedenus.rdfschema.Resource which represents a rdfs:Resource. Other classes which are defined by RDF/RDF-Schema are represented by sub-interfaces. They provide convenience methods like or de.hedenus.rdfschema.List.iterator().

The following example code creates a databinding instance which is backed by a RDF graph. You can access resources and list their properties.

	// a new databinding (includes the graph)
	RDFDatabinding dataBinding = new RDFDatabinding();
	// parse the RDF file
	dataBinding.parse(new URL(""));
	// get a resource
	Resource example4 = dataBinding.getResource("");
	// list all dc:description properties
	Resource[] hellos = example4.getProperties(Namespaces.DUBLINCORE11 + "description");
	for (int i = 0; i < hellos.length; i++)
	// list only (first) french dc:description
	System.out.println(example4.getProperty(Namespaces.DUBLINCORE11 + "description", (Locale)null));

Typed literals are also supported. For example, a xsd:dateTime property can be accessed as follows:

	DateTime dateTime = (DateTime)example4.getProperty(Namespaces.DUBLINCORE11 + "date", Namespaces.XMLSCHEMA + "dateTime");

The datatypes are internally created and mapped by de.hedenus.xmltypes.TypeFactory. Currently the most important XML Schema types are implemented. Here is a list of the mapped types.

Example 5: RDF-Schema Databinding Framework

To add more convenience, you can specifiy special Java-RDF type bindings. This is done in a subclass-from-basetype-way. I am experimenting with a POJO-annotations-approach, but this is for Java 5 and will also include a special marshaller/unmarshaller.

You can subclass from de.hedenus.rdfschema.ResourceImpl and add methods you like. As an example I create a class for RSS 1.0 channels. The new method items() gets the rdf:Seq of items (which is a rdfs:Container) and returns it as java.util.List:

	public class Channel extends ResourceImpl
		public static final String URI = Namespaces.RSS10 + "channel";
		public List items()
			Container seq = (Container)getProperty(Namespaces.RSS10 + "items");
			return seq.toList();

Now you must register your new implementing class. This done by creating a mapping text file (encoded US-ASCII) which contains URI-class pairs, separated by whitespace, one pair per row. You must put the file in the classpath as 'rdfschema/typemapping'.

; Java type mapping of RSS channel de.hedenus.mobilerss.Channel

Well, this is the most simple way. I started to write a RDF-to-Java code generator (generating getter/setter methods from rdf:Property/rdfs:range/rdfs:domain), but I think it is not worth the trouble.

A class for a RSS item can look like this:

	public class Item extends ResourceImpl
		public static final String URI = Namespaces.RSS10 + "item";
		public String getTitle()
			return String.valueOf(getProperty(Namespaces.RSS10 + "title", (String)null));
		public String getDescription()
			return String.valueOf(getProperty(Namespaces.RSS10 + "description", (String)null));

Finally, reading a RSS feed becomes quite easy:

	// a new databinding (includes the graph)
	// type mappings will be loaded from 'rdfschema/typemapping'
	RDFDatabinding dataBinding = new RDFDatabinding();

	// parse a RSS resource
	String home = "";
	dataBinding.parse(new URL(home));

	// get the channel instance
	// (it is assumed that the channel URI is the same as the resource URL)
	Channel channel = (Channel)dataBinding.getResource(home);

	// the items are listed in form of rdf:Seq
	for (Iterator i = channel.items().iterator(); i.hasNext();)
		// print next item
		Item item = (Item);
		String title = item.getTitle();
		// lookup an optional date information
		Date date = (Date)item.getProperty(Namespaces.DUBLINCORE11 + "date", Namespaces.XMLSCHEMA + "date");
		if (date != null)
			System.out.print(" (" + date.toString() + ")");

Example Application

As an example application I have written a simple RSS 1.0 client. The client will load and display the items of a specified RSS source file.

The application is suitable for Java Personal Profile and has been tested for Nokia 9500. Simply install the JAR file which is bundled in the download on your device. The following screenshots show what will happen:

(1) Start of RSS Client with a preselected URL. Now just click enter or click the button.

(2) The client loads the data - please be patient.

(3) When accessing the channel was successful the UI switches to a list of items. Use the up-down keys to scroll to an item and hit enter to select it.

(4) The item is displayed in a text panel. Use the TAB key to switch to the tab list on the right and to go back to the item list.

Implementation Status

The RDF-XML parser lacks implementation of following features:


This software is released under the Apache License 2.0. I appreciate if you send me an email about your application and give me some feedback.


Get the complete bundle including sources, binaries and API docs.