一、Maven概述[了解]

1．问题引入

1576483068494.png

目前存在的问题

运用我们目前学习的技术已经可以开发一个小型的项目了，但是在实际开发中，我们的项目规模要复杂的多，遇到的问题也更多！比如：
1、jar包的管理：多个项目依赖同一个jar包，要复制多次，jar升级时又得重新复制多次，jar之间还可能有多重依赖关系，容易管理混乱
2、项目的管理：项目规模越来越大，需要拆分成多个子模块，模块之间的相互依赖关系需要统一管理，并且项目生命周期中的编译，打包，测试，运行等步骤都需要统一管理

如何解决？

Maven项目管理工具（可以考虑作为骨架扩展） - 图2
开发一个工具对jar包和项目进行统一的管理，比如：
把jar包都编个坐标，记录并存放在一个地方（这个地方称作为仓库），项目中要用哪个jar就根据坐标来仓库中找就行了；
对项目生命周期和模块进行统一管理，能够自动化的执行编译，打包，测试，运行等操作。
而我们想到的这些解决方案，早就有大牛帮我们实现好了，那就是Maven！
总结：通俗的说:maven就是用来管理jar包+管理和构建项目
注意：这些工具都是帮助/辅助我们工作的，我们最终的开发产出物都是代码

2．初识Maven

官网
http://maven.apache.org/
百科介绍
Maven项目管理工具（可以考虑作为骨架扩展） - 图3
说人话
Maven是一个项目管理工具，可以对项目和jar包进行统一个管理，包括：项目的构建（执行项目的生命周期）、项目的生命周期（编译、测试、打包、部署等）、项目的模块依赖关系和jar包的依赖关系

3．Maven的相关概念

（1）项目对象模型**（POM）**

Project Object Mode**l：POM对象模型**，其实就是一个xml文件，名字叫做pom.xml，每个Maven工程中都有一个pom.xml文件，定义工程（所依赖的jar包）、（本工程的坐标、打包（jar/war）运行方式）。
Maven通过坐标对项目工程所依赖的jar包统一规范管理
企业使用时，也叫做GAV坐标
Maven的坐标使用如下三个量在 Maven 的仓库中唯一的确定一个jar。

  1. groupid：公司或组织的域名倒序+[当前项目名称]
  2. artifactId：当前项目的模块名称
  3. version：当前模块的版本

例如：要引入junit的测试jar，只需要在pom.xml配置文件中配置引入junit的坐标即可

  1. <dependency>
  2.     <groupId>junit</groupId>
  3.     <artifactId>junit</artifactId>
  4.     <version>4.12</version>
  5.     <scope>test</scope>
  6. </dependency>

（2）生命周期

清理、编译、测试、报告 、打包、部署、站点生成。
Maven项目管理工具（可以考虑作为骨架扩展） - 图4

  1. 清理：删除以前的编译结果，为重新编译做好准备。
  2. 编译：将Java 源程序编译为字节码文件。
  3. 测试：针对项目中的关键点进行测试，确保项目在迭代开发过程中关键点的正确性。
  4. 报告：在每一次测试后以标准的格式记录和展示测试结果。
  5. 打包：将一个包含诸多文件的工程封装为一个压缩文件用于安装或部署。Java 工程对应 jar 包，Web工程对应 war 包。
  6. 安装：在 Maven 环境下特指将打包的结果——jar 包安装到本地仓库中或把 war包安装到web容器中。
  7. 部署：将打包的结果部署到远程仓库或将war包部署到服务器上运行。

（3）Maven项目标准目录结构

Maven是约定思想的体现，约定>配置>编程，maven之前有一个ant工具（告诉它你的源代码在哪个路径下，然后编译输出到哪个路径）
Maven工程有自己标准的目录结构。
而 Maven 正是因为指定了特定目录保存文件才能够对我们的 Java 工程进行自动化构建(就是自动执行上面的生命周期)。
标准目录结构示例

  1. Project
  2. |-src
  3. | |-main
  4. | | |-java —— 存放项目的.java文件
  5. | | |-resources ——存放项目资源文件，如spring, hibernate配置文件
  6. |-webapp —— webapp目录是web工程的主目录
  7. |-WEB-INF
  8. |-web.xml
  9. | |-test
  10. | |-java —— 存放所有测试.java文件，如JUnit测试类
  11. | |-resources —— 测试资源文件
  12. |-target ——目标文件输出位置例如.class、.jar、.war文件
  13. |-pom.xml ——maven项目核心配置文件

Maven项目管理工具（可以考虑作为骨架扩展） - 图5

（4）Maven插件

maven 管理项目生命周期过程都是基于插件完成的，例如：开发中使用的tomcat插件。

（5）Maven仓库

Maven项目管理工具（可以考虑作为骨架扩展） - 图6
Maven项目管理工具（可以考虑作为骨架扩展） - 图7

仓库名称 作用
本地仓库 相当于缓存，工程第一次会从远程仓库（互联网）去下载jar 包，将jar包存在本地仓库（在程序员的电脑上）。第二次不需要从远程仓库去下载。先从本地仓库找，如果找不到才会去远程仓库找。
中央仓库（远程仓库） 是一种远程仓库，仓库中的jar包由专业团队（maven团队）统一维护。里面存放了全世界大多数流行开源软件jar包中央仓库的地址：http://mvnrepository.com/tags/maven
私服（远程仓库） 在公司内部架设一台私服，其它公司架设一台仓库，对外公开。

4．使用Maven的好处

通过上边介绍传统项目和maven项目在项目构建及依赖管理方面的区别，maven有如下的好处：
1、自动构建（生命周期管理）：maven对项目构建的过程进行标准化，通过一个命令即可完成构建过程。
2、依赖管理：maven工程不用手动导jar包，通过在pom.xml中定义坐标从maven仓库自动下载，方便且不易出错。
3、跨平台：maven命令可在window、linux上使用，命令无差别。
4、提升效率：遵循maven规范开发有利于提高大型团队的开发效率，降低项目的维护成本，大公司都会考虑使用maven来构建项目。
团队>个人

二、Maven实战[应用]

1．安装配置

下载
http://maven.apache.org/download.cgi
l 安装
解压到指定软件安装目录即可
l 目录介绍
bin：存放执行脚本文件的地方
boot：存放一些扩展的地方
conf：maven的核心配置文件存放的路径
lib：maven的依赖包
l 配置环境变量
1、配置JAVA_HOME和MAVEN_HOME
Maven项目管理工具（可以考虑作为骨架扩展） - 图8
2.配置path
Maven项目管理工具（可以考虑作为骨架扩展） - 图9
l 验证
Maven项目管理工具（可以考虑作为骨架扩展） - 图10
l 配置本地仓库
Maven项目管理工具（可以考虑作为骨架扩展） - 图11
1.在maven的安装目录中conf/ settings.xml文件，在这里配置本地仓库
指定本地仓库位置(默认在 ${user.dir}/.m2/repository，${user.dir}表示windows用户目录)
C:\develop\repository
Maven项目管理工具（可以考虑作为骨架扩展） - 图12
2.指定阿里云镜像位置（中央仓库默认不用配置，此处只是使用阿里云镜像替代中央仓库，提高jar的下载速度）

  1. <mirror>
  2.   <id>alimaven</id>
  3.   <name>aliyunmaven</name>
  4.   <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
  5.   <mirrorOf>central</mirrorOf>        
  6. </mirror>

Maven项目管理工具（可以考虑作为骨架扩展） - 图13

2．Eclipse关联Maven

Maven项目管理工具（可以考虑作为骨架扩展） - 图14
Maven项目管理工具（可以考虑作为骨架扩展） - 图15

3．IDEA关联Maven

Maven项目管理工具（可以考虑作为骨架扩展） - 图16

4．使用Maven管理项目(重点)

l 目录规范
使用maven创建的工程我们称它为maven工程，maven工程具有一定的目录规范，如下：

  • src/main/java —— 存放项目的.java文件
  • src/main/resources —— 存放项目资源文件，如spring,hibernate配置文件
  • src/test/java —— 存放所有单元测试.java文件，如JUnit测试类
  • src/test/resources —— 测试资源文件
  • target —— 项目输出位置，编译后的class文件会输出到此目录
  • pom.xml ——maven项目核心配置文件

l 项目示例
下面是一个完整的使用Maven管理的JavaWeb项目的目录结构

  1. Project
  2. |-src
  3. | |-main
  4. | | |-java —— 存放项目的.java文件
  5. | | |-resources —— 存放项目资源文件，如spring, hibernate配置文件
  6. |-webapp —— webapp目录是web工程的主目录
  7. |-WEB-INF
  8. |-web.xml
  9. | |-test
  10. | |-java ——存放所有测试.java文件，如JUnit测试类
  11. | |-resources —— 测试资源文件
  12. |-target —— 目标文件输出位置例如.class、.jar、.war文件
  13. |-pom.xml ——maven项目核心配置文件

Maven骨架：其实就是maven创建不同的项目结构
Maven项目管理工具（可以考虑作为骨架扩展） - 图17
Maven项目管理工具（可以考虑作为骨架扩展） - 图18

（1）普通Java项目

①创建项目

Maven项目管理工具（可以考虑作为骨架扩展） - 图19
Maven项目管理工具（可以考虑作为骨架扩展） - 图20
Maven项目管理工具（可以考虑作为骨架扩展） - 图21
Maven项目管理工具（可以考虑作为骨架扩展） - 图22

