Übersicht und Verwendung von Maven

01. Maven-Übersicht

Lassen Sie mich zunächst schnell das Konzept von Maven klären, damit wir schnell ein genaueres Maven-Anwendungsszenario erstellen können.

Maven ist weder Ameise noch Make Für die Build-Tools, denen ich zuvor ausgesetzt war, muss ich das tun Schreiben Sie einige detaillierte Schritte, z. B.: Kompilieren Sie project1/src/*.java und andere ähnliche Anweisungen.

Maven übernimmt den Ansatz „Konvention vor Konfiguration“ Einige gängige Entwicklungsvorgänge und -schritte wurden in Maven gefestigt, sodass Benutzer diese Anweisungen nicht mehr schreiben müssen.

Maven verfügt über integrierte Unterstützung für den Entwicklungsprozess. Es kann nicht nur kompilieren, sondern auch verpacken und veröffentlichen und alle diese Schritte auf einmal ausführen.

Maven ist nicht Ivy, Abhängigkeitsmanagement ist eine der Funktionen von Maven. Maven fügt der Abhängigkeitsbeziehung das Konzept des Umfangs hinzu und verfeinert die Abhängigkeitsaufteilung weiter Beziehungen.

maven positioniert sich als Projektmanagement-Tool. Es ist für die Verwaltung nahezu aller Aspekte des Projektentwicklungsprozesses verantwortlich.

a. Version: Maven hat seine eigene Versionsdefinition und Regeln

b Maven unterstützt viele Anwendungstypen und für jeden unterstützten Anwendungstyp ist eine Reihe von Build-Regeln und Toolsets definiert

Ausgabeverwaltung:Maven kann Verwalten Sie die vom Projekt erstellten Produkte und fügen Sie sie der Benutzerbibliothek hinzu. Diese Funktion kann für das Lieferverhalten zwischen dem Projektteam und anderen Abteilungen verwendet werden Abhängigkeitsverwirrung und gegenseitige Kontamination während des Entwicklungsprozesses;

e. Dokumentation und Build-Ergebnisse: Mavens Site-Befehl unterstützt die Veröffentlichung verschiedener Dokumentinformationen, einschließlich verschiedener Ausgaben von der Build-Prozess, Javadoc, Produktdokumentation usw.;

f. Projektbeziehung: Ein großes Projekt besteht normalerweise aus mehreren kleinen Projekten oder Modulen leicht zu verwalten mit Maven;

h. Portabilitätsverwaltung: Maven kann verschiedene Arten von Ausgabeergebnissen für verschiedene Entwicklungsszenarien ausgeben;

02. Maven-Lebenszyklus

umfassen: Verifizierung, Kompilierung, Tests, Verpackung und Bereitstellung.

Alle Ausführungsaktionen (Ziele) in Maven müssen ihre Ausführungsposition im Prozess angeben. Wenn Maven dann ausgeführt wird, werden diese Ziele der Reihe nach entsprechend der Entwicklung des Prozesses aufgerufen. Art der Verarbeitung. Dies ist auch ein grundlegender Planungsmechanismus von Maven. Im Allgemeinen hängen nachfolgende Prozesse von vorherigen Prozessen ab.

Natürlich stellt Maven auch Konfigurationsdateien bereit, die je nach Benutzeranforderungen bestimmte Phasen überspringen können.

03. Maven „Konvention ist besser als Konfiguration“

Benutzer müssen diese vereinbarten Inhalte jedoch nicht ändern, es sei denn, dies ist erforderlich.

/Projektverzeichnis pom.xml Konfigurationsdatei für Maven

/src Quellcodeverzeichnis

/src/main Projekt-Quellcode-Verzeichnis

/src/main/java Projekt-Java-Quellcode-Verzeichnis

/ src/main/resource Projektressourcenverzeichnis

/src/test Unit-Testverzeichnis

/src/test/java

/target Ausgabeverzeichnis, alle Ausgaben werden in diesem Verzeichnis gespeichert

/target/classes kompilierte Klassendatei

Jede Phase der Aufgabe weiß, wie sie ihre Arbeit richtig erledigt.

Beispielsweise kann die Kompilierungsaufgabe alle Java-Dateien aus src/main/java kompilieren und ihre Ausgabeklassendateien in target/classes speichern.

Die Übernahme der Strategie „Konvention statt Konfiguration“ kann den Arbeitsaufwand für die Änderung von Konfigurationen reduzieren und die Lernkosten senken. Noch wichtiger ist, dass dadurch einheitliche Spezifikationen in das Projekt eingeführt werden.

04. Maven-Versionsspezifikation

              <groupId>org.springframework</groupId>  <artifactId>spring-webmvc</artifactId>  <version>4.3.7.RELEASE</version>

Maven verwendet 4 Elemente, um eine bestimmte Ausgabe eindeutig zu lokalisieren: groupId:artifactId:packaging:version. Wie zum Beispiel org.springframework:spring:2.5.

groupId Gruppe, Firma, Gruppe, Organisation, Projekt oder andere Gruppe. Die Konvention für eine Gruppen-ID besteht darin, dass sie mit dem umgekehrten Domänennamen der Organisation beginnt, die das Projekt erstellt hat.

artifactId unter groupId stellt die eindeutige Kennung eines einzelnen Projekts dar. Zum Beispiel unser Kater, Commons usw. Fügen Sie keinen Punkt (.) in die Artefakt-ID ein.

Version Eine bestimmte Version eines Projekts. Release-Projekte haben eine feste Versionskennung, die auf eine bestimmte Version des Projekts verweist.

Obwohl das Verpackungsformat des Projekts auch ein wichtiger Teil der Maven-Koordinaten ist, ist es nicht Teil der eindeutigen Kennung des Projekts.

Die Gruppen-ID:Artefakt-ID:Version eines Projekts macht es zu einem eindeutigen Projekt. Sie können nicht gleichzeitig ein Projekt mit derselben Gruppen-ID, Artefakt-ID und denselben Versionskennungen haben.

Verpackung Der Typ des Projekts, der Standardwert ist jar, der die Ausgabe des Projekts nach dem Packen beschreibt.

Maven kann während der Versionsverwaltung mehrere spezielle Zeichenfolgen SNAPSHOT, LATEST, RELEASE verwenden.

Zum Beispiel „1.0-SNAPSHOT“. Die Bedeutung und Verarbeitungslogik jedes Teils ist wie folgt:

SCHNAPPSCHUSS: wird im Entwicklungsprozess verwendet und Maven wird installiert oder veröffentlicht Diese Komponente wird beim Erweitern des Symbols in einen Datums- und Uhrzeitwert in UTC-Zeit konvertiert.

Beispielsweise wird „1.0-SNAPSHOT“ zu 1.0-20100505-141000-1, wenn es am 5. Mai 2010 um 14:10 Uhr veröffentlicht wird.

NEUESTE: bezieht sich auf die neueste Version einer bestimmten Komponente. Bei dieser Version kann es sich um eine Release-Version oder eine Snapshot-Version handeln, je nachdem, welcher Zeitpunkt der letzte ist.

RELEASE: bezieht sich auf die letzte Release-Version.

05. Maven-Abhängigkeitsmanagement

Ich persönlich denke, Abhängigkeitsmanagement ist maven Die attraktivste Funktion besteht darin, dass sich Entwickler nur auf die direkten Abhängigkeiten des Codes konzentrieren können.

Wenn wir beispielsweise Spring verwenden, fügen Sie einfach die Beschreibung der Spring-Abhängigkeit hinzu. Was die externen Dinge betrifft, von denen Spring selbst abhängt, kann uns Maven helfen.

Jede externe Abhängigkeitsbeschreibung enthält die folgenden Elemente: Gruppen-ID, Artefakt-ID, Version, Bereich, Typ, optional. Die ersten drei sind erforderlich und haben folgende Bedeutung:

Die Version hier kann durch Intervallausdrücke ausgedrückt werden, z. B. (2.0,) bedeutet >2.0, [2.0,3.0 ) Gibt an, dass 2.0<=ver<3.0; mehrere Bedingungen durch Kommas getrennt sind, z. B. [1,3),[5,7].

Maven glaubt, dass sich die externen Abhängigkeiten des Programms mit der Phase und dem Anwendungsszenario des Programms ändern werden, sodass die Abhängigkeiten in Maven durch den Umfang begrenzt sind.

Bereich enthält die folgenden Werte:

Kompilieren (Kompilierungsbereich) --- Kompilieren ist die Standardeinstellung Bereichs- und Kompilierungsbereichsabhängigkeiten sind in allen Klassenpfaden verfügbar und auch gepackt.

bereitgestellt (bereitgestellter Bereich) ---> bereitgestellte Abhängigkeit wird nur verwendet, wenn das JDK oder ein Container die Abhängigkeit bereitgestellt hat.

Wenn Sie beispielsweise eine Webanwendung entwickeln, benötigen Sie die im Kompilierungsklassenpfad verfügbare Servlet-API, um das Servlet zu kompilieren, möchten diese Servlet-API jedoch nicht in das Paket aufnehmen KRIEG.

   runtime（运行时范围 --> runtime 依赖在运行和测试系统的时候需要，但在编译的时候不需要。

   比如你可能在编译的时候只需要 JDBC API JAR，而只有在运行的时候才需要 JDBC 驱动实现。

   test（测试范围）--> test 范围依赖 在一般的 编译和运行时都不需要，它们只有在测试编译和测试运行阶段可用。

   system（系统范围） --> system 范围依赖与 provided 类似，但是你必须显式的提供一个对于本地系统中 JAR 文件的路径。

    <dependency> <groupId>org.wltea</groupId> <artifactId>analyzer</artifactId> <version>2012_u6</version> <scope>system</scope> <systemPath>${project.basedir}/src/main/webapp/WEB-INF/lib/analyzer-2012_u6.jar</systemPath> </dependency>

   注意该范围是不推荐使用的（你应该一直尽量去从公共或定制的Maven仓库中引用依赖）。

   type 一般在pom引用依赖时候出现，其他时候不用， optional 是否可选依赖。

   依赖也可以是可选的，比如我们代码中没有任何cache依赖，但是hibernate可能要配置cache，所以该cache的依赖就是可选的。

06. maven 多项目管理

   maven的多项目管理也是非常强大的。一般来说，maven要求同一个工程的所有子项目都放置到同一个目录下，每一个子目录代表一个项目，比如

   总项目/ pom.xml 总项目的 pom 配置文件

   子项目1/pom.xml 子项目1的 pom 文件

   子项目2/ pom.xml 子项目2的 pom 文件

   按照这种格式存放，就是继承方式，所有具体子项目的pom.xml都会继承总项目pom的内容，取值为子项目pom内容优先。

   要设置继承方式，首先要在总项目的pom中加入如下配置

<modules>   <module>simple-weather</module>   <module>simple-webapp</module> </modules>

   其次在每个子项目中加入

<parent>   <groupId>org.sonatype.mavenbook.ch06</groupId>   <artifactId>simple-parent</artifactId>   <version>1.0</version> </parent>

   当然，继承不是唯一的配置文件共用方式，maven还支持引用方式。引用pom的方式更简单，在依赖中加入一个type为pom的依赖即可。

  <dependency>      <groupId>org.sonatype.mavenbook</groupId>      <artifactId>persistence-deps</artifactId>      <version>1.0</version>      <type>pom</type>   </dependency>

07. maven 内置属性

  用户可以在maven中定义一些属性，然后在其他地方用${xxx}进行引用。比如：

 value1

   maven 提供了三个隐式的变量，用来访问系统环境变量、POM信息和 maven 的 settings：

   env 暴露操作系统的环境变量，比如 env.PATH

   project 暴露 POM 中的内容，用点号(.)的路径来引用POM元素的值，比如 ${project.artifactId}。另外，java的系统属性比如user.dir等，也暴露在这里。 

   settings 暴露 maven 的 settings 的信息，也可以用点号(.)来引用。

08. maven profile

   profile 是 maven 的一个重要特性，它可以让 maven 能够自动适应外部的环境变化。

   比如同一个项目，在linux下编译linux的版本，在win下编译win的版本等。

   一个项目可以设置多个 profile，也可以在同一时间设置多个 profile 被激活（active）的。

   自动激活的 profile 的条件可以是各种各样的设定条件，组合放置在 activation 节点中，也可以通过命令行直接指定。

   profile 包含的其他配置内容可以覆盖掉 pom 定义的相应值。

   如果认为 profile 设置比较复杂，可以将所有的 profiles 内容移动到专门的 profiles.xml 文件中，不过记得和 pom.xml 放在一起。

09. maven 配置文件

   maven的主执行程序为 mvn.bat，linux下为mvn.sh，这两个程序都很简单，它们的共同用途就是收集一些参数，然后用 java.exe来运行maven的Main函数。

   maven 同样需要有配置文件，名字叫做 settings.xml，它放在两个地方，一个是 maven 安装目录的conf目录下，对所有使用该 maven 的用户都起作用。

   我们称为主配置文件，另外一个放在 %USERPROFILE%/.m2/settings.xml 下，我们成为用户配置文件，只对当前用户有效，且可以覆盖主配置文件的参数内容。

   还有就是项目级别的配置信息了，它存放在每一个 maven 管理的项目目录下，叫 pom.xml，主要用于配置项目相关的一些内容。

   当然，如果有必要用户也可以在 pom 中写一些配置，覆盖住配置文件和用户配置文件的设置参数内容。

   一般来说，settings文件配置的是比如repository库路径之类的全局信息，具体可以参考官方网站的文章。

10. maven 本地安装和中央库发布

   在maven中一般都会用到安装库文件的功能，一则是我们常用的hibernate要使用jmx库，但是因为sun的license限制，所以无法将其直接包含在repository中。

   所以我们使用mvn命令把jar安装到我们本地的repository中

 mvn install:install-file -DgroupId=com.sun.jdmk -DartifactId=jmxtools -Dversion=1.2.1 -Dpackaging=jar -Dfile=/path/to/file

   如果我们想把它安装到公司的repository中，需要使用命令

mvn deploy:deploy-file -DgroupId=com.sun.jdmk -DartifactId=jmxtools -Dversion=1.2.1 -Dpackaging=jar -Dfile=/path/to/file -Durl= -DrepositoryId=release-repo

   对于我们的工程输出，如果需要放置到公司的repository中的话，可以通过配置 pom 来实现

<distributionManagement> 
   <repository> 
      <id>mycompany-repository</id> 
      <name>MyCompany Repository</name> 
      <url>scp://repository.mycompany.com/repository/maven2</url> 
   </repository> </distributionManagement>

11. maven 常用命令

1. 创建Maven的普通java项目： 
   mvn archetype:create -DgroupId=packageName -DartifactId=projectName 
2. 创建Maven的Web项目： 
   mvn archetype:create -DgroupId=packageName -DartifactId=webappName -DarchetypeArtifactId=maven-archetype-webapp 
3. 编译源代码： mvn compile 
4. 编译测试代码：mvn test-compile 
5. 运行测试：mvn test 
6. 产生site：mvn site 
7. 打包：mvn package 8. 在本地Repository中安装jar：mvn install 
9. 清除产生的项目：mvn clean 
10. 生成eclipse项目：mvn eclipse:eclipse 
11. 生成idea项目：mvn idea:idea 
12. 组合使用goal命令，如只打包不测试：mvn -Dtest package 13. 编译测试的内容：mvn test-compile 
14. 只打jar包: mvn jar:jar 
15. 只测试而不编译，也不测试编译：mvn test -skipping compile -skipping test-compile 
( -skipping 的灵活运用，当然也可以用于其他组合命令) 
16. 清除eclipse的一些系统设置:mvn eclipse:clean

Das obige ist der detaillierte Inhalt vonÜbersicht und Verwendung von Maven. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!