Java-Cloud-Native
Persistence
MicroStream is a breakthrough Java-native object graph persistence layer built for microservices & serverless functions that need its own light-weight high-performance persistence. MicroStream eliminates expensive mappings or data conversion
Ultra-fast In-Memory Data Processing
Lowest Data Storage Costs in the Cloud
Revolutionary Simple Development
Serialize Your Application Data
Directly into the Cloud
MicroStream is a Java micro persistence layer built for cloud-native microservices and serverless systems that follows the system prevalence architectural pattern. MicroStream enables seamlessly storing any Java objects of any size and complexity transaction-save into cloud blob stores or other binary data stores. ACID transactions are journaled and deltas of the system state are regularly saved to disk. All transactions are appended to the storage and in a highly optimized serialization byte format. To reduce startup time and run also with small RAM capacity, MicroStream provides lazy-loading. At the system start, only object IDs must be loaded into memory. Related object references (subgraphs) are only restored in memory on demand.
Real Java object graph persistence engine
Store any Java object or object graphs of any size and complexity (POJOs).
Live mirroring of system state by micro snapshots
Object changes (the delta) are regularly serialized on disk.
Warp-speed in-memory data processing
Your Java object graph becomes an ultra-fast Java in-memory database.
For large memory & micro machine instances
Keep in RAM or restore only what's needed right now with lazy-loading.
Waver-thin persistence layer
Smallest persistence layer for Java, built for microservices & serverless.
Cloud-native data storage
Connects Java apps seamlessly with cloud native object storages.
Open Source
MicroStream is open source under EPL 2.0.
Distributed & highly scalable
Elastic horizontally scaling with MicroStream Cluster.
Run everywhere
On-prem, public cloud, private cloud, hybrid cloud, managed cloud service.
Frameworks using MicroStream
Fantastic Benefits
Java In-Memory Data Processing is Up to 1000x Faster than JPA + Tradiational RDBMS.
About this Demo
This is a trivial bookstore demo. 2 apps are running in parallel and different database queries are constantly being executed. One app is built with the traditional JPA stack and uses a hot cache. The other app is built with MicroStream. The code is available on GitHub.
| Persistence | MicroStream |
|---|---|
| Cache | None |
| Data Storage | AWS S3 |
| Database size | 250 GB |
| Query API | Java Streams |
| Persistence | Hibernate |
|---|---|
| Cache | EHCache |
| Data Storage | PostrgreSQL |
| Database size | 250 GB |
| Query API | Spring Data, SQL |
Fully In-memory data processing
Your object graph in memory becomes an ultra-fast in-memory data store.
Microsecond response time, up to 1000x faster queries
Common database queries take milliseconds, with MicroStream only microseconds.
Gigantic workloads and data throughput
The high performance enables to handle gigantic loads and throughput.
High-frequency low-latency transactions
Predestined for high-frequency transactions that require the lowest possible latency.
Real-time responsiveness
For systems that need high performance and real-time responsiveness.
Just Java VM power
The entire processing speed comes from the JVM.
MicroStream Simplifies & Accelerates Your Entire Database Development Process
- No more external database systems
- Only 1 data model: Java classes (POJOs)
- Mappings & data conversion eliminated
- Fully free data model design
- No more classic Selects, just call getter
- No more database-specific query language
- Tons of boilerplate code eliminated
- Use & store any Java types
- Pure Java approach
- Fits with all Java concepts
- Fully object-oriented
- Leads to a simple architecture
- Convenient API
- Easy data migration
Freely Data Model Design. No More Limitations.
MicroStream lets you design your object model fully free without any technical requirements or restrictions. You can use and combine any Java type and use your object graph as a powerful multi-model data structure. You can also use circular references trouble-free, while the depth of your object graph is unlimited. Whatever your object model will look like, MicroStream will be able to store it. There are no specific design rules, but to get maximum searching performance, you should design your object model for the best possible traversability.
Data model: Java object graphs
MicroStream uses the native object model of Java, just POJOs.
- Any object graph structure
- Number of objects is unlimited
- Number of edges is unlimited
- Circular references
Multi-model data structure
Java object graphs are a multi-model data structure.
- Use any Java types
- Use collections
- Use any document format
- Custom type handling
- Combine everything
No specific design rules
Design your object model freely. No specifications by MicroStream.
- No design specifications
- No limitations
- Just apply common OO design
Some Code
Use Plain Java Objects.
No Specific Requirements.
Beautiful Clean Code.
Your Java classes define your data model. With MicroStream, there are no specific requirements to your classes. You can just use plain Java objects (POJOs). There is no need for specific superclasses, interfaces, annotations, mappings, or any other internal configurations.
- Use plain Java objects (POJOs)
- No superclass, interfaces, annotations
- No other internal configurations required
- All Java types supported
- Inheritance is trouble-free
Javapublic class Customer {
private String firstname;
private String lastname;
private String email;
private LocalDate dateOfBirth;
private Boolean active;
private Set<Order> orders;
...
}
JavaDataRoot root = microstreamDemo.root();
root.getCustomers().add(customer);
microstreamDemo.store(root.getCustomers());
Storing Objects
ACID Transaction-Safe
To persist objects into the storage, you just have to call one simple store method. By default, MicroStream persists only new and changed objects (the delta). You decide explicitly, if and when an object is persisted. The data is stored as binary data appended to the file storage. Every store is an atomic all-or- nothing operation which is ACID transaction-safe.
- Atomic all-or-nothing operation
- ACID transaction-safe
- Append-log strategy
- Micro snapshot to store latest changes (delta)
- Snapshot of the whole system state
- Rollbacks
- High-speed due to serializing directly to disk
- Max IO speed by parallelizable write ops (channels)
Lazy-Loading.
Restore Subgraphs On- Demand to Run Small RAM Machines.
With lazy-loading, particular object references are loaded and restored in RAM only when accessed, otherwise, no memory is allocated. At any time, lazy references can also be cleared to reduce memory consumption. Objects that are not defined as lazy are loaded and restored in RAM automated on system start.
- Size and depth of lazy references are unlimited
- The object graph gets updated fully automated
- Clearing lazy references at any time
- Working copies to simplify concurrency handling
- Max IO speed by parallelizable read ops (channels)
Javapublic 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 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);
}
...
}
Searching & Filtering
in Microseconds
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 thousands of nodes takes only microseconds.
- No more database-specific query languages
- Java Streams API
- GraphQL
- Type-safe query API
- Ultra-fast in-memory execution
- Creating custom indexes
- Microsecond query time
- Low-latency realtime responsiveness
- Gigantic throughput and workloads
Class Evolution Handling
Changes to classes result in incompatible objects in your storage. With MicroStream, changes to your classes are hassle- free and handled on the fly. If a loaded object no longer fits its corresponding class, the object will be adapted automatically. Simple cases are covered by a heuristic. For more complex cases, you can define a type mapping. Finally, the updated object has just to be persisted again to add the new object version to the storage. You can either keep previous object versions or let remove them from the storage.
- Field added
- Field renamed
- Field removed
- Certain primitive type changes (int >> float)
- Custom type handler for any changes
Javapublic class Customer {
private String firstname;
private String lastname;
private String email;
private LocalDate dateOfBirth;
private Boolean active;
private Set<Order> orders;
...
}
Storage Garbage Collection
To min the required storage capacity, MicroStream provides a garbage collection process to clean up the storage. Legacy object versions as well as corrupt files are constantly removed from the storage behind the scenes fully automated. The GC also reorganizes and defragments the storage to optimize read performance. The MicroStream GC process is highly configurable.
Access to Your Data:
Easy. Transparent. Any Time. With Standards.
Access by external applications & services
With REST and GraphQL you can provide any external system easily access your in-memory data.
Administration
MicroStream provides you with a web app as well as a REST interface to access your storage data for admin purposes.
Easy migration in both directions
By using CSV Import/Export or other converters, any data can be migrated at any time in both directions easily.
Data Storage Viewer
MicroStream provides you a web interface with a hierarchical view on your data storage. You can use it to browse through you entire storage. As an alternative, MicroStream provides you also a REST interface to get access to your storage.
For Micro Machine Images and Big-RAM Machines
MicroStream runs on any machine. To run cloud-native microservices or serverless functions, you can run MicroStream on micro machines. But, MicroStream also runs on big RAM machines. The more RAM available, the better the performance. Using MicroStream with modern JVMs, you can process up to 16 TB of data in memory trouble-free. Thus, the suited machine size only depends on your use case.
- Loading data on-demand only
- Fast startup time
- Microservices & serverless approach
- You can keep the whole database in RAM
- Max performance
- Lowest possible latency
- Monolithic single node app approach
MicroStream Cluster & Cloud
Build distributed MicroStream apps & microservices that run in the cloud or on-prem hardware.
- Replication
- Horizontally scalable
- High availability
- Cloud-native
- On-Prem
- Managed cloud service
- Eays JAR deployment
- Enterprise support
Supported Storages
MicroStream stores your Java object graph in a binary format and enables you basically to use any data storage. MicroStream comes with various data storage connectors.
Use any JVM Technology
