MicroStream: MicroStream for Android

Ultra-High Performance

Java Object-Graph Persistence

For Android Mobile, Embedded & Edge Devices

Realize ultra-fast in-memory data processing on Android.
Microsecond Query Time. Low-Latency Data Access. Saves Energy.
Reduce Your Development Effort & Time-to-Market.

Get Started GitHub

Latest Version 5.0

Get Started

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

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.

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

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.

Kotlin
Java

class 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.

Kotlin
Java

class 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

Kotlin
Java

class 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 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

Kotlin
Java

fun 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 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

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 6 months
- Every 6 months a new version is published
- Updates always for the latest version
Community support on GitHub & StackOverflow

For enterprises using MicroStream for business critical applications or products:

Enterprise database connectors
Database connectors for all supported data storage solution.
Enterprise-grade Security
Long-term enhenced security updates to eliminate vulnerabilities.
Enterprise-grade Support
- Development support
- Production support
Long-Term Support (LTS)
Update Warranty - Updates for 8 years guaranted.

Java Object-Graph Persistence

MicroStream Persistence

Benefits

Features

Java In-Memory Data Processing Approach

Some Code

Get Started

Community Edition

Enterprise Edition

Upcoming Event

Products

Resources

Support

Company

Stay Connected

Java Object-Graph Persistence

Cookie

Cookie