MicroStream Persistence
MicroStream is joyfully easy to use Java API you can download via Maven.
MicroStream is a Java-native object graph persistence engine for storing any complex Java object graph or any single subgraph and restoring it in RAM at any time by using a fundamentally new serialization concept designed from scratch. With MicroStream, not only the entire object graph, but also partial subgraphs, or only single objects can be restored in RAM on demand. Beyond serialization, MicroStream is ACID transaction safe, can handle your class changes, provides a garbage collector for the storage files, multi-threaded IO and connectors for SQLite and plain file storage.
- Only one data model: your classes
- No more mappings
- Eliminates expensive latencies
- Ultra-fast IO ops
- Ultra-fast in-memory queries
- Saves lots of CPU power and energy
- Simple architecture
- Java only, developer's joy
- Reduces your development effort
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.
Java In-Memory Data Processing Approach
Turn Android Into a High- Performance In-Memory Data Processing Reactor.
Java provides the perfect data structure that is suited and used for every use-case. With an object graph, you can build up a highly complex data structure but allows you to store simple lists as well. Any node can be basically anything, a plain object, but also a collection, document, or binary. All Java types are supported. You can design your object graph freely. You can add millions of nodes, build subgraphs and connect objects with circle references. It's by nature a multi- model data structure for storing structured data but allows you also handling unstructured data by using collections. Searching object graphs in RAM is super-fast and takes mostly only microseconds.
- Predestined for building in-memory database apps
- Fully indexed out-of-the-box
- Scale from one object to millions of objects and subgraphs
- Incridible in-memory performance: Microsecond query time
- Eliminate bottlenecks and expensive latencies
- Java Object graph: the perfect data structure for any use-case
- Handle any complexity trouble-free
- Handling gigabyte database size in-memory is possible
- Fully automatic memory management by the ART
- Android SDK concepts only
- Real multi-model data structure - any Java type can be used
- Using circle references is possible
- Query 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.
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.
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
Loading Objects Dynamically Into RAM
If you have enough RAM, you can load your entire database into RAM to get max speed without the need for any I/O ops. However, if your RAM capacity is limited, you can use lazy-loading to load data on- demand only, such as bigger collections, BLOBs, documents etc. To reduce RAM usage and garbage collection pause time, lazy references can be removed from RAM at any time. Loaded objects are merged into the object graph fully automatic, thus you don't have to deal with inconvenient object 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
Queries
Microsecond Query-Time
with Java Streams API
Instead of querying a remote database server, 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 hundreds of nodes takes only microseconds.
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
Get Started
MicroStream is joyfully easy to use Java API you can download via Maven.
Community Edition
- Open Source
- Driven by our fast growing community
- Dynamic development of new features, concepts and innovations
- Timely adjustments to the latest Java versions
- Open Source database connectors
PostgreSQL, Maria DB, SQLite, Plain-File Storage
- Updates free for 12 months
- Every 12 months a new major release is published
- For each major release, all updates are free for 12 months
- Community support on GitHub & StackOverflow
Enterprise Edition
For enterprises using MicroStream for business critical applications or products:
- Enterprise database connectors
Database connectors for all supported data storage solution. - Enterprise-grade legal proof
- Legal proof of your right to use MicroStream
- Indemnity against claims of copyright infringement
- Enterprise-grade security
Long-term enhenced security updates to eliminate vulnerabilities. - Enterprise-grade support
- Development support
- Production support
- Long-Term Support: Update Warranty - Updates for 8 years guaranted.