Java-Native High-Performance Persistence

Store any Java Object Graph Natively, Relieved of Heavy-weight JPA. Microsecond Response Time. Ultra-High Throughput. Minimum of Latencies. Create Ultra-Fast In-Memory Database Applications & Microservices.

Get Started

What's the Problem with Data Storage in Java Today?

Java processes data in the form of object graphs in RAM. In contrast, relational databases store data in tables. Storing complex Java object graphs in tables isn't possible (impedance mismatch). Conversely, neither database nor cache returns Java objects. This problem was solved by object-relational mapping (ORM), which means all data are converted behind the scenes twice through every single read and write. Therefore, ORM is ineffective, leads to enormous performance losses, and creates its own set of issues.

Performance Issues

JPA queries require processing-intensive data conversions that reduce performance. When using in-memory data cache, data conversions can consume 90% of JPA queries time and effort.

Incompatible Concepts

Java: OOP, classes, methods, inheritance, only 8 data types, typesafty, clean code, POJOs.
RDBMS: tables & relations, stored procedures, stored functions, PL/SQL, SQL, views, up to 50 data types.

Inconvenient Development

To make ORM work, developers need to be experienced, must work with different data structures and models and adapt Java entity classes. Not to mention they still won't eliminate performance issues or the high cost of development.

NoSQL: Similar Challenges

NoSQL databases use different data structures, like JSON documents, column-­oriented, graphs, and key-value store. They are all also incompatible with real Java object graphs and require performance- reducing data conversions.

Huge Infrastructure

To get acceptable performance out, an infrastructure is required that is complex, highly scalable, and effortful to maintain. Scaling is a great feature, but keep in mind that your costs will equally scale high.

Inefficiency and Expensive

Every 100ms delay in searches reduce customer experience, increase bounce rates, drop traffic in potential customers, hurt your conversion rates, and finally cost you a certain percentage in sales and market share.


Why MicroStream?

MicroStream replaces JPA and streams your Java object graphs directly into Oracle and MySQL NoSQL database, Oracle Coherence distributed cache or Oracle Cloud Object Store. No more incompatible database data structure. No more mappings. No more data conversion. No waste of computing time. No network bottlenecks. No latencies. Ultra-fast. Game- changer concept that provides you fantastic benefits.

Ultra-fast

Every query executed in-memory in microseconds - up to 1000 times faster than JPA queries, up to 100 times faster than direct cache access. No magic, but simply core Java concepts and unleashed pure JVM power.

Built for Java

No more database data model. Java classes only. No more mappings. No more query language. Pure Java only. High- quality Java API. From Java developers especially for Java developers. Feels like from core Java.

Saving Money

With MicroStream only one machine is as powerful as an entire conventional database cluster that uses JPA. With MicroStream you will save up to 92% costs of infrastructure, on-premise and in the cloud.

How does it Work?

Java Object Graph - Perfect Multi Model Data Structure

Java Object Graphs are predestined to be used as In-Memory database on Android devices.

Java Object Graphs are predestined to be used as In-Memory database on Android devices.

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 basically be anything, a plain object, but also a collection, document, or binary. All Java types are supported. You can design your any object graph and any single object freely. You can have millions of nodes and subgraphs as well as only one single node. It is by nature a multi-model data structure for storing structured data but allows also handling unstructured data by using collections. Searching object graphs in RAM is super-fast and takes mostly only microseconds.

Only One Data Model: Java Classes Only!

Independent from Database Data Models. No more Mappings.
Let your Classes as they are. No Strings attached!

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 effortful to a special 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. No dependencies. Just POJOs. You can use your classes as they are. If you have to change your data model, simply change your classes. That's all.

Storing Data persistently on the Device

MicroStream enables you to persist single Objects and complex Subgraphs.

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 effortful to a special 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. No dependencies. Just POJOs. You can use your classes as they are. If you have to change your data model, simply change your classes. That's all

Store any single Object or Subgraph explicitly

Store any Java Type

Custom-tailored Type Handling for best Performance

Using Inheritance is Trouble-free

ACID Transactions

Multithreaded super-fast Write Operations

Strong Consistency

High Secure

