dotenv for Java, Kotlin and the JVM

[Just show me dotenv]

When working within the context of a modern microservice architecture, one often encounters services written in a variety of languages using a variety of frameworks. There are numerous benefits to microservice architectures, however configuring each service can be quite complex. Each framework may offer their own configuration method e.g. property files, yaml, json, etc. As the number of microservices pile up, this quickly becomes a dev ops nightmare.

To avoid this problem, we need a single method for configuration. Fortunately, there is one, dotenv, and most languages already offer a port. dotenv is a library originating from the Ruby community. It offers a simple, consistent, twelve-factor compliant method to configure an application using environment variables.

The dotenv Ruby project describes it as such:

Storing configuration in the environment is one of the tenets of a twelve-factor app. Anything that is likely to change between deployment environments–such as resource handles for databases or credentials for external services–should be extracted from the code into environment variables.
But it is not always practical to set environment variables on development machines or continuous integration servers where multiple projects are run. dotenv loads variables from a .env file into ENV when the environment is bootstrapped.
Ultimately, by choosing dotenv, we can ensure the configuration of all of our microservices is handled in exactly the same way! This includes those running in our development, test, staging, and production environments. Just provide a new `.env` file (or simply rely on the host’s existing environment variables).

As noted, most languages now offer such a port, here are some:

Node.js https://github.com/motdotla/dotenv
Go https://github.com/joho/godotenv
Python https://github.com/theskumar/python-dotenv
Ruby (the trailblazer) https://github.com/bkeepers/dotenv
Java https://github.com/cdimascio/java-dotenv

This post focuses on Java and JVM languages, so let’s see java-dotenv in action. (Note: java-dotenv also offers a Kotlin DSL).

Here goes:

Create a .env file in the root of your project

# formatted as key=value
MY_ENV_VAR1=some_value
MY_EVV_VAR2=some_value</code>

Using Java, initialize dotenv with its defaults and fetch an env var

import io.github.cdimascio.dotenv.Dotenv
Dotenv dotenv = Dotenv.load();
dotenv.get(“MY_ENV_VAR1”)</code>

Or using Kotlin, initialize dotenv with its defaults and fetch an env var

import io.github.cdimascio.dotenv.dotenv
val dotenv = dotenv()
dotenv[“MY_ENV_VAR1”]

To customize the dotenv configuration with Java, specify some options

Dotenv dotenv =Kotlinenv.configure()
.directory("./some/path")
.ignoreIfMalformed() //
.ignoreIfMissing()
.load();

Or with Kotlin, use the DSL to configure dotenv’s options

val dotenv = dotenv {
directory = "./some/path"
ignoreIfMalformed = true
ignoreIfMissing = true
}

For more usage details, visit https://github.com/cdimascio/java-dotenv

Installation

Maven

<dependency>
    <groupId>io.github.cdimascio</groupId>
    <artifactId>java-dotenv</artifactId>
    <version>3.0.0</version>
</dependency>

Gradle

compile 'io.github.cdimascio:java-dotenv:3.0.0'

Visit https://github.com/cdimascio/java-dotenv, if you like it, Star it!

Happy coding!

You may also like...

Leave a Reply