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