Initial version with README

Author: lancearlaus

.gitignore

@@ -15,3 +15,6 @@ project/plugins/project/
 # Scala-IDE specific
 .scala_dependencies
 .worksheet
+
+# IntelliJ IDEA specific
+.idea/

LICENSE

@@ -1,4 +1,4 @@
-                                 Apache License
+Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
 

README.md

@@ -0,0 +1,63 @@
+# Akka Spring Boot Integration Library
+
+Easy-to-use Scala-friendly integration of Akka with Spring Boot.
+Get started quickly with minimal code by using a library that favors convention over configuration.
+
+## Key Requirements
+* Akka configured via Spring configuration (property sources)
+* Supply a default actor system
+* Match actor system lifecycle to Spring context
+* Ease the creation of actor beans and actor references
+
+## Getting Started
+
+### build.sbt
+
+````scala
+libraryDependencies ++= "com.github.scalaspring" %% "akka-spring-boot" % "0.1.0"
+````
+
+### Create a Spring Configuration
+
+Create a configuration class that extends the ActorSystemConfiguration trait and imports the AkkaAutoConfiguration
+
+````scala
+  @Configuration
+  @ComponentScan
+  @Import(Array(classOf[AkkaAutoConfiguration]))
+  class Configuration extends ActorSystemConfiguration {
+
+    // Note: the EchoActor class is part of Akka test kit
+    @Bean
+    def echoActor = actorOf[EchoActor]
+
+  }
+````
+
+### Testing Your Configuration
+
+Create a ScalaTest-based test that uses the configuration
+
+````
+@ContextConfiguration(
+  loader = classOf[SpringApplicationContextLoader],
+  classes = Array(classOf[AkkaAutoConfigurationSpec.Configuration])
+)
+class AkkaAutoConfigurationSpec extends FlatSpec with TestContextManagement with Matchers with AskSupport with ScalaFutures with StrictLogging {
+
+  implicit val timeout: Timeout = (1 seconds)
+
+  @Autowired val echoActor: ActorRef = null
+
+  "Echo actor" should "receive and echo message" in {
+    val message = "test message"
+    val future = echoActor ? message
+
+    whenReady(future) { result =>
+      logger.info(s"""received result "$result"""")
+      result should equal(message)
+    }
+  }
+
+}
+````

build.sbt

@@ -0,0 +1,70 @@
+import sbt.Keys._
+
+// Common dependency versions
+val akkaVersion = "2.3.9"
+val springVersion = "4.1.6.RELEASE"
+val springBootVersion = "1.2.3.RELEASE"
+
+lazy val root = (project in file(".")).
+  settings(net.virtualvoid.sbt.graph.Plugin.graphSettings: _*).
+  settings(
+    organization        := "com.github.scalaspring",
+    name                := "akka-spring-boot-scala",
+    description         := "Integrates Akka and Spring Boot using standard Spring annotations and convention over configuration",
+    scalaVersion        := "2.11.6",
+    crossScalaVersions  := Seq("2.10.5"),
+    javacOptions        := Seq("-source", "1.7", "-target", "1.7"),
+    resolvers           += "Sonatype OSS Snapshots" at "https://oss.sonatype.org/content/repositories/snapshots",
+    libraryDependencies ++= Seq(
+      "com.typesafe.scala-logging" %% "scala-logging" % "3.+",
+      "com.typesafe.akka" %% "akka-actor" % akkaVersion,
+      "org.springframework" % "spring-context" % springVersion,
+      "org.springframework.boot" % "spring-boot-starter" % springBootVersion
+      // The following dependencies support configuration validation
+      //"javax.validation" % "validation-api" % "1.1.0.Final",
+      //"javax.el" % "javax.el-api" % "3.0.1-b04",
+      //"org.hibernate" % "hibernate-validator" % "5.1.3.Final",
+    ),
+    // Runtime dependencies
+    libraryDependencies ++= Seq(
+      "ch.qos.logback" % "logback-classic" % "1.1.2"
+    ).map { _ % "runtime" },
+    // Test dependencies
+    libraryDependencies ++= Seq(
+      "org.scalatest" %% "scalatest" % "2.2.4",
+      "com.github.lancearlaus" %% "scalatest-spring" % "0.1.0",
+      "org.springframework" % "spring-test" % springVersion,
+      "com.typesafe.akka" %% "akka-testkit" % akkaVersion
+    ).map { _ % "test" },
+    // Publishing settings
+    publishMavenStyle       := true,
+    publishArtifact in Test := false,
+    pomIncludeRepository := { _ => false },
+    publishTo := {
+      val nexus = "https://oss.sonatype.org/"
+      if (isSnapshot.value)
+        Some("snapshots" at nexus + "content/repositories/snapshots")
+      else
+        Some("releases"  at nexus + "service/local/staging/deploy/maven2")
+    },
+    pomExtra :=
+      <url>http://github.com/scalaspring/akka-spring-boot-scala</url>
+      <licenses>
+        <license>
+          <name>Apache License, Version 2.0</name>
+          <url>http://www.apache.org/licenses/LICENSE-2.0.html</url>
+          <distribution>repo</distribution>
+        </license>
+      </licenses>
+      <scm>
+        <url>git@github.com:scalaspring/akka-spring-boot-scala.git</url>
+        <connection>scm:git:git@github.com:scalaspring/akka-spring-boot-scala.git</connection>
+      </scm>
+      <developers>
+        <developer>
+          <id>lancearlaus</id>
+          <name>Lance Arlaus</name>
+          <url>http://lancearlaus.github.com</url>
+        </developer>
+      </developers>
+  )

project/plugins.sbt

@@ -0,0 +1,6 @@
+
+addSbtPlugin("net.virtual-void" % "sbt-dependency-graph" % "0.7.5")
+
+addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.0")
+
+addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "0.2.2")

