web-dev-qa-db-fra.com

Maven: le meilleur moyen de relier un JAR externe personnalisé à mon projet?

Ce sont mes premiers jours d'apprentissage de Maven et je continue à avoir des difficultés avec les bases. J'ai un fichier .jar externe (non disponible dans les dépôts publics) que je dois référencer dans mon projet et j'essaie de déterminer quelle est ma meilleure option. 

C'est un projet à petite échelle sans référentiel central pour les bibliothèques. Il doit donc s'agir d'un référentiel local (ajouté au contrôle de code source, vous ne savez pas s'il est censé fonctionner de cette manière?) Ou le fichier .jar doit être stocké sur disque en dehors de tout référentiel formel.

1) Quelle est ma meilleure option pour ajouter le fichier .jar aux références de mon projet avec maven, étant donné que je souhaite que le projet et la bibliothèque soient tous deux sous contrôle de code source?

2) Je n'arrive toujours pas à faire voir la dépendance à Eclipse. Je l'ai ajouté manuellement à la section du pom, et il apparaît bien dans la liste des dépendances dans m2Eclipse. mvn compile et le package mvn réussissent tous les deux, mais l’exécution du programme a pour résultat:

Exception in thread "main" Java.lang.Error: Unresolved compilation problems:
        LibraryStuff cannot be resolved to a type

Ceci est après l'édition du POM en tant que:

<dependency>
  <groupId>stuff</groupId>
  <artifactId>library</artifactId>
  <version>1.0</version>
  <systemPath>${lib.location}/MyLibrary.jar</systemPath>
  <scope>system</scope>
</dependency>

Devrais-je exécuter mvn install: install-file alors que j’avais déjà le fichier pom.xml modifié comme ci-dessus?

Merci!

javamaven-2mavenm2eclipse
123
Alexandr Kurilin

Je pense que vous devriez utiliser mvn install:install-file pour renseigner votre référentiel local avec les fichiers jar de la bibliothèque, puis vous devez changer la portée du système en compilation.

Si vous commencez avec maven, je suggère d'utiliser directement les plugins maven et non IDE car cela ajoute une couche supplémentaire de complexité.

En ce qui concerne l’erreur, placez-vous les fichiers JAR requis sur votre classpath? Si vous utilisez des types de la bibliothèque, vous devez également y avoir accès lors de l'exécution. Cela n'a rien à voir avec Maven lui-même.

Je ne comprends pas pourquoi vous voulez mettre la bibliothèque en contrôle de source - il s’agit de code source et non de binaires binaires. 

58
stalker

Vous pouvez créer un référentiel In Project, de sorte que vous n'ayez pas à run mvn install:install-file chaque fois que vous travaillez sur un nouvel ordinateur.

<repository>
    <id>in-project</id>
    <name>In Project Repo</name>
    <url>file://${project.basedir}/libs</url>
</repository>

<dependency>
    <groupId>dropbox</groupId>
    <artifactId>dropbox-sdk</artifactId>
    <version>1.3.1</version>
</dependency>

/groupId/artifactId/version/artifactId-verion.jar

détail lire cet article

http://charlie.cu.cc/2012/06/how-add-external-libraries-maven/

187
Charlie Wu

Le manuel Maven dit de faire ceci:

mvn install:install-file -Dfile=non-maven-proj.jar -DgroupId=some.group -DartifactId=non-maven-proj -Dversion=1 -Dpackaging=jar
24
Vladislav Rastrusny

Ceci peut être facilement réalisé en utilisant l'élément <scope> imbriqué dans l'élément <dependency>.

Par exemple:

 <dependencies>
   <dependency>
     <groupId>ldapjdk</groupId>
     <artifactId>ldapjdk</artifactId>
     <scope>system</scope>
     <version>1.0</version>
     <systemPath>${basedir}\src\lib\ldapjdk.jar</systemPath>
   </dependency>
 </dependencies>

Référence: http://www.tutorialspoint.com/maven/maven_external_dependencies.htm

21
Jignesh Gohel

update Nous avons depuis installé notre propre serveur Nexus, beaucoup plus facile et plus propre.

