Ayant Maven2 de copier les ressources du répertoire de construction, mais de ne PAS les regrouper dans le BOCAL

J'ai commencé un nouveau projet Maven dans NetBeans, d'accepter toutes les valeurs par défaut. Le POM, avec tous les JAR dépendances dépouillé, est cut-n-collé au bas de cette question.

L'application lit dans les différents fichiers de propriétés (par exemple, la journalisation et de configuration). Il se lit aussi dans les ressources externes telles que les polices, les images et les sons. Je ne veux PAS que toutes ces ressources de manière à être enfermé dans le fichier JAR. Au lieu de cela, j'ai l'intention de les déployer dans des sous-répertoires sous le répertoire où le POT est déployé.

Une vue simplifiée de la structure de répertoire du projet ressemble à ceci:

-src
   |---main
           |---java
                   |---com.mypackage, etc
           |---resources
                        |---conf
                        |---fonts
                        |---images
                        |---sounds
+target

Ce que je comme après une nouvelle version devrait ressembler à ceci:

+src
-target
       |---myproject-1.0.0.jar (compiled contents of "src/main/java" ONLY)
       |---conf
       |---fonts
       |---images
       |---sounds

Cependant, quand je fais un "clean-et-build" ou un "exec" à travers NetBeans (ou de la ligne de commande)... ce que je suis fait se ressemble à ceci:

