Premiers pas avec Maven

Others 2021-04-01 08:56:55 views: null

table des matières

Préface

Démarrage rapide de Maven

Préparation pom.xml

Ecrire le code principal du projet

Écrire le code de test

Package et exécuter

Coordonnées et dépendances Maven

Coordonnées détaillées

Configuration de base dépendante

Résumé des commandes couramment utilisées par Maven

Préface

J'ai spécialement étudié les connaissances de base de Maven auparavant, mais je n'ai pas noté la signification de nombreuses balises de base à ce moment-là. Par conséquent, je ne me souviens pas du tout de la signification de nombreuses balises de base et je n'ai nulle part où la trouver Je ne peux que relire le livre. Il est très encombrant et je fais ce dont j'ai besoin. Un résumé d'introduction simple.

 

Démarrage rapide de Maven

Préparation pom.xml

Commencez par créer un projet maven, puis nous examinons le cœur de maven, pom.xml. POM (Project Object Model, Project Object Model) définit les informations de base du projet, utilisées pour décrire comment le projet est construit, déclarer les dépendances du projet, etc. Ce qui suit est le pom.xml du projet hello-world que je viens de créer:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.qingcha.maven</groupId>
    <artifactId>hello-world</artifactId>
    <version>1.0-SNAPSHOT</version>


</project>

La première ligne du code est l'en-tête XML, qui spécifie la version et le codage du document xml. L'élément project est suivi de l'élément project. Le projet est l'élément racine de tout pom.xml. Il déclare également certains espaces de noms et éléments xsd liés à pom. Bien que ces attributs ne soient pas obligatoires, l'utilisation de ces attributs autorise l'utilisation de tiers des outils (tels que ide L'éditeur xml in) nous aide à éditer le pom rapidement.

Le premier élément enfant modelVersion sous l'élément racine spécifie la version du modèle pom actuel. Pour Maven 2 et Maven 3, il ne peut s'agir que de 4.0.0.

Le plus important est les trois sous-éléments suivants: groupId, artifactId et version. Ils définissent conjointement les coordonnées de base d'un projet . Dans le monde de Maven, tout pot, pom ou guerre est distingué en fonction de ces coordonnées de base.

Le groupId définit le groupe auquel appartient le projet . Ce groupe est souvent associé à l'organisation ou à la société où se trouve le projet. Par exemple, si un projet nommé myapp est créé sur googlecode, le groupId doit être com.googlecode.myapp.

L'artéfactId définit l'ID unique du projet Maven actuel dans le groupe , et différents sous-projets (modules) du groupe se voient souvent attribuer des ID uniques différents.

version spécifie la version actuelle du projet actuel --- 1.0-SNAPSHOT , SNAPSHOT signifie instantané, indiquant que le projet est toujours en développement et est une version instable. Au fur et à mesure que le projet se développe, la version sera continuellement mise à jour, comme la mise à niveau vers 1.0, 1.1-SNAPSHOT, 1.1, etc.

Ecrire le code principal du projet

Le code principal du projet est différent du code de test. Le code principal sera empaqueté dans le composant final (tel que jar), tandis que le code de test n'est utilisé que lorsque le test est en cours d'exécution et ne sera pas empaqueté. Par défaut, Maven suppose que le code principal du projet se trouve dans le répertoire src / main / java . Tant que la convention est respectée, aucune configuration supplémentaire n'est requise. Maven recherchera automatiquement dans ce répertoire pour trouver le code principal du projet, nous devons donc suivre la convention Maven et le créer dans ce répertoire. Notre propre fichier: com / qingcha / maven / helloworld / HelloWorld.java, son contenu est le suivant:

package com.qingcha.maven.helloworld;

public class HelloWorld {

    public String sayHello() {
        return "hello, world";
    }

    public static void main(String[] args) {
        System.out.println(new HelloWorld().sayHello());
    }
}

Une chose à noter ici est que le package de classes Java dans le projet doit être basé sur le groupId et l'artifactId du projet , ce qui est plus clair, plus logique et pratique pour rechercher des composants ou des classes Java.

Une fois le code écrit, utilisez maven pour compiler, exécutez la commande dans le répertoire racine du projet: mvn clean compile, puis vous verrez la console afficher les informations suivantes

[INFO] Scanning for projects...
[INFO] 
[INFO] -------------------< com.qingcha.maven:hello-world >--------------------
[INFO] Building hello-world 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ hello-world ---
[INFO] Deleting /project/Open-source/helloworld/target
[INFO] 
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ hello-world ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ hello-world ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding UTF-8, i.e. build is platform dependent!
[INFO] Compiling 1 source file to /project/Open-source/helloworld/target/classes
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.050 s
[INFO] Finished at: 2020-01-04T12:46:11+08:00
[INFO] ------------------------------------------------------------------------

À partir des informations de sortie, maven effectue principalement trois opérations:

  • clean task: utilisez le plugin clean pour supprimer d'abord le répertoire target /, par défaut toute la sortie de la build maven se trouve dans le répertoire target /
  • tâche de ressources: comme nous n'avons pas défini de ressources de projet, ignorez-la ici
  • tâche de compilation: compilez le code principal du projet dans le répertoire target / classes

Écrire le code de test

Afin de rendre la structure du projet claire, le code principal du projet et le code de test doivent être situés dans des répertoires séparés. Le répertoire du code principal mentionné ci-dessus est src / main / java, correspondant à Maven

Le répertoire de code de test par défaut dans le projet est src / test / java , nous devons donc également suivre la convention pour créer nos classes de test dans ce répertoire. Bien sûr, pour tester d'abord, vous devez introduire des dépendances. Généralement, le projet junit est utilisé en java. Les dépendances sont les suivantes

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.qingcha.maven</groupId>
    <artifactId>hello-world</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

L'élément dependencies est ajouté au fichier XML ci-dessus. Cet élément peut contenir plusieurs éléments de dépendance pour déclarer les dépendances du projet. Ici, les dépendances de junit sont ajoutées. D'après les connaissances précédentes, nous savons déjà que groupId, artifactId et version constituent le plus basique d'un projet Maven. Avec cette déclaration, Maven peut télécharger automatiquement junit-4.12.jar (à télécharger depuis l'entrepôt central de Maven).

