maven經常使用命令

 

 

上面是指定端口運行程序的，也能夠先指定好，直接在上面的地方寫jettty:run           固然，若是你是在控制檯運行且安裝了maven，直接能夠進入項目的文件中：mvn jetty:run

就是說，在控制檯運行只要加上一個mvn就ok了

 

 

你先須要理解maven的生命週期與插件目標這兩個概念。
拿Maven clean來講吧。生命週期爲clean.插件目標爲maven-clean-plugin:clean。
Maven build是這個插件讓你本身去配置執行目標的。
Maven clean 清除上一次Maven執行的結果
Maven generate-sources會根據pom配置去生成源代碼格式的包

Maven install將項目輸出構件部署到本地倉庫

maven最主要的做用有兩個方面，一個是對jar包的依賴解決功能，本身管理jar包，另外一個功能就是項目的構建，打包部署。如今我以爲最重要的仍是maven的生命週期和插件機制，下面就來總結一下吧。

 

 

mvn install 是將你打好的jar包安裝到你的本地庫中，通常沒有設置過是在 用戶目錄下的 .m2\下面。
mvn package 只是將你的代碼打包到輸出目錄，通常的是 target下面。

eclipse插件，m2eclipse

1.maven install至關於maven原生的命令： mvn install

2.aven build是 m2eclipse這個插件本身創造的概念，須要你來配置到底須要執行什麼命令，以下圖中的goals輸入的就是你想執行的命令：

 Goals就是mvn的意思，因此中間不須要加mvn了

 

　　Eclipse中maven經常使用的命令

　　點擊Run As就能夠發現幾個Maven的命令：

　　Maven Build:

　　這個命令用於編譯Maven工程，執行命令後會在target文件夾中的classes中生成對應的class文件。

　　Maven Clean:

　　刪除target文件夾，即刪除生成的package包以及class等文件。

　　Maven Test:

　　先自動進行編譯，在運行全部的測試用例。

　　Maven install:

　　發佈生成對應的package包。

注意：

　　留意上面的命令的做用，build和test都會生成相應的class文件。也就是說，當你新建一個maven工程，或者clean一個maven工程後，若是沒有使用這兩個命令，直接針對類進行測試，會跑出java.class.notfound的錯誤。由於此時尚未編譯生成class文件。

　　只有使用了上面的兩個命令後，才能針對某個類進行單元測試。

　什麼是maven?

　　Maven是一個用於項目構建的工具，經過它便捷的管理項目的生命週期。即項目的jar包依賴，開發，測試，發佈打包。

　　下面我本身總結一下它的幾個特色，看了這些特色，也許對maven有更多的瞭解。

　　1 jar包依賴

　　這個也許會maven最突出的特色了使用maven不須要上網單獨下載jar包，只須要在配置文件pom.xml中配置jar包的依賴關係，就能夠自動的下載jar包到咱們的項目中。這樣，別人開發或者使用這個工程時，不須要來回的拷貝jar包，只須要複製這個pom.xml就能夠自動的下載這些jar包。

　　並且，咱們本身下載jar包，還有可能形成版本的不一致，這樣在協同開發的過程當中就有可能形成代碼運行的不一致。經過使用maven精確的匹配jar包，就不會出現這種問題了。

　　2 項目座標

　　Maven經過特定的標識來定義項目名稱，這樣既能夠惟一的匹配其餘的jar包，也能夠經過發佈，使別人能使用本身的發佈產品。這個標識就被叫作座標，長的其實很普通，就是簡單的xml而已：

1   <groupId>com.test</groupId>
2   <artifactId>maventest</artifactId>
3   <version>0.0.1-SNAPSHOT</version>
4   <packaging>jar</packaging>
5 
6   <name>maventest</name>
7   <url>http://maven.apache.org</url>

　　groupId：所述的項目名稱，因爲有的項目並非一個jar包構成的，而是由不少的jar包組成的。所以這個groupId就是整個項目的名稱。

　　artifactId：包的名稱。

　　version：版本號。

　　packaging：包的類型，通常都是jar，也能夠是war之類的。若是不填，默認就是jar。

　　name和url，一個是名稱，一個是maven的地址。主要就是上面的幾個參數。

　　當想要依賴什麼jar的時候就能夠經過下面的方式依賴：

1 <dependencies>
2     <dependency>
3       <groupId>junit</groupId>
4       <artifactId>junit</artifactId>
5       <version>3.8.1</version>
6       <scope>test</scope>
7     </dependency>
8   </dependencies>

　　各個屬性的內容基本上都是同樣的。