Dans notre entreprise, nous avions des pots qui étaient communs mais qui n'étaient pas hébergés dans des dépôts Maven, nous ne voulions pas non plus les avoir dans un stockage local. Nous avons créé un référentiel mvn (public) très simple sur Github (mais vous pouvez l’héberger sur n’importe quel serveur ou localement):
note que cela n’est idéal que pour gérer quelques fichiers jar rarement copiés

  1. Créer un repo sur GitHub:
    https://github.com/<user_name>/mvn-repo/

  2. Ajouter un référentiel dans pom.xml 
    (Notez que le fichier brut du chemin complet sera un peu différent du nom du référentiel)

    <repository>
    <id>project-common</id>
    <name>Project Common</name>
    <url>https://github.com/<user_name>/mvn-repo/raw/master/</url>
</repository>

  3. Ajouter une dépendance à l'hôte (Github ou serveur privé)
    une. Tout ce que vous devez savoir, c'est que les fichiers sont stockés dans le modèle mentionné par @glitch
    /groupId/artifactId/version/artifactId-version.jar
    b. Sur votre hôte, créez les dossiers correspondant à ce modèle.
    Si vous avez un fichier jar nommé service-sdk-0.0.1.jar, créez le dossier service-sdk/service-sdk/0.0.1/ et placez-y le fichier jar service-sdk-0.0.1.jar.
    c. Testez-le en essayant de télécharger le fichier jar depuis un navigateur (dans notre cas: https://github.com/<user_name>/mvn-repo/raw/master/service-sdk/service-sdk/0.0.1/service-sdk-0.0.1.jar

  4. Ajoutez une dépendance à votre fichier pom.xml:

    <dependency>
    <groupId>service-sdk</groupId>
    <artifactId>service-sdk</artifactId>
    <version>0.0.1</version>
</dependency>

  5. Prendre plaisir

20
Kenny Cason

N'utilisez pas systemPath. Contrairement à ce que les gens ont dit ici, vous pouvez placer un fichier jar externe dans un dossier situé dans le répertoire de votre projet extrait et le retrouver comme tout autre dépendance. Voici deux étapes cruciales:

  1. Utilisez "mvn install: install-file" avec -DlocalRepositoryPath.
  2. Configurez un référentiel pour qu'il pointe vers ce chemin dans votre POM.

C'est assez simple et vous pouvez trouver un exemple étape par étape ici: http://randomizedsort.blogspot.com/2011/10/configuring-maven-to-use-local-library.html

11
Nehc

Si vous rencontrez le même problème et que vous utilisez spring-boot v1.4 + , vous pouvez le faire de cette manière.

Il existe un includeSystemScope que vous pouvez utiliser pour ajouter des dépendances de la portée du système au jar.

par exemple.

J'utilise le pilote Oracle dans mon projet.

<dependency>
        <groupId>com.Oracle</groupId>
        <artifactId>ojdbc14</artifactId>
        <version>10.2.0.3.0</version>
        <scope>system</scope>
        <systemPath>${project.basedir}/src/main/resources/extra-jars/ojdbc14-10.2.0.3.0.jar</systemPath>
    </dependency>

faites alors includeSystemScope = true pour inclure le fichier jar dans le chemin/BOOT-INF/lib/**

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <includeSystemScope>true</includeSystemScope>
    </configuration>
</plugin>

et exclure de la ressource pour éviter les doublons, le pot est assez gros ~

<build>
    <testSourceDirectory>src/test/Java</testSourceDirectory>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <excludes>
                <exclude>**/*.jar</exclude>
            </excludes>
        </resource>
    </resources>
</build>

Bonne chance!

5
chendu

_ {Méthode Maven pour ajouter des pots non Maven au projet Maven} _

Projet Maven et bocaux non Maven

_ {Ajoutez les plugins d'installation maven dans votre section de construction)

<plugin>
        <groupId>org.Apache.maven.plugins</groupId>
        <artifactId>maven-install-plugin</artifactId>
        <version>${version.maven-install-plugin}</version>
        <executions>

            <execution>
                <id>install-external-non-maven1-jar</id>
                <phase>clean</phase>
                <configuration>
                    <repositoryLayout>default</repositoryLayout>
                    <groupId>jar1.group</groupId>
                    <artifactId>non-maven1</artifactId>
                    <version>${version.non-maven1}</version>
                    <file>${project.basedir}/libs/non-maven1.jar</file>
                    <packaging>jar</packaging>
                    <generatePom>true</generatePom>
                </configuration>
                <goals>
                    <goal>install-file</goal>
                </goals>
            </execution>
            <execution>
                <id>install-external-non-maven2-jar</id>
                <phase>clean</phase>
                <configuration>
                    <repositoryLayout>default</repositoryLayout>
                    <groupId>jar2.group</groupId>
                    <artifactId>non-maven2</artifactId>
                    <version>${version.non-maven2}</version>
                    <file>${project.basedir}/libs/non-maven2.jar</file>
                    <packaging>jar</packaging>
                    <generatePom>true</generatePom>
                </configuration>
                <goals>
                    <goal>install-file</goal>
                </goals>
            </execution>
            <execution>
                <id>install-external-non-maven3-jar</id>
                <phase>clean</phase>
                <configuration>
                    <repositoryLayout>default</repositoryLayout>
                    <groupId>jar3.group</groupId>
                    <artifactId>non-maven3</artifactId>
                    <version>${version.non-maven3}</version>
                    <file>${project.basedir}/libs/non-maven3.jar</file>
                    <packaging>jar</packaging>
                    <generatePom>true</generatePom>
                </configuration>
                <goals>
                    <goal>install-file</goal>
                </goals>
            </execution>
        </executions>
    </plugin>

_ {Ajouter la dépendance} _

<dependencies>
    <dependency>
        <groupId>jar1.group</groupId>
        <artifactId>non-maven1</artifactId>
        <version>${version.non-maven1}</version>
    </dependency>
    <dependency>
        <groupId>jar2.group</groupId>
        <artifactId>non-maven2</artifactId>
        <version>${version.non-maven2}</version>
    </dependency>
    <dependency>
        <groupId>jar3.group</groupId>
        <artifactId>non-maven3</artifactId>
        <version>${version.non-maven3}</version>
    </dependency>
</dependencies>

Références Note je suis le propriétaire du blog

5
craftsmannadeem

Changez votre systemPath .

<dependency>
  <groupId>stuff</groupId>
  <artifactId>library</artifactId>
  <version>1.0</version>
  <systemPath>${project.basedir}/MyLibrary.jar</systemPath>
  <scope>system</scope>
</dependency>
4
Aung Myat Hein

Le fichier pom.xml examinera votre référentiel local pour essayer de trouver la dépendance qui correspond à votre artefact. De plus, vous ne devriez pas vraiment utiliser les attributs scope et systemPath du système, ceux-ci sont normalement réservés aux éléments contenus dans le JDK et non au JRE.

Voir cette question pour savoir comment installer des artefacts Maven.

3
Tim Sparg

Notez que tous les exemples qui utilisent 

<repository>...</respository>

besoin extérieur 

<repositories>...</repositories>

balises fermantes. Ce n'est pas clair d'après certains exemples.

2
user3897528

La meilleure solution ici consiste à installer un référentiel: Nexus ou Artifactory. Si vous donne un endroit pour mettre des choses comme ça, et plus loin, cela accélère les choses en mettant vos objets en cache de l'extérieur.

Si la chose que vous traitez est open source, vous pourriez aussi envisager de mettre au centre.

Voir le guide .

2
bmargulies

Avec Eclipse Oxygen, vous pouvez effectuer les tâches suivantes:

  1. Placez vos bibliothèques dans WEB-INF/lib
  2. Projet -> Configurer le chemin de construction -> Ajouter une bibliothèque -> Bibliothèque d'applications Web

Maven les prendra lors de l'installation du projet.

0
Rick

Si le fichier jar externe n’est créé que par un projet Maven, vous pouvez alors copier l’ensemble du projet sur votre système et exécuter une opération. 

mvn install

dans le répertoire du projet. Cela ajoutera le fichier jar dans le répertoire .m2, qui est le référentiel maven local. 

Maintenant, vous pouvez ajouter le 

<dependency>
     <groupId>copy-from-the=maven-pom-of-existing-project</groupId>
     <artifactId>copy-from-the=maven-pom-of-existing-project</artifactId>
     <version>copy-from-the=maven-pom-of-existing-project</version>
</dependency>

Cela garantira que vous 

mvn exec:Java

travaux. Si vous utilisez suggéré ici 

<scope>system</scope>

Ensuite, vous devrez ajouter des classes individuellement lors de l’exécution en ligne de commande.

Vous pouvez ajouter les fichiers externes en exécutant la commande décrite ici

mvn install:install-file -Dfile=<path-to-file> -DgroupId=<group-id> \
-DartifactId=<artifact-id> -Dversion=<version> -Dpackaging=<packaging>
0
Bug Killer