知識庫 / Reactive RSS 訂閱

1. 引言

本文將重點介紹如何將 Akka 集成到 Spring Framework 中，以便將 Spring 類型的服務注入到 Akka 演員中。

在閲讀本文之前，建議您對 Akka 的基本知識有所瞭解。

2. Akka 中的依賴注入

Akka 是基於 Actor 併發模型的強大應用程序框架。該框架使用 Scala 編寫，當然也完全可用於 Java 應用程序中。因此，我們經常會希望將 Akka 集成到現有的 Spring 應用程序中，或者僅僅使用 Spring 來將 Bean 注入到 Actor 中

Spring/Akka 集成的問題在於 Spring 中 Bean 的管理與 Akka 中 Actor 的管理之間的差異：Actor 具有與典型的 Spring Bean 生命週期不同的特定生命週期

此外，Actor 被分為 Actor 本身（這是一種內部實現細節，不能由 Spring 管理）和 Actor 引用，後者可通過客户端代碼訪問，並且在不同 Akka 運行時之間是可序列化和可移植的。

幸運的是，Akka 提供了機制，即 Akka 擴展，這使得使用外部依賴注入框架變得相對容易。

3. Maven 依賴項

為了在我們的 Spring 項目中演示 Akka 的使用，我們需要至少一個 Spring 依賴項——spring-context 庫，以及 akka-actor 庫。 庫的版本可以從 pom 的 <properties> 部分提取：

<properties>
    <spring.version>5.3.25</spring.version>
    <akka.version>2.4.14</akka.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>com.typesafe.akka</groupId>
        <artifactId>akka-actor_2.12</artifactId>
        <version>${akka.version}</version>
    </dependency>

</dependencies>

請務必查閲 Maven Central 以獲取 spring-context 和 akka-actor 依賴項的最新版本。

請注意，akka-actor 依賴項的名稱中包含 _2.11 後綴，這表明該 Akka 框架版本是在 Scala 2.11 上構建的。相應的 Scala 庫版本將作為傳遞依賴項包含在您的構建中。

4. 將 Spring Bean 注入到 Akka 演員中

讓我們創建一個簡單的 Spring/Akka 應用程序，其中包含一個可以根據請求回覆人名的單個演員。問候邏輯將被提取到一個單獨的服務中。我們希望自動注入這個服務到演員實例中。 Spring 集成將幫助我們完成這項任務。

4.1. 定義 Actor 和 Service

為了演示將 Service 注入到 Actor 中的方法，我們將創建一個簡單的 Actor 類 GreetingActor，該類作為未類型 Actor (擴展 Akka 的 UntypedActor 基類) 定義。 Akka 中每個 Actor 的主要方法是 onReceive 方法，該方法接收一個消息並根據某些指定邏輯進行處理。

在我們的例子中，GreetingActor 的實現會檢查消息是否為預定義的類型 Greet，然後從 Greet 實例中獲取人的姓名，然後使用 GreetingService 接收該人的問候語，並以接收到的問候語字符串回覆發送者。 如果消息的類型為其他未知的類型，則會將該消息傳遞給 Actor 的預定義的 unhandled 方法。

讓我們看看：

@Component
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class GreetingActor extends UntypedActor {

    private GreetingService greetingService;

    // constructor

    @Override
    public void onReceive(Object message) throws Throwable {
        if (message instanceof Greet) {
            String name = ((Greet) message).getName();
            getSender().tell(greetingService.greet(name), getSelf());
        } else {
            unhandled(message);
        }
    }

    public static class Greet {

        private String name;

        // standard constructors/getters

    }
}

請注意，Greet消息類型被定義為該行為的靜態內部類，這被認為是好的實踐。接受的消息類型應儘可能地定義在行為中，以避免混淆該行為可以處理的消息類型。

請注意Spring註解@Component和@Scope——這些定義了該類為Spring管理Bean，具有prototype作用域。

@Component
public class GreetingService {

    public String greet(String name) {
        return "Hello, " + name;
    }
}

public class SpringExtension 
  extends AbstractExtensionId<SpringExtension.SpringExt> {

    public static final SpringExtension SPRING_EXTENSION_PROVIDER 
      = new SpringExtension();

    @Override
    public SpringExt createExtension(ExtendedActorSystem system) {
        return new SpringExt();
    }

    public static class SpringExt implements Extension {
        private volatile ApplicationContext applicationContext;

        public void initialize(ApplicationContext applicationContext) {
            this.applicationContext = applicationContext;
        }

        public Props props(String actorBeanName) {
            return Props.create(
              SpringActorProducer.class, applicationContext, actorBeanName);
        }
    }
}

public class SpringActorProducer implements IndirectActorProducer {

    private ApplicationContext applicationContext;

    private String beanActorName;

    public SpringActorProducer(ApplicationContext applicationContext, 
      String beanActorName) {
        this.applicationContext = applicationContext;
        this.beanActorName = beanActorName;
    }

    @Override
    public Actor produce() {
        return (Actor) applicationContext.getBean(beanActorName);
    }

    @Override
    public Class<? extends Actor> actorClass() {
        return (Class<? extends Actor>) applicationContext
          .getType(beanActorName);
    }
}

@Configuration
@ComponentScan
public class AppConfiguration {

    @Autowired
    private ApplicationContext applicationContext;

    @Bean
    public ActorSystem actorSystem() {
        ActorSystem system = ActorSystem.create("akka-spring-demo");
        SPRING_EXTENSION_PROVIDER.get(system)
          .initialize(applicationContext);
        return system;
    }
}

ActorRef greeter = system.actorOf(SPRING_EXTENSION_PROVIDER.get(system)
  .props("greetingActor"), "greeter");

FiniteDuration duration = FiniteDuration.create(1, TimeUnit.SECONDS);
Timeout timeout = Timeout.durationToTimeout(duration);

Future<Object> result = ask(greeter, new Greet("John"), timeout);

Assert.assertEquals("Hello, John", Await.result(result, duration));