②编写代码

Maven项目管理工具（可以考虑作为骨架扩展） - 图23

③编写测试

Maven项目管理工具（可以考虑作为骨架扩展） - 图24
l 添加Test依赖
可以通过http://mvnrepository.com/tags/maven网址搜索jar包的坐标

  1. <dependencies>
  2.        <dependency>
  3.            <groupId>junit</groupId>
  4.            <artifactId>junit</artifactId>
  5.            <version>4.12</version>
  6.        </dependency>
  7. </dependencies>

配置maven的编译级别

  1. <!--编译插件，可以配置编译版本，因为maven默认是按照1.5进行编译的-->
  2. <build>
  3.     <plugins>
  4.         <plugin>
  5.             <groupId>org.apache.maven.plugins</groupId>
  6.             <artifactId>maven-compiler-plugin</artifactId>
  7.             <version>3.1</version>
  8.             <configuration>
  9.                 <source>1.8</source>
  10.                 <target>1.8</target>
  11.                 <encoding>utf-8</encoding>
  12.             </configuration>
  13.         </plugin>
  14.     </plugins>
  15. </build>

测试用例（Use Case）：针对一个功能或者一个功能点的测试逻辑

（2）JavaWeb项目

①创建项目

Maven项目管理工具（可以考虑作为骨架扩展） - 图25
Maven项目管理工具（可以考虑作为骨架扩展） - 图26
Maven项目管理工具（可以考虑作为骨架扩展） - 图27
Maven项目管理工具（可以考虑作为骨架扩展） - 图28
Maven项目管理工具（可以考虑作为骨架扩展） - 图29
解决IntelliJ IDEA创建Maven项目速度慢问题
https://www.cnblogs.com/del88/p/6286887.html
增加属性：archetypeCatalog=internal
或者
全局属性
在maven的VM Options加上 -DarchetypeCatalog=internal 参数，如下：
Maven项目管理工具（可以考虑作为骨架扩展） - 图30
Maven项目管理工具（可以考虑作为骨架扩展） - 图31

②完善目录

Maven项目管理工具（可以考虑作为骨架扩展） - 图32

③添加依赖
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.    <modelVersion>4.0.0</modelVersion>
  5.    <groupId>com.bigdata</groupId>
  6.    <artifactId>maven_02</artifactId>
  7.    <version>1.0-SNAPSHOT</version>
  8.    <packaging>war</packaging>
  9.    <properties>
  10.        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  11.        <maven.compiler.source>1.8</maven.compiler.source>
  12.        <maven.compiler.target>1.8</maven.compiler.target>
  13.    </properties>
  14.    <dependencies>
  15.        <dependency>
  16.            <groupId>junit</groupId>
  17.            <artifactId>junit</artifactId>
  18.            <version>4.12</version>
  19.            <scope>test</scope>
  20.        </dependency>
  21.        <!-- Servlet -->
  22.        <dependency>
  23.            <groupId>javax.servlet</groupId>
  24.            <artifactId>javax.servlet-api</artifactId>
  25.            <version>3.1.0</version>
  26.            <!--只需编译无需打包,tomcat自带-->
  27.            <scope>provided</scope>
  28.        </dependency>
  29.        <!-- JSP -->
  30.        <dependency>
  31.            <groupId>javax.servlet.jsp</groupId>
  32.            <artifactId>jsp-api</artifactId>
  33.            <version>2.2</version>
  34.            <!--只需编译无需打包,tomcat自带-->
  35.            <scope>provided</scope>
  36.        </dependency>
  37.        <!-- JSTL -->
  38.        <dependency>
  39.            <groupId>javax.servlet</groupId>
  40.            <artifactId>jstl</artifactId>
  41.            <version>1.2</version>
  42.            <!--只是运行时依赖-->
  43.            <scope>runtime</scope>
  44.        </dependency>
  45.    </dependencies>
  46.    <build>
  47.         <plugins>
  48.            <!--配置编译级别-->
  49.            <plugin>
  50.                <groupId>org.apache.maven.plugins</groupId>
  51.                <artifactId>maven-compiler-plugin</artifactId>
  52.                <version>3.1</version>
  53.                <configuration>
  54.                    <source>1.8</source>
  55.                    <target>1.8</target>
  56.                </configuration>
  57.            </plugin>
  58.            <!--打包跳过单元测试-->
  59.            <plugin>
  60.                <groupId>org.apache.maven.plugins</groupId>
  61.                <artifactId>maven-surefire-plugin</artifactId>
  62.                <version>2.18.1</version>
  63.                <configuration>
  64.                    <skipTests>true</skipTests>
  65.                </configuration>
  66.            </plugin>
  67.            <!-- Tomcat -->
  68.            <plugin>
  69.                <groupId>org.apache.tomcat.maven</groupId>
  70.                <artifactId>tomcat7-maven-plugin</artifactId>
  71.                <version>2.2</version>
  72.                <configuration>
  73.                    <path>/${project.artifactId}</path>
  74.                    <port>8080</port>
  75.                </configuration>
  76.            </plugin>
  77.        </plugins>
  78.    </build>
  79. </project>

④编写代码

Maven项目管理工具（可以考虑作为骨架扩展） - 图33

  1. import javax.servlet.ServletException;
  2. import javax.servlet.annotation.WebServlet;
  3. import javax.servlet.http.HttpServlet;
  4. import javax.servlet.http.HttpServletRequest;
  5. import javax.servlet.http.HttpServletResponse;
  6. import java.io.IOException;
  7. import java.util.Date;
  8. @WebServlet("/hello")
  9. public class HelloServlet extends HttpServlet {
  10.    @Override
  11.    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  12.        doPost(req, resp);
  13.    }
  14.    @Override
  15.    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  16.        resp.getWriter().write(new Date().toString());
  17.    }
  18. }

⑤部署运行

l 添加到外置Tomcat运行
Maven项目管理工具（可以考虑作为骨架扩展） - 图34
Maven项目管理工具（可以考虑作为骨架扩展） - 图35
Maven项目管理工具（可以考虑作为骨架扩展） - 图36
Maven项目管理工具（可以考虑作为骨架扩展） - 图37
http://localhost:8080/hello
l 使用Tomcat插件运行
Maven项目管理工具（可以考虑作为骨架扩展） - 图38
或手动指定命令
Maven项目管理工具（可以考虑作为骨架扩展） - 图39

5．常见Maven命令

image.png

（1）clean

clean是maven工程的清理命令，执行 clean会删除整个target目录及内容。

（2）compile

compile是maven工程的编译命令，作用是将src/main/java下的文件编译为class文件输出到target目录下。

（3）test

test是maven工程的测试命令，会执行src/test/java下的单元测试类。
注意：
1、需要注掉pom.xml中打包跳过测试那一段
2、Maven要求测试类放在src/test/java目录下，且测试方法的
类名以Test结尾、方法名以test开头

（4）package

package是maven工程的打包命令，对于java工程执行package打成jar包，对于web工程打成war包。

（5）install

install是maven工程的安装命令，执行install将项目打成jar包或war包发布到本地仓库。

三、Maven扩展(了解)

1．Maven的生命周期

l 何为生命周期？
• Maven生命周期就是为了对所有的构建过程进行抽象和统一
• 包括项目清理，初始化，编译，打包，测试，部署等几乎所有构建步骤
l Maven三大生命周期
生命周期Maven有三套相互独立的生命周期，
• clean：在进行真正的构建之前进行一些清理工作
• default：构建的核心部分，编译，测试，打包，部署等等
• site：生成项目报告，站点，发布站点
它们是相互独立的，你可以仅仅调用clean来清理工作目录，仅仅调用site来生成站点。当然你也可以直接运行 mvn clean install site 运行所有这三套生命周期。
Maven项目管理工具（可以考虑作为骨架扩展） - 图41

（1）clean生命周期

clean生命周期每套生命周期都由一组阶段(Phase)组成，我们平时在命令行输入的命令总会对应于一个特定的阶段。比如，运行mvn clean ，这个的clean是Clean生命周期的一个阶段。有Clean生命周期，也有clean阶段。Clean生命周期一共包含了三个阶段：
l pre-clean 执行一些需要在clean之前完成的工作
l clean 移除所有上一次构建生成的文件
l post-clean 执行一些需要在clean之后立刻完成的工作

mvn clean 中的clean就是上面的clean，在一个生命周期中，运行某个阶段的时候，它之前的所有阶段都会被运行，也就是说，mvn clean 等同于 mvn pre-clean clean ，如果我们运行 mvn post-clean ，那么 pre-clean，clean 都会被运行。这是Maven很重要的一个规则，可以大大简化命令行的输入。

（2）site生命周期

l pre-site 执行一些需要在生成站点文档之前完成的工作
l site 生成项目的站点文档
l post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
l site-deploy 将生成的站点文档部署到特定的服务器上

这里经常用到的是site阶段和site-deploy阶段，用以生成和发布Maven站点，这可是Maven相当强大的功能，Manager比较喜欢，文档及统计数据自动生成，很好看。

（3）default生命周期

