Java Based Akka application Part 1: Your base Project

Akka is a free, open-source toolkit and runtime for building highly concurrent, distributed, and resilient message-driven applications on the JVM. Along with Akka you have akka-streams  a module that makes the ingestion and processing of streams easy  and Alpakka, a Reactive Enterprise Integration library for Java and Scala, based on Reactive Streams and Akka.

On this blog I shall focus on creating an Akka project using Java as well as packaging it.

You already know that Akka is built on Scala, thus why Java and no Scala? There are various reasons to go for Java.

◉ Akka is a toolkit running on the JVM so you don’t have to be proficient with Scala to use it.

◉ You might have a team already proficient with Java but not in Scala.

◉ It’s much easier to evaluate if you already have a codebase on Java and the various build tools (maven etc)

Will shall go for the simple route and Download the Application from lightbend quickstart. The project received, will be backed with typed actors.

After some adaption the maven file would look like this, take note that we shall use lombok.

<project>

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.gkatzioura</groupId>

    <artifactId>akka-java-app</artifactId>

    <version>1.0</version>

    <properties>

      <akka.version>2.6.10</akka.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>com.typesafe.akka</groupId>

            <artifactId>akka-actor-typed_2.13</artifactId>

            <version>${akka.version}</version>

        </dependency>

        <dependency>

            <groupId>ch.qos.logback</groupId>

            <artifactId>logback-classic</artifactId>

            <version>1.2.3</version>

        </dependency>

        <dependency>

            <groupId>org.projectlombok</groupId>

            <artifactId>lombok</artifactId>

            <version>1.18.16</version>

            <scope>provided</scope>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-compiler-plugin</artifactId>

                <version>3.8.0</version>

                <configuration>

                    <source>11</source>

                    <target>11</target>

                </configuration>

            </plugin>

            <plugin>

                <groupId>org.codehaus.mojo</groupId>

                <artifactId>exec-maven-plugin</artifactId>

                <version>1.6.0</version>

                <configuration>

                    <executable>java</executable>

                    <arguments>

                        <argument>-classpath</argument>

                        <classpath />

                        <argument>com.gkatzioura.Application</argument>

                    </arguments>

                </configuration>

            </plugin>

        </plugins>

    </build>

</project>

Now there is one Actor that is responsible for managing your other actors. This is the top level actor called Guardian Actor. It is created along with the ActorSystem and when it stops the ActorSystem will stop too.

In order to create an actor you define the message the actor will receive and you specify why it will behave to those messages.

package com.gkatzioura;

import akka.actor.typed.Behavior;

import akka.actor.typed.javadsl.AbstractBehavior;

import akka.actor.typed.javadsl.ActorContext;

import akka.actor.typed.javadsl.Behaviors;

import akka.actor.typed.javadsl.Receive;

import lombok.AllArgsConstructor;

import lombok.Getter;

public class AppGuardian extends AbstractBehavior<AppGuardian.GuardianMessage> {

    public interface GuardianMessage {}

    static Behavior<GuardianMessage> create() {

        return Behaviors.setup(AppGuardian::new);

    }

    @Getter

    @AllArgsConstructor

    public static class MessageToGuardian implements GuardianMessage {

        private String message;

    }

    private AppGuardian(ActorContext<GuardianMessage> context) {

        super(context);

    }

    @Override

    public Receive<GuardianMessage> createReceive() {

        return newReceiveBuilder().onMessage(MessageToGuardian.class, this::receiveMessage).build();

    }

    private Behavior<GuardianMessage> receiveMessage(MessageToGuardian messageToGuardian) {

        getContext().getLog().info("Message received: {}",messageToGuardian.getMessage());

        return this;

    }

}

Akka is message driven so the guardian actor should be able to consume messages send to it. Therefore messages that implement the GuardianMessage interface are going to be processed.

By creating the actor the createReceive method is used in order to add handling of the messages that the actor should handle.

Be aware that when it comes to logging instead of spinning up a logger in the class use the

getContext().getLog()

Behind the scenes the log messages will have the path of the actor automatically added as akkaSource Mapped Diagnostic Context (MDC) value.

Last step would be to add the Main class.

package com.gkatzioura;

import java.io.IOException;

import akka.actor.typed.ActorSystem;

import lombok.extern.slf4j.Slf4j;

@Slf4j

public class Application {

    public static final String APP_NAME = "akka-java-app";

    public static void main(String[] args) {

        final ActorSystem<AppGuardian.GuardianMessage> appGuardian = ActorSystem.create(AppGuardian.create(), APP_NAME);

        appGuardian.tell(new AppGuardian.MessageToGuardian("First Akka Java App"));

        try {

            System.out.println(">>> Press ENTER to exit <<<");

            System.in.read();

        }

        catch (IOException ignored) {

        }

        finally {

            appGuardian.terminate();

        }

    }

}

The expected outcome is to have our Guardian actor to print the message submitted. By pressing enter the Akka application will terminate through the guardian actor.