Les meilleures pratiques pour la copie des fichiers avec Maven

https://stackoverflow.com/questions/586202

06-09-2019
|

Question

J'ai des fichiers de configuration et divers documents que je veux copier de l'environnement de dev dans le répertoire dev-serveur à l'aide Maven2. Étrangement, Maven ne semble pas forte à cette tâche.

Certaines des options:

Utilisation simple une tâche Copier dans Maven

<copy file="src/main/resources/config.properties" tofile="${project.server.config}/config.properties"/>

Utiliser le plugin Ant pour exécuter Copier Ant.
Construire un artefact de type zip , à côté de l'artefact "principal" du POM qui est généralement de type jar , puis déballer cet artefact du référentiel dans le répertoire cible.
maven-ressources plugin, comme mentionné ci-dessous.
plugin Maven Assembly - mais cela semble exiger beaucoup de définitions manuelles, quand je veux faire les choses simplement et
Cette page montre même comment construire un plugin faire la copie!
maven-upload plugin, comme mentionné ci-dessous.
maven-dependency-plugin avec copie , comme mentionné ci-dessous.

Tous ceux-ci semblent inutilement ad hoc: Maven est censé exceller à faire ces tâches standard sans chichi et déranger.

Un conseil?

La solution

Ne pas avoir peur du plug-in AntRun. Tout simplement parce que certaines personnes ont tendance à penser que Ant et Maven sont dans l'opposition, ils ne sont pas. Utilisez la tâche de copie si vous devez effectuer une personnalisation unique inévitable:

<project>
  [...]
  <build>
    <plugins>
      [...]
      <plugin>
        <artifactId>maven-antrun-plugin</artifactId>
        <executions>
          <execution>
            <phase>deploy</phase>
            <configuration>
              <tasks>

                <!--
                  Place any Ant task here. You can add anything
                  you can add between <target> and </target> in a
                  build.xml.
                -->

              </tasks>
            </configuration>
            <goals>
              <goal>run</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  [...]
</project>

Pour répondre à cette question, je me concentre sur les détails de ce que vous avez demandé. Comment puis-je copier un fichier? La question et le nom de la variable me conduisent à une plus grandes questions comme: « Y at-il une meilleure façon de traiter le provisionnement du serveur? » Utilisez Maven comme système de construction pour générer l'artefact déployable, puis effectuer ces personnalisations soit dans des modules séparés ou ailleurs entièrement. Si vous partagiez un peu plus de votre environnement de construction, il pourrait y avoir une meilleure façon - il existe des plugins à disposition un certain nombre de serveurs. Pouvez-vous fixer un ensemble qui est décompressé dans la racine du serveur? Quel serveur utilisez-vous?

Encore une fois, je suis sûr qu'il ya une meilleure façon.

Autres conseils

