Installation

Build Configuration
You can find the MicroStream libraries in our Maven repository:
Maven
Gradle (Groovy)
Gradle (Kotlin)
Scala SBT
Apache Ivy
Apache Buildr
Bazel
Maven
pom.xml
<repositories>
    <repository>
        <id>microstream-releases</id>
        <url>https://repo.microstream.one/repository/maven-public</url>
    </repository>
</repositories>
​
<dependencies>
    <dependency>
        <groupId>one.microstream</groupId>
        <artifactId>storage.embedded</artifactId>
        <version>02.02.00-MS-GA</version>
    </dependency>
</dependencies>
​
Gradle (Groovy)
build.gradle
repositories {
    maven {
        url 'https://repo.microstream.one/repository/maven-public'
    }
}
​
dependencies {
    implementation 'one.microstream:storage.embedded:02.02.00-MS-GA'
}
​
Gradle (Kotlin)
build.gradle.kts
repositories {
    maven {
        url = uri("https://repo.microstream.one/repository/maven-public")
    }
}
​
dependencies {
    implementation("one.microstream:storage.embedded:02.02.00-MS-GA")
}
​
Scala SBT
build.sbt
resolvers += "microstream-releases" at "https://repo.microstream.one/repository/maven-public"
​
libraryDependencies += "one.microstream" % "storage.embedded" % "02.02.00-MS-GA"
​
Apache Ivy
ivysettings.xml
<resolvers>
    <ibiblio name="microstream-releases" 
        root="https://repo.microstream.one/repository/maven-public" 
        m2compatible="true" />
</resolvers>
ivy.xml
<dependencies>
    <dependency org="one.microstream" 
        name="storage.embedded" 
        rev="02.02.00-MS-GA" />
</dependencies>
Apache Buildr
Buildfile
repositories.remote << 'https://repo.microstream.one/repository/maven-public'
​
define 'my-app' do
  compile.with 'one.microstream:storage.embedded:02.02.00-MS-GA'
end
​
Bazel
WORKSPACE
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
​
RULES_JVM_EXTERNAL_TAG = "2.8"
RULES_JVM_EXTERNAL_SHA = "79c9850690d7614ecdb72d68394f994fef7534b292c4867ce5e7dec0aa7bdfad"
​
http_archive(
    name = "rules_jvm_external",
    strip_prefix = "rules_jvm_external-%s" % RULES_JVM_EXTERNAL_TAG,
    sha256 = RULES_JVM_EXTERNAL_SHA,
    url = "https://github.com/bazelbuild/rules_jvm_external/archive/%s.zip" % RULES_JVM_EXTERNAL_TAG,
)
​
load("@rules_jvm_external//:defs.bzl", "maven_install")
​
maven_install(
    artifacts = [
        "one.microstream:storage.embedded:02.02.00-MS-GA"
    ],
    repositories = [
        "https://repo.microstream.one/repository/maven-public"
    ],
)
BUILD
maven_jar(
    name = "microstream",
    artifact = "one.microstream:storage.embedded:02.02.00-MS-GA"
)
Modules
These are the different modules that make up MicroStream.
ArtifactId
Description
base
Collection of common utilities. Math, IO, Exceptions, Threads, String operations, and so on.
communication
Top-level framework for sending and receiving object graphs between Java applications. Only data is transferred, no program code ("bytecode"). The other application may be programmed in any language as long as it adheres to the transmitted communication protocol. Usable directly in the program code of a Java application to communicate with other applications or processes. The concrete form of persistence is left open and delivered via a specific implementation as a plugin. Examples of specific persistent forms are binary data, CSV, XML, Json.
communication.binary
Plugin framework for the top-level framework communication to convert the transferred object graphs to and from binary data.
persistence
Base framework to convert a graph of java objects into a persistent form and back. Usable as a common, abstract base for all technologies implementing a specific persistent representation like binary data, CSV, XML or Json.
From a technical point of view, storage as well as serialization is a process that puts a graph of Java instances into a persistent form. The only difference is that network communication serialization discards this persistent form while a database solution preserves it.
persistence.binary
Extension of the persistence base framework with a concrete implementation of the persistent form as binary data. This persistent form is superior to all text-based formats in storage and performance needs, making it the preferred method for storage and network serialization.
persistence.binary.jdk8
Specialized type handlers for JDK 8 collection types.
storage
Basic framework to manage a graph of Java data persisted as binary data as a database. Can be used both to implement an embedded database solution (in the same process as the Java application) and a standalone or server-mode database solution (in a separate process). Other forms of persistence than binary data are deliberately not supported because they would not bring any noteworthy advantages but many disadvantages for the task.
storage.embedded
Top-level framework for use in a Java application that adds an embedded database solution to its object graphs. Can be used directly in the program code of a Java application to comfortably and efficiently persist its data.
storage.embedded.configuration
Layer with support for external configuration files (XML, INI) and convenience functionality to create foundations for the embedded storage.
Dependency Graph

Changelog

Next - Data-Store

Overview

Last updated 1 month ago

ArtifactId	Description
base	Collection of common utilities. Math, IO, Exceptions, Threads, String operations, and so on.
communication	Top-level framework for sending and receiving object graphs between Java applications. Only data is transferred, no program code ("bytecode"). The other application may be programmed in any language as long as it adheres to the transmitted communication protocol. Usable directly in the program code of a Java application to communicate with other applications or processes. The concrete form of persistence is left open and delivered via a specific implementation as a plugin. Examples of specific persistent forms are binary data, CSV, XML, Json.
communication.binary	Plugin framework for the top-level framework communication to convert the transferred object graphs to and from binary data.
persistence	Base framework to convert a graph of java objects into a persistent form and back. Usable as a common, abstract base for all technologies implementing a specific persistent representation like binary data, CSV, XML or Json. From a technical point of view, storage as well as serialization is a process that puts a graph of Java instances into a persistent form. The only difference is that network communication serialization discards this persistent form while a database solution preserves it.
persistence.binary	Extension of the persistence base framework with a concrete implementation of the persistent form as binary data. This persistent form is superior to all text-based formats in storage and performance needs, making it the preferred method for storage and network serialization.
persistence.binary.jdk8	Specialized type handlers for JDK 8 collection types.
storage	Basic framework to manage a graph of Java data persisted as binary data as a database. Can be used both to implement an embedded database solution (in the same process as the Java application) and a standalone or server-mode database solution (in a separate process). Other forms of persistence than binary data are deliberately not supported because they would not bring any noteworthy advantages but many disadvantages for the task.
storage.embedded	Top-level framework for use in a Java application that adds an embedded database solution to its object graphs. Can be used directly in the program code of a Java application to comfortably and efficiently persist its data.
storage.embedded.configuration	Layer with support for external configuration files (XML, INI) and convenience functionality to create foundations for the embedded storage.