l Default生命周期
Default生命周期是Maven生命周期中最重要的一个，绝大部分工作都发生在这个生命周期中。这里，只解释一些比较重要和常用的阶段：
l validate
l generate-sources
l process-sources
l generate-resources
l process-resources 复制并处理资源文件，至目标目录，准备打包。
l compile 编译项目的源代码。
l process-classes
l generate-test-sources
l process-test-sources
l generate-test-resources
l process-test-resources 复制并处理资源文件，至目标测试目录。
l test-compile 编译测试源代码。
l process-test-classes
l test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
l prepare-package
l package 接受编译好的代码，打包成可发布的格式，如 JAR 。
l pre-integration-test
l integration-test
l post-integration-test
l verify
l install 将包安装至本地仓库，以让其它项目依赖。
l deploy 将最终的包复制到远程的仓库，以让其它开发人员与项目共享。
运行任何一个阶段的时候，它前面的所有阶段都会被运行
这也就是为什么我们运行mvn install 命令的时候，代码会被编译，测试，打包。
注意：default生命周期中不包含clean,开发中如果修改代码后打包运行没有更改的效果,需要重新执行clean命令

2．Maven依赖范围

依赖：项目需要依靠一个jar
依赖范围：依赖一个jar，并不一定是在项目整个生命周期都需要它，可能只是在某一个阶段需要，那么依赖范围就是在定义在哪些阶段依赖这个jar
A依赖B，需要在A的pom.xml文件中添加B的坐标，大家注意到我们之前添加坐标时还有写了一个scope ，这是依赖的范围。
scope有几个可选值， 如：

  1. compile： 默认值，表示编译依赖范围。即编译、测试、运行时都需要，会被打包。（默认值compile表明该jar一直全程存在/需要）
  2. test：表示测试依赖范围。即测试时需要，编译和运行时不需要，不会被打包。比如：junit。
  3. provided：表示已提供依赖范围。即编译、测试时需要，运行时不需要，不会被打包。比如：servlet-api和jsp-api被tomcat容器提供。服务器本身会提供这些jar，避免和服务器上的这些包冲突
  4. runtime: 表示运行时提供依赖范围。即编译时不需要，运行和测试时需要，会被打包。比如：jstl、jdbc驱动。
  5. system：system范围依赖与provided类似，但是你必须显式的提供一个对于本地系统中JAR文件的路径，需要指定systemPath磁盘路径，system依赖不推荐使用。

Maven项目管理工具（可以考虑作为骨架扩展） - 图42
l 测试各个scope
package打war观察jsp-api和servlet-api是否在war中存在？不在
package打war观察mysql-connctor-java是否在war中存在？在

  1. <dependency>
  2.    <groupId>junit</groupId>
  3.    <artifactId>junit</artifactId>
  4.    <version>4.12</version>
  5.    <scope>test</scope>
  6. </dependency>
  7. <!-- Servlet -->
  8. <dependency>
  9.    <groupId>javax.servlet</groupId>
  10.    <artifactId>javax.servlet-api</artifactId>
  11.    <version>3.1.0</version>
  12.    <!--只需编译无需打包,tomcat自带-->
  13.    <scope>provided</scope>
  14. </dependency>
  15. <!-- JSP -->
  16. <dependency>
  17.    <groupId>javax.servlet.jsp</groupId>
  18.    <artifactId>jsp-api</artifactId>
  19.    <version>2.2</version>
  20.    <!--只需编译无需打包,tomcat自带-->
  21.    <scope>provided</scope>
  22. </dependency>
  23. <!-- JSTL -->
  24. <dependency>
  25.    <groupId>javax.servlet</groupId>
  26.    <artifactId>jstl</artifactId>
  27.    <version>1.2</version>
  28.    <!--只是运行时依赖-->
  29.    <scope>runtime</scope>
  30. </dependency>
  31. <dependency>
  32.    <groupId>mysql</groupId>
  33.    <artifactId>mysql-connector-java</artifactId>
  34.    <version>5.1.40</version>
  35.    <scope>runtime</scope>
  36. </dependency>

l 测试总结：

  • 默认引入 的jar包 —-compile 【默认范围 可以不写】（编译、测试、运行 都有效 ）
  • servlet-api 、jsp-api —-provided （编译、测试 有效， 运行时无效 防止和tomcat下jar冲突）
  • jdbc驱动jar包 —-runtime （测试、运行 有效 ）
  • junit —-test （测试有效）

依赖范围由强到弱的顺序是：compile>provided>runtime>test
总结：
开发中一般使用默认compile即可,如果有错误再进行修改,修改的原则也很简单记住常用的几个provided:servlet和jsp

3．Maven的插件(增强功能)

l Maven的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的，每个插件都能实现多个功能，每个功能就是一个插件目标
l maven插件可以完成一些特定的功能。例如，集成jdk插件可以方便的修改项目的编译环境；集成tomcat插件后，无需安装tomcat服务器就可以运行tomcat进行项目的发布与测试。
l 在pom.xml中通过plugin标签引入maven的功能插件。

  1. <plugins>
  2.   <!-- Compile -->
  3.   <plugin>
  4.     <groupId>org.apache.maven.plugins</groupId>
  5.     <artifactId>maven-compiler-plugin</artifactId>
  6.     <version>3.3</version>
  7.     <configuration>
  8.       <source>1.8</source>
  9.       <target>1.8</target>
  10.       <encoding>UTF-8</encoding>
  11.     </configuration>
  12.   </plugin>
  13.   <!-- 打包跳过Test -->
  14.   <plugin>
  15.     <groupId>org.apache.maven.plugins</groupId>
  16.     <artifactId>maven-surefire-plugin</artifactId>
  17.     <version>2.18.1</version>
  18.     <configuration>
  19.       <skipTests>true</skipTests>
  20.     </configuration>
  21.   </plugin>
  22.   <!--   配置Tomcat插件 -->
  23.   <plugin>
  24.     <groupId>org.apache.tomcat.maven</groupId>
  25.     <artifactId>tomcat7-maven-plugin</artifactId>
  26.     <version>2.2</version>
  27.     <configuration>
  28.       <!--<path>/${project.artifactId}</path>-->
  29.       <path>/</path>
  30.       <port>80</port>
  31.     </configuration>
  32.   </plugin>
  33.   <!--  maven的源码打包插件 -->
  34.   <plugin>
  35.     <artifactId>maven-source-plugin</artifactId>
  36.     <version>2.4</version>
  37.     <executions>
  38.       <execution>
  39.         <phase>package</phase>
  40.         <goals>
  41.           <goal>jar-no-fork</goal>
  42.         </goals>
  43.       </execution>
  44.     </executions>
  45.   </plugin>
  46.   <!-- 资源文件拷贝插件 -->
  47.   <plugin>
  48.     <groupId>org.apache.maven.plugins</groupId>
  49.     <artifactId>maven-resources-plugin</artifactId>
  50.     <version>2.7</version>
  51.     <executions>
  52.       <execution>
  53.         <id>copy-xmls</id>
  54.         <phase>process-sources</phase>
  55.         <goals>
  56.           <goal>copy-resources</goal>
  57.         </goals>
  58.         <configuration>
  59.           <outputDirectory>${basedir}/target/classes</outputDirectory>
  60.           <resources>
  61.             <resource>
  62.               <directory>${basedir}/src/main/java</directory>
  63.               <includes>
  64.                 <include>**/*.xml</include>
  65.               </includes>
  66.             </resource>
  67.             <resource>
  68.               <directory>${basedir}/src/main/resources</directory>
  69.               <includes>
  70.                 <include>**/*.xml</include>
  71.               </includes>
  72.             </resource>
  73.           </resources>
  74.         </configuration>
  75.       </execution>
  76.     </executions>
  77.   </plugin>
  78. </plugins>

四、Maven构建SSM工程[应用]

l 需求：SSM整合实现查询商品列表
l 整合思路回顾
SSM=(Mybatis+Spring)+SpringMVC
=(Dao层+Service层)+Web层
Dao层和Service分别开发完毕之后，然后按照三个整合目标完成后续工作：
目标1：数据库连接池和数据库事务交给Spring管理
目标2：SqlSessionFactory作为单例交给Spring管理
目标3：Spring扫描Mapper接口创建并管理Mapper代理对象，我们使用的时候直接去容器中拿到Mapper代理对象进行使用
测试Mybatis+Spring
再整合SpringMVC（相当于在已有整合工程的基础上开发SpringMVC的入门案例）
细节1：Controller层扫描应该配置在Springmvc的配置文件中
细节2：Spring框架使用监听器启动（配置在web.xml中）
l POM.xml
注意：以后到公司使用Maven也是这样，引入一个Jar包需要三步：定义版本、锁定版本、引入jar包；但是这么干未免太过麻烦，所以每个公司都有自己的POM文件模板，项目经理会提供给你你直接使用即可，比如像我们今天的项目就需要一个这样的模板

（一）依赖传递[理解]

在Maven的POM文件中导入一个jar的坐标，那么Maven会把这个jar所依赖的jar全部下载下来，这种机制就叫做依赖传递。
我们直接导入的jar叫做直接依赖；由Maven补全的jar叫做间接依赖。

（二）依赖冲突的解决[理解]

l 第一声明者优先原则：哪个jar坐标导入在前（pom文件中该jar的坐标配置在上面），依赖jar的版本和这个jar的版本保持一致
l 路径近者优先原则：在pom.xml中明确配置了某一个jar的版本（明确告诉maven我要使用哪个版本，那就是用哪个版本），那么就以此为准
l 版本锁定：好处在父子工程中体现的更明显

