Skip to content
File-backed append-only object store.
Java Shell
Branch: master
Clone or download

Latest commit

Fetching latest commit…
Cannot retrieve the latest commit at this time.

Files

Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
java-dirty-benchmarks
java-dirty
.gitignore
.travis.yml
README.md
pom.xml

README.md

java-dirty

Build Status

A fast file-based append-only object store, using memory mapped files.

Is java-dirty safe to use with multiple concurrent writers?

Absolutely not - but it's fast enough that putting it behind e.g. a Disruptor and consuming writes in a single thread should be fine.

Downloading from Maven

<dependency>
  <groupId>uk.co.probablyfine</groupId>
  <artifactId>java-dirty</artifactId>
  <version>1.6</version>
</dependency>

Usage

Creating a store.

Store<Foo> store = Store.of(Foo.class).from("/path/to/file");

Inserting an object

store.put(new Foo(1,2));

Iterating over all objects in the store

store.all().forEach(System.out::println);

Iterate over objects, most recent first

store.reverse().forEach(System.out::println);

Iterate over objects from a starting index

store.from(100).forEach(System.out::println);

Access an index directly

Optional<Foo> foo = store.get(1234);

Reset the entire store

store.reset(); // Reset position to 0, overwriting old entries

Close the store and its backing file

store.close();

Trying to read from/write to a closed store will throw a ClosedStoreException.

Observe each write

store.observeWrites((object, index) ->
  System.out.println("Stored "+object+" at "+index);
);

java-dirty does not support replacements, or deletions. Both .all() and .reverse() expose a Stream.

Examples

Look up most recent version of an object by index

Optional<StoredObject> first = store
    .reverse()
    .filter(x -> x.indexField == valueToFind)
    .findFirst();

Build an lookup index using write observers

Store<StoredObject> store = Store.of(StoredObject.class).from("/some/path");

Map<Integer, Integer> index = new HashMap<>();

store.observeWrites((object, location) -> {
  index.put(object.indexField, location);
});

store.put(new StoredObject(1234,5));

store.get(index.get(1234)); // Optional[StoredObject(1234,5)];

Supported Fields

java-dirty will only persist primitive fields on objects. All primitive types are currently supported.

Performance

See the README in java-dirty-benchmarks for the latest

You can’t perform that action at this time.