MicroStream Micro Persistence
MicroStream is joyfully easy to use Java API you can download via Maven.
MicroStream is a object graph persistence engine for storing any object graph of any size and complexity persistently on disk or into any other storage targets. MicroStream enables you to store changes on your object graph (the delta) only and reload partial subgraphs into RAM only when needed, by using lazy-loading. MicroStream comes with its own powerful and high-secure serialization, and a highly optimized binary format. MicroStream is transaction-safe, cares for class changes, provides garbage collection for your storage, and provides connectors to SQLite and many other storage targets. The entire framework is Open Source.
- Only one data model: your classes
- No more mappings or data conversion
- Eliminates expensive latencies
- High-performance IO ops
- Ultra-fast in-memory searching and filtering
- Simple architecture
- Fully object-oriented programming concept
- Tiny Java API, runs with Java, Kotlin, and any other JVM languages
- Reduces your development effort
- Developer's joy
Benefits
Warp Speed
In comparison to the traditional SQLite queries, pure Java in-memory ops are executed in microseconds - up to an unbelievable 1000x faster. This eliminates your performance issues and lets you build fascinating new innovations, features, and products.
Save up to 92% CPU Power
The incredible performance of pure Java in-memory data processing maximizes data throughput and minimizes the required CPU power for your server-side apps and microservices and saves up to 92% of your data center costs.
Developer Joy
Developers love the pure Java data processing approach, the fully OO-programming model, the high-quality API and simple architecture. Boost your entire database app development process and reduce your time to market.
Features
MicroStream is joyfully easy to use Java API you can download via Maven.
Tiny Java Library
MicroStream is a tiny Java library without any dependencies which you can download via Maven. It runs within your apps.
Data Model: Java Classes Only
Only 1 data model: Java classes. No more specific database model. No expensive mappings or data conversion. Design your model freely.
Multi-Model Data Structure
A Java object graph is by nature a multi-model data structure. You can add any object, lists and other collections, key-value pairs as well as any document.
No Annoying Restrictions
No need for special superclasses, interfaces such as Serializable, annotations or any other internal configurations. Just use POJOs.
Store Any Java Type
Any meaningful Java types can be persisted. Storing any types from 3rd party APIs is trouble-free.
Dynamic Store Ops
Store any single object, any subgraph, or the complete object graph by calling only one store method. In any case, only the delta will be stored.
ACID Transaction-Safty
Any meaningful Java types can be persisted. Storing any types from 3rd party APIs is trouble-free.
Append-Only Log
Each store operation adds the objects appended to your storage by using a binary data format for best performance.
Lazy-Loading
Each store is an atomic operation, ACID transaction-safe, and strong consistent.
No Object Copies
Loaded objects are fully automated merged into your object graph. You don't have to deal with inconvenient object copies and persistent contexts.
Queries: Java Streams API
The Java Streams API enables you to search even huge and complex object graphs in memory in microsecond query time.
No Classic Selects, Just Getter
Loaded objects are fully automated merged into your object graph. You don't have to deal with inconvenient object copies and persistent contexts.
Memory Management
With MicroStream, RAM is still fully managed by the ART, but you can remove lazy-loaded references at any time to free up RAM.
Multithreaded IO Ops
By using channels, IO operations will be executed multithreaded which increases the performance of your application.
Class Change Handling
Different versions of your classes are handled automatically through the runtime. No refactorings required.
Storage Garbage Collector
Legacy and corrupt objects in the storage are removed by the MicroStream garbage collector automatically through the runtime.
REST Interface
MicroStream provides you a REST API that enables remote access to your persistent storage data.
Storage Viewer
MicroStream comes with a web interface that allows you to browse through your persistent storage data.
Backup
Reliable and fully individual configurable data backup.
Simple Migration
Both, migrating the data to or away from MicroStream is simple by using CSV import/export.
Runs Wherever Java Runs
MicroStream runs on mobile & edge devices, as well as on desktops, on the server, in containers, and in the cloud.
In-Memory Data Processing Approach
Turn Android Into a High- Performance In-Memory Data Processing Reactor.
Both, Java and Kotlin provide the perfect data structure that is suited and used for every use-case. An object graph is by nature a multi-model data structure. You can store both, structured as well as unstructured data. With an object graph, you can store simple lists only or create highly complex data structure with millions of relations and circular references. Any node of your object graph can be basically anything, such as a plain object, collection, document, or binary. Almost all types you can use in Java and Kotlin are supported, and can be persisted. You can design your object model freely. There are no design rules or limitations my MicroStream. You can use collections, subtypes, and circular references. Searching and filtering object graphs in memory by using Java Streams is incredible fast and takes mostly only microseconds.
- High-performance in-memory database apps
- Fully indexed out-of-the-box
- Scale from one object to millions of objects and subgraphs
- Incredible in-memory speed: Microsecond searching time
- Eliminate bottlenecks and expensive latencies
- Object graph: the perfect multi-model data structure for any use-case
- Handle any complexity trouble-free
- Fully automatic memory management by Android Runtime
- Use Java / Kotlin concepts only
- Using subtypes and circle references is trouble-free
- Search and filter object graphs with Java Streams API
- Tremendous data throughput
Some Code
MicroStream is joyfully easy to use Java API you can download via Maven.
Data Model: Just POJOs
Your Java classes are your only data model. There is no more additional database data model. Thus, you don't have to adapt your classes effortfully to a specific database data model. You can design your object model freely and use any Java type. There is no need for special superclasses, special interfaces, annotations, mappings, or any other internal configurations. You can use just POJOs.
Javaclass Customer {
private val firstname: String? = null
private val lastname: String? = null
private val email: Email? = null
private val status: Status? = null
private val orders = Lazy.Reference>(HashSet())
...
}public class Customer {
private String firstname;
private String lastname;
private String email;
private LocalDate dateOfBirth;
private Boolean active;
private Set<Order> orders;
...
}Data model:
Java classes only
No dependencies,
just use POJOs
No need for special superclasses, interfaces or annotations
Use existing classes as they are, no strings attached
Any Java types
are supported
Use any types from 3rd party APIs
Design your object model freely without any limitations
Using inheritance
is trouble-free
Migrating to MicroStream is trouble-free
Persisting Objects
MicroStream enables you to store any Java type. To persist data, you only have to call one store method. It's your decision, if and when an object or subgraph should be persisted. The data are stored as binary data appended to the file storage. Every store is an atomic operation that is transaction-safe.
Javaclass Customer {
...
fun addOrder(newOrder: Order, persister: Persister) {
val orders = orders.get()
orders.add(newOrder)
persister.store(orders)
}
}
val root = MicorStreamDemo.root()
root.getCustomer(customerId)!!.addOrder(
newOrder,
MicorStreamDemo.storage()
)DataRoot root = microstreamDemo.root();
root.getCustomers().add(customer);
microstreamDemo.store(root.getCustomers());Store any single object or subgraph explicitly
Store any Java type, any suited type is supported
Using inheritance is trouble-free
Binary data format, no expensive mappings
Atomic operation and ACID transaction-safe
Strong consistency
Append-only log strategy
Multithreaded write ops for max performance
Gigantic data throughput
Custom-tailored type handling for best performance
Replaces 3 CRUD ops: Create, Update & Delete
Javaclass Customer {
...
private val orders = Lazy.Reference<MutableSet<Order?>>(HashSet())
...
fun orders(): Stream<Order?> {
return orders.set().stream()
}
}public class Customer {
...
private Lazy<Set<Order>> orders;
...
public Set<Order> getOrders() {
return Lazy.get(this.orders);
}
public void setOrders(final Set<Order> orders) {
this.orders = Lazy.Reference(orders);
}
...
}
Loading Objects with Lazy-Loading
If you have enough RAM, you can load your entire database into RAM to get max speed without the need for any further IO ops. However, if your RAM capacity is limited, you can use lazy-loading to load particular object-references only when needed, such as bigger collections, BLOBs, documents etc. To reduce RAM usage and to avoid garbage collection pause time, lazy references can be removed from RAM explicitly at any time. Loaded objects are merged into the object graph fully automated, thus you don't have to deal with inconvenient object deep copies.
Sufficient RAM available: Restore the entire object-graph
RAM limited: Load single objects or subgraphs on-demand
Loaded objects are merged into the object graph automatically
No inconvenient object copies
No more classic selects, simply call getter
Minimizing expensive IO ops
Multithreaded read ops for max performance
Gigantic data throughput
Javafun booksByAuthor(publicationYear: Int): MutableMap<Author, MutableList<Book?>>? {
return MicorStreamDemo.root().books()
.filter {
book -> book.publicationDate().year == publicationYear
}
.collect(groupingBy(Book::author))
}public static void booksByAuthor()
{
final Map<Author, List<Book>> booksByAuthor =
ReadMeCorp.data().books().stream()
.collect(groupingBy(book -> book.author()));
booksByAuthor.entrySet().forEach(e -> {
System.out.println(e.getKey().name());
e.getValue().forEach(book -> {
System.out.print('\t');
System.out.println(book.title());
});
});
}
Queries
Microsecond Query-Time
with Java Streams API
Instead of querying a remote database, just search your object graph in memory by using Java Streams. The Streams API is an enormously powerful and fully typesafe Java API for searching object graphs highly efficiently. Searching even giant and complex object graphs by iterating thousands of nodes will usually take only microseconds while executing classic SQLs usually take milliseconds and thus are up to 1000x slower.
Core Java instead of database query languages
Queries are executed in- memory
Simultaneously query execution with Parallel Streams
No network bottlenecks, no latency.
Type-safe, clean and great testable code
Minimizing expensive IO ops