Java does not provide a native method to store data. For storing and querying data we use external SQL/NoSQL DBMS.
The core problem is: all DBMS use totally different data structure than we use in Java.
Java
RDBMS
NoSQL DBMS
key-value-, document-, column-, graph- or object-store
This problem is well known for almost 40 years and leads to many fatal consequences:
MicroStream is the very first Native Data Store for Java
MicroStream is a unique storage technology that stores Java object-graphs natively, which means similar as they are in the RAM, without expensive transformation to any incompatible data structure. That is the key difference to all database-systems and provides you fantastic benefits.
CEO, MicroStream
In Java we use object-graphs for almost everything, of course for processing data also.
It's commonly known, that object-graphs are predestined for huge and complex data structure and
we can query them in-memory in only microseconds.
Why transforming this perfect structure to a totally alien structure to store data?
It's only because database-systems have always dictated the storage format and Java doesn't provide a native solution.
We believe from a Java-side perspective, the logical consequence and most efficient way is storing data exactly the same manner as the Java-VM does.
That's why MicroStream stores Java object-graphs natively, which means exactly 1:1 as the JVM holds it in the memory.
Thus, MicroStream feels like a native and simple to use Java data storage function, which eliminates lots of technical problems
in today's data processing, simplifies the entire database development process, reduces the costs and provides completely new possibilities.
MicroStream stores your Java object-graph 1:1 as it is. No more loss of computing time through mapping objects to an incompatible database data-structure.
Your entire database is located in the memory within your business-logic-layer. No more database-server, no more storage-layer needed.
Your Java object-graph is your database, which is located in the RAM and fully managed by the Java-VM.
Queries even on a huge object-graph located in the memory are commonly executed in microseconds. Up to 1,000 times faster than any conventional DBMS.
Frequently executed queries are fully automated optimized by the Java VM's JIT- compiler and can be accelerated up to nanoseconds.
Because your database is located in the RAM, there is no more bottleneck or latencies that brakes your database accesses.
With MicroStream, your Java classes are your only one data model, nothing else. This simplifies the entire database development process significantly.
MicroStream allows you to store any Java object without the need to adapt your Java classes. No superclasses, no interfaces, no annotations, no dependencies.
With MicroStream there is no more need to use complex ORM-frameworks like Hibernate and additional data-caching frameworks.
With MicroStream you can freely design Java your data model without the need to adapt your classes to an alien database data structure.
MicroStream is a tiny Java API. You can include it in any Java program via Maven. The engine feels like a native Java method for storing data.
The only requirement is Java 8. MicroStream has absolutely no dependencies on any third-party APIs.
Simple architecture and paradigm. Ultra-fast. Pure Java approach. Get the maximum power out of the JVM
Java itself provides you almost everything you need to create incredible fast in-memory database applications.
The only thing missing so far was a native storage function to store data persistent on disk. With MicroStream, exactly this is now possible.
MicroStream is the only one data-storage that stores Java object-graphs natively
Relational Database Systems | NoSQL Database Systems | MicroStream Native Java Data-Store |
---|---|---|
![]() |
![]() |
![]() |
Processes:
Java + RDBMS server |
Processes:
Java + NoSQL DBMS server |
Processes:
Java only
|
Architecture:
3-tier |
Architecture:
3-tier |
Architecture:
2-tier
|
Data Structure:
Tables & Relations |
Data Structure:
Key-Value / Document / Column / Graph |
Data Structure:
Native Java object-graph
|
Compatible to Java object-graphs:
No - Impedance mismatch |
Compatible to Java object-graphs:
No - Impedance mismatch |
Compatible to Java object-graphs:
Yes
|
Needed data models:
Java classes + database data model |
Needed data models:
Java classes + database data model |
Needed data models:
Java classes only
|
Mapping needed:
Yes |
Mapping needed:
Yes |
Mapping needed:
No
|
Data model design:
Strongly adapted to DBMS |
Data model design:
Strongly adapted to DBMS |
Data model design:
Freely
|
Additional data-cache needed:
In many cases |
Additional data-cache needed:
In many cases |
Additional data-cache needed:
No
|
Query language:
SQL |
Query language:
SQL / proprietary |
Query language:
Java API
|
Complexity of development:
High |
Complexity of development:
High |
Complexity of development:
Low
|
Loss of performance through mapping:
Yes |
Loss of performance through mapping:
Yes |
Loss of performance through mapping:
No mapping
|
MicroStream allows you to store any plain Java object-graph.
You don't have to adapt your Java classes efforts.
public class Customer { private String firstname; private String lastname; private String mail; private Integer age; private Boolean active; private Set<Order> orders; ... }
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); } ... }
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()); }); }); }
MicroStream enables you to store and load
any Java object-graph 1:1 as it is by calling only 1 simple method.
DataRoot root = microstreamDemo.root(); root.getCustomers().add(customer); microstreamDemo.store(root.getCustomers());
MicroStream allows you to store and load single entities
Java serialization | Blob-Stores | MicroStream Native Java Data-Store |
|
Storing complete object-graphs | ✓ | ✓ | ✓ |
Storing single entities | ✓ | ||
Loading complete object-graphs | ✓ | ✓ | ✓ |
Loading single entities & updating the object-graph in the memory partially | ✓ |
MicroStream is a tiny Java API that you can include in any Java application and run in any JVM from Java 8
Desktop
On-Premise
Cloud
Container-ready
Great for
MicroServices