Java-Native Persistence

Ultra high-speed

• No more loss of performance through mapping
• Pure Java in-memory computing paradigm
• Your object-graph is a in-memory database
• Query executing time down to nanoseconds
• JIT-compiler boost even for your database operations
• No network bottleneck

Simplifies your entire
database development process

• Feels like a native data store function for Java
• 1 data structure - your Java object-graph
• 1 data model - your Java classes
• No more impedance mismatch, no more mapping
• No more JPA, no more caching-framework
• Simple architecture
• 100% pure Java

Saving time,
resources & money

• 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

No more mapping

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.

Pure Java in-memory computing

Your entire database is located in the memory within your business-logic-layer. No more database-server, no more storage-layer needed.

In-memory database

Your Java object-graph is your database, which is located in the RAM and fully managed by the Java-VM.

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.

JIT-compiler boost

Frequently executed queries are fully automated optimized by the Java VM's JIT- compiler and can be accelerated up to nanoseconds.

No network bottleneck

Because your database is located in the RAM, there is no more bottleneck or latencies that brakes your database accesses.

Only 1 data model

With MicroStream, your Java classes are your only one data model, nothing else. This simplifies the entire database development process significantly.

Use your classes as they are

MicroStream allows you to store any Java object without the need to adapt your Java classes. No superclasses, no interfaces, no annotations, no dependencies.

No more complex JPA

With MicroStream there is no more need to use complex ORM-frameworks like Hibernate and additional data-caching frameworks.

Design your data model freely

With MicroStream you can freely design Java your data model without the need to adapt your classes to an alien database data structure.

Easy to use

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.

No special requirements

The only requirement is Java 8. MicroStream has absolutely no dependencies on any third-party APIs.

• Special superclasses
• Special interfaces
• Annotations
• Mappings
• Other internal configurations

    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 no longer accessible are automatically
  deleted by the garbage collector of the Java-VM

• 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

• 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 by 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

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

• Any file-system
• Only changes are stored (single entities)
• Append-only strategy
• Transaction-safe
• Super fast
• Multithreaded store process for maximum speed
• Splitting the storage into many files for even more speed is possible
• Using different distributed file systems is possible

Getting Started