Heute habe ich versucht, eine geeignete Lösung zum Einrichten eines Maven-Projekts zu finden, das sowohl Java- als auch Scala-Code enthält (mit wechselseitigen Abhängigkeiten).

Die Lösungen, die ich gefunden habe, bestehen normalerweise darin, das Scala-Maven-Plugin oder das Maven-Scala-Plugin im @ aufzurufeprocess-resources phase, damit es vor dem Standard-Maven-Compiler-Plugin ausgeführt wird (Beispiele:http: //www.hascode.com/2012/03/snippet-mixing-scala-java-in-a-maven-project, https: //itellity.wordpress.com/2014/08/21/mixing-scala-and-java-in-a-maven-project, die offizielle Scala-Maven-Plugin-Seite:http: //davidb.github.io/scala-maven-plugin/example_java.htm).

Das führt zu der Lösung, die so aussieht:

<build>
    <plugins>
        <plugin>
            <groupId>net.alchim31.maven</groupId>
            <artifactId>scala-maven-plugin</artifactId>
            <recompileMode>incremental</recompileMode>
            <executions>
                <execution>
                    <id>scala-compile</id>
                    <phase>process-resources</phase>
                    <goals>
                        <goal>add-source</goal>
                        <goal>compile</goal>
                    </goals>
                </execution>
                <execution>
                    <id>scala-test-compile</id>
                    <phase>process-test-resources</phase>
                    <goals>
                        <goal>testCompile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Diese Lösung funktioniert gut - Die Scala-Kompilierung wird im @ aufgerufeprocess-resources phase und kompiliert sowohl Java- als auch Scala-Code, sodass alle .class-Dateien bereit sind, wenn das Maven-Compiler-Plugin im @ ausgeführt wircompile phase.

Das Problem ist, dass diese Lösung für mich nicht sauber aussieht. Aufrufen des Scala-Kompilierungsprozesses vor der Kompilierungsphase, um sicherzustellen, dass er ausgeführt wird, bevor das Maven-Compiler-Plugin "hacky" zu sein scheint.

Scala-Compiler kompiliert sowieso Java-Klassen, also dachte ich, ich könnte das Standard-Maven-Compiler-Plugin einfach komplett ausschalten und dann den Scala-Compiler im @ ausführecompile Phase. Es sieht für mich viel sauberer aus, obwohl die Konfiguration etwas länger ist:

<build>
    <plugins>
        <plugin>
            <groupId>net.alchim31.maven</groupId>
            <artifactId>scala-maven-plugin</artifactId>
            <recompileMode>incremental</recompileMode>
            <executions>
                <execution>
                    <id>scala-compile</id>
                    <phase>compile</phase>
                    <goals>
                        <goal>add-source</goal>
                        <goal>compile</goal>
                    </goals>
                </execution>
                <execution>
                    <id>scala-test-compile</id>
                    <phase>test-compile</phase>
                    <goals>
                        <goal>testCompile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <executions>
                <execution>
                    <id>default-compile</id>
                    <phase>none</phase>
                </execution>
                <execution>
                    <id>default-testCompile</id>
                    <phase>none</phase>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Ich frage mich, warum diese Lösung nicht in Blog-Posts oder auf der offiziellen Plugin-Seite empfohlen wird. Gibt es Nachteile bei diesem Ansatz? Gibt es irgendwelche Probleme, mit denen ich bei der Verwendung der zweiten Lösung anstelle der ersten rechnen sollte?