Hoy he estado tratando de encontrar una solución adecuada para configurar un proyecto maven que contenga tanto código Java como Scala (con dependencias bidireccionales entre ellos).

Las soluciones que he encontrado generalmente consisten en invocar scala-maven-plugin o maven-scala-plugin en elprocess-resources fase para que se ejecute antes del complemento predeterminado del compilador maven (ejemplos: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/, la página oficial scala-maven-plugin:http://davidb.github.io/scala-maven-plugin/example_java.html)

Eso lleva a la solución que se ve así:

<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>

Esta solución funciona bien: la compilación Scala se invoca en elprocess-resources fase y compila tanto el código de Java como el de Scala para que los archivos .class estén listos cuando el complemento del compilador maven se ejecute encompile fase.

El problema es que esta solución no me parece limpia. Invocar el proceso de compilación Scala antes de la fase de compilación solo para asegurarse de que se ejecute antes de que el complemento compilador maven parezca "hacky".

El compilador Scala compila clases Java de todos modos, así que pensé que podría desactivar completamente el complemento predeterminado del compilador maven y luego el compilador Scala podría ejecutarse en elcompile fase. Me parece mucho más limpio, aunque la configuración es un poco más larga:

<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>

Me pregunto por qué esta solución no es la recomendada en las publicaciones de blog o en la página oficial de complementos. ¿Hay alguna desventaja en este enfoque? ¿Hay algún problema que deba esperar al usar las segundas soluciones en lugar de la primera?