java - que - maven tutorial español pdf

Creando una aplicación scala con maven(que tiene una fuente Java mezclada)

Question

Tengo una aplicación en la que me gustaría tener una fuente mixta de Java y Scala (en realidad está migrando una aplicación java a Scala, pero un poco a la vez).

Puedo hacer que esto funcione en IDEs, muy bien. Pero no estoy seguro de cómo hacer esto con maven - scalac puede compilar java y scala entrelazados, pero ¿cómo configurarlo para el módulo?

Además, ¿mi fuente scala tiene que ser una carpeta diferente a la java?

Answer 1

Aquí hay un pequeño enlace de proyecto ( https://github.com/mebinjacob/mongo-scala-java-maven-poc ) que hice usando scala, java y mongo db.

Nota en el pom.xml del proyecto, uno puede especificar la carpeta de origen de los archivos scala, puede ser el mismo que el de java o una carpeta diferente, como src / main / scala. No hay ningún mandato para que las clases scala estén en carpetas src separadas. Los probé a los dos y ambos funcionan muy bien. El fragmento del pom al que me refiero es

    <build>
    <plugins>
        <plugin>
            <groupId>org.scala-tools</groupId>
            <artifactId>maven-scala-plugin</artifactId>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <goal>testCompile</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <sourceDir>src/main/scala</sourceDir>
                <jvmArgs>
                    <jvmArg>-Xms64m</jvmArg>
                    <jvmArg>-Xmx1024m</jvmArg>
                </jvmArgs>
            </configuration>
        </plugin>
    </plugins>
</build>

Answer 2

Lo resolví hace algún tiempo al tener un módulo Maven escrito en Scala y el otro en Java. Pero dado que Scala y Java pueden cruzar el uno con el otro (Java -> Scala -> Java o al revés), entonces esto es algo muy deseable sin proyectos de múltiples módulos.

Hay un trabajo en curso para resolver esto, puedes leerlo here y pronto se lanzará una nueva versión del maven-scala-plugin.

Answer 3

Mira Sonatype Maven Cookbook Capítulo 3. Scala y Maven

Answer 4

Necesita combinar varios enfoques para mezclar clases de Scala y Java libremente. Esta solución funcionó para mí:

   <properties>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <!-- <encoding>UTF-8</encoding> -->
        <scala.tools.version>2.10</scala.tools.version>
        <scala.version>2.10.3</scala.version>
    </properties>
<build>
        <sourceDirectory>src/main/scala</sourceDirectory>
        <testSourceDirectory>src/test/scala</testSourceDirectory>
        <plugins>
            <plugin>
                <groupId>org.scala-tools</groupId>
                <artifactId>maven-scala-plugin</artifactId>
                <version>2.15.2</version>
                <executions>                    
                    <execution>
                        <id>scala-compile-first</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>scala-test-compile</id>
                        <phase>process-test-resources</phase>
                        <goals>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>                
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.1.3</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                        <configuration>
                            <args>
                                <arg>-make:transitive</arg>
                                <arg>-dependencyfile</arg>
                                <arg>${project.build.directory}/.scala_dependencies</arg>
                            </args>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.13</version>
                <configuration>
                    <useFile>false</useFile>
                    <disableXmlReport>true</disableXmlReport>               
                    <includes>
                        <include>**/*Test.*</include>
                        <include>**/*Suite.*</include>
                    </includes>
                </configuration>
            </plugin>       
        </plugins>
    </build>

Answer 5

Sí, la parte scala tiene que estar en un módulo separado y en el directorio src/main/scala . Maven considera fuente mixta como esto como una herejía.

Habilita la compilación scala al importar el complemento scala maven . La página de "usage" como un buen ejemplo.

Answer 6

Una vez hice una pregunta muy similar sobre cómo incluir código que no es Java en un proyecto de Maven. La esencia de la respuesta era tener bajo un directorio diferente para cada lenguaje de programación, y encontrar / escribir un plugin Maven que supiera qué hacer con cada uno. P.ej:

src/
|-- main
|   |-- bin
|   |-- sh
|   |-- sql
|   |-- scala
|   |-- java
|   `-- resources
|-- site
...

Answer 7

Usando el plugin maven scala, una configuración como la siguiente funcionará para un proyecto que mezcla Java y scala source (la fuente scala por supuesto va en el directorio / scala, como lo mencionó otra persona).

Puede ejecutar run mvn compile, test, etc ... y todo funcionará normalmente. Muy agradable (ejecutará scalac primero automáticamente).

Para un gran IDE, IntelliJ 8 funciona bien: agrega el scala plug in, luego agrega un scala facet, y luego ajusta la configuración de compilación para que scala ejecute scalac primero (crítico si tienes dependencias circulares con scala y java source).

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>demo</groupId>
<artifactId>scala-java-app</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>scala-java-app</name>
<repositories>
    <repository>
        <id>scala-tools.org</id>
        <name>Scala-tools Maven2 Repository</name>
        <url>http://scala-tools.org/repo-releases</url>
    </repository>
</repositories>
<pluginRepositories>
    <pluginRepository>
        <id>scala-tools.org</id>
        <name>Scala-tools Maven2 Repository</name>
        <url>http://scala-tools.org/repo-releases</url>
    </pluginRepository>
</pluginRepositories>
<build>
    <plugins>
        <plugin>
            <groupId>org.scala-tools</groupId>
            <artifactId>maven-scala-plugin</artifactId>
            <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>
        </plugin>
        <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>1.5</source>
                <target>1.5</target>
            </configuration>
        </plugin>
    </plugins>  
</build>
<dependencies>
    <dependency>
        <groupId>org.scala-lang</groupId>
        <artifactId>scala-library</artifactId>
        <version>2.7.2</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>3.8.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>