To build Spring for Stardog, you need a relase of Stardog; we use Gradle to build Stardog for Spring. Then,

• edit build.gradle to point stardogLocation at a Stardog release directory;
• run gradlew, which will download and bootstrap a gradle build environment;
• then run gradlew build, which eventually results in a stardog-spring.jar in build/libs; finally,
• gradlew install does a build, generates a POM, and installs the POM in local Maven repo; alternately,
• mvn install will work, too:

  mvn install:install-file
        -DgroupId=com.clarkparsia.stardog
        -DartifactId=stardog-spring
        -Dversion=0.0.2
        -Dfile=stardog-spring.jar
        -Dpackaging=jar
        -DpomFile=pom.xml

Spring for Stardog 0.0.3 provides a set of capabilities for rapidly building Stardog-backed applications with the Spring Framework. As with many other parts of Spring, Stardog's Spring integration uses the template design pattern for abstracting standard boilerplate away from application developers.

At the lowest level, Spring for Stardog includes

1. DataSouce and DataSourceFactoryBean for managing Stardog connections
2. SnarlTemplate for transaction- and connection-pool safe Stardog programming
3. DataImporter for easy bootstrapping of input data into Stardog

Future releases of Spring for Stardog will address other common enterprise capabilities: Spring Batch, Spring Data, etc.

There are three Beans to add to a Spring application context:

• DataSourceFactoryBean: com.clarkparsia.stardog.ext.spring.DataSourceFactoryBean
• SnarlTemplate: com.clarkparsia.stardog.ext.spring.SnarlTemplate
• DataImporter: com.clarkparsia.stardog.ext.spring.DataImporter

DataSourceFactoryBean is a Spring FactoryBean that configures and produces a DataSource. All of the Stardog ConnectionConfiguration and ConnectionPoolConfig methods are also property names of the DataSourceFactoryBean—for example, "to", "url", "createIfNotPresent".

DataSource is a Spring for Stardog class, similar to javax.sql.DataSource, that can be used to retrieve a Connection from the ConnectionPool. This additional abstraction serves as place to add Spring-specific capabilities (e.g. spring-tx support in the future) without directly requiring Spring in Stardog.

SnarlTemplate provides a template abstraction over much of Stardog's native API, SNARL, and follows the same approach of other Spring template, i.e., JdbcTemplate, JmsTemplate, and so on.

The key methods on SnarlTemplate include the following:

query(String sparqlQuery, Map args, RowMapper)

query() executes the SELECT query with provided argument list, and invokes the mapper for result rows.

doWithAdder(AdderCallback)

doWithAdder() is a transaction- and connection-pool safe adder call.

doWithGetter(String subject, String predicate, GetterCallback)

doWithGetter() is the connection pool boilerplate method for the Getter interface, including the programmatic filters.

doWithRemover(RemoverCallback)

doWithRemover() As above, the remover method that is transaction and pool safe.

execute(ConnectionCallback)

execute() lets you work with a connection directly; again, transaction and pool safe.

construct(String constructSparql, Map args, GraphMapper)

construct() executes a SPARQL CONSTRUCT query with provided argument list, and invokes the GraphMapper for the result set.

DataImporter is a new class that automates the loading of RDF files into Stardog at initialization time.

It uses the Spring Resource API, so files can be loaded anywhere that is resolvable by the Resource API: classpath, file, url, etc. It has a single load method for further run-time loading and can load a list of files at initialization time. The list assumes a uniform set of file formats, so if there are many different types of files to load with different RDF formats, there would be different DataImporter beans configured in Spring.

Here's a sample applicationContext:

query() with SELECT queries

doWithGetter

doWithAdder

doWithRemover

construct()