Create ultra-fast Java in-memory database applications.
Ultra-fast. Super easy to use.

Final Release is out !
GET STARTED
 
Built for ultra high-speed database applications, light-weight web- & microservices, high-complex data structure, realtime solutions, AI & ML.

MicroStream -
Native Java Data-Store

Getting Started
 
Create ultra-fast Java in-memory database apps with pure Java.
Predestinated for Microservices which have to store data.
Super easy to use.
 

Fantastic benefits


Ultra high-speed
Saving time,
resources & money
icons8-rocket-80
icons8-get-cash-80
process_100px
Simplifies your entire
database development process
No more loss of performance through mapping
Pure Java in-memory computing paradigma
JIT-compiler boost even for your
Your object-graph is a in-memory database
Query executing time down to nanoseconds
No network bottleneck
database operations
Feels like a native data store function for Java
1 data structure - your Java object-graph
No more impedance mismatch, no more mapping
No more JPA, no more caching-framework
100% pure Java
Simple architecture
1 data model - your Java classes
Super easy to use
Simple implementing
No JPA/NoSQL expert know-how needed
Faster results
Reduces your time to market and costs of
development, testing and maintenance

Only 1 data model: Your Java classes.


Use your classes as they are. No strings attached.

MicroStream allows you to store any plain Java object-graph.
You don't have to adapt your Java classes effortly.
public class Customer {

   
private String firstname;
   
private String lastname;
   
private String mail;
   
private Integer age;
   
private Boolean active;
   
private Set<Order> orders;     
   
   
...
No need for ...
Special superclasses
Special interfaces
Annotations
Mappings
Other internal configurations

Ultra high-speed

No more mapping
In-memory database
change_100px
historical_100px
integrated_circuit_100px
Java-Duke_100px
database_100px
electronics_100px
Java-Duke_100px
Pure Java in-memory computing
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 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.
No network bottleneck
network_100px
error_100px
integrated_circuit_100px
search_100px
In-memory queries
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.
Because your database is located in the RAM, there is no more bottleneck or latencies that brakes your database accesses.
speed_100px
Java-Duke_100px
JIT-compiler boost
Freequently executed queries are fully automated optimized by the Java VM's JIT- compiler and can be accelerated up to nanoseconds.

Simplifies & accelerates
your entire development process

Only 1 data model
No more complex JPA
mind_map_100px
Java-Duke_100px
icons8_settings_100px
icons8_settings_100px
icons8_settings_100px
icons8_settings_100px
icons8_settings_100px
icons8_settings_100px
approval_100px
Javacode_100px
Use your classes as they are
With MicroStream, your Java classes are your only one data model, nothing else. This simplifies the entire database development process significant.
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 addtional data-caching frameworks.
static_view_level2_100px
checked_100px
snipping_100px
new_document_100px
approval_100px
Design your data model freely
Easy to use
No special requirements
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 into 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 to any third-party APIs.
 

MicroStream Architecture

Runtime architecture diagram.
You only need a Java-VM from Java 8
and any file-system
Ready for On-Premise, Cloud, Container & Microservices
Any Java API can be used additionally
No application-server needed
Server / VM / Container
Java-VM
RAM
Your Business-Logic
MicroStream
MicroStream-Java-Object-Graph
Native
Java Object-Graph
Any Java API
File-Storage
MicroStream-Java-Object-Graph
Native
Java Object-Graph

Your object-graph Graph is
the ultimative Java in-memory database.

Predestined for complex data structure
You can design your object-graph freely
All Java concepts can be used, e.g. collections
All Java APIs & frameworks can be used, e.g. Java streams API, Apache Lucene
Running through huge object-graphs takes only microseconds
Maximum query speed powered by the JVM's JIT-compiler
Concurrent writes can be managed by using Java standard concepts
If RAM is not enough, data can be loaded on demand with MicroStream
Deleted references are removed by the JVM's garbage collector
JetstreamDB-ObjectGraph

Loading Data into the memory

MicroStream-Loading-Data
RAM
Java Object-Graph
File-Storage
Java Object-Graph
MicroStream
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);
   }
You get a fully indexed in-memory database by default
You can pre-load any amount of data into the memory
When accessing an entity MicroStream loads the data into the
memory fully automized behind the scenes (lazy-loading)
Multithreaded load-process for maximum speed
References that are not longer accassable are automatically
deleted by the garbage collector of the Java-VM
 

Why MicroStream ?


MicroStream is the very first Native Data Store for Java.
jet-black
Java
Java Object-Graph
File-Storage
Java Object-Graph
MicroStream-Arrow-Data-Transfer
MicroStream-Java-Object-Graph
MicroStream-Java-Object-Graph
MicroStream is a unique storage technology that stores Java object-graphs natively, which means similar as they are in the RAM, without expensive transforma-tion to any incompatible data structure. That is the key difference to all database-systems and provides you fantastic benefits.
Feels like a native Java function for storing data
Only 1 data structure (object-graph), only 1 data model (Java classes)
No more impedance mismatch, no more mapping
No more loss of performance through mapping
Makes pure Java in-memory computing paradigma possible
Simple architecture, super easy to use
Simplifies and accelerates your entire database development process
Maxing out the ultra-fast in-memory computing power of the JVM

Storing Data persistently

MicroStream-LazyLoading
RAM
Java Object-Graph
File-Storage
Java Object-Graph
MicroStream
MicroStream enables you to store and load
any Java object-graph 1:1 as it is by calling only 1 simple method.
Any file-system
Only changes are stored (single entities)
Append-only strategy
Transaction-safe
Multithreaded store process for maximum speed
Super fast
Splitting the storage into many files for even more speed is possible
Using different distributed file systems is possible
DataRoot root = microstreamDemo.root();
root.
getCustomers().add(customer);
 