　　這裏要注意的是jar包的命名規則：

　　artifactId-version[-classifier].packaging

　　好比上面的pom.xml生成的jar包名字就是：maventest-0.0.1-SNAPSHOT.jar。

　　這裏的classifier是可選的，可是有的項目可能還須要導出附屬的一些文件，如javadoc，source等等，那麼這個地方就須要配置一個字符串。通常都是JDKXXX之類的。

 

 

 

Maven 使用介紹

建立project

先去官方網站下載一個最新版本http://maven.apache.org/download.cgi. 下載後解壓，使用以前最好先將maven的bin目錄設置到path環境變量裏面。

maven無非也就是用來build一個project的，直接先上一個例子，在命令行下輸入下面的命令：

mvn archetype:generate DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=com.mycompany.app -DartifactId=myapp

mvn就是maven的命令行程序，archetype:generate中的archetype是plugin的名字，generate是goal的名字，命令行後面的是一些參數。關於archetype和goal以及後面的參數，後面再細說。

若是是第一次運行，這個過程會有點慢，maven須要下載一些依賴項，中間若是有輸入提示信息，直接回車使用默認值就能夠了。這條命令執行完後，會在你的當前目錄下生成一個名爲myapp的目錄：

注意這個目錄結構，src/main/java 和 src/test/java 是不能改動，否則maven會沒法找到源文件。下面是maven一個標準的目錄結構：

src/main/java	Application/Library sources
src/main/resources	Application/Library resources
src/main/filters	Resource filter files
src/main/assembly	Assembly descriptors
src/main/config	Configuration files
src/main/scripts	Application/Library scripts
src/main/webapp	Web application sources
src/test/java	Test sources
src/test/resources	Test resources
src/test/filters	Test resource filter files
src/site	Site

另外maven還生成了一個重要的文件pom.xml，maven就是經過這個文件來來管理整個project，能夠理解位相似於eclipse的.project文件。默認生成的pom.xml文件的內容以下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

/* 1-1 */ < 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.mycompany.app</ groupId >      < artifactId >my-app</ artifactId >      < version >1.1.0.1</ version >      < packaging >jar</ packaging >      < name >myapp</ name >      < url >http://maven.apache.org</ url >      < properties >          < project.build.sourceEncoding >UTF-8</ project.build.sourceEncoding >      </ properties >      < dependencies >          < dependency >              < groupId >junit</ groupId >              < artifactId >junit</ artifactId >              < version >3.8.1</ version >              < scope >test</ scope >          </ dependency >      </ dependencies > </ project >

解釋一下這個xml文件的內容：

• modelVersion： 這個XML文件所使用的POM格式的版本
• groupId： 至關於這個project的全部者或者機構的一個標識，通常是com.company.xxx這種格式
• artifactId：  這個project最後所生成的文檔(jar、war)的名字，好比對於junit這個開源的project，它的artifactId就是junit
• packaging： 這個project的打包的類型，通常是war、jar等值
• version： project的版本
• name： project的名字，生成文檔等內容的時候會用的這個名字

這個project建立好後和普通的project沒有什麼不一樣，咱們直接往裏面放源代碼進行開發就能夠了，若是有目錄想修改的也徹底能夠。

 

POM & archetype

archetype就是一個project的模板，上面咱們生成的project就是用默認的archetype生成的。若是使用不一樣的archetype，生成的project結構會有所不一樣。 一個archetype指明瞭

• 1) 項目的目錄結構以及什麼目錄是放source code，哪些是放test source code，哪些目錄是放resource的。
• 2) 一個默認的pom.xml文件，這個默認的pom.xml文件中的groupId，artifactId，version用佔位符表示，在建立project的時候經過參數傳進來。

pom.xml文件的POM全稱是Project Object Model，這個文件對於maven的使用者來講是一個和maven交互的渠道，pom.xml包含了一個maven project的配置，一個project該如何編譯打包，project有哪些依賴項等等。

仔細看一下咱們前面建立project的命令：mvn archetype:generate DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=com.mycompany.app -DartifactId=myapp

1. 1) archetype:generate， 這是一個maven的plugin，用來從一個archetype建立一個project，關於plugin後面再說。
2. 2) DarchetypeGroupId，這個就是指的archetype的groupid，也就是說是用的哪一個archetype，或者說用哪一個項目模板。
3. 3) 後面的兩個參數，用來放大pom.xml文件裏面，做爲當前建立的project的描述信息。

Project建立好了，看如何去編譯，直接進入的project的目錄，在命令行下：

mvn compile

