Getting Started

Prerequisites

For the code in this chapter the artifact storage.embedded is needed. Look here how to get it.

Hello World

// Initialize a storage manager ("the database") with purely defaults.
final EmbeddedStorageManager storageManager = EmbeddedStorage.start();
// print the last loaded root instance,
// replace it with a current version and store it
System.out.println(storageManager.root());
storageManager.setRoot("Hello World! @ " + new Date());
storageManager.storeRoot();
// just exit, no shutdown required
System.exit(0);

This simplest example will create a new storage if no existing storage is found, if a existing storage is found it will be loaded (this is all done at line 2 in the example above).

In line 6 the current storage's content is printed.

Line 7 assigns some data to the storage, replacing existing data if there is some.

In line 8 everything gets stored.

The Root Instance

When using MicroStream, your entire database is accessed starting at a root instance. This instance is the root object of an object graph that gets persisted by the MicroStream storage logic. While the root instance can be of any type (for example just a collection or an array), it is a good idea to define an explicit root type specific for the application. In this simple example, it is a class called DataRoot, which wraps a single String.

public class DataRoot
{
private String content;
public DataRoot()
{
super();
}
public String getContent()
{
return this.content;
}
public void setContent(final String content)
{
this.content = content;
}
@Override
public String toString()
{
return "Root: " + this.content;
}
}

More about root instances:

Creating a Database

The following code is all that is required to setup a an application backed by a MicroStream database. The application's convenience root instance is defined and an EmbeddedStorageManager instance, linked to the root, is created (and its database managing threads are started). This is a fully operational Java database application.

// Application-specific root instance
final DataRoot root = new DataRoot();
// Initialize a storage manager ("the database") with the given directory.
final EmbeddedStorageManager storageManager = EmbeddedStorage.start(
root, new File("data")
);

Storing Data

// Set content data to the root element, including the time to visualize
// changes on the next execution.
root.setContent("Hello World! @ " + new Date());
// Store the modified root and its content.
storageManager.storeRoot();

This call is all that is necessary to store data in the simplest case.

Stopping a Live Database

Shutting down the storage manager is possible, but not necessary since the storage concept is, of course, inherently crash-safe. Explicitly calling shutdown is only required to stop the storage management threads in an application that is supposed to continue running afterwards. In every other case, it is pefectly fine to just "kill" the storage manager along with the application.

//storageManager.shutdown();
System.exit(0);

storageManager.storeRoot() is a special case method that always stores the root object. If you want to store any other object than the root itself, just call storageManager.store(modifiedObject)

The full code for the Hello World example is on GitHub.