src/main/java/com/github/lancearlaus/akka/spring/ActorBean.java

@@ -0,0 +1,74 @@
+package com.github.lancearlaus.akka.spring;
+
+import org.springframework.beans.factory.annotation.Autowire;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Scope;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotate actor beans (not actor references!) within a Spring configuration.
+ *
+ * This annotation SHOULD only be required for Actor-based classes used from third-party
+ * libraries, etc. Please use the {@code ActorComponent} annotation to annotate your
+ * classes instead if you're creating your own actors for use with Spring.
+ *
+ * @see com.github.lancearlaus.akka.spring.ActorComponent
+ */
+@Bean
+@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+@Target({ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ActorBean {
+    /**
+     * The name of this bean, or if plural, aliases for this bean. If left unspecified
+     * the name of the bean is the name of the annotated method. If specified, the method
+     * name is ignored.
+     */
+    String[] name() default {};
+
+    /**
+     * Are dependencies to be injected via convention-based autowiring by name or type?
+     */
+    Autowire autowire() default Autowire.NO;
+
+    /**
+     * The optional name of a method to call on the bean instance during initialization.
+     * Not commonly used, given that the method may be called programmatically directly
+     * within the body of a Bean-annotated method.
+     * <p>The default value is {@code ""}, indicating no init method to be called.
+     */
+    String initMethod() default "";
+
+    /**
+     * The optional name of a method to call on the bean instance upon closing the
+     * application context, for example a {@code close()} method on a JDBC
+     * {@code DataSource} implementation, or a Hibernate {@code SessionFactory} object.
+     * The method must have no arguments but may throw any exception.
+     * <p>As a convenience to the user, the container will attempt to infer a destroy
+     * method against an object returned from the {@code @Bean} method. For example, given
+     * an {@code @Bean} method returning an Apache Commons DBCP {@code BasicDataSource},
+     * the container will notice the {@code close()} method available on that object and
+     * automatically register it as the {@code destroyMethod}. This 'destroy method
+     * inference' is currently limited to detecting only public, no-arg methods named
+     * 'close' or 'shutdown'. The method may be declared at any level of the inheritance
+     * hierarchy and will be detected regardless of the return type of the {@code @Bean}
+     * method (i.e., detection occurs reflectively against the bean instance itself at
+     * creation time).
+     * <p>To disable destroy method inference for a particular {@code @Bean}, specify an
+     * empty string as the value, e.g. {@code @Bean(destroyMethod="")}. Note that the
+     * {@link org.springframework.beans.factory.DisposableBean} and the
+     * {@link java.io.Closeable}/{@link java.lang.AutoCloseable} interfaces will
+     * nevertheless get detected and the corresponding destroy/close method invoked.
+     * <p>Note: Only invoked on beans whose lifecycle is under the full control of the
+     * factory, which is always the case for singletons but not guaranteed for any
+     * other scope.
+     * @see org.springframework.context.ConfigurableApplicationContext#close()
+     */
+    String destroyMethod() default AbstractBeanDefinition.INFER_METHOD;
+}

src/main/java/com/github/lancearlaus/akka/spring/ActorComponent.java

@@ -0,0 +1,23 @@
+package com.github.lancearlaus.akka.spring;
+
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.context.annotation.Scope;
+import org.springframework.stereotype.Component;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotate actor-specific beans classes.
+ *
+ * This is a Spring meta-annotation, the purpose of which is to make code more readable and to avoid
+ * the common mistake of instantiating actors as singletons (the default for Spring beans).
+ */
+@Component
+@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ActorComponent {
+}

src/main/java/com/github/lancearlaus/akka/spring/config/AkkaConfigAutoConfiguration.java

@@ -0,0 +1,58 @@
+package com.github.lancearlaus.akka.spring.config;
+
+import com.typesafe.config.Config;
+import com.typesafe.config.ConfigFactory;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
+import org.springframework.core.env.ConfigurableEnvironment;
+
+import java.util.Map;
+
+import static com.github.lancearlaus.akka.spring.config.AkkaConfigPropertySourceAdapter.convertIndexedProperties;
+import static com.github.lancearlaus.akka.spring.config.AkkaConfigPropertySourceAdapter.getPropertyMap;
+
+/**
+ * Links Spring environment (property sources) and Akka configuration (Config).
+ * This allows Akka configuration to be specified via standard Spring-based property source(s) and also allows
+ * Spring to access Akka-based defaults.
+ *
+ * This configuration provides the following:
+ *
+ * 1. An Akka configuration bean populated with Akka defaults, overridden by Spring defined properties. This allows
+ *    Akka configuration to be specified via any Spring supported property source (files, URLs, YAML, etc.) while
+ *    still leveraging Akka defaults when not specified.
+ * 2. An optional property sources placeholder configurer. Created if not defined elsewhere, this bean processes @Value
+ *    annotations that reference properties.
+ *
+ * Note: This class is intentionally written in Java to enable use in Java-only projects and due to the fact that
+ * a static factory method is required for the {@code PropertySourcesPlaceholderConfigurer} bean. Do not instantiate
+ * this bean in a non-static method, especially in configurations that have autowired properties. You've been warned.
+ */
+@Configuration
+public class AkkaConfigAutoConfiguration {
+
+    /**
+     * Creates an Akka configuration populated via Spring properties with fallback to Akka defined properties.
+     */
+    @Bean
+    public Config akkaConfig(ConfigurableApplicationContext applicationContext, ConfigurableEnvironment environment) {
+        final Map<String, Object> converted = convertIndexedProperties(getPropertyMap(environment));
+        final Config defaultConfig = ConfigFactory.defaultReference(applicationContext.getClassLoader());
+
+        return ConfigFactory.parseMap(converted).withFallback(defaultConfig);
+    }
+
+    /**
+     * Create placeholder configurer to support {@code @Value} annotations that reference environment properties.
+     *
+     * Only one placeholder configurer is required, hence the conditional
+     */
+    @Bean @ConditionalOnMissingBean(PropertySourcesPlaceholderConfigurer.class)
+    public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
+        return new PropertySourcesPlaceholderConfigurer();
+    }
+
+}

src/main/java/com/github/lancearlaus/akka/spring/config/AkkaConfigPropertySource.java

@@ -0,0 +1,45 @@
+package com.github.lancearlaus.akka.spring.config;
+
+import com.typesafe.config.Config;
+import com.typesafe.config.ConfigValue;
+import org.springframework.core.env.EnumerablePropertySource;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Adapts Akka configuration properties to Spring by exposing them as a standard Spring EnumerablePropertySource.
+ */
+public class AkkaConfigPropertySource extends EnumerablePropertySource<Config> {
+
+    public static final String PROPERTY_SOURCE_NAME = "akkaConfig";
+
+    public AkkaConfigPropertySource(Config config) {
+        super(PROPERTY_SOURCE_NAME, config);
+    }
+
+    @Override
+    public String[] getPropertyNames() {
+        final Set<Map.Entry<String, ConfigValue>> entries = source.entrySet();
+        final List<String> names = new ArrayList<>(entries.size());
+
+        for (Map.Entry<String, ConfigValue> entry : entries) {
+            names.add(entry.getKey());
+        }
+
+        return names.toArray(new String[names.size()]);
+    }
+
+    @Override
+    public Object getProperty(String name) {
+        try {
+            return source.hasPath(name) ? source.getAnyRef(name) : null;
+        } catch (Throwable t) {
+            // Catch bad path exceptions and return null
+            return null;
+        }
+    }
+
+}