microstreamDemo.
store(root.getCustomers());
 

Runs everywhere

MicroStream is a tiny Java API that you can include in any Java application and run in any JVM from Java 8.
Desktop
Cloud
computer_100px
cloud_checked_100px
server_100px
On-Premise
cargo_ship_100px
Container-ready
puzzle_100px
puzzle_100px
Great for
MicroServices
Getting Started
 
 
 
 

What's the Problem with Data Storage in Java ?


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
MicroStream-Java-Object-Graph
Table-Structure
RDBMS
In Java we use object-graphs
for almost everything
RDBMS store data in tables
connected by relations
Key-Value-Structure
NoSQL DBMS
NoSQL DBMS provide totally different data structure like key-value, document,  
key-value-, document-, column-, graph- or object-store

Impedance Mismatch !


All database systems of today are totally incompatible to Java.


This problem is well known since almost 40 years and leads to many fatal consequences:
High-complex architecture
2 totally different data models needed
Need to adapt your Java classes effortly
Database query language & Java query API needed
Strongly limited, flat Java object model
Infamouse source of error
OR-mapping leads to tremendous loss of performance
High effort and costs for the entire database
High-complex mapping framework needed
Need of experienced JPA/NoSQL specialists
In most cases additional caching framework needed
development process and maintenance
Learn more on Wikipedia ...
 
MicroStream-Arrow-Blue
Icon-Flash-White

What is pure Java in-memory computing paradigma?

Simple architecture and paradigma. Ultra-fast. Pure Java approach. Get the maximum power out of the JVM.
Data model: Your Java classes only
static_view_level2_100px
database_100px
Database-Management-System: Your business logic is your DBMS
mind_map_100px
In-Memory Database: Your Java object-graph is your database
search_100px
Query language: Any suitable Java API, e.g. Java streams API
electronics_100px
In-memory speed: Querying even huge object-graphs takes only microseconds
speed_100px
JIT compiler boost: Most frequent queries are accelerated up to nanoseconds
MicroStream_Mascot_100px
Data storage: MicroStream - Native Java Data Store
administrative_tools_100px
Processes: Java server only, no more DMBS-server needed
layers_100px
Architecture: 2-tier
Java itself provides you almost everything you need to create increadible 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.
Java-Duke_100px
 
Markus Kett
CEO, MicroStream
 
In Java we use object-graphs for almost everything, off 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.
Markus-Kett-MicroStream-200
 

What's different to Java serialization and Blob-Stores ?


MicroStream allows you to store and load single entities.
checked_100px
Storing complete object-graphs
checked_100px
Storing single entities
checked_100px
checked_100px
Loading complete object-graphs
checked_100px
checked_100px
checked_100px
Loading single entities & updating the object-graph
in the memory partially
checked_100px
Java serialization
Blob-Stores
MicroStream
 

Queries executed in microseconds.
Much faster than any conventional database-systems.

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());
});
});
}
Your Java object-graph is your in-memory database
Write your queries with Java streams. Pure Java. Typesafe. Good testable
No more alien query language needed
Querying even a huge Java object-graphs takes only microseconds
Queries up to 1,000 times faster than any DBMS
Frequently used queries are optimized bei the JVM's JIT-compiler
and accelerated up to nanoseconds
Much faster than common data-caches, because no
(OR-)mapping is needed.
100% pure Java-VM power.
 

Only 1 data structure - that's the key difference !


MicroStream is the only one data-storage that stores Java object-graphs natively.
Processes:
Java + RDBMS server
Compatible to Java object-graphs:
No - Impedance mismatch
Processes:
Java + NoSQL DBMS server
Compatible to Java object-graphs:
No - Impedance mismatch
Processes:
Java only
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
Additional data-cache needed:
In many cases
Additional data-cache needed:
In many cases
Additional data-cache needed:
No
Data Structure:
Tables & Relations
Data Structure:
Key-Value / Document / Column / Graph
Data Structure:
Native Java object-graph
Architecture:
3-tier
Architecture:
3-tier
Architecture:
2-tier
Complexity of development:
High
Complexity of development:
High
Complexity of development:
Low
Query language:
SQL
Query language:
SQL /proprietary
Query language:
Java API
Data model design:
Strongly adapted to DBMS
Data model design:
Strongly adapted to DBMS
Data model design:
Freely
Loss of performance through mapping:
Yes
Loss of performance through mapping:
Yes
Loss of performance through mapping:
No mapping
Relational Database Systems
NoSQL Database Systems
Java
Java Object-Graph
Server_100px-2
MicroStream-Java-Object-Graph
database_100px
Java-Duke_100px
Java
Java Object-Graph
Server_100px-2
Java-Duke_100px
MicroStream-Java-Object-Graph
Java
Java Object-Graph
Server_100px-2
Java-Duke_100px
MicroStream-Java-Object-Graph
MicroStream
MicroStream-Arrow-Data-Transfer
MicroStream-Arrow-Data-Transfer
MicroStream-Arrow-Data-Transfer
RDBMS Server
Tables & Relations
Server_100px-2
database_100px
Table-Structure
NoSQL-DBMS Server
Key-Value, Document, Column,
Server_100px-2
database_100px
Key-Value-Structure
File-Storage
Java Object-Graph
MicroStream-Java-Object-Graph
document_100px
document_100px
document_100px
 
© 2019 MicroStream Software. All Rights Reserved.
MicroStream-Logo-Graphic-grey
MicroStream-Logo-Text-grey