Build a mixed Scala 2.8/Java application from scratch with Maven

In this tutorial I will show you how to build an application by Maven that consists of Java and Scala source files. The project automatically uses the latest Scala 2.8-Snapshot until it’s released (Maven will look for the latest version of the Scala language each time you build it).
We will setup the project to use cross-compiling, so the java-classes can access Scala-classes and vice versa.

The good thing about maven projects is that you don’t need an IDE to start a project, thus remaining independent from certain IDE-features. In my next article, i will show how to configure eclipse to open the maven project. But for now i’ll show how to create the project from command line only.

If you’re impatient and just want to see the resulting pom.xml, you can also download the complete source:
Complete maven project

I’m using the following libraries/tools:

• Java 1.6.0.18 (32 Bit)
• Maven 2.2.1

You don’t need the scala-compiler/library, as maven will automatically download the needed files. I’m assuming that you already set up all necessary environment variables (M2_HOME, JAVA_HOME, M2_REPO) and path-variables (if not, google around – it’s easy).
To startup the project, we are creating a simple scala-archetyped-maven application, which creates a minimal pom.xml to start with. Before switching to eclipse, we will setup the project on the command line. On the CL, type

mvn archetype:generate

From the archetype list, Choose 30: internal -> scala-archetype-simple (A simple scala project). Choose your groupId for the app and an artifactId, the remaining questions can be answered by just clicking enter, using the default values. My settings:

Define value for groupId: : de.mackaz
Define value for artifactId: : tutorial1
Define value for version:  1.0-SNAPSHOT: :
Define value for package:  de.mackaz: :
Confirm properties configuration:
groupId: de.mackaz
artifactId: tutorial1
version: 1.0-SNAPSHOT
package: de.mackaz
Y: :

Now maven creates a subfolder named like the artifactId (in my case scalajavatut).
Switch to that folder and compile the project by typing

mvn compile

Maven will download all necessary libraries, and you should see a “BUILD SUCCESSFUL” in the end.

Now we’ll change the scala language version, as the archetype is built on 2.7.7. Open the pom.xml with your favourite text editor, change the line

<scala.version>2.7.0</scala.version>

to

<scala.version>2.8.0-SNAPSHOT</scala.version>

We also need to add the Scala snapshot-repository, where Scala 2.8 is located. Add this to your pom.xml:

<repositories>
   (...)
   <!-- Scala 2.8 Latest -->
   <repository>
      <id>scala-tools.org.snapshots</id>
      <name>Scala Tools Maven2 Repository</name>
      <url>http://scala-tools.org/repo-snapshots</url>
      <snapshots />
   </repository>
</repositories>

Now we will change the maven-scala-plugin to enable java/scala crosscompiling. In your pom.xml, find the maven-scala-plugin, located in build/plugins/plugin. Replace the current settings with the following snippet.

<plugin>
  <groupId>org.scala-tools</groupId>
  <artifactId>maven-scala-plugin</artifactId>
  <version>2.13.1</version>
  <executions>
    <execution>
      <id>compile</id>
      <goals><goal>compile</goal></goals>
      <phase>compile</phase>
    </execution>
    <execution>
      <id>test-compile</id>
      <goals><goal>testCompile</goal></goals>
      <phase>test-compile</phase>
    </execution>
    <execution>
      <phase>process-resources</phase>
      <goals><goal>compile</goal></goals>
    </execution>
  </executions>
  <configuration>
    <scalaVersion>${scala.version}</scalaVersion>
    <args>
      <arg>-target:jvm-1.5</arg>
      <!-- to support mix java/scala only -->
      <arg>-make:transitivenocp</arg>
      <arg>-dependencyfile</arg>
      <arg>${project.build.directory}/.scala_dependencies</arg>
    </args>
  </configuration>
</plugin>

Now we can remove the following lines just below <build>, as the compiler already knows where to find the source files (especially because we can’t define multiple source directories in this way, but we need that when we later add a java-src-folder):

<sourceDirectory>src/main/scala</sourceDirectory>
<testSourceDirectory>src/test/scala</testSourceDirectory>

The simple scala maven archetype also created a behavior driven test using the Scala Specs library. Because we’re using Scala 2.8, we need the specs library version that’s build against Scala 2.8, so we need to change the version of the Scala Specs Dependency, currently 1.2.5, to the corresponding version. During the time of writing, the current version is 1.6.1-2.8.0.Beta1-RC1. It should look like this:

<!-- Specs (Behavior Driven Testing through JUnit) -->
<dependency>
 <groupId>org.scala-tools.testing</groupId>
 <artifactId>specs</artifactId>
 <version>1.6.1-2.8.0.Beta1-RC1</version>
 <scope>test</scope>
</dependency>

Now try to re-compile the project by running

mvn clean compile

which should result in “BUILD SUCCESSFUL” again. You can also run the junit/specs-tests now with the command

mvn test

resulting in 2 – hopefully – successful tests.

To test the scala-java “communication”, it would be nice to start the scala-app from the command line by a maven task. Therefore you need to tell maven which class is the main-class. In my case, maven generated an App.scala in the package de.mackaz, so my main class is de.mackaz.App.
Add the following launcher to the configuration-section of the maven-scala-plugin (build/plugins/plugin/maven-scala-plugin), just before the args-settings

(...)
<configuration>
   <scalaVersion>${scala.version}</scalaVersion>
   <launchers>
      <launcher>
         <id>myLauncher</id>
         <mainClass>de.mackaz.App</mainClass>
      </launcher>
   </launchers>
   (...)
</configuration>

Now you can run your app with the command

mvn scala:run

which should result in a “Hello world” on your console (unless you changed the generated App.scala).

Now that the project successfully compiles and the tests run through, we can add a java class to test cross-compiling.
In the folder ${artifactId}/src/main, where the scala sources recide, we add a directory namend java, which contains all our java sources. There we add a java class, my class is called HelloScala.java. Now my project directory looks like this:

+-scalajavatut/
  +-pom.xml
  +-src/
  | +-main/
  | | +-java/
  | | | +-de/
  | | |   +-mackaz/
  | | |     +-HelloScala.java
  | | +-scala/
  | |   +-de/
  | |     +-mackaz/
  | |       +-App.scala
  | +-test/
  |   +-scala/
  |     +-de/
  |       +-mackaz/
  |         +-AppTest.scala
  |         +-MySpec.scala

To show how nice scala and java communicate, i altered the maven-generated App.scala, which now looks like this:
Artikel

package de.mackaz

object App {
  // call java class
  def main(args: Array[String]) = HelloScala.helloScala

  def helloJava():String = "Hello from Scala!"
}

My java file (HelloScala.java) looks like this:

package de.mackaz;

public class HelloScala {
  public static void helloScala() {
    System.out.println("Hello from Java");
    // call scala class
    System.out.println("Scala says: " + App.helloJava());
  }
}

Now your can run the project by typing

mvn scala:run

and at the end of the output you should see

[INFO] launcher 'myLauncher' selected => de.mackaz.App
Hello from Java
Scala says: Hello from Scala!
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 7 seconds
[INFO] Finished at: Wed Mar 24 18:14:22 CET 2010
[INFO] Final Memory: 14M/33M
[INFO] ------------------------------------------------------------------------

And that’s it! With this maven project, you are ready to build a large java/scala application, where you are free to mix scala and java.
In the next article, i will show you how to setup eclipse to open this project.

[EDIT]
If you liked (or disliked!) the tutorial, feel free to leave a comment. Questions are also welcome. Thank you!