編譯完後maven會建立一個target目錄去保存編譯結果。 咱們須要編譯成一個什麼樣的內容，以及要輸出到什麼地方等等，都是能夠在pom.xml文件裏面配置的，可是由於咱們目前並無指定這些內容，因此maven會使用默認值。

咱們還能夠用maven執行test：

mvn test

第一次執行時，maven會去下載一些依賴項。另外要注意的時，若是咱們更改了默認的目錄結構，maven會由於找bu到test而沒法去執行test。若是隻須要編譯test能夠執行：

mvn test-compile

要把項目打包，執行：

mvn package

mvn會根據pom.xml裏面的packaging選項打包成相應的文件。

 

repository & dependency

maven裏面有一個repository的概念，當咱們的項目依賴於某個jar時，maven會去repository裏面去找。repository分兩種，一種是遠程的，一種是本地的。若是有幾個project都用到junit，咱們能夠把junit放在repository裏面，幾個project能夠公用，節約存儲空間並且方便管理，這個repository的位置能夠在pom.xml裏面設置。

本地的默認的路徑是安裝用戶的目錄下的 .m2\repository 文件夾。若是一個依賴項在本地的repository裏面沒有，那麼maven會去他本身的遠程的repositoryhttp://repo.maven.apache.org/maven2 去下載後放到本地的repository裏面。

也就是說，咱們若是咱們的project須要要引用一個依賴項，咱們只須要在pom.xml文件中進行配置，maven會自動幫咱們去引用。 咱們以前的建立project裏面須要寫單元測試，引用到了junit，看pom中的配置：

1 2 3 4 5 6 7 8

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

每個須要爲每個 dependency 指明groupId，artifactId，version。scope很簡單，意思是說咱們須要怎麼引用，好比咱們上面的例子裏面設置的是test，意思是說只在test裏面引用junit。 可是咱們如何知道groupId，artifactId和version呢？ 好比我如今想引用log4j，這個幾個值怎麼填？ 能夠去http://mirrors.ibiblio.org/maven2/ 上去查找。好比log4j，咱們就在上面這個地址加上log4j，也就是http://mirrors.ibiblio.org/maven2/junit/。進去後會有一個maven-metadata.xml，打開就能夠知道這些值了而後添加這個dependency了。

若是要把一個project安裝到本地的repository裏面，能夠執行下面的命令：

mvn install

 

到這裏就說完了建立，編譯，測試，打包以及安裝，大部分的項目也就是作這些事情。

再介紹幾個其它命令：

1. mvn site ： 爲你的project建立一個站點
2. mvn clean： 清除target目錄下的全部文件
3. mvn eclipse:eclipse ：爲project生成eclipse的工程文件和classpath文件

 

build lifecycle & build phase & goal

maven有一套build的生命週期，是按照一套順序走下來的，這一套順序就叫一個生命週期(lifecycle)。maven內置三種生命週期：default, clean 和 site。一個生命週期分爲多個build phase，下面是default生命週期所有的build phase：

• validate：validate the project is correct and all necessary information is available.
• initialize：initialize build state, e.g. set properties or create directories.
• generate-sources：generate any source code for inclusion in compilation.
• process-sources：process the source code, for example to filter any values.
• generate-resources：generate resources for inclusion in the package.
• process-resources：copy and process the resources into the destination directory, ready for packaging.
• compile：compile the source code of the project.
• process-classes：post-process the generated files from compilation, for example to do bytecode enhancement on Java classes.
• generate-test-sources：generate any test source code for inclusion in compilation.
• process-test-sources：process the test source code, for example to filter any values.
• generate-test-resources：create resources for testing.
• process-test-resources：copy and process the resources into the test destination directory.
• test-compile：compile the test source code into the test destination directory
• process-test-classes：post-process the generated files from test compilation, for example to do bytecode enhancement on Java classes. For Maven 2.0.5 and above.
• test：run tests using a suitable unit testing framework. These tests should not require the code be packaged or deployed.
• prepare-package：perform any operations necessary to prepare a package before the actual packaging. This often results in an unpacked, processed version of the package. (Maven 2.1 and above)
• package：take the compiled code and package it in its distributable format, such as a JAR.
• pre-integration-test：perform actions required before integration tests are executed. This may involve things such as setting up the required environment.
• integration-test：process and deploy the package if necessary into an environment where integration tests can be run.
• post-integration-test：perform actions required after integration tests have been executed. This may including cleaning up the environment.
• verify：run any checks to verify the package is valid and meets quality criteria.
• install：install the package into the local repository, for use as a dependency in other projects locally.
• deploy：done in an integration or release environment, copies the final package to the remote repository for sharing with other developers and projects.

