Le migliori pratiche per la copia di file con Maven

https://stackoverflow.com/questions/586202

06-09-2019
|

Domanda

Ho config file e documenti vari che voglio copiare da ambiente dev, il dev-server di directory utilizzando Maven2.Stranamente, Maven non sembra forte a questo compito.

Alcune delle opzioni:

Semplice utilizzare un copia compito in Maven

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

Utilizzare la Formica plugin per eseguire copia da Ant.
Costruire un manufatto di tipo zip, a fianco del "principale" artefatto del POM che di solito è di tipo vaso, poi decomprimere quel manufatto dal repository nella directory di destinazione.
maven-risorse plugin, come indicato di seguito.
Maven Assemblea plugin -- ma questo sembra richiedere un sacco di manuale di definizioni, quando voglio fare le cose semplicemente e "convenzionalmente."
Questa pagina anche illustrato come creare un plugin per fare la copia!
maven-upload plugin, come indicato di seguito.
maven-dipendenza-plugin con copia, come indicato di seguito.

Tutti questi sembrano inutilmente ad hoc:Maven è supposto per excel a fare i compiti senza confusione e fastidio.

Qualche consiglio?

Soluzione

Non rifuggire dal plugin Antrun. Solo perché alcune persone tendono a pensare che Ant e Maven sono in opposizione, non lo sono. Utilizzare l'attività di copia, se avete bisogno di eseguire alcune inevitabili una tantum di personalizzazione:

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

Per rispondere a questa domanda, mi sto concentrando sui dettagli di quello che hai chiesto. Come faccio a copiare un file? La domanda e il nome della variabile mi portano a una serie di domande più grandi come: "C'è un modo migliore per affrontare il provisioning dei server?" Utilizzare Maven come un sistema di compilazione per generare artefatto schierabili, quindi eseguire queste personalizzazioni sia in moduli separati o da qualche altra parte del tutto. Se hai condiviso un po 'più del vostro ambiente di compilazione, ci potrebbe essere un modo migliore - ci sono i plugin a disposizione un certo numero di server. Potrebbe collegare un assembly che viene decompresso nella root del server? Quello del server stai usando?

Anche in questo caso, sono sicuro che ci sia un modo migliore.

Altri suggerimenti

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

Per copiare un file di uso:

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

Per copiare la cartella con sottocartelle utilizzare configurazione successiva:

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

Il plugin Maven dipendenza mi ha salvato un sacco di tempo accarezza con compiti formica:

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

Il dipendenza: copiare è documentend, e ha obiettivi più utili come disfare.

Per un semplice copia-compiti posso consigliare copia-rinominare-maven-plugin.E ' semplice da usare:

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

Se si desidera copiare uno o più file, sostituire il <sourceFile>...</destinationFile> parte con

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

Inoltre è possibile specificare più esecuzioni in più fasi, se necessario, il secondo obiettivo è di "rinominare", che semplicemente fa quello che dice, mentre il resto della configurazione è sempre la stessa.Per ulteriori esempi di utilizzo consultare il L'Utilizzo Della Pagina.

Nota:Questo plugin è possibile copiare solo i file, non di directory.(Grazie a @james.garriss di questa limitazione).

La soluzione formica sopra è più semplice da configurare, ma ho avuto la fortuna utilizzando il Maven-upload-plugin da Atlassian. Non sono riuscito a trovare una buona documentazione, ecco come lo uso:

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

Le variabili come "$ {} jboss.host" di cui sopra sono definiti nel mio ~ / .m2 / settings.xml e vengono attivate utilizzando i profili Maven. Questa soluzione non è vincolato a JBoss, questo è proprio quello che ho chiamato il mio variabili. Ho un profilo per il dev, test e dal vivo. Quindi, per caricare il mio orecchio a un'istanza JBoss in ambiente di test avrei eseguire:

mvn upload:upload -P test

Ecco uno snipet da 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>
       ...

Note: L'esperto di pronti contro termine Atlassian che ha questo plugin è qui: https://maven.atlassian.com/public/

vi consiglio di scaricare i sorgenti e guardando la documentazione dentro per vedere tutte le caratteristiche del plugin fornisce.