Covers 3 CRUD Operations: Create, Update & Delete

Loading Data

MicroStream allows you to load single Objects and complex Subgraphs. No more classic Selects. Just calling Getter.

After starting your app, MicroStream initially loads all object IDs only and creates the entire object graph structure in RAM. Thus, you get a fully indexed in-memory database.

Loading Data is fully automized

Loading data is different from database systems. MicroStream is fully object-oriented. There are no more classic selects. To read an object, you just have to call its get method as you are used to, and MicroStream takes care of the rest.

Fully In-Memory is best, but not mandatory

You decide, how much data you load into RAM. If you have enough RAM, you can load the entire database into RAM and benefit from max speed without any IO ops. If your data storage is much bigger than your RAM, you can load data on-demand only. In order to do that, MicroStream enables you to load any single object as well as complex subgraphs lazy.

No Object Copies

Loaded objects are merged into the object graph automatically, so you never have to deal with inconvenient object copies.

Load any single Subgraph on Demand

Loaded Objects are automatically merged into the Object Graph

No inconvenient Object Copies

No more classic Selects, simply call Getter

Memory Management by MicroStream or explicit

Multithreaded super-fast Read Operations

Queries with Java Streams API Executed in Microseconds,
up to 1000x faster than JPA,
even up to 100x faster than Accessing a Local Cache.

Java Streams API is an enormously powerful and fully typesafe query language for searching object graphs. Searching even giant and complex object- graphs in the memory takes only microseconds while database systems waste milliseconds for the same result. In other words, Java Streams are X- times faster than any mobile database system.

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());
        });
    });
}

Core Java instead of proprietary Query Languages

Queries are executed In-Memory

Parallel Execution of Queries possible

No Network Bottlenecks, no Latencies

Type-safe, good testable and clean Code

More Core Features

Storage Garbage Collector

Legacy and corrupt data are removed from the storage by MicroStream automatically.

Class Version Handling

Different versions of your classes are handled automatically. Custom mappings are also supported.

Backups

Reliable and fully individual configurable data backup processes.

REST Interface

REST interface allows remote access to the storage data.

Storage Browser

Graphical user interface for browsing through your storage data remotely.

Highly Configurable

MicroStream is highly configurable through its API.

High Quality API

MicroStream is a high-quality tiny Java API.

Simple Implementation

MicroStream can be included in any Java project via Maven.

Runs wherever Java Runs

One and the Same Java API for All Platforms.

Desktop

On-Premise

Cloud

Container

Perfect persistence for

Microservices

Mobile & Embedded

Native

JDK 8+

Use any JVM Technology

Supported Storages

RDBMS

NoSQL

Object Store

Distributed Cache

Mobile

Anything Missing in MicroStream?

With MicroStream You Can Use all Java Concepts

RapidClipse X is a visual Java IDE based on Eclipse, that lets you create complete and great looking Java in- memory database apps with MicroStream in record time.

Learn

OpenJ9 is a very powerful Java-VM optimized for big RAM sizes and providing 63% less memory footprint. Thus, OpenJ9 is perfect for your MicroStream in- memory database apps.

Learn

Apache Lucene is a powerful search engine for Java. Lucene allows you to add such as full-text search to your MicroStream app.

Learn

GraphQL is a query language for APIs. With GraphQL you can open your MicroStream app to external users and apps, allowing external queries.

Learn

Get Started

Updates are free for 6 months or choose our Long Term Update Warranty for enterprises.

Perfect to get started and for small projects

Community

  • MicroStream is open source
    and contains all features

     
  • Supported and drivven by our
    fantastic community

     
  • 6 months update support free
    Every MicroStream major release is
    supported for 6 monts, which means
    we deliver updates for free.

FREE!

For business critical projects

Enterprise

For enterprises using MicroStream for business critical applications or products:

  • Update Long-Term Support (LTS)
    We provide you updates for all major releases for 8 years guaranted.
    Every major release is supported 8 years.
     
  • Enterprise-grade Security
    Long-term security updates to eliminate vulnerabilities.
     
  • Subscription models:
    • (Virtual) Processor model (vCPU)
    • Embedded model for independent software vendors
    • Individual model that fits to your business is possible