（三）搭建SSM工程[应用]

1．新建一个 ssm_maven 项目,使用下图选中的骨架

Maven项目管理工具（可以考虑作为骨架扩展） - 图43

2．下一步填写坐标

Maven项目管理工具（可以考虑作为骨架扩展） - 图44

3．确认是否使用的自己的私服，然后直接下一步完成

Maven项目管理工具（可以考虑作为骨架扩展） - 图45

4．在 main 目录下新建 java 和 resources 文件夹

Maven项目管理工具（可以考虑作为骨架扩展） - 图46

5．把 java 和 resources 文件夹转成 source root

Maven项目管理工具（可以考虑作为骨架扩展） - 图47

6．修改编译版本，在 pom.xml 文件中添加

  1. <build>
  2.   <plugins>
  3.     <!-- 设置编译版本为 1.8 -->
  4.     <plugin>
  5.       <groupId>org.apache.maven.plugins</groupId>
  6.       <artifactId>maven-compiler-plugin</artifactId>
  7.       <version>3.1</version >
  8.       <configuration>
  9.         <source>1.8</source>
  10.         <target>1.8</target>
  11.         <encoding>UTF-8</encoding>
  12.       </configuration>
  13.     </plugin>
  14.   </plugins>
  15. </build>

7．定义 pom.xml

maven 工程首先要识别依赖，web 工程实现 SSM 整合，需要依赖 spring-webmvc5.0.2、
spring5.0.2、mybatis3.4.5 等，在 pom.xml 添加工程如下依赖：（在实际企业开发中会有专门得人来编写 pom.xml）
分两步：
1）锁定依赖版本
2）添加依赖

  1. <groupId>com.mavenDemo.maven</groupId>
  2.  <artifactId>ssm_maven</artifactId>
  3.  <version>1.0-SNAPSHOT</version>
  4.  <packaging>war</packaging>
  5. <!-- POM文件模板开始 -->
  6.  <properties>
  7.    <!-- 项目编码 -->
  8.    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  9.    <!-- 编译及输出的时候应用那个版本的jdk -->
  10.    <maven.compiler.source>1.7</maven.compiler.source>
  11.    <maven.compiler.target>1.7</maven.compiler.target>
  12.    <!-- 定义spring的版本 -->
  13.    <spring.version>5.0.2.RELEASE</spring.version>
  14.  </properties>
  15.  <dependencyManagement>
  16.    <dependencies>
  17.      <!-- 底层容器 -->
  18.      <!-- SpringBean管理 -->
  19.      <dependency>
  20.        <groupId>org.springframework</groupId>
  21.        <artifactId>spring-beans</artifactId>
  22.        <version>${spring.version}</version>
  23.      </dependency>
  24.      <!-- Spring IOC管理 -->
  25.      <dependency>
  26.        <groupId>org.springframework</groupId>
  27.        <artifactId>spring-context</artifactId>
  28.        <version>${spring.version}</version>
  29.      </dependency>
  30.      <!-- Spring AOP管理 -->
  31.      <dependency>
  32.        <groupId>org.springframework</groupId>
  33.        <artifactId>spring-aop</artifactId>
  34.        <version>${spring.version}</version>
  35.      </dependency>
  36.      <!-- 切面功能包里面包含了我们用的切面切入点织入等功能-->
  37.      <dependency>
  38.        <groupId>org.aspectj</groupId>
  39.        <artifactId>aspectjweaver</artifactId>
  40.        <version>1.8.7</version>
  41.      </dependency>
  42.      <!-- 数据库操作 -->
  43.      <!-- mybatis的核心包 -->
  44.      <dependency>
  45.        <groupId>org.mybatis</groupId>
  46.        <artifactId>mybatis</artifactId>
  47.        <version>3.4.5</version>
  48.      </dependency>
  49.      <!-- mybatis与spring的整合包 -->
  50.      <dependency>
  51.        <groupId>org.mybatis</groupId>
  52.        <artifactId>mybatis-spring</artifactId>
  53.        <version>1.3.1</version>
  54.      </dependency>
  55.      <!-- 事务操作 -->
  56.      <dependency>
  57.        <groupId>org.springframework</groupId>
  58.        <artifactId>spring-tx</artifactId>
  59.        <version>${spring.version}</version>
  60.      </dependency>
  61.      <!-- JDBC辅助 -->
  62.      <dependency>
  63.        <groupId>org.springframework</groupId>
  64.        <artifactId>spring-jdbc</artifactId>
  65.        <version>${spring.version}</version>
  66.      </dependency>
  67.      <!-- 页面功能 -->
  68.      <!-- SpringMVC -->
  69.      <dependency>
  70.        <groupId>org.springframework</groupId>
  71.        <artifactId>spring-webmvc</artifactId>
  72.        <version>${spring.version}</version>
  73.      </dependency>
  74.      <!-- ServletAPI -->
  75.      <dependency>
  76.        <groupId>javax.servlet</groupId>
  77.        <artifactId>jsp-api</artifactId>
  78.        <version>2.0</version>
  79.        <scope>provided</scope>
  80.      </dependency>
  81.      <dependency>
  82.        <groupId>javax.servlet</groupId>
  83.        <artifactId>servlet-api</artifactId>
  84.        <version>2.5</version>
  85.        <scope>provided</scope>
  86.      </dependency>
  87.      <!-- JSTL -->
  88.      <dependency>
  89.        <groupId>jstl</groupId>
  90.        <artifactId>jstl</artifactId>
  91.        <version>1.2</version>
  92.      </dependency>
  93.      <dependency>
  94.        <groupId>taglibs</groupId>
  95.        <artifactId>standard</artifactId>
  96.        <version>1.1.2</version>
  97.      </dependency>
  98.      <!-- 单元测试 -->
  99.      <dependency>
  100.        <groupId>org.springframework</groupId>
  101.        <artifactId>spring-test</artifactId>
  102.        <version>${spring.version}</version>
  103.      </dependency>
  104.      <dependency>
  105.        <groupId>junit</groupId>
  106.        <artifactId>junit</artifactId>
  107.        <version>4.12</version>
  108.      </dependency>
  109.    </dependencies>
  110.  </dependencyManagement>
  111.  <dependencies>
  112.    <!-- 底层容器 -->
  113.    <!-- SpringBean管理 -->
  114.    <dependency>
  115.      <groupId>org.springframework</groupId>
  116.      <artifactId>spring-beans</artifactId>
  117.    </dependency>
  118.    <!-- Spring IOC管理 -->
  119.    <dependency>
  120.      <groupId>org.springframework</groupId>
  121.      <artifactId>spring-context</artifactId>
  122.    </dependency>
  123.    <!-- Spring AOP管理 -->
  124.    <dependency>
  125.      <groupId>org.springframework</groupId>
  126.      <artifactId>spring-aop</artifactId>
  127.    </dependency>
  128.    <!-- 切面功能包里面包含了我们用的切面切入点织入等功能-->
  129.    <dependency>
  130.      <groupId>org.aspectj</groupId>
  131.      <artifactId>aspectjweaver</artifactId>
  132.    </dependency>
  133.    <!-- 数据库操作 -->
  134.    <!-- mybatis的核心包 -->
  135.    <dependency>
  136.      <groupId>org.mybatis</groupId>
  137.      <artifactId>mybatis</artifactId>
  138.    </dependency>
  139.    <!-- mybatis与spring的整合包 -->
  140.    <dependency>
  141.      <groupId>org.mybatis</groupId>
  142.      <artifactId>mybatis-spring</artifactId>
  143.    </dependency>
  144.    <!-- 事务操作 -->
  145.    <dependency>
  146.      <groupId>org.springframework</groupId>
  147.      <artifactId>spring-tx</artifactId>
  148.    </dependency>
  149.    <!-- JDBC辅助 -->
  150.    <dependency>
  151.      <groupId>org.springframework</groupId>
  152.      <artifactId>spring-jdbc</artifactId>
  153.    </dependency>
  154.    <!-- 页面功能 -->
  155.    <!-- SpringMVC -->
  156.    <dependency>
  157.      <groupId>org.springframework</groupId>
  158.      <artifactId>spring-webmvc</artifactId>
  159.    </dependency>
  160.    <!-- ServletAPI -->
  161.    <dependency>
  162.      <groupId>javax.servlet</groupId>
  163.      <artifactId>jsp-api</artifactId>
  164.    </dependency>
  165.    <dependency>
  166.      <groupId>javax.servlet</groupId>
  167.      <artifactId>servlet-api</artifactId>
  168.    </dependency>
  169.    <!-- JSTL -->
  170.    <dependency>
  171.      <groupId>jstl</groupId>
  172.      <artifactId>jstl</artifactId>
  173.    </dependency>
  174.    <dependency>
  175.      <groupId>taglibs</groupId>
  176.      <artifactId>standard</artifactId>
  177.    </dependency>
  178.    <!-- 单元测试 -->
  179.    <dependency>
  180.      <groupId>org.springframework</groupId>
  181.      <artifactId>spring-test</artifactId>
  182.    </dependency>
  183.    <dependency>
  184.      <groupId>junit</groupId>
  185.      <artifactId>junit</artifactId>
  186.    </dependency>
  187.    <!-- 数据库驱动 -->
  188.    <!-- Oracle驱动 -->
  189.    <dependency>
  190.      <groupId>com.oracle</groupId>
  191.      <artifactId>ojdbc14</artifactId>
  192.      <version>10.2.0.4.0</version>
  193.    </dependency>
  194.    <!-- mysql驱动 -->
  195.    <dependency>
  196.      <groupId>mysql</groupId>
  197.      <artifactId>mysql-connector-java</artifactId>
  198.      <version>5.1.7</version>
  199.    </dependency>
  200.    <!-- 数据源 -->
  201.    <dependency>
  202.      <groupId>commons-dbcp</groupId>
  203.      <artifactId>commons-dbcp</artifactId>
  204.      <version>1.4</version>
  205.    </dependency>
  206.  </dependencies>
  207. <!-- POM文件模板结束 -->