這些build phase是按照順序執行的，若是執行後面的build phase，前面的build phase 也會被執行。例如若是執行：

mvn deploy

前面的install、verify一直到validate這些build phase都會執行。

每個build phase是由goal組成的，一個goal其實就是一個任務，一個goal能夠關聯到一個build phase也能夠不關聯到任何build phase 。 不關聯到任何phase的goal是能夠獨立執行的，例如：

mvn clean dependency:copy-dependencies package

上面的命令會致使先執行clean這個phase，而後拷貝依賴項，最後打包。注意，這裏clean這個goal是clean這個lifecycle裏面的一個goal，因此能夠看到不一樣lifecycle的build phase和goal是能夠混合在一塊兒執行的。 若是一個goal被綁定到多個phase上，那麼goal就會被執行屢次。

phase的順序是已經固定的，若是一個phase沒有綁定到任何goal，那麼phase就不會被執行。 一個goal能夠經過兩種方式綁定到一個phase，一個是指定packaging，另外一個就是plugin。

 

packaging&plugin

plugin就是用來向maven提供goal的。一個plugin裏面能夠有多個goal，這就是爲何咱們在指明goal時，前面會用一個冒號與plugin的名字。

一個plugin本身能夠指定本身的goal綁定到哪一個lifecycle的哪個Phase上，另外也能夠配置一個goal綁定到哪一個phase上。能夠在pom.xml裏面配置。 看兩個配置：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

< plugin >     < groupId >org.codehaus.modello</ groupId >     < artifactId >modello-maven-plugin</ artifactId >     < version >1.4</ version >     < executions >       < execution >         < configuration >           < models >             < model >src/main/mdo/maven.mdo</ model >           </ models >           < version >4.0.0</ version >         </ configuration >         < goals >           < goal >java</ goal >         </ goals >       </ execution >     </ executions >   </ plugin >

這個就在當前的lifecycle裏面添加了一個名字叫java的goal，這goal會根據本身的配置去綁定到一個phase，在phase執行的時候這個goal會執行。而且在這個配置裏面，能夠指定多個execution來讓這個goal執行屢次。

看另外一個示例配置：

1 2 3 4 5 6 7 8 9 10 11 12 13

< plugin >     < groupId >com.mycompany.example</ groupId >     < artifactId >display-maven-plugin</ artifactId >     < version >1.0</ version >     < executions >       < execution >         < phase >process-test-resources</ phase >         < goals >           < goal >time</ goal >         </ goals >       </ execution >     </ executions >   </ plugin >

這個名爲time的goal把本身綁定到了process-test-resource這個phase上。

在默認狀況下，並非全部的phase都綁定了goal，好比clean這個lifecycle是有三個phase的，可是隻有其中的一個名爲clean的phase默認綁定了一個clean:clean goal，其它兩個phase默認沒有綁定任何goal。

以前已經提到過packaging，在pom.xml能夠指定packaging，每種packaging都設定了一組phase和goal之間的綁定關係。在default lifecycle下，當packaging爲 ejb/ejb3/jar/par/rar/war 其中之一的值的時候，只有如下的phase綁定了goal，具體以下：

process-resources	resources:resources
compile	compiler:compile
process-test-resources	resources:testResources
test-compile	compiler:testCompile
test	surefire:test
package	jar:jar
install	install:install
deploy	deploy:deploy

 

總結

首先搞清楚maven的project的目錄結構，而後理解maven的lifecycle，lifecycle是由build phase組成，每個build phase會綁定到goal。goal是由plugin提供的。 每一種packaging的值都代表了必定的phase和goal之間的綁定關係。

另一個很重要的就是dependency，咱們要在項目中引用一個依賴，只須要在pom.xml指定依賴的名字和版本，maven會自動去遠程的repository下載，而後放到本地的repository裏面，這樣之後全部的project均可以共用

其它細節能夠參考http://maven.apache.org/guides/index.html。

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 

ps：

通常使用狀況是這樣，首先經過cvs或svn下載代碼到本機，而後執行mvn eclipse:eclipse生成ecllipse項目文件，而後導入到eclipse就好了；修改代碼後執行mvn compile或mvn test檢驗，也能夠下載eclipse的maven插件。

mvn -version/-v               顯示版本信息 
mvn archetype:generate        建立mvn項目 
mvn archetype:create -DgroupId=com.oreilly -DartifactId=my-app   建立mvn項目

