java内存对象映射文件_java-dirty: java-dirty 是一个快速的基于文件的对象存储系统，只能往存储里添加对象，使用内存映射文件技术...

java-dirty

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

uk.co.probablyfine

java-dirty

1.6

Usage

Creating a store.

Store 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 = 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 first = store

.reverse()

.filter(x -> x.indexField == valueToFind)

.findFirst();

Build an lookup index using write observers

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

Map 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