8．Dao 层

在src/main/java 中定义 dao 接口，实现查询全部：

（1）pojo 模型类

在src/main/java 创建模型类
Maven项目管理工具（可以考虑作为骨架扩展） - 图48

（2） dao 层代码

Maven项目管理工具（可以考虑作为骨架扩展） - 图49
配置文件：注意配置文件的位置
Maven项目管理工具（可以考虑作为骨架扩展） - 图50
在 src/main/resources 创建 spring-core.xml

  1. <!-- 1. 引入外部的配置文件 -->
  2.     <context:property-placeholder location="classpath:ssm.properties" />
  3.     <!-- 2. 配置注解bean的包扫描 -->
  4.     <context:component-scan base-package="cn.mavenDemo">
  5.         <!-- 排除springmvc的Controller注解 -->
  6.         <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
  7.     </context:component-scan>
  8.     <!-- 3. 配置数据源 -->
  9.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
  10.         <!-- 四大属性 -->
  11.         <property name="driverClassName" value="${jdbc.driver}" />
  12.         <property name="url" value="${jdbc.url}" />
  13.         <property name="username" value="${jdbc.username}" />
  14.         <property name="password" value="${jdbc.userpass}" />
  15.     </bean>
  16.     <!-- 4.session 工厂 -->
  17.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  18.         <!-- 绑定数据源 -->
  19.         <property name="dataSource" ref="dataSource" />
  20.         <!-- 加载配置文件 -->
  21.         <property name="configLocation" value="classpath:SqlMapConfig.xml" />
  22.         <!-- 加载映射文件 -->
  23.         <property name="mapperLocations" value="classpath:com/**/*Mapper.xml" />
  24.     </bean>
  25.     <!-- 5.mybaits的专用接口扫描 -->
  26.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  27.         <property name="basePackage" value="cn.mavenDemo.ssm.dao" />
  28.     </bean>
  29.     <!-- 6.事务管理器 -->
  30.     <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  31.         <!-- 绑定数据源 -->
  32.         <property name="dataSource" ref="dataSource" />
  33.     </bean>
  34.     <!-- 7.声明式事务 -->
  35.     <tx:advice id="txAdvice" transaction-manager="txManager">
  36.         <tx:attributes>
  37.             <!-- 查询方法 : 只读事务,当前有事务沿用当前的事务,没事务以非事务方式运行,保证快 -->
  38.             <tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
  39.             <!-- 操作方法 : 非只读,以读已提交数据为事务隔离界别,如果有事务用当前事务,没事创建一个新的始终保持在事务方法中运行 -->
  40.             <!-- READ_COMMITTED 读已提交 并发访问速度快 但是不安全 牺牲安全保证速度 -->
  41.             <tx:method name="insert*" isolation="READ_COMMITTED" />
  42.             <tx:method name="update*" isolation="READ_COMMITTED" />
  43.             <tx:method name="delete*" isolation="READ_COMMITTED" />
  44.             <tx:method name="*" read-only="true" propagation="SUPPORTS"/>
  45.         </tx:attributes>
  46.     </tx:advice>
  47.     <!-- 8.AOP 代理实现 -->
  48.     <aop:config>
  49.         <!-- 配置切入点 -->
  50.         <aop:pointcut id="serviceCut" expression="execution(* cn.mavenDemo.ssm.service..*.*(..))" />
  51.         <!-- 织入 -->
  52.         <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceCut" />
  53.     </aop:config>

在 src/main/resources 创建SqlMapConfig.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3.        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.        "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.    <!-- 1. 显示SQL语句 -->
  7.    <settings>
  8.        <setting name="logImpl" value="STDOUT_LOGGING"/>
  9.    </settings>
  10.    <!-- 2. 配置别名包 -->
  11.    <typeAliases>
  12.        <package name="cn.mavenDemo.pojo" />
  13.    </typeAliases>
  14. </configuration>

创建ssm.properties

  1. jdbc.driver = oracle.jdbc.OracleDriver
  2. jdbc.url = jdbc:oracle:thin:@127.0.0.1:1521:orcl
  3. jdbc.username = ssmoperate
  4. jdbc.userpass = orcl

（3）Service 层

Maven项目管理工具（可以考虑作为骨架扩展） - 图51
Maven项目管理工具（可以考虑作为骨架扩展） - 图52

（4）Web 层

Maven项目管理工具（可以考虑作为骨架扩展） - 图53
配置文件
在 src/main/resources 创建 spring-mvc.xml

  1. <!-- 1.配置controller注解 -->
  2.    <context:component-scan base-package="cn.mavenDemo">
  3.        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" />
  4.    </context:component-scan>
  5.    <!-- 2.加载预置的SpringMVC -->
  6.    <mvc:annotation-driven />
  7.    <!-- 3.配置视图解析器/WEB-INF/pages/account_list.jsp  -->
  8.    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  9.        <!-- 前缀 -->
  10.        <property name="prefix" value="/WEB-INF/pages/" />
  11.        <!-- 后缀 -->
  12.        <property name="suffix" value=".jsp" />
  13.    </bean>

