上面是指定端口运行程序的，也可以先指定好，直接在上面的地方写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-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) archetype:generate，这是一个maven的plugin，用来从一个archetype创建一个project，关于plugin后面再说。
2) DarchetypeGroupId，这个就是指的archetype的groupid，也就是说是用的哪个archetype，或者说用哪个项目模板。
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

到这里就说完了创建，编译，测试，打包以及安装，大部分的项目也就是做这些事情。

再介绍几个其它命令：

mvn site ：为你的project创建一个站点
mvn clean：清除target目录下的所有文件
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包
1、JAR 文件就是 Java Archive File，顾名思意，它的应用是与 Java 息息相关的，是 Java 的一种文档格式。
2、JAR 文件与 ZIP 文件唯一的区别就是在 JAR 文件的内容中，包含了一个 META-INF/MANIFEST.MF 文件，这个文件是在生成 JAR 文件的时候自动创建的。
jar包：可以叫他文件包，通常是开发时要引用通用类，打成包便于存放管理。
在eclipse里面打jar包，手动调用jar包
tips:static修饰的类与方法，方便在没有创建对象的情况下来进行调用（方法/变量）
举例使用maven，比较程序员与程序员之间的区别，达尔文说过：人和动物的差别在于，普通vs优秀，在于优秀程序员善于使用工具，一个优秀程序员=三个普通程序员，质量，思考方式等等
完成一个小小的需求
普通程序员实现
举例子-需求：
1、采用来源项目HTTPclient爬虫下载帅哥图片
2、图片质量要高清的
3、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环境变量)

1、配置MAVEN_HOME : D:\apache-maven-3.5.4\ apache-maven-3.5.4
2、把此命令添加到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

<groupId>dongnaoedu</groupId>

<artifactId>HelloMaven</artifactId>

<version>0.0.1-SNAPSHOT</version>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</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">

<groupId> maven</groupId>

<artifactId> HelloMaven2</artifactId>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>maven</groupId>

<artifactId>HelloMaven</artifactId>

<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

来源：oschina

链接：https://my.oschina.net/u/4384474/blog/3866471

标签

eclipse

java

Archetype

apache

junit