# java-dirty

**Repository Path**: mirrors/java-dirty

## Basic Information

- **Project Name**: java-dirty
- **Description**: java-dirty 是一个快速的基于文件的对象存储系统，只能往存储里添加对象，使用内存映射文件技术
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: https://www.oschina.net/p/java-dirty
- **GVP Project**: No

## Statistics

- **Stars**: 2
- **Forks**: 0
- **Created**: 2020-11-06
- **Last Updated**: 2026-01-17

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# java-dirty

[![Build Status](https://travis-ci.org/mrwilson/java-dirty.png?branch=master)](https://travis-ci.org/mrwilson/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
```xml
<dependency>
  <groupId>uk.co.probablyfine</groupId>
  <artifactId>java-dirty</artifactId>
  <version>1.6</version>
</dependency>
```
## Usage

### Creating a store.
```java
Store<Foo> store = Store.of(Foo.class).from("/path/to/file");
```
### Inserting an object
```java
store.put(new Foo(1,2));
```
### Iterating over all objects in the store
```java
store.all().forEach(System.out::println);
```
### Iterate over objects, most recent first
```java
store.reverse().forEach(System.out::println);
```
### Iterate over objects from a starting index
```java
store.from(100).forEach(System.out::println);
```
### Access an index directly
```java
Optional<Foo> foo = store.get(1234);
```
### Reset the entire store
```java
store.reset(); // Reset position to 0, overwriting old entries
```
### Close the store and its backing file
```java
store.close();
```
Trying to read from/write to a closed store will throw a ClosedStoreException.
### Observe each write
```java
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<Foo>.

## Examples

### Look up most recent version of an object by index

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

### Build an lookup index using write observers

```java
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