Il y a aussi un élément scope derrière, scope est l'étendue de la dépendance . Si l' étendue de la dépendance est test, cela signifie que la dépendance n'est valide que pour le test. En d'autres termes, l'utilisation du code junit dans le code de test ne pose aucun problème, mais l'utilisation du code junit dans le code principal provoquera des erreurs de compilation. Si vous ne déclarez pas cet élément, la portée par défaut est compile, ce qui signifie que la dépendance est valide pour le code principal et le code de test. Sera présenté en détail ci-dessous

L'étape suivante consiste à créer la classe de test. Sous la version mac d'idée, placez la souris sous le nom de la classe à créer, puis appuyez sur option + entrée pour créer rapidement la classe de test. Le code simple de la classe de test est comme suit:

package com.qingcha.maven.helloworld;

import org.junit.Assert;
import org.junit.Test;

public class HelloWorldTest {

    @Test
    public void sayHello() {
        HelloWorld helloWorld = new HelloWorld();
        Assert.assertEquals("hello, world", helloWorld.sayHello());
    }
}

Ensuite, nous utilisons Maven pour exécuter le test, exécuter le test mvn clean, les informations de sortie sont les suivantes:

[INFO] Scanning for projects...
[INFO] 
[INFO] -------------------< com.qingcha.maven:hello-world >--------------------
[INFO] Building hello-world 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ hello-world ---
[INFO] Deleting /project/Open-source/helloworld/target
[INFO] 
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ hello-world ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ hello-world ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding UTF-8, i.e. build is platform dependent!
[INFO] Compiling 1 source file to /project/Open-source/helloworld/target/classes
[INFO] 
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ hello-world ---
[WARNING] Using platform encoding (UTF-8 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory /project/Open-source/helloworld/src/test/resources
[INFO] 
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ hello-world ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding UTF-8, i.e. build is platform dependent!
[INFO] Compiling 1 source file to /project/Open-source/helloworld/target/test-classes
[INFO] 
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ hello-world ---
[INFO] Surefire report directory: /project/Open-source/helloworld/target/surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.qingcha.maven.helloworld.HelloWorldTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.069 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.017 s
[INFO] Finished at: 2020-01-04T13:10:58+08:00
[INFO] ------------------------------------------------------------------------

Le succès en bas indique que notre classe de test a réussi l'exécution. En analysant les informations de sortie ci-dessus, Maven a effectué un total de six tâches:

  • clean task: utilisez le plugin clean pour supprimer d'abord le répertoire target /, par défaut toute la sortie de la build maven se trouve dans le répertoire target /
  • tâche de ressources: comme nous n'avons pas défini de ressources de projet, ignorez-la ici
  • tâche de compilation: compilez le code principal du projet dans le répertoire target / classes
  • Tâche testResources: les ressources ne sont pas définies, ignorer
  • Tâche testCompile: compilation de code de test
  • tâche de test: exécuter le test

Package et exécuter

Une fois le projet compilé et testé, l'étape suivante importante consiste à créer un package. Le nouveau projet actuel ne spécifie pas le type de package. Utilisez le type de package par défaut jar. Exécutez simplement la commande mvn clean package to package, et vous pouvez voir le résultat

[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ hello-world ---
[INFO] Building jar: /project/Open-source/helloworld/target/hello-world-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.010 s
[INFO] Finished at: 2020-01-04T13:41:38+08:00
[INFO] ------------------------------------------------------------------------

De même, Maven effectuera des opérations telles que la compilation et les tests avant l'empaquetage , puis exécutera la tâche jar à la fin, c'est-à-dire utilisera le plug-in jar pour générer un package appelé hello-world-1.0-SNAPSHOT.jar à partir du fichier principal code du projet, qui se trouve également dans / Sous le répertoire cible.

À ce stade, nous avons la sortie du projet. Si nécessaire, nous pouvons copier ce fichier jar dans le chemin de classe d'autres projets pour utiliser la classe HelloWorld. Mais comment d'autres projets Maven peuvent-ils référencer directement ce pot? Une étape d'installation supplémentaire est nécessaire, exécutez mvn clean install:

[INFO] --- maven-install-plugin:2.4:install (default-install) @ hello-world ---
[INFO] Installing /project/Open-source/helloworld/target/hello-world-1.0-SNAPSHOT.jar to /Users/xujia/Downloads/mydocument/maven/maven-repository/com/qingcha/maven/hello-world/1.0-SNAPSHOT/hello-world-1.0-SNAPSHOT.jar
[INFO] Installing /project/Open-source/helloworld/pom.xml to /Users/xujia/Downloads/mydocument/maven/maven-repository/com/qingcha/maven/hello-world/1.0-SNAPSHOT/hello-world-1.0-SNAPSHOT.pom
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.009 s
[INFO] Finished at: 2020-01-04T13:48:19+08:00
[INFO] ------------------------------------------------------------------------

De même, lorsque la commande d'installation est exécutée, les tâches de compilation, de test et d'empaquetage seront automatiquement exécutées . À partir des informations de sortie, vous pouvez voir que la tâche d'installation installe le package jar généré par le projet dans l'entrepôt local Maven. Vous pouvez ouvrir le dossier correspondant pour voir le projet HelloWorld Pom et jar. Lorsque nous avons parlé du téléchargement de pom et jar of junit, nous avons dit que seuls les composants peuvent être utilisés par tous les projets Maven après leur téléchargement dans l'entrepôt local . Voici le même principe. Seulement après l'installation des composants de HelloWorld dans l'entrepôt local, autre Maven Le projet peut l'utiliser.

Le package jar généré par l'empaquetage par défaut ne peut pas être exécuté directement, car les informations de classe avec la méthode main ne seront pas ajoutées au manifeste (ouvrez le fichier META-INF / MANIFEST.MF dans le fichier jar, vous ne pourrez pas voir la ligne Main-Class), afin de générer un fichier jar exécutable, nous devons utiliser le plugin maven-shade-plugin (il existe de nombreuses façons de générer un package jar exécutable, si vous êtes intéressé, vous pouvez le google vous-même) , configurez le plugin comme suit:

<build>
                    <!-- 两种方式可以生成可执行jar包 -->
            <!--<plugin>-->
                <!--<groupId>org.apache.maven.plugins</groupId>-->
                <!--<artifactId>maven-shade-plugin</artifactId>-->
                <!--<version>3.2.1</version>-->
                <!--<executions>-->
                    <!--<execution>-->
                        <!--<phase>package</phase>-->
                        <!--<goals>-->
                            <!--<goal>shade</goal>-->
                        <!--</goals>-->
                        <!--<configuration>-->
                            <!--<transformers>-->
                                <!--<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">-->
                                    <!--<mainClass>com.qingcha.maven.helloworld.HelloWorld</mainClass>-->
                                <!--</transformer>-->
                            <!--</transformers>-->
                        <!--</configuration>-->
                    <!--</execution>-->
                <!--</executions>-->
            <!--</plugin>-->

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.qingcha.maven.helloworld.HelloWorld</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>
    </build>

Maintenant, exécutez à nouveau mvn clean install, vous verrez hello-world-1.0-SNAPSHOT.jar et original-hello-world-1.0-SNAPSHOT.jar dans le répertoire / target, le premier est exécutable avec le pot d'informations Main-Class, le dernier est le bocal d'origine. Ouvrez le META-INF / MANIFEST.MF de hello-world-1.0-SNAPSHOT.jar, vous pouvez voir qu'il contient les informations de la classe principale et vous pouvez déterminer où se trouve l'entrée du programme (La commande à décompresser le package jar est: jar xvf hello-world-1.0-SNAPSHOT.jar)

Manifest-Version: 1.0
Archiver-Version: Plexus Archiver
Built-By: xujia
Created-By: Apache Maven 3.5.4
Build-Jdk: 1.8.0_172
Main-Class: com.qingcha.maven.helloworld.HelloWorld

Enfin, exécutez le package jar: java -jar hello-world-1.0-SNAPSHOT.jar, vous pouvez voir la sortie de la console bonjour, monde, parfait ~

 

Coordonnées et dépendances Maven

Coordonnées détaillées

Les coordonnées Maven introduisent l'ordre pour divers composants, chaque composant doit clairement définir ses propres coordonnées, et un groupe de coordonnées Maven est défini par certains éléments, ils sont groupId, artifactId, version, packaging, classifier, donnez d'abord un groupe Les coordonnées sont définies comme suit:

<groupId>org.sonatype.nexus</groupId>
<artifactId>nexus-indexer</artifactId>
<version>2.0.0</version>
<packaging>jar</packaging>

Expliquons chaque élément de coordonnées en détail ci-dessous

  • groupId : définissez le projet réel auquel appartient le projet Maven actuel. Tout d'abord, il n'y a pas nécessairement de relation univoque entre le projet Maven et le projet proprement dit. Par exemple, le projet actuel de springframework a de nombreux projets Maven, tels que spring-core, spring-context, etc. Par conséquent, un projet réel est souvent divisé en plusieurs modules, ce qui est similaire au concept de groupe que nous avons mentionné ci-dessus. Deuxièmement, le groupId ne doit pas correspondre à l'organisation ou à la société à laquelle appartient le projet, car il existe de nombreux projets réels sous une organisation. Si le groupId est uniquement défini au niveau de l'organisation, alors l'artefactId ne peut définir que le projet Maven, alors le niveau réel du projet sera difficile à définir. Enfin, la représentation de groupId est similaire à la représentation des noms de package Java, généralement dans une correspondance biunivoque avec le nom de domaine. Dans l'exemple ci-dessus, le groupId est org.sonatype.nexus, org.sonatype représente une organisation à but non lucratif créée par Sonatype, nexus identifie le projet réel Nexus et le groupId correspond au nom de domaine nexus.sonatype.org.
  • artifactId : cet élément définit un projet Maven (module) dans le projet réel. L'approche recommandée consiste à utiliser le nom du projet réel comme préfixe de artifactId, tel que nexus-indexer dans l'exemple ci-dessus.
  • version : Cet élément définit la version actuelle du projet Maven. Par exemple, la version de nexus-indexer dans l'exemple ci-dessus est 2.0.0.
  • packaging : cet élément définit comment le projet Maven est packagé. Premièrement, la méthode d'empaquetage correspond généralement à l'extension de fichier du composant généré. Si l'empaquetage est jar dans l'exemple ci-dessus, le nom de fichier final est nexus-indexer-2.0.0.jar. Pour les projets Maven qui utilisent l'empaquetage de guerre, il y aura un fichier .war dans le composant final généré, mais ce n'est pas absolu. Deuxièmement, la méthode d'emballage affectera le cycle de vie de la construction. Par exemple, l'emballage en pot et l'emballage de guerre utiliseront des commandes différentes. Enfin, lorsque l'empaquetage n'est pas défini, Maven utilisera la valeur jar
  • classifier : cet élément est utilisé pour aider à définir certains composants auxiliaires de la sortie de construction. Le composant auxiliaire correspond au composant principal. Par exemple, le composant principal de l'exemple ci-dessus est nexus-indexer-2.0.0.jar. Le projet peut également générer nexus-indexer-2.0.0-javadoc.jar et nexus-indexer - en utilisant des plug-ins 2.0.0-sources.jar Certains composants accessoires incluent la documentation java et le code source. A ce stade, javadoc et les sources sont les classificateurs de ces deux composants accessoires. De cette manière, le composant accessoire a également sa propre coordonnée unique. Notez que vous ne pouvez pas définir directement le classificateur du projet, car les composants accessoires ne sont pas générés directement par le projet par défaut, mais sont générés à l'aide de plug-ins supplémentaires.

Parmi les cinq éléments ci-dessus, groupId, artifactId et version doivent être définis, l'empaquetage est facultatif (jar par défaut) et le classificateur ne peut pas être défini directement.

Configuration de base dépendante

Une déclaration de dépendance peut contenir les éléments suivants:

<project>
    ...
    <dependencies>
        <dependency>
            <groupId>...</groupId>
            <artifactId>...</artifactId>
            <version>...</version>
            <type>...</type>
            <scope>...</scope>
            <optional>...</optional>
            <exclusions>
                ...
                <exclusion>
                    ...
                </exclusion>
            </exclusions>
        </dependency>
        ...
    </dependencies>
    ...
</project>

Les dépendances sous l'élément racine project peuvent contenir un ou plusieurs éléments de dépendance pour déclarer une ou plusieurs dépendances de projet. Les éléments que chaque dépendance peut contenir sont les suivants:

1. groupId, artifactId et version: les coordonnées de base de la dépendance. Pour toute dépendance, les coordonnées de base sont les plus importantes, et Maven peut trouver les dépendances requises en fonction des coordonnées.

2. Type: le type de dépendance, correspondant au packaging défini par les coordonnées du projet. Dans la plupart des cas, cet élément n'a pas besoin d'être déclaré et sa valeur par défaut est jar.

3. Portée: La portée de la dépendance. Il y en a trois qui sont couramment utilisées:

  • compile: Compilez la plage de dépendances, si elle n'est pas spécifiée, la plage de dépendances sera utilisée par défaut. Les dépendances Maven utilisant cette plage de dépendances sont valides pour les trois chemins de classe de compilation, de test et d'exécution
  • test: plage de dépendances de test, uniquement valide pour le chemin de classe de test, ce type de dépendance ne peut pas être utilisé lors de la compilation du code principal ou de l'exécution du projet
  • fourni: la portée de dépendance a été fournie. La dépendance Maven utilisant cette portée de dépendance est valide pour la compilation et le test du chemin de classe, mais non valide au moment de l'exécution. Un exemple typique est servlet-api. Cette dépendance est nécessaire lors de la compilation et du test du projet, mais lors de l'exécution du projet, puisque le conteneur est déjà fourni, il n'est pas nécessaire que Maven l'introduise encore et encore.
  • runtime: plage de dépendances d'exécution, valide pour le test et l'exécution, non valide au moment de la compilation

4. Facultatif: indiquez si la dépendance est facultative. Lorsqu'elle est vraie, cela signifie qu'il s'agit d'une dépendance facultative. Si le projet A dépend du projet B, le projet B dépend des projets X et Y, et les dépendances de B sur X et Y sont facultatives. dépendances, alors X et Y n'auront aucun effet sur A, c'est-à-dire qu'aucun transfert de dépendance n'aura lieu.

5. Exclusions: utilisé pour exclure les dépendances transitives. Il convient de noter que lors de la déclaration d'exclusion, seuls les identifiants groupId et artifactId sont requis, et l'élément version n'est pas nécessaire. En effet, seuls les identificateurs groupId et artifactId sont nécessaires pour localiser de manière unique un dans le graphe de dépendance.

Il y a beaucoup de choses qui dépendent de celui-ci. Pour un bon projet, il est également très important de gérer les dépendances entre plusieurs projets. Le chapitre d'introduction enregistrera ce point en premier.

 

Résumé des commandes couramment utilisées par Maven

  • mvn clean compile: supprimez le répertoire / target et compilez le code principal du projet
  • mvn clean test: exécute tout le code de test
  • mvn clean package -D maven.test.skip = true: package, mais n'exécute ni ne compile les cas de test
  • mvn clean package -U -D skipTests: empaquetez et mettez à jour l'instantané, n'exécutez pas les cas de test, mais compilez les classes de cas de test pour générer les fichiers de classe correspondants sous les classes cible / test.
  • mvn clean install: déployez le package fini dans l'entrepôt maven local pour une utilisation par d'autres projets
  • mvn clean deploy: déployez le package fini dans l'entrepôt maven local et l'entrepôt de serveur privé maven distant
  • dépendance mvn: arborescence: afficher l'arborescence des dépendances
  • mvn dependency: tree -D output = *. txt: affiche l'arborescence des dépendances et affiche l'arborescence dans le texte

 

Je suppose que tu aimes

Origine blog.csdn.net/m0_38001814/article/details/103831721
conseillé
Classement
du quotidien
Plus
2024-06-09(0)
2024-06-08(0)
2024-06-07(0)
2024-06-06(0)
2024-06-05(0)
2024-06-04(2)
2024-06-03(0)
2024-06-02(1)
2024-06-01(0)
2024-05-31(0)

Code World

© 2018 codetd.com