java -u with - Maven: ajouter une dépendance à un pot par chemin relatif




5 Answers

Je veux que le fichier jar soit dans une bibliothèque tierce partie dans le contrôle source, et liez-le par chemin relatif à partir du fichier pom.xml.

Si vous voulez vraiment cela (comprendre, si vous ne pouvez pas utiliser un référentiel d'entreprise), alors mon conseil serait d'utiliser un "référentiel de fichiers" local au projet et de ne pas utiliser une dépendance portée par le system . Le system visé doit être évité, de telles dépendances ne fonctionnent pas bien dans beaucoup de situations (par exemple dans l'assemblage), elles causent plus de problèmes que d'avantages.

Donc, à la place, déclarez un référentiel local au projet:

<repositories>
  <repository>
    <id>my-local-repo</id>
    <url>file://${basedir}/my-repo</url>
  </repository>
</repositories>

Installez votre localRepositoryPath tierce en utilisant install:install-file avec le paramètre localRepositoryPath :

mvn install:install-file -Dfile=<path-to-file> -DgroupId=<myGroup> \ 
                         -DartifactId=<myArtifactId> -Dversion=<myVersion> \
                         -Dpackaging=<myPackaging> -DlocalRepositoryPath=<path>

Mise à jour: Il semble que install:install-file ignore le localRepositoryPath lors de l'utilisation de la version 2.2 du plugin. Cependant, cela fonctionne avec la version 2.3 et ultérieure du plugin. Utilisez donc le nom complet du plugin pour spécifier la version:

mvn org.apache.maven.plugins:maven-install-plugin:2.3.1:install-file \
                         -Dfile=<path-to-file> -DgroupId=<myGroup> \ 
                         -DartifactId=<myArtifactId> -Dversion=<myVersion> \
                         -Dpackaging=<myPackaging> -DlocalRepositoryPath=<path>

maven-install-plugin documentation

Enfin, déclarez-le comme toute autre dépendance (mais sans la portée du system ):

<dependency>
  <groupId>your.group.id</groupId>
  <artifactId>3rdparty</artifactId>
  <version>X.Y.Z</version>
</dependency>

C'est une meilleure solution à mon humble avis que d'utiliser une portée system car votre dépendance sera traitée comme un bon citoyen (par exemple, il sera inclus dans une assemblée et ainsi de suite).

Maintenant, je dois mentionner que la «bonne façon» de faire face à cette situation dans un environnement d'entreprise (peut-être pas le cas ici) serait d'utiliser un référentiel d'entreprise.

environments different

J'ai un pot de propriété que je veux ajouter à mon pom en tant que dépendance.

Mais je ne veux pas l'ajouter à un dépôt. La raison en est que je veux que mes commandes mvn compile habituelles telles que mvn compile , etc, fonctionnent correctement. (Sans demander aux développeurs de l'ajouter à un référentiel par eux-mêmes).

Je veux que le fichier jar soit dans une bibliothèque tierce partie dans le contrôle source, et liez-le par chemin relatif à partir du fichier pom.xml.

Cela peut-il être fait? Comment?




C'est une autre méthode en plus de ma réponse précédente à Puis-je ajouter des jars à maven 2 buildpath sans les installer?

Cela contournera la limite lors de l'utilisation de générations multi-modules, en particulier si le JAR téléchargé est référencé dans des projets enfants en dehors du parent. Cela réduit également le travail d'installation en créant les fichiers POM et SHA1 dans le cadre de la construction. Il permet également au fichier de résider n'importe où dans le projet sans fixer les noms ni suivre la structure du référentiel maven.

Cela utilise le maven-install-plugin. Pour que cela fonctionne, vous devez configurer un projet multi-module et avoir un nouveau projet représentant la construction pour installer les fichiers dans le référentiel local et s'assurer que l'un est en premier.

Le projet multi-module pom.xml ressemblerait à ceci:

<packaging>pom</packaging>
<modules>
<!-- The repository module must be first in order to ensure
     that the local repository is populated -->
    <module>repository</module>
    <module>... other modules ...</module>
</modules>

Le fichier repository / pom.xml contiendra alors les définitions pour charger les fichiers JAR qui font partie de votre projet. Voici quelques extraits du fichier pom.xml.

<artifactId>repository</artifactId>
<packaging>pom</packaging>

L'empaquetage de pom empêche ceci de faire n'importe quels essais ou compiler ou produire n'importe quel dossier de jar. La viande du fichier pom.xml se trouve dans la section build où le plugin maven-install est utilisé.

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-install-plugin</artifactId>
            <executions>
                <execution>
                        <id>com.ibm.db2:db2jcc</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>install-file</goal>
                        </goals>
                        <configuration>
                            <groupId>com.ibm.db2</groupId>
                            <artifactId>db2jcc</artifactId>
                            <version>9.0.0</version>
                            <packaging>jar</packaging>
                            <file>${basedir}/src/jars/db2jcc.jar</file>
                            <createChecksum>true</createChecksum>
                            <generatePom>true</generatePom>
                        </configuration>
                </execution>
                <execution>...</execution>
            </executions>
        </plugin>
    </plugins>
</build>

Pour installer plus d'un fichier, ajoutez simplement plus d'exécutions.




Fondamentalement, ajoutez ceci au fichier pom.xml:

...

<repositories>
   <repository>
       <id>lib_id</id>
       <url>file://${project.basedir}/lib</url>
   </repository>
</repositories>

...

<dependencies>
  ...
  <dependency>
      <groupId>com.mylibrary</groupId>
      <artifactId>mylibraryname</artifactId>
      <version>1.0.0</version>
  </dependency>
  ...
</dependencies>



Cela fonctionne pour moi: Disons que j'ai cette dépendance

<dependency>
    <groupId>com.company.app</groupId>
    <artifactId>my-library</artifactId>
    <version>1.0</version>
    <scope>system</scope>
    <systemPath>${project.basedir}/lib/my-library.jar</systemPath>
</dependency>

Ensuite, ajoutez le chemin de classe pour votre dépendance système manuellement comme ceci

<Class-Path>libs/my-library-1.0.jar</Class-Path>

Config complète:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.4</version>
    <configuration>
        <archive>
            <manifestEntries>
                <Build-Jdk>${jdk.version}</Build-Jdk>
                <Implementation-Title>${project.name}</Implementation-Title>
                <Implementation-Version>${project.version}</Implementation-Version>
                <Specification-Title>${project.name} Library</Specification-Title>
                <Specification-Version>${project.version}</Specification-Version>
                <Class-Path>libs/my-library-1.0.jar</Class-Path>
            </manifestEntries>
            <manifest>
                <addClasspath>true</addClasspath>
                <mainClass>com.company.app.MainClass</mainClass>
                <classpathPrefix>libs/</classpathPrefix>
            </manifest>
        </archive>
    </configuration>
</plugin>
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.5.1</version>
    <executions>
        <execution>
            <id>copy-dependencies</id>
            <phase>package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>${project.build.directory}/libs/</outputDirectory>
            </configuration>
        </execution>
    </executions>
</plugin>



Vous pouvez utiliser eclipse pour générer un fichier Jar exécutable: Export / Runable Jar




Related