mvn package              生成target目錄，編譯、測試代碼，生成測試報告，生成jar/war文件 
mvn jetty:run            運行項目於jetty上, 
mvn compile              編譯 
mvn test                 編譯並測試 
mvn clean                清空生成的文件 
mvn site                 生成項目相關信息的網站 
mvn -Dwtpversion=1.0 eclipse:eclipse        生成Wtp插件的Web項目 
mvn -Dwtpversion=1.0 eclipse:clean          清除Eclipse項目的配置信息(Web項目) 
mvn eclipse:eclipse                         將項目轉化爲Eclipse項目

在應用程序用使用多個存儲庫 
<repositories>    
    <repository>      
        <id>Ibiblio</id>      
        <name>Ibiblio</name>      
        <url>http://www.ibiblio.org/maven/</url>    
    </repository>    
    <repository>      
        <id>PlanetMirror</id>      
        <name>Planet Mirror</name>      
        <url>http://public.planetmirror.com/pub/maven/</url>    
    </repository>  
</repositories>

mvn deploy:deploy-file -DgroupId=com -DartifactId=client -Dversion=0.1.0 -Dpackaging=jar -Dfile=d:\client-0.1.0.jar -DrepositoryId=maven-repository-inner -Durl=ftp://xxxxxxx/opt/maven/repository/

發佈第三方Jar到本地庫中：

mvn install:install-file -DgroupId=com -DartifactId=client -Dversion=0.1.0 -Dpackaging=jar -Dfile=d:\client-0.1.0.jar

-DdownloadSources=true

-DdownloadJavadocs=true

mvn -e              顯示詳細錯誤 信息. 
mvn validate        驗證工程是否正確，全部須要的資源是否可用。 
mvn test-compile    編譯項目測試代碼。 。 
mvn integration-test     在集成測試能夠運行的環境中處理和發佈包。 
mvn verify               運行任何檢查，驗證包是否有效且達到質量標準。     
mvn generate-sources     產生應用須要的任何額外的源代碼，如xdoclet。

 

經常使用命令： 
mvn -v 顯示版本 
mvn help:describe -Dplugin=help 使用 help 插件的  describe 目標來輸出 Maven Help 插件的信息。 
mvn help:describe -Dplugin=help -Dfull 使用Help 插件輸出完整的帶有參數的目標列 
mvn help:describe -Dplugin=compiler -Dmojo=compile -Dfull 獲取單個目標的信息,設置  mojo 參數和  plugin 參數。此命令列出了Compiler 插件的compile 目標的全部信息 
mvn help:describe -Dplugin=exec -Dfull 列出全部 Maven Exec 插件可用的目標 
mvn help:effective-pom 看這個「有效的 (effective)」POM，它暴露了 Maven的默認設置

mvn archetype:create -DgroupId=org.sonatype.mavenbook.ch03 -DartifactId=simple -DpackageName=org.sonatype.mavenbook 建立Maven的普通java項目，在命令行使用Maven Archetype 插件 
mvn exec:java -Dexec.mainClass=org.sonatype.mavenbook.weather.Main Exec 插件讓咱們可以在不往 classpath 載入適當的依賴的狀況下，運行這個程序 
mvn dependency:resolve 打印出已解決依賴的列表 
mvn dependency:tree 打印整個依賴樹

mvn install -X 想要查看完整的依賴蹤影，包含那些由於衝突或者其它緣由而被拒絕引入的構件，打開 Maven 的調試標記運行 
mvn install -Dmaven.test.skip=true 給任何目標添加maven.test.skip 屬性就能跳過測試 
mvn install assembly:assembly 構建裝配Maven Assembly 插件是一個用來建立你應用程序特有分發包的插件

mvn jetty:run     調用 Jetty 插件的 Run 目標在 Jetty Servlet 容器中啓動 web 應用 
mvn compile       編譯你的項目 
mvn clean install 刪除再編譯

mvn hibernate3:hbm2ddl 使用 Hibernate3 插件構造數據庫

 

-----------------------------------------------------------------------------------------------------------------------------------------------------------------

課程目標：瞭解什麼是jar包，使用maven完成一個下載圖片的需求
maven下載安裝配置（*）
環境變量配置
下載maven：http://maven.apache.org/download.cgi
maven_home
path添加
驗證結果
mvn -version
maven倉庫
遠程
私服
搭建私服
通常在企業內部局域網中使用
中央倉庫
maven內置遠程倉庫地址

