Conociendo Akka

¿Qué es Akka?

Es una plataforma (o framework) inspirado por Erlang que busca el desarrollo simple de aplicaciones escalables y multihilo.

Permite crear servicios transaccionales, duraderos y en tiempo real que distribuyen lógica y datos de forma conjunta.

Se puede usar con Java o Scala distintivamente.

Donde la concurrencia no se basa en la memoria compartida entre varios hilos y los métodos de sincronización (como en Java) sino que está basado en el sistema Actor-Modelo para ello.

Donde un actor es un objeto con el que puedes interactuar enviándole mensajes: cada actor puede procesar mensajes y enviarle mensajes a otros actores. Además de que los actores pueden tener un estado interno pero la comunicación sólo ocurre pasando mensajes y nunca a través de estructuras compartidas.

Donde una máquina virtual JVM pueden correr millones de actores a la vez construyendo una jerarquía padre (supervisor)-hijo con los padres monitorizando el comportamietno de los hijos. Permitiendo una forma sencilla splitear nuestros actores entre varios nodos de un cluster.

Un sencillo ejemplo con Akka

Iniciaremos creando unproyecto con Maven:

$ mvn archetype:generate -DgroupId=com.codemonkey -DartifactId=akka-hello-world -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Nos ubicamos en el directorio creado:

$ cd akka-hello-world

Editamos el archivo pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.codemonkey</groupId>
    <artifactId>akka-hello-world</artifactId>
    <version>1.0</version>
    <dependencies>
        <dependency>
            <groupId>com.typesafe.akka</groupId>
            <artifactId>akka-actor-typed_2.13</artifactId>
            <version>2.9.5</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.12.1</version>
                <configuration>
                    <source>21</source>
                    <target>21</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Construimos el proyecto:

$ mvn clean install -X

Observemos la clase principal.

HelloWorld.java

package com.codemoneky;

import akka.actor.typed.ActorSystem;
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;

public class HelloWorld extends AbstractBehavior<String> {

    public static Behavior<String> create() {
        return Behaviors.setup(HelloWorld::new);
    }

    private HelloWorld(ActorContext<String> context) {
        super(context);
    }

    @Override
    public Receive<String> createReceive() {
        return newReceiveBuilder()
                .onMessage(String.class, this::onMessage)
                .build();
    }

    private Behavior<String> onMessage(String message) {
        System.out.println("Mensaje recibido: " + message);
        return this;
    }

    public static void main(String[] args) {
        ActorSystem<String> system = ActorSystem.create(HelloWorld.create(), "HelloWorldSystem");
        system.tell("Hola Mundo");
        // Termina el sistema después de enviar el mensaje
        system.terminate();
    }
}

Esta clase mostrará un mensaje "Hola Mundo".

Compilamos el proyecto:

$ mvn compile

Ejecutamos:

$ mvn exec:java -Dexec.mainClass="com.codemonkey.HelloWorld"

¡Hemos creado nuestra primera aplicación con Akka!

En pocas palabras, Akka sirve para construir aplicaciones concurrentes, distribuidas y escalables en Java o Scala. Basado en el modelo de actores, facilita la gestión de procesos paralelos, comunicación asíncrona y sistemas tolerantes a fallos. Es ideal para aplicaciones en tiempo real, como chats, streaming, o microservicios, ya que simplifica la concurrencia y permite manejar grandes volúmenes de datos o usuarios de forma eficiente.

Enlaces:

https://akka.io/
https://emanuelpeg.blogspot.com/2022/09/por-que-usar-akka.html
https://www.bairesdev.com/blog/introduction-to-akka-an-open-source-library/
https://scalac.io/technologies/akka/
https://unpocodejava.com/2013/02/19/que-es-akka/