Maven: ajouter une dépendance à un jar par le chemin relatif

utilisant le champ d'application system . ${basedir} est le répertoire de votre pom.

<dependency>
    <artifactId>..</artifactId>
    <groupId>..</groupId>
    <scope>system</scope>
    <systemPath>${basedir}/lib/dependency.jar</systemPath>
</dependency>

cependant, il est conseillé d'installer votre bocal dans le dépôt, et de ne pas le transmettre au SCM - après tout, c'est ce que maven essaie d'éliminer.

c'est une autre méthode en plus de ma réponse précédente à puis-je ajouter des pots à maven 2 build classpath sans les installer?

cela va contourner la limite en utilisant des constructions multi-modules, surtout si le JAR téléchargé est référencé dans des projets enfants à l'extérieur du parent. Cela réduit également le travail de configuration en créant les fichiers POM et SHA1 dans le cadre de la compilation. Il permet également le fichier de résider n'importe où dans le projet sans fixer les noms ou suivre la structure du dépôt maven.

cela utilise le maven-install-plugin. Pour que cela fonctionne, vous devez mettre en place un projet multi-modules et avoir un nouveau projet représentant la construction pour installer des fichiers dans le dépôt local et s'assurer que l'un d'eux est premier.

Vous multi-projet de 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 référentiel/pom.fichier xml contient alors les définitions pour charger les Pots qui font partie de votre projet. Voici quelques extraits de la pom.fichier xml.

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

l'emballage pom l'empêche de faire des tests ou de compiler ou générer des fichiers jar. De la viande de la pom.xml est dans la section build où le maven-install-plugin 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, il suffit d'ajouter plus d'exécutions.

j'ai déjà écrit à propos d'un modèle pour avoir fait cela.

il est très similaire à la solution proposée par Pascal, bien qu'il déplace toutes ces dépendances dans un module de dépôt dédié de sorte que vous n'avez pas à le répéter partout où la dépendance est utilisée s'il s'agit d'une construction multi-modules.

ça marche 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 complet:

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

nous nous sommes mis à gradle et cela fonctionne beaucoup mieux dans gradle ;). nous spécifions juste un dossier dans lequel nous pouvons déposer des pots pour des situations temporaires comme celle-ci. Nous avons encore la plupart de nos jars définis dans la section Gestion des dépendances (i.e. le même que maven). C'est juste une dépendance de nous définir.

donc en gros, maintenant nous pouvons simplement déposer n'importe quel pot que nous voulons dans notre lib dir pour des tests temporaires si ce n'est pas un dépôt maven quelque part.

en gros, Ajoute ça au 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>

un petit ajout à la solution Postée par Pascal

quand j'ai suivi cette route, j'ai eu une erreur dans maven lors de l'installation de ojdbc jar.

[INFO] --- maven-install-plugin:2.5.1:install-file (default-cli) @ validator ---
[INFO] pom.xml not found in ojdbc14.jar

après l'ajout de-DpomFile, le problème a été résolu.

$ mvn install:install-file -Dfile=./lib/ojdbc14.jar -DgroupId=ojdbc \
   -DartifactId=ojdbc -Dversion=14 -Dpackaging=jar -DlocalRepositoryPath=./repo \
   -DpomFile=~/.m2/repository/ojdbc/ojdbc/14/ojdbc-14.pom

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