/** HelloActor 처리할 수 있는 명령들 */
sealed class HelloActorCommand
data class Hello(val message: String, val replyTo: ActorRef<Any>) : HelloActorCommand()

/** HelloActor 반환할 수 있는 응답들 */
sealed class HelloActorResponse
data class HelloResponse(val message: String) : HelloActorResponse()

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

/** HelloActor 클래스 */
class HelloActor private constructor(
    private val context: ActorContext<HelloActorCommand>,
) : AbstractBehavior<HelloActorCommand>(context) {

    companion object {
        fun create(): Behavior<HelloActorCommand> {
            return Behaviors.setup { context -> HelloActor(context) }
        }
    }

    override fun createReceive(): Receive<HelloActorCommand> {
        return newReceiveBuilder()
            .onMessage(Hello::class.java, this::onHello)
            .build()
    }

    private fun onHello(command: Hello): Behavior<HelloActorCommand> {

        if (command.message == "Hello") {
            command.replyTo.tell(HelloResponse("Kotlin"))
        }
        return this
    }
}

import akka.actor.testkit.typed.javadsl.ActorTestKit
import org.junit.jupiter.api.AfterAll
import org.junit.jupiter.api.BeforeAll
import org.junit.jupiter.api.Test

class HelloActorTest {

    companion object {
        private lateinit var testKit: ActorTestKit

        @BeforeAll
        @JvmStatic
        fun setup() {
            testKit = ActorTestKit.create()
        }

        @AfterAll
        @JvmStatic
        fun teardown() {
            testKit.shutdownTestKit()
        }
    }

    @Test
    fun testHelloActorRespondsWithKotlin() {
        val probe = testKit.createTestProbe<Any>()

        val helloActor = testKit.spawn(HelloActor.create())

        helloActor.tell(Hello("Hello", probe.ref()))

        probe.expectMessage(HelloResponse("Kotlin"))
    }
}

TypedActor의 경우 UntypedActor와 비교 코드 리팩토리를 할수 있는 장점도 있습니다.

TypeCheck를 하지 않는 액터(Untyped)경우 실행타임에 처리할수 없는 메시지를 알수 있지만

TypedActor의 경우 코드수정 단계에서 알수 있으며 OOP의 특성을 적극 활용할수 있습니다.

Hello를 응답할때마다 카운트를 증가시키고~ 몇번 응답을 했는지 알려주는 Command도 생성

/** 이벤트 정의 */

data class GetHelloCount(val replyTo: ActorRef<Any>) : HelloActorCommand()
data class HelloCountResponse(val count: Int) : HelloActorResponse()

/** HelloActor 클래스 */
class HelloActor private constructor(
    private val context: ActorContext<HelloActorCommand>,
) : AbstractBehavior<HelloActorCommand>(context) {

    override fun createReceive(): Receive<HelloActorCommand> {
        return newReceiveBuilder()
            .onMessage(Hello::class.java, this::onHello)
            .onMessage(GetHelloCount::class.java, this::onGetHelloCount)
            .build()
    }      private var helloCount: Int = 0

    private fun onHello(command: Hello): Behavior<HelloActorCommand> {
        if (command.message == "Hello") {
            helloCount++
            command.replyTo.tell(HelloResponse("Kotlin"))
        }
        return this
    }

    private fun onGetHelloCount(command: GetHelloCount): Behavior<HelloActorCommand> {
        command.replyTo.tell(HelloCountResponse(helloCount))
        return this
    }

/** 추가되는 유닛테스트 코드 */

        helloActor.tell(GetHelloCount(probe.ref()))

        probe.expectMessage(HelloCountResponse(1))