Bene, Maven non dovrebbe essere buono a fare i compiti granulare fine, non è un linguaggio di scripting come bash o formica, è piuttosto dichiarativa - tu dici - ho bisogno di una guerra, o un orecchio, e si ottiene . Tuttavia, se è necessario personalizzare come la guerra o l'orecchio dovrebbe essere simile dentro, hai un problema. Non è solo procedurale come formica, ma dichiarativa. Questo ha alcuni vantaggi in principio, e potrebbe avere un sacco di svantaggi alla fine.

Credo che il concetto iniziale era quello di avere i plugin sottili, che "solo di lavoro", ma la realtà è diversa se si fa roba non standard.

Se invece metti abbastanza impegno nei vostri pom e alcuni plugin personalizzati, si otterrà una migliore costruire ambiente come con la formica per esempio (dipende da voi progetto, naturalmente, ma diventa sempre più vero per i progetti più grandi) .

Ho avuto un'esperienza molto buona con copia-maven-plugin . Ha una sintassi molto più conveniente e conciso rispetto a Maven-risorse-plugin.

Un modo generico per copiare i file arbitrari è quello di utilizzare Maven Wagon astrazione trasporti. E 'in grado di gestire diverse destinazioni tramite protocolli come file, HTTP, FTP, SCP o WebDAV.

Ci sono alcuni plugin che forniscono servizi per copiare i file attraverso l'uso di Wagon. Degna di nota sono:

Out-of-the-box Maven Deploy Plugin

C'è la deploy-file obiettivo . E 'abbastanza inflessibile, ma può ottenere il lavoro fatto:
```
mvn deploy:deploy-file -Dfile=/path/to/your/file.ext -DgroupId=foo 
-DartifactId=bar -Dversion=1.0 -Durl=<url> -DgeneratePom=false
```
notevole svantaggio di utilizzare Maven Deploy Plugin è che è designato per lavorare con i repository Maven. Assume particolare struttura e metadati. Si può vedere che il file è posto sotto foo/bar/1.0/file-1.0.ext e si creano file di checksum. Non v'è alcun modo per aggirare questo.
Wagon Maven Plugin

Utilizza il upload-single obiettivo :
```
mvn org.codehaus.mojo:wagon-maven-plugin:upload-single
-Dwagon.fromFile=/path/to/your/file.ext -Dwagon.url=<url>
```
L'uso di Wagon Maven Plugin per la copia è semplice e sembra essere il più versatile.

Negli esempi sopra <url> può essere di qualsiasi protocollo supportato. Vedere l'elenco dei Wagon Provider . Ad esempio

la copia di file in locale: file:///copy/to
SSH la copia di file di host remoto in esecuzione: scp://host:22/copy/to

Gli esempi precedenti passaggio plug parametri nella linea di comando. In alternativa, plugin possono essere configurati direttamente in POM. Poi l'invocazione sarà semplicemente come mvn deploy:deploy-file@configured-execution-id. Oppure può essere associato a particolare fase di costruzione.

Si prega di notare che per i protocolli come SCP per lavorare è necessario definire un interno del POM:

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

Se la destinazione si sta copiando a richiede l'autenticazione, le credenziali possono essere fornite tramite Server impostazioni . repositoryId / serverId passato ai plugin deve corrispondere al server definito nelle impostazioni.

Posso solo supporre che i vostri $ {} project.server.config proprietà è qualcosa personalizzato definito ed è al di fuori della struttura delle directory standard.

Se è così, allora io userei il compito di copia.

Un altro modo è quello di raggruppare queste cose in un artefatto utilizzando il plugin di montaggio. Quindi è possibile utilizzare il plugin di dipendenza per decomprimere questi file in cui si desidera. Ci sono anche copiare gol nella dipendenza plugin per copiare gli artefatti.

Sono stato in grado di mettere insieme un certo numero di fonti diverse per questa risposta:

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

Da ~/.m2/settings.xml:

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

Quindi eseguire il comando: (la -X è per il debug)

mvn -X upload:upload

Per riassumere alcune delle belle risposte di cui sopra: Maven è stato progettato per compilare moduli e copiare i risultati in un repository Maven. Qualsiasi copia di moduli in una directory di distribuzione / installatore ingresso deve essere eseguita al di fuori del contesto della funzionalità di base di Maven, ad esempio con l'Ant / Maven copia di comando.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow

Le migliori pratiche per la copia di file con Maven

Out-of-the-box Maven Deploy Plugin

Wagon Maven Plugin