+src
-target
       |---classes
                  |---("src/main/java" and "src/main/resources" slammed together)
       |---myproject-1.0.0.jar (the "classes" subdirectory JAR'ed up)

Quelqu'un peut me pointer dans la bonne direction pour obtenir que le premier plutôt que le second? Je m'excuse si c'est une question idiote (je suis un Maven rookie), ou si j'ai oublié une déjà demandé à dupliquer. Cependant, à partir de la recherche que j'ai fait sur un Débordement de Pile... on dirait que tous les doublons de questions, essayez d'aller le autres! (c'est à dire obtenir des ressources en un POT plutôt que de les garder hors)

pom.xml:

<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>steveperkins</groupId>
    <artifactId>myproject</artifactId>
    <packaging>jar</packaging>
    <version>1.0.0</version>
    <name>My Project</name>
    <url>http://maven.apache.org</url>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.0.2</version>
                <configuration>
                    <source>1.4</source>
                    <target>1.4</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
    ...

OriginalL'auteur Steve Perkins | 2010-10-25

10

Bien que la proposition de solutions qui fonctionnent, ils ne font que contourner les conventions de maven. Une meilleure alternative serait de filtrer les ressources, de sorte qu'ils ne sont pas inclus dans le pot, mais toujours disponibles en tant que ressources tout en travaillant dans l'IDE. Dans le pom, il devrait ressembler à ceci:
```
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <executions>
                <execution>
                    <goals>
                        <goal>jar</goal>
                    </goals>
                    <configuration>
                        <excludes>
                            <exclude>/conf/**</exclude>
                            <exclude>/fonts/**</exclude>
                            <exclude>/images/**</exclude>
                            <exclude>/sounds/**</exclude>
                        </excludes>
                    </configuration>
                </execution>
            </executions>
        </plugin>
   </plugins>
</build>
```
Ceci reviendrait à exclure du pot sans aucune solution de contournement.

Ici est la page de doc pour le jar du plugin.

Si la ci-dessus sera répondre à votre question, permettez-moi de suggérer quelques possibilité supplémentaire qui pourrait vous aider dans votre effort. Dans une deuxième étape, toujours rendre ces ressources disponibles vous pourriez package de votre projet à l'aide de la assemblée plugin. cela vous permettra de créer un fichier zip et placez tous les fichiers, les ressources et le bocal dans un endroit approprié, de sorte que lorsque le zip est déballé tout tombe en place.

Si ce projet fait partie d'un plus grand travail que vous pouvez toujours utiliser l'assemblée plugin pour chaque où vous auriez à cette situation et dans le projet principal, vous pourrez extraire et de les remonter dans un grand zip avec toutes les artefacts.

Enfin, je vous suggère de laisser la structure du répertoire cible. Si vous le personnaliser, il serait préférable de le faire à travers le Maven variables, de sorte que les changements se propager dans les autres plugins. Si vous avez manuellement supprimer et renommer des trucs une fois que Maven a traversé, vous risquez de rencontrer des problèmes plus tard. Normalement, le Maven jar du plugin devrait être capable de l'obtenir si vous le configurer de la manière que vous voulez si vous n'avez pas besoin de s'inquiéter à propos de ce qui vient sous la cible. Personnellement, j'utilise Eclipse et le pusign est très bon à l'obtention de l'IDE et Maven config dans la synchronisation. Pour NetBeans je soupçonne ce serait également le cas. Si ce n'est la meilleure approche serait de configurer votre projet dans NetBeans pour l'utiliser target/classes comme un dossier cible pour les construit des artefacts et de la cible/test-classes pour des trucs construits à partir de src/test/java.

Ce ne serait pas donner ce que l'OP demande (c'est à dire conf, police, etc dans la racine du répertoire cible), au moins pas sans plus d'efforts.
C'est mon point de vue, il doe morve besoin de changer son dossier racine. Nettoyage autour de l'hypothèse de conventions de maven est le chemin d'accès à l'obscurité. Maven est un grand aussi longtemps que vous jouer gentil avec elle. Si vous essayez de changer le monde autour de lui, il se cassera dans de nombreux endroits inattendus
C'est pourquoi j'ai suggéré d'utiliser l'autre emplacement que src/main/resources pour réaliser ce que l'OP a demandé sans casser tout.
J'aime cette approche meilleur parce qu'il joue bien avec le "exec", utilisé par NetBeans pour exécuter l'application à partir de l'IDE. Je n'ai pas vraiment soin si tout sauf l'évier de la cuisine est copié à "target/classes" pendant le processus de génération... juste aussi longtemps que je me retrouve avec des non-Java des ressources à l'extérieur le fichier JAR un livrable final. Je peux utiliser un assembleur pour emballer le tout une fois que le bol est correctement construit.
Cependant, je dois noter que cette pom exemple ci-dessus ne fonctionne pas pour moi. J'ai fini par faire la promotion de ce <configuration> élément à deux niveaux, d'être un enfant direct de l' <plugin> élément... et puis éliminé la <exécutions> élément tout à fait. A bien fonctionné ensuite.

OriginalL'auteur Newtopian

Personnellement, je ne voudrais pas utiliser l'emplacement par défaut de ressources, mais un "extra" emplacement et configurer les ressources plugin pour copier où vous le souhaitez à partir de là:

<project>
  ...
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-resources-plugin</artifactId>
        <version>2.4.3</version>
        <executions>
          <execution>
            <id>copy-resources</id>
            <!-- here the phase you need -->
            <phase>validate</phase>
            <goals>
              <goal>copy-resources</goal>
            </goals>
            <configuration>
              <outputDirectory>${basedir}/target</outputDirectory>
              <resources>          
                <resource>
                  <directory>src/non-packaged-resources</directory>
                  <filtering>true</filtering>
                </resource>
              </resources>              
            </configuration>            
          </execution>
        </executions>
      </plugin>
    </plugins>
    ...
  </build>
  ...
</project>

Si vous insistez avec l'aide de l'emplacement par défaut (src/main/resources), je pense que vous aurez à configurer certaines exclusions (voir ci-dessous) pour éviter de ressources copié par défaut et ensuite utiliser la même méthode que ci-dessus.

Une autre option serait d'utiliser la AntRun plugin maven et Ant pour déplacer des fichiers, mais ce n'est pas vraiment le maven façon donc je ne vais pas le détailler.

Ressources

OriginalL'auteur Pascal Thivent

0

Vous pouvez sonfigure une exécution spéciale de ressources:copier-ressources objectif.

OriginalL'auteur Eugene Kuleshov
0

Eugene est sur la bonne voie, mais il y a une meilleure façon de faire ce travail.

Il devrait ressembler à quelque chose comme ceci:
```
<build>
  <outputDirectory>target/${artifactId}-${version}</outputDirectory>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <version>2.3.1</version>
      <configuration>
        <classesDirectory>${project.build.outputDirectory}</classesDirectory>
        <outputDirector>target</outputDirectory>
      </configuration>
    </plugin>
  </plugins>
  <resources>
    <resource>
      <directory>src/main/resources/conf</directory>
      <targetPath>../conf</targetPath>
    </resource>
    <resource>
      <directory>src/main/resources/ANOTHER_PATH</directory>
      <targetPath>../ANOTHER_PATH</targetPath>
    </resource>
  </resources>
</build>
```
Vous ne serez pas en mesure de se débarrasser des "classes" de répertoire, mais vous serez en mesure de lui donner un autre nom qui ne devrait pas interférer avec NetBeans.

Vous pouvez trouver plus d'informations sur le <outputDirectory> élément ici.

Vous pouvez trouver plus d'informations sur le jar du plugin ici.

Vous pouvez trouver plus d'informations sur le <resource> élément ici.

Comme une note de côté, vous pourriez envisager de l'exécution de Maven en vertu d'un JDK 1.6 de la fourche et le maven-compiler-plugin pour utiliser votre JDK 1.4 pour la compilation. Vous pouvez en savoir plus sur cette ici. Cela devrait vous donner un coup de pouce à votre compilation. Vous pouvez aussi dire infaillible lors de l'exécution des cas de test à utiliser le JDK 1.4 pour l'exécution ainsi.

OriginalL'auteur jgifford25

Vous devez vous connecter pour publier un commentaire.