maven-model-builder-3.5.4\org\apache\maven\model\pom-4.0.0.xml
找jar包
本地->私服->中央倉庫
找好了jar包，下載的jar放在哪
通通在本地倉庫
本地maven庫
修改配置文件（可選）
不修改放在默認的庫 .m2\repository
本地倉庫
mvn archetype:generate
eclipse配置maven
在線安裝：eclipse安裝maven插件;http://m2eclipse.sonatype.org/sites/m2e
添加maven安裝路徑
添加maven倉庫
配置maven倉庫
maven經常使用命令（*）
mvn archetype:generate
利用默認模板建立mvn項目
mvn compile
編譯Java文件而且放到target下
mvn clean
清除target下全部文件
mvn test
運行測試代碼
mvn package
打包命令，團隊協作共享
mvn install
把打的包放在本地倉庫
maven三套生命週期（瞭解）
Maven有三套相互獨立的生命週期，請注意這裏說的是「三套」，並且「相互獨立」，初學者容易將Maven的生命週期當作一個總體，其實否則。這三套生命週期分別是：
Clean Lifecycle 在進行真正的構建以前進行一些清理工做。
Default Lifecycle 構建的核心部分，編譯，測試，打包，部署等等。
Site Lifecycle 生成項目報告，站點，發佈站點。
每一個生命週期會執行不止一個命令
maven jar依賴範圍（瞭解）
1. compile 默認的範圍，編譯測試運行都有效。
2. provided 編譯和測試時有效，最後是在運行的時候不會被加入。官方舉了一個例子。好比在JavaEE web項目中咱們須要使用servlet的API，可是呢Tomcat中已經提供這個jar，咱們在編譯和測試的時候須要使用這個api，可是部署到tomcat的時候，若是還加入servlet構建就會產生衝突，這個時候就可使用provided。
3. runtime 在測試和運行時有效。
4. test 在測試時有效。
5. system 與本機系統相關聯，可移植性差。編譯和測試時有效。
6. import 導入的範圍，它只在使用dependencyManagement中，表示從其餘pom中導入dependecy的配置。
課程練習
瞭解是是jar包
一、JAR 文件就是 Java Archive File，顧名思意，它的應用是與 Java 息息相關的，是 Java 的一種文檔格式。
二、JAR 文件與 ZIP 文件惟一的區別就是在 JAR 文件的內容中，包含了一個 META-INF/MANIFEST.MF 文件，這個文件是在生成 JAR 文件的時候自動建立的。
jar包：能夠叫他文件包，一般是開發時要引用通用類，打成包便於存放管理。
在eclipse裏面打jar包，手動調用jar包
tips:static修飾的類與方法，方便在沒有建立對象的狀況下來進行調用（方法/變量）
舉例使用maven，比較程序員與程序員之間的區別，達爾文說過：人和動物的差異在於，普通vs優秀，在於優秀程序員善於使用工具，一個優秀程序員=三個普通程序員，質量，思考方式等等
完成一個小小的需求
普通程序員實現
舉例子-需求：
一、採用來源項目HTTPclient爬蟲下載帥哥圖片
二、圖片質量要高清的
三、HTTPclient要3.1版本，參考文檔見附件
什麼是HTTPclient：字面理解
在官網查看使用文檔
http://hc.apache.org/httpclient-3.x/
tutorial
找jar包，付費，版本不對，下載的是空包或者是廣告。。。。特別浪費時間，工做效率低下
http://127.0.0.1:8088/1.jpg
放置圖片在tomcat中
D:\apache-tomcat-9.0.10\webapps\ROOT
File file=new File("1.jpg");
FileOutputStream fos =new FileOutputStream(file);
fos.write(responseBody);
fos.close();
優秀程序員的實現
作項目不只須要技術，還須要要學會管理，善用工具
須要依賴各類jar,以及版本管理
自動讓maven管理依賴
優秀程序員工做效率是普通程序員的三倍
httpclient jar包引入maven
關鍵字解釋
generate 用於建立Maven 項目。
DartifactId 指定項目名稱。
DgroupId 指定包的名稱。
Dversion 指定版本號。
生成web工程標準結構->javaEE tools
---------------------------------------------------------------------------------------------------------------------------------

 

Maven教程

1.1. 介紹、環境配置

1.1.1. Maven介紹

Maven是一個採用純Java編寫的開源項目管理工具, Maven採用了一種被稱之爲Project Object Model (POM)概念來管理項目，全部的項目配置信息都被定義在一個叫作POM.xml的文件中, 經過該文件Maven能夠管理項目的整個生命週期，包括清除、編譯，測試，報告、打包、部署等等。目前Apache下絕大多數項目都已經採用Maven進行管理. 而Maven自己還支持多種插件, 能夠方便更靈活的控制項目, 開發人員的主要任務應該是關注商業邏輯並去實現它, 而不是把時間浪費在學習如何在不一樣的環境中去依賴jar包,插件以及項目部署等。