<build>
    <plugins>
        ...
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <version>2.3</version>
        </plugin>
    </plugins>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include> **/*.properties</include>
            </includes>
        </resource>
    </resources>
    ...
</build>

Pour copier un fichier de l'utilisation:

        <plugin>
            <artifactId>maven-resources-plugin</artifactId>
            <version>3.1.0</version>
            <executions>
                <execution>
                    <id>copy-resource-one</id>
                    <phase>install</phase>
                    <goals>
                        <goal>copy-resources</goal>
                    </goals>

                    <configuration>
                        <outputDirectory>${basedir}/destination-folder</outputDirectory>
                        <resources>
                            <resource>
                                <directory>/source-folder</directory>
                                <includes>
                                    <include>file.jar</include>
                                </includes>
                            </resource>
                        </resources>
                    </configuration>
                </execution>
           </executions>
        </plugin>

Pour copier le dossier avec des sous-dossiers utiliser la configuration suivante:

           <configuration>
              <outputDirectory>${basedir}/target-folder</outputDirectory>
              <resources>          
                <resource>
                  <directory>/source-folder</directory>
                  <filtering>true</filtering>
                </resource>
              </resources>              
            </configuration>

Le plugin de dépendance maven m'a sauvé beaucoup de temps à des tâches de fourmi caressait:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
        <execution>
            <id>install-jar</id>
            <phase>install</phase>
            <goals>
                <goal>copy</goal>
            </goals>
            <configuration>
                <artifactItems>
                    <artifactItem>
                        <groupId>...</groupId>
                        <artifactId>...</artifactId>
                        <version>...</version>
                    </artifactItem>
                </artifactItems>
                <outputDirectory>...</outputDirectory>
                <stripVersion>true</stripVersion>
            </configuration>
        </execution>
    </executions>
</plugin>

dépendance: copier est documentend, et a des objectifs plus utiles comme déballer.

Pour une simple copie-tâches que je peux recommander copier-renommer-maven-plugin . Il est directe et simple à utiliser:

<project>
  ...
  <build>
    <plugins>
      <plugin>
        <groupId>com.coderplus.maven.plugins</groupId>
        <artifactId>copy-rename-maven-plugin</artifactId>
        <version>1.0</version>
        <executions>
          <execution>
            <id>copy-file</id>
            <phase>generate-sources</phase>
            <goals>
              <goal>copy</goal>
            </goals>
            <configuration>
              <sourceFile>src/someDirectory/test.environment.properties</sourceFile>
              <destinationFile>target/someDir/environment.properties</destinationFile>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

Si vous souhaitez copier plus d'un fichier, remplacez la partie <sourceFile>...</destinationFile> avec

<fileSets>
  <fileSet>
    <sourceFile>src/someDirectory/test.environment.properties</sourceFile>
    <destinationFile>target/someDir/environment.properties</destinationFile>
  </fileSet>
  <fileSet>
    <sourceFile>src/someDirectory/test.logback.xml</sourceFile>
    <destinationFile>target/someDir/logback.xml</destinationFile>
  </fileSet>                
</fileSets>

En outre, vous pouvez spécifier plusieurs exécutions en plusieurs phases si nécessaire, le deuxième but est « Rename », qui fait tout simplement ce qu'il dit alors que le reste de la configuration reste la même. Pour plus d'exemples d'utilisation font référence à la Utilisation-.

Remarque : Ce plugin ne peut copier des fichiers, pas les répertoires. (Merci à @ james.garriss pour trouver cette limitation.)

La solution fourmi est au-dessus plus facile à configurer, mais je l'ai eu de la chance en utilisant le maven-plugin-upload de Atlassian. Je ne pouvais pas trouver une bonne documentation, voici comment je l'utilise:

<build>
  <plugin>
    <groupId>com.atlassian.maven.plugins</groupId>
    <artifactId>maven-upload-plugin</artifactId>
    <version>1.1</version>
    <configuration>
       <resourceSrc>
             ${project.build.directory}/${project.build.finalName}.${project.packaging}
       </resourceSrc>
       <resourceDest>${jboss.deployDir}</resourceDest>
       <serverId>${jboss.host}</serverId>
       <url>${jboss.deployUrl}</url>
     </configuration>
  </plugin>
</build>

Les variables telles que "$ {} jboss.host" référencé ci-dessus sont définis dans mon ~ / .m2 / settings.xml et sont activés en utilisant des profils de Maven. Cette solution est limitée à JBoss, c'est exactement ce que j'ai appelé mes variables. J'ai un profil pour dev, test, et en direct. Donc, pour télécharger mon oreille à une instance jboss dans un environnement de test j'exécuter:

mvn upload:upload -P test

Voici un snipet de settings.xml:

<server>
  <id>localhost</id>
  <username>username</username>
  <password>{Pz+6YRsDJ8dUJD7XE8=} an encrypted password. Supported since maven 2.1</password>
</server>
...
<profiles>
  <profile>
    <id>dev</id>
    <properties>
      <jboss.host>localhost</jboss.host> 
      <jboss.deployDir>/opt/jboss/server/default/deploy/</jboss.deployDir>
      <jboss.deployUrl>scp://root@localhost</jboss.deployUrl>
    </properties>
  </profile>
  <profile>
    <id>test</id>
    <properties>
       <jboss.host>testserver</jboss.host>
       ...

Notes: Le repo maven Atlassian qui a ce plugin est ici: https://maven.atlassian.com/public/

Je vous conseille de télécharger les sources et en regardant la documentation à l'intérieur pour voir toutes les fonctionnalités du plug-in fournit.

Eh bien, Maven n'est pas censé être bon à faire de fines tâches granulaires, ce n'est pas un langage de script comme bash ou fourmi, il est plutôt déclarative - vous dites - je besoin d'une guerre ou une oreille, et vous obtenez . Toutefois, si vous avez besoin de personnaliser la façon dont la guerre ou l'oreille devrait ressembler à l'intérieur, vous avez un problème. Il est tout simplement pas la procédure comme fourmi, mais déclarative. Cela a des avantages au début, et pourrait avoir beaucoup d'inconvénients à la fin.

Je suppose que le concept initial était d'avoir de beaux plugins, qui « fonctionne », mais la réalité est différente si vous faites des choses non standard.

Si vous mettez cependant assez d'efforts dans vos poms et quelques plugins personnalisés, vous aurez un bien meilleur construire environnement avec des fourmis par exemple (dépend de vous projet bien sûr, mais il devient de plus en plus vrai pour les grands projets) .

J'ai eu une très bonne expérience avec copier-maven-plugin . Il a une syntaxe beaucoup plus pratique et concise par rapport à maven-ressources-plugin.

Une façon générique pour copier des fichiers arbitraires est d'utiliser l'abstraction de transport Maven Wagon. Il peut gérer différentes destinations via des protocoles tels que file, HTTP, FTP, SCP ou WebDAV.

Il y a quelques plugins qui fournissent pour copier des fichiers à l'aide de Wagon. Les plus notables sont:

Out-of-the-box Maven Plugin Déployer

Il est deploy-file but . Il assez rigide, mais peut faire le travail:
```
mvn deploy:deploy-file -Dfile=/path/to/your/file.ext -DgroupId=foo 
-DartifactId=bar -Dversion=1.0 -Durl=<url> -DgeneratePom=false
```
inconvénient majeur à l'utilisation Maven Deploy Plugin est qu'il est désigné pour travailler avec les dépôts Maven. Elle suppose structure particulière et les métadonnées. Vous pouvez voir que le fichier est placé sous foo/bar/1.0/file-1.0.ext et fichiers de contrôle sont créés. Il n'y a pas moyen de contourner cela.
Wagon Maven Plugin

Utilisez le upload-single but :
```
mvn org.codehaus.mojo:wagon-maven-plugin:upload-single
-Dwagon.fromFile=/path/to/your/file.ext -Dwagon.url=<url>
```
L'utilisation de Wagon Maven Plugin pour la copie est simple et semble être le plus polyvalent.

Dans les exemples ci-dessus <url> peut être de tout protocole pris en charge. Voir la liste des fournisseurs Wagon . Par exemple

fichier de copie localement: file:///copy/to
fichier de copie à distance en cours d'exécution SSH hôte: scp://host:22/copy/to

Les exemples ci-dessus des paramètres de plugin passe dans la ligne de commande. En variante, le greffon peut être configuré directement dans POM. Ensuite, l'invocation sera simplement comme mvn deploy:deploy-file@configured-execution-id. Ou il peut être lié à la phase de construction particulière.

S'il vous plaît noter que pour les protocoles tels que SCP à travailler, vous devrez définir une extension dans votre POM:

<build>
  [...]
  <extensions>
    <extension>
      <groupId>org.apache.maven.wagon</groupId>
      <artifactId>wagon-ssh</artifactId>
      <version>2.12</version>
    </extension>
  </extensions>

Si la destination vous copiez requiert une authentification, les informations d'identification peuvent être fournis par Server paramètres . repositoryId / serverId passé aux plug-ins doit correspondre au serveur défini dans les paramètres.

Je ne peux que supposer que vos $ {} project.server.config propriété est quelque chose de personnalisé défini et est en dehors de la mise en page du répertoire standard.

Si oui, alors j'utiliser la tâche de copie.

Une autre façon est de regrouper ces choses dans un artefact à l'aide du plug-in de montage. Ensuite, vous pouvez utiliser le plug-in de dépendance pour décompresser ces fichiers où vous voulez. Il y a aussi copier des objectifs dans la dépendance de plugin pour copier des objets.

J'ai pu rassembler un certain nombre de sources différentes pour cette réponse:

...
<repository>
    <id>atlassian</id>
    <name>Atlassian Repo</name>
    <url>https://maven.atlassian.com/content/repositories/atlassian-public</url>
</repository>
...
<dependency>
    <groupId>com.atlassian.maven.plugins</groupId>
    <artifactId>maven-upload-plugin</artifactId>
    <version>1.1</version>
</dependency>
...
<plugin>
    <groupId>com.atlassian.maven.plugins</groupId>
    <artifactId>maven-upload-plugin</artifactId>
    <version>1.1</version>
    <configuration>
        <serverId>jira-repo</serverId>
        <resourceSrc>
            ${project.build.directory}/${project.build.finalName}.${project.packaging}
        </resourceSrc>
        <resourceDest>opt/jira/webapps</resourceDest> <!-- note: no leading slash -->
        <url>scp://root@jira</url>
    </configuration>
</plugin>
...

De ~/.m2/settings.xml:

...
<servers>
  <server>
    <id>jira-repo</id>
    <username>myusername</username>
    <password>mypassword</password>
  </server>
</servers>
...

Ensuite, exécutez la commande suivante: (-X est pour le débogage)

mvn -X upload:upload

Pour résumer quelques-unes des réponses fines ci-dessus: Maven est conçu pour construire des modules et copier les résultats dans un dépôt Maven. Toute copie des modules dans un répertoire d'entrée d'installation de déploiement / doit se faire en dehors du contexte de la fonctionnalité de base de Maven, par exemple avec le Ant / Maven copie commande.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow

Les meilleures pratiques pour la copie des fichiers avec Maven

Out-of-the-box Maven Plugin Déployer

Wagon Maven Plugin