Web.xml
加载 spring 容器，配置 springmvc 前端控制器

  1. <!DOCTYPE web-app PUBLIC
  2.  "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
  3.  "http://java.sun.com/dtd/web-app_2_3.dtd" >
  4. <web-app>
  5.   <display-name>Archetype Created Web Application</display-name>
  6.   <!-- 加载spring配置 -->
  7.   <context-param>
  8.     <param-name>contextConfigLocation</param-name>
  9.     <param-value>classpath:spring-core.xml</param-value>
  10.   </context-param>
  11.   <!-- 过滤器 -->
  12.   <filter>
  13.     <filter-name>EncodingFilter</filter-name>
  14.     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  15.     <init-param>
  16.       <param-name>encoding</param-name>
  17.       <param-value>UTF-8</param-value>
  18.     </init-param>
  19.   </filter>
  20.   <filter>
  21.     <filter-name>RestFulFilter</filter-name>
  22.     <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  23.   </filter>
  24.   <filter-mapping>
  25.     <filter-name>EncodingFilter</filter-name>
  26.     <url-pattern>/*</url-pattern>
  27.   </filter-mapping>
  28.   <filter-mapping>
  29.     <filter-name>RestFulFilter</filter-name>
  30.     <url-pattern>/*</url-pattern>
  31.   </filter-mapping>
  32.   <!-- 配置spring的监听器 -->
  33.   <listener>
  34.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  35.   </listener>
  36.   <!-- springmvc核心servlet -->
  37.   <servlet>
  38.     <servlet-name>springmvc</servlet-name>
  39.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  40.     <!-- 加载一下springmvc的配置文件 -->
  41.     <init-param>
  42.       <param-name>contextConfigLocation</param-name>
  43.       <param-value>classpath:spring-mvc.xml</param-value>
  44.     </init-param>
  45.   </servlet>
  46.   <servlet-mapping>
  47.     <servlet-name>springmvc</servlet-name>
  48.     <url-pattern>/</url-pattern>
  49.   </servlet-mapping>
  50. </web-app>

（5）JSP

Index.jsp

  1. <%@ page isELIgnored="false" contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3. <head>
  4.     <title>系统首页</title>
  5.     <script type="text/javascript">
  6.         function goView() {
  7.             window.location.href = "${pageContext.request.contextPath}/AccountViewAction/AccountView";
  8.         }
  9.         function goAdd() {
  10.             alert("准备添加");
  11.         }
  12.     </script>
  13. </head>
  14. <body>
  15.     <div>
  16.         <h1>欢迎使用账户信息管理系统</h1>
  17.         <h3>请选择你要使用的功能 :</h3>
  18.         <input type="button" value="添加" onclick="goAdd();" />
  19.         &nbsp;&nbsp;&nbsp;&nbsp;
  20.         <input type="button" value="查询" onclick="goView();" />
  21.     </div>
  22. </body>
  23. </html>

AccountList.jsp

  1. <%@ page isELIgnored="false" contentType="text/html;charset=UTF-8" language="java" %>
  2. <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
  3. <%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
  4. <html>
  5. <head>
  6.     <title>数据展示</title>
  7. </head>
  8. <body>
  9.     <div>
  10.         <c:if test="${not empty accounts}">
  11.             <table border="1">
  12.                 <thead>
  13.                     <tr>
  14.                         <th>编号</th>
  15.                         <th>姓名</th>
  16.                         <th>金额</th>
  17.                     </tr>
  18.                 </thead>
  19.                 <tbody>
  20.                     <c:forEach items="${accounts}" var="a">
  21.                         <tr align="center">
  22.                             <td>${a.id}</td>
  23.                             <td>${a.name}</td>
  24.                             <td>
  25.                                 <fmt:formatNumber type="currency" value="${a.money}" />
  26.                             </td>
  27.                         </tr>
  28.                     </c:forEach>
  29.                 </tbody>
  30.             </table>
  31.         </c:if>
  32.     </div>
  33. </body>
  34. </html>

（6）运行与调试

已添加 tomcat7 插件，双击右侧 tomcat7 运行
Maven项目管理工具（可以考虑作为骨架扩展） - 图54

五、分模块构建工程[应用]

l 分析
Maven项目管理工具（可以考虑作为骨架扩展） - 图55
l 分模块开发细节注意
注意：表现层工程web.xml去加载Spring applicationContext开头的配置文件时，我们要使用classpath
l 理解继承和聚合
通常继承和聚合同时使用
父工程的特征：packing： pom , （jar/war）
| 何为继承？
继承是为了消除重复，如果将dao、service、web分开创建独立的工程，则每个工程的pom.xml文件中内容存在重复，比如设置编译版本、锁定spring的版本等，可以将这些重复的内容提取出放在父工程的pom.xml中定义
l 何为聚合？
项目开发通常分模块/分工程开发，每个模块开发完成要运行整个工程需要将每个模块聚合在一起，比如：dao、service、web三个工程最终打成一个war包运行
*l 依赖范围对传递依赖的影响（了解）
service层依赖于dao层，有一个scope（runtime）
假如dao层依赖于一个jar包A，也有一个scope（test）配置
service能否使用A这个jar？看两个scope的值
Maven项目管理工具（可以考虑作为骨架扩展） - 图56

（一）搭建分模块工程

基于上边的三个工程分析
继承：创建一个 parent 工程将所需的依赖都配置在 pom 中
聚合：聚合多个模块运行。

1．需求

需求描述——将 SSM 工程拆分为多个模块开发：
ssm_dao ssm_service ssm_web
Maven项目管理工具（可以考虑作为骨架扩展） - 图57

2．创建父工程maven-parent

（1）选择骨架创建父工程

Maven项目管理工具（可以考虑作为骨架扩展） - 图58
注意代码所在的路径
Maven项目管理工具（可以考虑作为骨架扩展） - 图59
添加项目的打包方式
Maven项目管理工具（可以考虑作为骨架扩展） - 图60
定义 pom.xml
在父工程的 pom.xml 中抽取一些重复的配置的，比如：锁定 jar 包的版本、设置编译版本等。

  1. <properties>
  2. <spring.version>5.0.2.RELEASE</spring.version>
  3. <springmvc.version>5.0.4.RELEASE</springmvc.version> <mybatis.version>3.4.5</mybatis.version>
  4. </properties>
  5. <dependencyManagement>
  6.   <dependencies>
  7.     <!-- Mybatis -->
  8.     <dependency>
  9.         <groupId>org.mybatis</groupId>
  10.         <artifactId>mybatis</artifactId>
  11.         <version>${mybatis.version}</version> 
  12.     </dependency>
  13.     <!-- springMVC -->
  14.     <dependency>
  15.         <groupId>org.springframework</groupId> 
  16.       <artifactId>spring-webmvc</artifactId> 
  17.       <version>${springmvc.version}</version>
  18.     </dependency>
  19.     <dependency>
  20.         <groupId>org.springframework</groupId> 
  21.       <artifactId>spring-context</artifactId> 
  22.       <version>${spring.version}</version>
  23.     </dependency>
  24.     <!-- spring -->
  25.     <dependency>
  26.         <groupId>org.springframework</groupId> 
  27.       <artifactId>spring-core</artifactId> 
  28.       <version>${spring.version}</version>
  29.     </dependency>
  30.     <dependency>
  31.         <groupId>org.springframework</groupId> 
  32.       <artifactId>spring-aop</artifactId> 
  33.       <version>${spring.version}</version>
  34.     </dependency>
  35.     <dependency>
  36.         <groupId>org.springframework</groupId>
  37.       <artifactId>spring-web</artifactId>
  38.         <version>${spring.version}</version>
  39.     </dependency>
  40.     <dependency>
  41.         <groupId>org.springframework</groupId>
  42.         <artifactId>spring-expression</artifactId> 
  43.       <version>${spring.version}</version>
  44.     </dependency>
  45.     <dependency>
  46.         <groupId>org.springframework</groupId> 
  47.       <artifactId>spring-beans</artifactId> 
  48.       <version>${spring.version}</version>
  49.     </dependency>
  50.     <dependency>
  51.         <groupId>org.springframework</groupId> 
  52.       <artifactId>spring-aspects</artifactId> 
  53.       <version>${spring.version}</version>
  54.     </dependency>
  55.     <dependency>
  56.         <groupId>org.springframework</groupId>
  57.         <artifactId>spring-context-support</artifactId> 
  58.       <version>${spring.version}</version>
  59.     </dependency>
  60.     <dependency>
  61.         <groupId>org.springframework</groupId> 
  62.       <artifactId>spring-test</artifactId> 
  63.       <version>${spring.version}</version>
  64.     </dependency>
  65.     <dependency>
  66.         <groupId>org.springframework</groupId> 
  67.       <artifactId>spring-jdbc</artifactId> 
  68.       <version>${spring.version}</version>
  69.     </dependency>
  70.     <dependency>
  71.       <groupId>org.springframework</groupId>
  72.       <artifactId>spring-tx</artifactId>
  73.       <version>${spring.version}</version>
  74.     </dependency>
  75.   </dependencies>
  76. </dependencyManagement>
  77. <build>
  78.   <plugins>
  79.   <plugin>
  80.     <groupId>org.apache.maven.plugins</groupId>
  81.     <artifactId>maven-compiler-plugin</artifactId>
  82.     <version>3.1</version>
  83.     <configuration>
  84.       <target>1.8</target>
  85.       <source>1.8</source>
  86.     </configuration>
  87.     </plugin>
  88.   </plugins>
  89. </build>

将父工程发布至仓库
Maven项目管理工具（可以考虑作为骨架扩展） - 图61

（2）ssm_dao 子模块

在父工程上右击创建 maven 模块：
Maven项目管理工具（可以考虑作为骨架扩展） - 图62
选择“跳过骨架选择”
Maven项目管理工具（可以考虑作为骨架扩展） - 图63
填写模块名称
Maven项目管理工具（可以考虑作为骨架扩展） - 图64
下一步，确定项目的目录
Maven项目管理工具（可以考虑作为骨架扩展） - 图65
添加打包方式是 jar
Maven项目管理工具（可以考虑作为骨架扩展） - 图66
定义 pom.xml

  1. <dependencies>
  2.   <!-- Mybatis 和 mybatis 与 spring 的整合 --> 
  3.   <dependency>
  4.       <groupId>org.mybatis</groupId>
  5.       <artifactId>mybatis</artifactId>
  6.   </dependency>
  7.   <dependency>
  8.       <groupId>org.mybatis</groupId>
  9.       <artifactId>mybatis-spring</artifactId> 
  10.     <version>1.3.1</version>
  11.   </dependency>
  12.   <!-- MySql 驱动 -->
  13.   <dependency>
  14.       <groupId>mysql</groupId>
  15.       <artifactId>mysql-connector-java</artifactId> 
  16.     <version>5.1.32</version>
  17.   </dependency>
  18.   <!-- druid 数据库连接池 -->
  19.   <dependency>
  20.     <groupId>com.alibaba</groupId>
  21.     <artifactId>druid</artifactId>
  22.     <version>1.0.9</version>
  23.   </dependency>
  24.   <!-- spring 相关 -->
  25.   <dependency>
  26.       <groupId>org.springframework</groupId> 
  27.     <artifactId>spring-context</artifactId>
  28.   </dependency>
  29.   <dependency>
  30.       <groupId>org.springframework</groupId> 
  31.     <artifactId>spring-core</artifactId>
  32.   </dependency>
  33.   <dependency>
  34.       <groupId>org.springframework</groupId> 
  35.     <artifactId>spring-aop</artifactId>
  36.   </dependency>
  37.   <dependency>
  38.       <groupId>org.springframework</groupId> 
  39.     <artifactId>spring-web</artifactId>
  40.   </dependency>
  41.   <dependency>
  42.       <groupId>org.springframework</groupId>
  43.       <artifactId>spring-expression</artifactId>
  44.   </dependency>
  45.   <dependency>
  46.       <groupId>org.springframework</groupId> 
  47.     <artifactId>spring-beans</artifactId>
  48.   </dependency>
  49.   <dependency>
  50.       <groupId>org.springframework</groupId> 
  51.     <artifactId>spring-aspects</artifactId>
  52.   </dependency>
  53.   <dependency>
  54.       <groupId>org.springframework</groupId>
  55.     <artifactId>spring-context-support</artifactId>
  56.   </dependency>
  57.   <dependency>
  58.       <groupId>org.springframework</groupId> 
  59.     <artifactId>spring-test</artifactId>
  60.   </dependency>
  61.   <dependency>
  62.       <groupId>org.springframework</groupId> 
  63.     <artifactId>spring-jdbc</artifactId>
  64.   </dependency>
  65.   <dependency>
  66.       <groupId>org.springframework</groupId> 
  67.     <artifactId>spring-tx</artifactId>
  68.   </dependency>
  69. </dependencies>

只添加到层的 pom，mybatis 和 spring 的整合相关依赖
dao 模块代码编写（省略）
把 dao 模块 install 到本地仓库（省略）

（3）ssm_service 子模块（参考dao）

定义 pom.xml
ssm_service 模块的 pom.xml 文件中需要继承父模块，ssm_service 依赖 ssm_dao 模块，添加spring 相关的依赖：

  1. <dependencies>
  2.   <!-- spring 相关 -->
  3.   <dependency>
  4.     <groupId>org.springframework</groupId> 
  5.     <artifactId>spring-jdbc</artifactId>
  6.   </dependency>
  7.   <dependency>
  8.       <groupId>org.springframework</groupId>
  9.     <artifactId>spring-tx</artifactId>
  10.   </dependency>
  11.   <!--    dao 层的依赖 -->
  12.   <dependency>
  13.       <groupId>com.mavenTest.ssm_mavenTestt</groupId>
  14.       <artifactId>ssm_dao</artifactId>
  15.       <version>1.0-SNAPSHOT</version>
  16.   </dependency>
  17. </dependencies>

把 service 模块 install 到本地仓库（省略）

（4）ssm_web 子模块

选择骨架创建 web 子模块
Maven项目管理工具（可以考虑作为骨架扩展） - 图67
Maven项目管理工具（可以考虑作为骨架扩展） - 图68
定义模块名称，下一步确认使用自己的本地仓库
Maven项目管理工具（可以考虑作为骨架扩展） - 图69
使用骨架创建 web 项目会花费些时间，请耐心等待
创建 java 和 resources 文件夹，转成 source root
Maven项目管理工具（可以考虑作为骨架扩展） - 图70
定义 pom.xml
ssm_web 模块的 pom.xml 文件中需要继承父模块，ssm_web 依赖 ssm_service 模块,和springmvc 的依赖

  1. <dependencies>
  2.   <!-- 依赖 service -->
  3.   <dependency>
  4.     <groupId>com.mavenTest.ssm_mavenTestt</groupId>
  5.     <artifactId>ssm_service</artifactId> 
  6.     <version>1.0-SNAPSHOT</version>
  7.   </dependency>
  8.   <!-- springMVC -->
  9.   <dependency>
  10.       <groupId>org.springframework</groupId>
  11.     <artifactId>spring-webmvc</artifactId> 
  12.     <version>${springmvc.version}</version>
  13.   </dependency>
  14.   <dependency>
  15.       <groupId>javax.servlet</groupId>
  16.       <artifactId>servlet-api</artifactId>
  17.     <version>2.5</version> 
  18.     <scope>provided</scope>
  19.   </dependency>
  20.   <dependency>
  21.       <groupId>javax.servlet</groupId>
  22.       <artifactId>jsp-api</artifactId>
  23.           <version>2.0</version>
  24.       <scope>provided</scope>
  25.   </dependency>
  26.   <!-- jstl -->
  27.   <dependency>
  28.       <groupId>javax.servlet</groupId>
  29.       <artifactId>jstl</artifactId>
  30.       <version>1.2</version>
  31.   </dependency>
  32. </dependencies>

controller代码编写和配置文件（省略）
注意 web.xml 中的配置：使用通配符加载
Maven项目管理工具（可以考虑作为骨架扩展） - 图71

（5）运行调试

方法 1：在 ssm_web 工程的 pom.xml 中配置 tomcat 插件运行
Maven项目管理工具（可以考虑作为骨架扩展） - 图72
运行 ssm_web 工程它会从本地仓库下载依赖的 jar 包，所以当 ssm_web 依赖的 jar 包内容修改了必须及时发布到本地仓库，比如：ssm_web 依赖的 ssm_service 修改了，需要及时将ssm_service 发布到本地仓库。
方法 2：在父工程的 pom.xml 中配置 tomcat 插件运行，自动聚合并执行
推荐方法 2，如果子工程都在本地，采用方法 2 则不需要子工程修改就立即发布到本地仓库，父工程会自动聚合并使用最新代码执行。
注意：如果子工程和父工程中都配置了 tomcat 插件，运行的端口和路径以子工程为准。

3．分模块构建工程-依赖整合

每个模块都需要 spring 或者 junit 的 jar，况且最终 package 打完包最后生成的项目中的
jar 就是各个模块依赖的整合，所以我们可以把项目中所需的依赖都可以放到父工程中,模块
中只留模块和模块之间的依赖，那父工程的 pom.xml 可以如下配置：

  1. <properties>
  2.   <spring.version>5.0.2.RELEASE</spring.version>
  3.   <springmvc.version>5.0.2.RELEASE</springmvc.version>
  4.   <mybatis.version>3.4.5</mybatis.version>
  5. </properties>
  6. <dependencyManagement>
  7.   <dependencies>
  8.     <!-- Mybatis -->
  9.     <dependency>
  10.     <groupId>org.mybatis</groupId>
  11.     <artifactId>mybatis</artifactId>
  12.     <version>${mybatis.version}</version>
  13.     </dependency>
  14.     <!-- springMVC -->
  15.     <dependency>
  16.     <groupId>org.springframework</groupId>
  17.     <artifactId>spring-webmvc</artifactId>
  18.     <version>${springmvc.version}</version>
  19.     </dependency>
  20.     <dependency>
  21.     <groupId>org.springframework</groupId>
  22.     <artifactId>spring-context</artifactId>
  23.     <version>${spring.version}</version>
  24.     </dependency>
  25.     <!-- spring -->
  26.     <dependency>
  27.     <groupId>org.springframework</groupId>
  28.       <artifactId>spring-core</artifactId>
  29.       <version>${spring.version}</version>
  30.     </dependency>
  31.     <dependency>
  32.       <groupId>org.springframework</groupId> 
  33.       <artifactId>spring-aop</artifactId> 
  34.       <version>${spring.version}</version>
  35.     </dependency>
  36.     <dependency>
  37.       <groupId>org.springframework</groupId> 
  38.       <artifactId>spring-web</artifactId> 
  39.       <version>${spring.version}</version>
  40.     </dependency>
  41.     <dependency>
  42.       <groupId>org.springframework</groupId>
  43.       <artifactId>spring-expression</artifactId> 
  44.       <version>${spring.version}</version>
  45.     </dependency>
  46.     <dependency>
  47.       <groupId>org.springframework</groupId>
  48.       <artifactId>spring-beans</artifactId>
  49.       <version>${spring.version}</version>
  50.     </dependency>
  51.     <dependency>
  52.       <groupId>org.springframework</groupId> 
  53.       <artifactId>spring-aspects</artifactId>
  54.       <version>${spring.version}</version>
  55.     </dependency>
  56.     <dependency>
  57.       <groupId>org.springframework</groupId>
  58.       <artifactId>spring-context-support</artifactId>
  59.       <version>${spring.version}</version>
  60.     </dependency>
  61.     <dependency>
  62.       <groupId>org.springframework</groupId> 
  63.       <artifactId>spring-test</artifactId> 
  64.       <version>${spring.version}</version>
  65.     </dependency>
  66.     <dependency>
  67.       <groupId>org.springframework</groupId>
  68.       <artifactId>spring-aop</artifactId> 
  69.       <version>${spring.version}</version>
  70.     </dependency>
  71.     <dependency>
  72.       <groupId>org.springframework</groupId>
  73.       <artifactId>spring-web</artifactId> 
  74.       <version>${spring.version}</version>
  75.     </dependency>
  76.     <dependency>
  77.       <groupId>org.springframework</groupId>
  78.     <artifactId>spring-expression</artifactId>
  79.       <version>${spring.version}</version>
  80.     </dependency>
  81.     <dependency>
  82.       <groupId>org.springframework</groupId> 
  83.       <artifactId>spring-beans</artifactId>
  84.       <version>${spring.version}</version>
  85.     </dependency>
  86.     <dependency>
  87.       <groupId>org.springframework</groupId> 
  88.       <artifactId>spring-aspects</artifactId> 
  89.       <version>${spring.version}</version>
  90.     </dependency>
  91.     <dependency>
  92.       <groupId>org.springframework</groupId>
  93.       <artifactId>spring-context-support</artifactId>
  94.       <version>${spring.version}</version>
  95.     </dependency>
  96.     <dependency>
  97.       <groupId>org.springframework</groupId> 
  98.       <artifactId>spring-test</artifactId> <version>${spring.version}</version>
  99.     </dependency>
  100.     <!-- spring 相关 -->
  101.     <dependency>
  102.       <groupId>org.springframework</groupId>
  103.       <artifactId>spring-context</artifactId>
  104.     </dependency>
  105.     <dependency>
  106.       <groupId>org.springframework</groupId> 
  107.       <artifactId>spring-core</artifactId>
  108.     </dependency>
  109.     <dependency>
  110.       <groupId>org.springframework</groupId>
  111.       <artifactId>spring-aop</artifactId>
  112.     </dependency>
  113.     <dependency>
  114.       <groupId>org.springframework</groupId>
  115.       <artifactId>spring-web</artifactId>
  116.     </dependency>
  117.     <dependency>
  118.       <groupId>org.springframework</groupId>
  119.       <artifactId>spring-expression</artifactId>
  120.     </dependency>
  121.     <dependency>
  122.       <groupId>org.springframework</groupId>
  123.       <artifactId>spring-beans</artifactId>
  124.     </dependency>
  125.     <dependency>
  126.       <groupId>org.springframework</groupId> 
  127.       <artifactId>spring-aspects</artifactId>
  128.     </dependency>
  129.     <dependency>
  130.       <groupId>org.springframework</groupId>
  131.     <artifactId>spring-context-support</artifactId>
  132.     </dependency>
  133.     <dependency>
  134.       <groupId>org.springframework</groupId> 
  135.       <artifactId>spring-test</artifactId>
  136.     </dependency>
  137.     <dependency>
  138.       <groupId>org.springframework</groupId>
  139.       <artifactId>spring-jdbc</artifactId>
  140.     </dependency>
  141.     <dependency>
  142.       <groupId>org.springframework</groupId> 
  143.       <artifactId>spring-tx</artifactId>
  144.     </dependency>
  145.     <!-- spring 相关 事务相关 -->
  146.     <dependency>
  147.       <groupId>org.springframework</groupId> 
  148.       <artifactId>spring-jdbc</artifactId>
  149.     </dependency>
  150.     <dependency>
  151.       <groupId>org.springframework</groupId> 
  152.       <artifactId>spring-tx</artifactId>
  153.     </dependency>
  154.     <!-- junit 测试 -->
  155.     <dependency>
  156.       <groupId>junit</groupId>
  157.       <artifactId>junit</artifactId>
  158.       <version>4.12</version>
  159.       <scope>test</scope>
  160.     </dependency>
  161.     <dependency>
  162.       <groupId>javax.servlet</groupId>
  163.       <artifactId>servlet-api</artifactId>
  164.       <version>2.5</version>
  165.       <scope>provided</scope>
  166.     </dependency>
  167.     <dependency>
  168.       <groupId>javax.servlet</groupId>
  169.       <artifactId>jsp-api</artifactId>
  170.       <version>2.0</version><scope>provided</scope>
  171.     </dependency>
  172.     <!-- jstl -->
  173.     <dependency>
  174.       <groupId>javax.servlet</groupId>
  175.       <artifactId>jstl</artifactId>
  176.       <version>1.2</version>
  177.     </dependency>
  178.   </dependencies>
  179. </dependencyManagement>
  181. <build>
  182.   <plugins>
  183.     <plugin>
  184.       <groupId>org.apache.maven.plugins</groupId>
  185.       <artifactId>maven-compiler-plugin</artifactId>
  186.       <version>3.1</version>
  187.       <configuration>
  188.         <target>1.8</target>
  189.         <source>1.8</source>
  190.       </configuration>
  191.     </plugin>
  192.     <plugin>
  193.       <groupId>org.apache.tomcat.maven</groupId>
  194.       <artifactId>tomcat7-maven-plugin</artifactId>
  195.       <version>2.2</version>
  196.     </plugin>
  197.   </plugins>
  198. </build>

六、Maven私服[了解]

公司在自己的局域网内搭建自己的远程仓库服务器，称为私服（私有服务器），私服服务器即是公司内部的maven远程仓库，每个员工的电脑上安装maven软件并且连接私服服务器，员工将自己开发的项目打成jar并发布到私服服务器，其它项目组从私服服务器下载所依赖的构件（jar）。
Maven私服作用：
1、我们不能联网的情况下，它帮我们从互联网下载jar（私服中jar的来源1）
2、自己开发的jar上传到私服供（共享给）团队使用（私服中jar的来源2）
3、最终私服就是让我们下载jar的
Maven项目管理工具（可以考虑作为骨架扩展） - 图73
私服还充当一个代理服务器，当私服上没有jar包会从互联网中央仓库自动下载。
Maven项目管理工具（可以考虑作为骨架扩展） - 图74
Maven服务器：某一个机器上安装了可以提供Maven私服功能的软件，那么这个机器就叫做Maven私有服务器。

（一）搭建私服环境

nexus是Maven仓库管理器(maven私服软件)，通过nexus可以搭建maven私服仓库，同时nexus还提供强大的仓库管理功能等。
l 安装nexus
n 解压nexus-2.12.0-01-bundle.zip（无中文和空格路径下），进入bin目录
Maven项目管理工具（可以考虑作为骨架扩展） - 图75
n 管理员身份运行cmd，进入bin目录，执行nexus.bat install（若安装后卸载可执行nexus.bat uninstall）
Maven项目管理工具（可以考虑作为骨架扩展） - 图76
n services.msc进入服务管理，查看nexus服务
Maven项目管理工具（可以考虑作为骨架扩展） - 图77
n 若nexus服务已经安装，可以使用两种方式启动nexus
u bin目录下执行nexus.bat start
u 直接启动nexus服务
n 查看nexus的配置文件conf/nexus.properties
Maven项目管理工具（可以考虑作为骨架扩展） - 图78
n 访问http://localhost:8081/nexus/ 内置登录名：admin/admin123
Maven项目管理工具（可以考虑作为骨架扩展） - 图79
n 仓库类型
Maven项目管理工具（可以考虑作为骨架扩展） - 图80
nexus的仓库有4种类型：

  1. hosted，宿主仓库，部署自己的jar到这个类型的仓库，包括releases和snapshot两部分，Releases公司内部发布版本仓库、 Snapshots 公司内部测试版本仓库
  2. proxy，代理仓库，用于代理远程的公共仓库，如maven中央仓库，用户连接私服，私服自动去中央仓库下载jar包或者插件。
  3. group，仓库组，用来合并多个hosted/proxy仓库，通常我们配置自己的maven连接仓库组。
  4. virtual(虚拟)：兼容Maven1 版本的jar或者插件

接下来三件事：
1、 把我们的项目发布到私服；
2、 从私服上下载jar；
3、 如何向私服上上传第三方的jar

（二）项目发布到nexus私服

对远程的一个操作：url、用户名、密码都得有，后续上传就是围绕这三个信息进行；
第一步：maven软件settings.xml中配置连接私服的用户名和密码（放在servers标签内）

  1. <!--配置用户名密码开始-->
  2. <server>
  3.   <id>releases</id>
  4.   <username>admin</username>
  5.   <password>admin123</password>
  6. </server>
  7. <server>
  8.   <id>snapshots</id>
  9.   <username>admin</username>
  10.   <password>admin123</password>
  11. </server>
  12. <!--配置用户名密码结束-->

第二步：配置项目的pom.xml

  1. <!--添加到要上传的项目pom中确定上传路径开始-->
  2. <distributionManagement>
  3.   <repository>
  4.     <id>releases</id>
  5.     <url>http://localhost:8081/nexus/content/repositories/releases/</url>
  6.   </repository> 
  7.   <snapshotRepository>
  8.     <id>snapshots</id>
  9.     <url>http://localhost:8081/nexus/content/repositories/snapshots/</url>
  10.   </snapshotRepository> 
  11. </distributionManagement>
  12. <!--添加到要上传的项目pom中确定上传路径结束-->

注意：pom.xml这里 和 settings.xml 配置 对应
第三步：执行mvn deploy命令

（三）从nexus私服下载jar

在maven的settings.xml文件中配置下载模板（放在profiles标签内）

  1. <profile>   
  2.   <!--profile的id-->
  3.   <id>dev</id>   
  4.   <repositories>   
  5.     <repository>  
  6.       <!--仓库id，repositories可以配置多个仓库，保证id不重复-->
  7.       <id>nexus</id>   
  8.       <!--仓库地址，即nexus仓库组的地址-->
  9.       <url>http://localhost:8081/nexus/content/groups/public/</url>   
  10.       <!--是否下载releases构件-->
  11.       <releases>   
  12.         <enabled>true</enabled>   
  13.       </releases>   
  14.       <!--是否下载snapshots构件-->
  15.       <snapshots>   
  16.         <enabled>true</enabled>   
  17.       </snapshots>   
  18.     </repository>   
  19.   </repositories>  
  20.   <pluginRepositories>  
  21.     <!-- 插件仓库，maven的运行依赖插件，也需要从私服下载插件 -->
  22.     <pluginRepository>  
  23.       <!-- 插件仓库的id不允许重复，如果重复后边配置会覆盖前边 -->
  24.       <id>public</id>  
  25.       <name>Public Repositories</name>  
  26.       <url>http://localhost:8081/nexus/content/groups/public/</url>  
  27.     </pluginRepository>  
  28.   </pluginRepositories>  
  29. </profile>

激活下载模板配置

  1. <!--激活模板开始-->
  2. <activeProfiles>
  3.   <activeProfile>dev</activeProfile>
  4. </activeProfiles>
  5. <!--激活模板结束-->

测试：删除本地的dao工程，终端进入service工程下执行mvn compile
Maven项目管理工具（可以考虑作为骨架扩展） - 图81

（四）把第三方jar放入本地仓库或者私服

第三方jar放入本地仓库

  1. mvn install:install-file -Dfile=ojdbc14-10.2.0.4.0.jar -DgroupId=com.oracle -DartifactId=ojdbc14 -Dversion=10.2.0.4.0 -Dpackaging=jar

第三方jar放入私服
maven的settings配置文件中配置第三方仓库的server信息

  1. <server> 
  2. <id>thirdparty</id> 
  3. <username>admin</username> 
  4. <password>admin123</password> 
  5. </server>

执行命令

  1. mvn deploy:deploy-file -Dfile=ojdbc14-10.2.0.4.0.jar -DgroupId=com.oracle -DartifactId=ojdbc14 -Dversion=10.2.0.4.0 -Dpackaging=jar -Durl=http://localhost:8081/nexus/content/repositori