Maven正是爲了將開發人員從這些任務中解脫出來而誕生的

1.1.2. Maven可以作什麼

l  Jar的聲明式依賴性管理

l  項目自動構建

1.1.3. 環境配置

l  http://maven.apache.org/download.html 下載最新版本Maven 3.5.4 (Binary zip)

 

l  解壓到 D(自己就是綠色版不須要安裝):

 

l  配置環境變量(配置以前,必須肯定配置了JDK環境變量)

一、配置MAVEN_HOME :               D:\apache-maven-3.5.4\ apache-maven-3.5.4
二、把此命令添加到Path中:             ;%MAVEN_HOME%\bin

 

l  驗證安裝是否成功

在命令行上輸入: mvn -version;回車, 如看到下面信息表示安裝成功

 

1.1.4. Maven目錄分析

l  bin：含有mvn運行的腳本

l  boot：含有plexus-classworlds類加載器框架

l  conf：含有settings.xml配置文件

l  lib：含有Maven運行時所須要的java類庫

l  Settings.xml 中默認的用戶庫: ${user.home}/.m2/repository,能夠修改成本地倉庫在settings.xml配置本地倉庫名稱;

 

Maven默認倉庫下載地址在: maven的lib目錄下maven-model-builder-3.5.4.jar的pom.xml中

 

1.2. 第一個Maven演示

1.2.1.      建立目錄結構

Convention Over Configuration (約定優於配置)。在現實生活中，有不少常識性的東西，地球人都知道。好比說：如何過馬路(紅燈停綠燈行)，如何開門，關門等。

對於這些事情，人們已經有了默認的約定, 在軟件開發過程當中，道理也是相似的，若是咱們事先約定好全部項目的目錄結構，標準開發過程(編譯，測試) , 全部人都遵循這個約定。軟件項目的管理就會變得簡單不少。在如今流行的不少框架中，都使用了這個概念

咱們來看看，maven工程標準目錄結構

HelloMaven  --src    -----main  ----------java       --用來存放Java文件  ----------resources   --用來存放資源文件  -----test  ---------java        --用來存放測試的Java文件  ---------resources  --target           --項目輸出位置,編譯完畢後自動生成  --pom.xml        -- 項目對象模型的描述 ，它是maven配置的核心

1.2.2.      創建pom.xml

<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"> <!-- 當前pom的版本號 -->   <modelVersion>4.0.0</modelVersion> <!-- groupId: 組織名稱 -->   <groupId>dongnaoedu</groupId> <!-- 當前項目模塊名稱 -->   <artifactId>HelloMaven</artifactId> <!-- 當前項目的版本, SNAPSHOT鏡像版,不穩定版本 -->   <version>0.0.1-SNAPSHOT</version>     <!-- 當前模塊須要依賴的相關jar包,也稱爲依賴管理, 全部被依賴的包都是經過"座標"定位的 -->     <dependencies>         <!-- 須要依賴junit 經過 groupId+artifactId+version來查找,若是本地沒有則到中央倉庫下載 -->        <dependency>            <!-- 當前jar所屬的命名空間 -->            <groupId>junit</groupId>            <!-- 依賴的項目模塊的名稱 -->            <artifactId>junit</artifactId>            <!-- 依賴的版本號 -->            <version>4.9</version>            <!-- 依賴的範圍, 有 test compile privlege -->            <scope>test</scope>        </dependency>         </dependencies> </project>

pom.xml 文件是maven對一個項目的核心配置，這個文件將包含你但願如何構建項目的大多數配置信息。POM很複雜，不用所有去了解，只要使用一些經常使用的配置就能夠了

1.2.3.      利用模板建立Java類與測試類

mvn archetype:generate

1.2.4.      命令測試

打開cmd命令行, 進入項目根目錄執行mvn compile命令, 查看根目錄變化

cmd 中繼續錄入mvn clean命令，而後再次查看根目錄變化

cmd 中錄入 mvn compile命令, 查看根目錄變化

cmd 中錄入 mvn test命令，查看根目錄變化

cmd 中錄入 mvn package命令,查看根目錄變化

1.3. Maven核心概念

1.3.1.      Maven插件

Maven的核心僅僅定義了抽象的生命週期，具體的任務都是交由插件完成的每一個插件都能實現多個功能，每一個功能就是一個插件目標

