MicroStream Reference Manual
MicroStream HomeAPI Docs
3.0
3.0
  • Preface
  • System Requirements
  • License
  • Changelog
  • Installation
  • Data-Store
    • Overview
    • Getting Started
    • Root Instances
    • Configuration
      • Properties
      • Storage Files and Directories
      • Using Channels
      • Housekeeping
      • Backup
      • Lock File
    • Storing Data
      • Convenience Methods and Explicit Storing (Transactions)
      • Lazy and Eager Storing
      • Transient Fields
      • Best Practice
    • Loading Data
      • Lazy Loading
        • Touched Timestamp, Null-Safe Variant
        • Clearing Lazy References
    • Deleting Data
    • Queries
    • Application Life-Cycle
    • Legacy Type Mapping
      • User Interaction
    • Backup Strategies
    • Import / Export
    • Housekeeping
    • Customizing
      • Custom Type Handler
      • Custom Legacy Type Handler
      • Custom Class Loader
      • Custom Storing Behavior
      • Optional Storage Manager Reference in Entities
    • REST Interface
      • Setup
      • REST API
      • Client GUI
    • FAQ
      • Data Model
      • Data Management
      • File Storage
      • Java Features
      • Miscellaneous
    • Addendum
      • Supported Java Features
      • Specialized Type Handlers
      • Examples and Demo Projects
  • Cache
    • Overview
    • Getting Started
    • Configuration
      • Properties
      • Storage
    • Use Cases
      • Hibernate Second Level Cache
      • Spring Cache
  • Basic Concepts
    • Layered Entities
      • Configuration
      • Defining Entities
      • Creating Entities
      • Updating Entities
      • Versioning
      • Logging
      • Multiple Layers
    • Wrapping
      • Configuration
      • Usage
Powered by GitBook
On this page
  • Build Configuration
  • Modules
  • Dependency Graph
Export as PDF

Installation

PreviousChangelogNextOverview

Last updated 3 years ago

This is the manual for older MicroStream versions (Version < 5.0).

The new documentation (Version >= 5.0) is located at:

Build Configuration

You can find the MicroStream libraries in our :

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>03.00.00-MS-GA</version>
    </dependency>
</dependencies>

build.gradle
repositories {
    maven {
        url 'https://repo.microstream.one/repository/maven-public'
    }
}

dependencies {
    implementation 'one.microstream:storage.embedded:03.00.00-MS-GA'
}

build.gradle.kts
repositories {
    maven {
        url = uri("https://repo.microstream.one/repository/maven-public")
    }
}

dependencies {
    implementation("one.microstream:storage.embedded:03.00.00-MS-GA")
}

build.sbt
resolvers += "microstream-releases" at "https://repo.microstream.one/repository/maven-public"

libraryDependencies += "one.microstream" % "storage.embedded" % "03.00.00-MS-GA"

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="03.00.00-MS-GA" />
</dependencies>
Buildfile
repositories.remote << 'https://repo.microstream.one/repository/maven-public'

define 'my-app' do
  compile.with 'one.microstream:storage.embedded:03.00.00-MS-GA'
end

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:03.00.00-MS-GA"
    ],
    repositories = [
        "https://repo.microstream.one/repository/maven-public"
    ],
)
BUILD
maven_jar(
    name = "microstream",
    artifact = "one.microstream:storage.embedded:03.00.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.

cache

cache.hibernate

Hibernate region factory for jcache implementation

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

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.

storage.restadapter

storage.restclient

storage.restclient.app

storage.restclient.jersey

REST client implementation which utilizes Jersey as a webservice framework.

storage.restservice

Abstract REST service interface, which uses the REST adapter to access low level storage data.

storage.restservice.sparkjava

REST service implementation which utilizes SparkJava and provides REST endpoints.

Dependency Graph

JSR-107

for JDK 8 collection types.

Adapter for low-level storage data externalization. Used by the to adapt to a MicroStream Storage.

Abstract REST client interface, which serves as a Java wrapper for the .

Executable with web user interface, which connects to a REST service.

https://docs.microstream.one/
Maven repository
JCache Provider
REST service
REST API
client app
Specialized type handlers