J'ai un projet qui contient un seul module et quelques dépendances. Je voudrais créer un pot, dans un répertoire séparé, qui contient le module compilé. De plus, j'aimerais avoir les dépendances à côté de mon module.

Peu importe comment je tord le processus "build jar" d'IntelliJ, la sortie de mon module semble vide (en plus d'un fichier META-INF).

Voici comment créer un bocal avec IntelliJ 10 http://blogs.jetbrains.com/idea/2010/08/quickly-create-jar-artifact/

File-> Project Structure-> Project Settings-> Artifacts-> Cliquez sur green plus sign-> Jar->From modules with dependencies...

Ce qui précède définit le "squelette" à l'endroit où le pot sera enregistré. Pour le construire et l'enregistrer, procédez comme suit:

Extraire dans le pot cible

D'accord

Construire | Construire un artefact | Construire

Essayez d'extraire le fichier .jar de

ProjectName | out | artefacts | ProjectName_jar | ProjectName.jar

C'est toujours un problème en 2017, j'espère que cela aidera quelqu'un là-bas! J'ai trouvé 2 possibilités pour créer des pots de travail sous IntelliJ 2017.2

1. Création d'artefact à partir d'IntelliJ:

• Accédez à la structure du projet:

• Créez un nouvel artefact:

• Sélectionnez la classe principale et assurez-vous de modifier le dossier manifeste:

Vous devez changer le répertoire du manifeste:

<project folder>\src\main\java 

remplacer "java" par "resources"

<project folder>\src\main\resources

Voici à quoi cela devrait ressembler:

• Ensuite, vous choisissez les dépendances ce que vous voulez emballer dans votre pot, ou près de votre fichier pot

• Pour construire votre artefact, allez à construire des artefacts et choisissez "reconstruire". Il créera un dossier "out" avec votre fichier jar et ses dépendances.

2. Utilisation du plugin maven-assembly-plugin

Ajouter une section de construction au fichier pom

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <finalName>ServiceCreate</finalName>
                    <appendAssemblyId>false</appendAssemblyId>
                    <archive>
                        <manifest>
                            <mainClass>com.svt.optimoo.App</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

• Créez une nouvelle configuration d'exécution / débogage:

• Choisissez l'application:

• Remplissez le formulaire
• Ajouter l'objectif maven "assembly: single" après la dernière génération à exécuter

• Enregistrez-le, puis exécutez

Cette procédure créera le fichier jar sous le dossier "target"

J'ai récemment rencontré ce problème et je pense que ces étapes sont faciles à suivre si une solution ou un lien antérieur manque de détails.

Comment créer un .jarutilisant IntelliJ IDEA 14.1.5:

1. Fichier> Enregistrer tout.
2. Exécutez le pilote ou la classe avec la méthode principale.
3. Fichier> Structure du projet.
4. Sélectionnez l'onglet "Artefacts".
5. Cliquez sur le bouton vert plus en haut de la fenêtre.
6. Sélectionnez JAR dans le menu déroulant Ajouter. Sélectionnez "A partir de modules avec dépendances"
7. Sélectionnez la classe principale.
8. Le bouton radio doit sélectionner "extraire vers le fichier JAR cible". Appuyer sur OK.
9. Cochez la case "Construire sur marque"
10. Appuyez sur Appliquer et OK.
11. Dans le menu principal, sélectionnez la liste déroulante de génération.
12. Sélectionnez l'option construire des artefacts.

Pour ceux qui bénéficient des images comme moi:

File -> Project Structure

Voici 2 exemples avec le projet maven, étape par étape:

Méthode 1: construire un pot avec maven et pom.xml

1. Fichier, nouveau, projet, maven
2. créer un package, créer un programme java à l'intérieur de ce package

3. sur pom.xml, ajoutez maven-jar-plugin.

       <plugin>
           <!-- Build an executable JAR -->
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-jar-plugin</artifactId>
           <version>3.1.0</version>
           <configuration>
               <archive>
                   <manifest>
                       <addClasspath>true</addClasspath>
                       <classpathPrefix>lib/</classpathPrefix>
                       <mainClass>somePackage.sample</mainClass>
                   </manifest>
               </archive>
           </configuration>
       </plugin>
   

capture d'écran: 4. ouvrez la boîte de projet maven en cliquant sur l'icône de recherche et tapez maven,

5. cliquez sur nettoyer, puis cliquez sur installer

6. votre fichier jar apparaîtra dans le dossier cible

7. testez votre pot en utilisant java -jar

Méthode 2: créer un pot avec maven sans modification de pom.xml

1. Fichier, nouveau, projet, maven
2. créer un package, créer un programme java à l'intérieur de ce package (comme ci-dessus)
3. File-> Project Structure-> Project Settings-> Artifacts-> Cliquez sur green plus sign-> Jar->From modules with dependencies

Très important!

Le MANIFEST.MF doit se trouver dans votre dossier de ressources et le Main.Class doit faire référence à {package} - {class-name-that-contains-main-class}

4. puis cliquez sur construire dans le menu, construire des artefacts, construire

5. trouver le pot dans le dossier out

6. exécuter :)

Il est probablement un peu tard, mais j'ai réussi à le résoudre de cette façon -> ouvrir avec winrar et supprimer ECLIPSEF.RSA et ECLIPSEF.SF dans le dossier META-INF, en plus mettre "Main-class: main_class_name" (sans ".class" ) dans MANIFEST.MF. Assurez-vous d'avoir appuyé deux fois sur "Entrée" après la dernière ligne, sinon cela ne fonctionnera pas.

Lorsque j'utilise ces solutions, cette erreur arrive:

java -jar xxxxx.jar

aucun attribut manifeste principal, dans xxxxx.jar

et la solution est :

Vous devez changer le répertoire du manifeste:

<project folder>\src\main\java 

changer java en ressources

<project folder>\src\main\resources

J'essayais de construire un pot à partir d'une application Kotlin multi-module et j'obtenais l'erreur notoire `` aucun attribut manifeste principal ''. La création du répertoire manifeste dans src/main/resourcesn'a pas fonctionné non plus.

Au lieu de cela, il fonctionne lors de la création en srcdirect: src/META-INF/MANIFEST.MF.

Comme le disent les gens ci-dessus, mais je dois noter un point. Vous devez cocher la case:

Inclure dans la construction du projet

Idée 8.1.3

Jar est ok, car il y a une sortie compilée dans le répertoire 'output' (project / out / production //)

Je suppose que vous devez exécuter «make» avant de construire le pot

pour les dépendances il suffit de cocher "afficher la bibliothèque" et de choisir ce que vous voulez.

Avec Maven, vous pouvez utiliser ce plugin:

 <build>
    <plugins>

        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>[path you class main]</mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase> 
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Vous voudrez peut-être jeter un œil à Maven ( http://maven.apache.org ). Vous pouvez l'utiliser soit comme processus de construction principal de votre application, soit simplement pour effectuer certaines tâches via la boîte de dialogue Modifier les configurations. Le processus de création d'un JAR d'un module dans Maven est assez trivial, si vous voulez qu'il inclue toutes les dépendances dans un JAR auto-exécutable qui est également trivial.

Si vous n'avez jamais utilisé Maven auparavant, vous voulez lire Better Builds With Maven .

Si vous utilisez des bibliothèques tierces avec votre projet ou si vous rencontrez des problèmes pour créer correctement le fichier MANIFEST.MF, il peut y avoir des conflits lors de l'exécution de fichiers JAR générés à l'aide de

File > Project Structure > Artifacts > '+' > JAR > From modules with dependencies > .....

méthode mentionnée ci-dessus.

Au lieu de cela, je vous suggère de créer un JAR vide et d'ajouter manuellement tous les autres éléments à la racine de sortie. Un merveilleux article de blog pour cette méthode peut être trouvé ici: http://karthicraghupathi.com/2016/07/10/creating-an-executable-jar-in-intellij-idea/ J'ai essayé les étapes mentionnées ici et tout a bien fonctionné pour moi!

Certaines des autres réponses sont inutiles car dès que vous réimportez le projet IntelliJ IDEA à partir du projet maven, toutes les modifications seront perdues.

La construction du bocal doit être déclenchée par une configuration d'exécution / débogage, et non par les paramètres du projet.

Jetbrains a une belle description de la façon dont vous pouvez accomplir cela ici:

https://www.jetbrains.com/help/idea/maven.html

Faites défiler jusqu'à la section intitulée «Configuration des déclencheurs pour les objectifs Maven».

(Le seul inconvénient de leur description est que leurs captures d'écran sont dans le jeu de couleurs noir sur blanc par défaut au lieu du thème super génial de Darcula. Ugh!)

Donc, en gros, ce que vous faites, c'est que vous ouvrez le panneau "Projets Maven", vous trouvez le projet qui vous intéresse, (dans votre cas, le projet qui construit votre pot), en dessous, vous trouvez l'objectif maven que vous voulez exécuter , (généralement l'objectif "package" crée des fichiers jars), vous ouvrez le menu contextuel sur celui-ci, (cliquez avec le bouton droit sur une machine Windows) et il y aura une option "Exécuter avant d'exécuter / déboguer ..." que vous pouvez sélectionnez et il vous prendra par la main à partir de là. Vraiment facile.

Dans le cas où vous essayez de construire un pot avec kotlin, vous devez créer un src/main/javadossier et utiliser ce dossier comme emplacement pour le dossier META-INF.

Voici la réponse officielle de l' aide IntelliJ IDEA 2018.3 . J'ai essayé et ça a marché.

Pour construire un fichier JAR à partir d'un module;

1. Dans le menu principal, choisissez Build | Construisez un artefact.

2. Dans la liste déroulante, sélectionnez l'artefact souhaité du type JAR. La liste affiche tous les artefacts configurés pour le projet en cours. Pour que tous les artefacts configurés soient créés, choisissez l'option Générer tous les artefacts.

Mon problème était le suivant: j'ai utilisé Intellij IDEA (essayé différentes versions) + Gradle. Quand j'ai compilé le projet et construit le pot artifacf, comme indiqué dans les réponses ci-dessus, j'ai reçu une erreur - "aucun manifeste principal attrubute ..."

Cette solution a fonctionné pour moi (merci à Thilina Ashen Gamage (voir ci-dessus) pour un conseil):

Extrait - si vous utilisez des bibliothèques externes et créez un projet via Paramètres du projet - Artefacts - Ajouter (+) - Pot - À partir de modules avec des dépendances , alors probablement en raison d'un bogue de programme, le dossier META-INF avec le fichier MANIFEST_MF ne comprend pas dans le bocal. Pour éviter cela, créez un fichier jar VIDE .

Paramètres du projet - Artefacts - Ajouter (+) - Jar - JAR VIDE . Le dossier META-INF sera ajouté au dossier des ressources . Sélectionnez ensuite votre classe principale. Vous verrez la structure du pot suivante: Notez la présence d'un dossier META-INF Ensuite, vous pouvez construire votre projet et construire des artefacts. Cette solution a également fonctionné pour les applications javaFX.

Si vous travaillez sur un projet spring / mvn, vous pouvez utiliser cette commande:

mvn package -DskipTests

Le fichier jar sera enregistré dans le répertoire cible.

Ant et Maven sont largement utilisés. Je préfère Ant, je pense que c'est plus léger et vous le développeur êtes plus en contrôle. Certains suggèrent que c'est son inconvénient :-)