Maven的生命週期與插件目標相互綁定，以完成某個具體的構建任務, Maven的插件在: .m2\repository\org\apache\maven\plugins

1.3.2.      Maven座標

相似在平面幾何中座標（x,y）能夠標識平面中惟一的一點, Maven世界擁有大量構建，咱們須要找一個用來惟一標識一個構建的統一規範

擁有了統一規範，就能夠把查找工做交給機器

Com.dongnao

l  groupId：定義當前Maven項目組  (實際對應JAVA的包的結構,有些跟公司名稱相關的項目)

l  artifactId：定義實際項目中的一個模塊(項目的惟一的標識符,實際對應項目的名稱,就是項目根目錄的名稱)

l  version：定義當前項目的當前版本

1.3.3.      Maven倉庫

l  何爲Maven倉庫：用來統一存儲全部Maven共享構建的位置就是倉庫

l  Maven配置jar包的路徑爲：groupId/artifactId/version

l  本地倉庫(~/.m2/repository/)：每一個用戶只有一個本地倉庫

l  中央倉庫(Maven默認的遠程倉庫)：Maven默認的遠程倉庫下載地址爲：http://repo1.maven.org/maven2

l  私服：是一種特殊的遠程倉庫, 它是架設在局域網內的倉庫, 主要是爲了團隊協做開發

1.4. 第二個Maven演示

1.4.1.      目錄結構

HelloMaven2  --src  -----main  ----------java  ----------resources  -----test  ---------java  ---------resources  --pom.xml

1.4.2.      創建Pom.xml

<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> maven</groupId>     <artifactId> HelloMaven2</artifactId>     <version>1.0.0</version>     <packaging>jar</packaging>     <dependencies>        <dependency>            <groupId>junit</groupId>            <artifactId>junit</artifactId>            <version>4.9</version>            <scope>test</scope>        </dependency>        <dependency>            <groupId>maven</groupId>            <artifactId>HelloMaven</artifactId>            <version>1.0.0</version>            <scope>compile</scope>        </dependency>     </dependencies> </project>

1.4.3.      建立Java類與測試類(同上)

1.4.4.      命令測試

l  在HelloWorld目錄下執行 mvn clean \mvn compile \mvn test 都正常

l  在HelloWorld目錄下執行命令mvn package 系統報錯說沒有找到依賴, 由於HelloWorld依賴Hello模塊,可是此模塊在我的倉庫和中央倉庫中並不存在

l  須要從新構建Hello第一個項目並安裝到數據倉庫, 在Hello根目錄下執行mvn clean install, 就會部署到本地倉庫中

1.5. Maven與Eclipse整合

1.5.1.      配置maven插件

去除多移的勾選項，最後結果以下：

1.5.2.      user settings

1.6.Maven開發項目

1.6.1建立Java項目

l  在Eclipse建立項目的時候選擇Maven Project

l  next後選擇默認工做空間

注意：若是不是建立簡單項目，將在後繼的步驟中,選擇相關嚮導；此嚮導也是插件,第一次使用的時候.也要從遠程倉庫中下載相應的jar包, 所以須要網絡環境

l  建立完畢後默認生成的項目包目錄以下

 l  經過在pom.xml中單擊右鍵選擇相應的命令便可 

1.7.Maven私服

1.7.1關於中央倉庫注意事項

l  地址: 目前來講: http://repo.maven.apache.org/maven2/是真正的Maven中央倉庫的地址，該地址內置在Maven的源碼中其餘的都是鏡像

l  索引: 中央倉庫帶有索引文件以方便用戶對其進行搜索，完整的索引文件大小約爲60M，索引每週更新一次

l  黑名單: 若是某個IP地址惡意的下載中央倉庫內容，例如全公司100臺機器使用同一個IP反覆下載，這個IP（甚至是IP段）會進入黑名單，所以稍有規模的使用Maven時，應該用Nexus架設私服

1.7.2爲何須要私服

       爲何要搭建nexus私服，緣由不少，例若有些公司都不提供外網給項目組人員，所以就不能使用maven訪問遠程的倉庫地址，因此頗有必要在局域網裏找一臺有外網權限的機器，搭建nexus私服，而後開發人員連到這臺私服上，這樣的話就能夠經過這臺搭建了nexus私服的電腦訪問maven的遠程倉庫

1.8.eclipse裏面maven執行

保存後，buildpath 

1.9.做業

做業：建立2個maven工程，使用其中一個生成jar,mvn install上傳jar到本地倉庫，另外一個使用pom.xml引用前一個的jar