Maven项目管理工具-优快云博客

本文链接：https://blog.youkuaiyun.com/gy99csdn/article/details/124357244

Maven项目管理工具

1.Maven介绍
2.Maven的使用
3.Maven常用命令
4.maven工程运行调试
- 4.1 端口占用处理
- 4.2 断点调试
5.依赖传递
6. 定义pom.xml
7.分模块构建工程
8.maven私服[了解]
9. 把第三方jar包放入本地仓库或私服

1.Maven介绍

1.1 什么是Maven

1.1.1 什么是Maven

Maven是一个项目管理工具，它包含了一个项目对象模型 (POM：Project Object Model)，一组标准集合，一个项目生命周期(Project Lifecycle)，一个依赖管理系统(Dependency Management System)，和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。

1.1.2 Maven能解决什么问题

项目开发不仅仅是写写代码而已，期间会伴随着各种必不可少的事情要做，下面列举几个感受一下：

（1）我们需要引用各种jar包，尤其是比较大的工程，引用的jar包往往有几十个乃至上百个，每用到一种jar包，都需要手动引入工程目录，而且经常遇到各种让人抓狂的jar包冲突，版本冲突。
（2）我们辛辛苦苦写好了Java文件，可是只懂0和1的白痴电脑却完全读不懂，需要将它编译成二进制字节码。好歹现在这项工作可以由各种集成开发工具帮我们完成，Eclipse、IDEA等都可以将代码即时编译。

（3）世界上没有不存在bug的代码，计算机喜欢bug就和人们总是喜欢美女帅哥一样。为了追求美为了减少bug，因此写完了代码，我们还要写一些单元测试，然后一个个的运行来检验代码质量。
（4）再优雅的代码也是要出来卖的。我们后面还需要把代码与各种配置文件、资源整合到一起，定型打包，如果是web项目，还需要将之发布到服务器，供人蹂躏。

Maven可以把你从上面的繁琐工作中解放出来，帮助构建工程，管理jar包，编译代码，还能帮你自动运行单元测试，打包，生成报表，甚至能帮你部署项目，生成Web站点。

1.1.3 Maven的优势举例

项目要想运行起来，就必须将该项目所依赖的一些jar包添加到工程中，否则项目就不能运行。试想如果具有相同架构的项目有十个，那么我们就需要将这一份jar包复制到十个不同的工程中。一起来看一个CRM项目的工程大小。
在这里插入图片描述
原因主要是因为上面的WEB程序要运行，必须将项目运行所需的Jar包复制到工程目录中，从而导致了工程很大。
同样的项目，如果使用Maven工程来构建，会发现总体上工程的大小会少很多。如下图:

1.2 Maven的两个作用

1.2.1 Maven的依赖管理

Maven的一个核心特性就是依赖管理。当我们涉及到多模块的项目（包含成百个模块或者子项目），管理依赖就变成一项困难的任务。Maven展示出了它对处理这种情形的高度控制。

传统的WEB项目中，我们必须将工程所依赖的jar包复制到工程中，导致了工程的变得很大。那么maven工程是如何使得工程变得很少呢？
在这里插入图片描述
通过分析发现：
maven工程中不直接将jar包导入到工程中，而是通过在pom.xml文件中添加所需jar包的坐标，这样就很好的避免了jar直接引入进来，在需要用到jar包的时候，只要查找pom.xml文件，再通过pom.xml文件中的坐标，到一个专门用于”存放jar包的仓库”(maven仓库)中根据坐标从而找到这些jar包，再把这些jar包拿去运行。

1.2.2 项目的一键构建

在这里插入图片描述
通过tomcat:run的这个命令，我们发现现在的工程编译，测试，运行都变得非常简单。

2.Maven的使用

2.1 Maven的安装及配置

在这里插入图片描述
bin:存放了maven的命令，比如我们前面用到的mvn tomcat:run
boot:存放了一些maven本身的引导程序，如类加载器等
conf:存放了maven的一些配置文件，如setting.xml文件
lib:存放了maven本身运行所需的一些jar包
至此我们的maven软件就可以使用了，前提是你的电脑上之前已经安装并配置好了JDK。
Maven及JDK配置
配置 MAVEN_HOME ，变量值就是maven安装的路径（bin目录之前一级目录）
在这里插入图片描述
上面配置了我们的Maven软件，注意这个目录就是之前你解压maven的压缩文件包在的的目录，最好不要有中文和空格。
再次检查JDK的安装目录，如下图：

2.2 Maven仓库

2.2.1 Maven仓库的分类

maven的工作需要从仓库下载一些jar包，如下图所示，本地的项目A、项目B等都会通过maven软件从远程仓库（可以理解为互联网上的仓库）下载jar包并存在本地仓库，本地仓库就是本地文件夹，当第二次需要此jar包时则不再从远程仓库下载，因为本地仓库已经存在了，可以将本地仓库理解为缓存，有了本地仓库就不用每次从远程仓库下载了。
在这里插入图片描述
本地仓库 ：用来存储从远程仓库或中央仓库下载的插件和jar包，项目使用一些插件或jar包，优先从本地仓库查找
默认本地仓库位置在 ${user.dir}/.m2/repository，$ {user.dir}表示windows用户目录。

远程仓库：如果本地需要插件或者jar包，本地仓库没有，默认去远程仓库下载。
远程仓库可以在互联网内也可以在局域网内。
中央仓库 ：在maven软件中内置一个远程仓库地址https://mvnrepository.com/repos/central ，它是中央仓库，服务于整个互联网，它是由Maven团队自己维护，里面存储了非常全的jar包，它包含了世界上大部分流行的开源项目构件。

2.2.2 Maven本地仓库的配置

配置本地仓库，将 “repository.rar”解压至自己的电脑上，解压在D:\repository目录下（可以放在没有中文及空格的目录下）。

在这里插入图片描述
在MAVE_HOME/conf/settings.xml文件中配置本地仓库位置（maven的安装目录下）：

2.2.3 Maven本地仓库的配置

maven仓库地址、私服等配置信息需要在setting.xml文件中配置，分为全局配置和用户配置。

在maven安装目录下的有 conf/setting.xml文件，此setting.xml文件用于maven的所有project项目，它作为maven的全局配置。

如需要个性配置则需要在用户配置中设置，用户配置的setting.xml文件默认的位置在： ${user.dir} /.m2/settings.xml目录中,$ {user.dir} 指windows 中的用户目录。

maven会先找用户配置，如果找到则以用户配置文件为准，否则使用全局配置文件。

在这里插入图片描述

2.3 Maven工程的认识

2.3.1 Maven工程的目录结构

在这里插入图片描述
作为一个maven工程，它的src目录和pom.xml是必备的。
进入src目录后，我们发现它里面的目录结构如下：

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

注意：如果是普通的java项目，那么就没有webapp目录。

2.3.2 Maven工程的运行

进入maven工程目录（当前目录有pom.xml文件），运行tomcat:run命令。
在这里插入图片描述
根据上边的提示信息，通过浏览器访问：http://localhost:8080/maven-helloworld/

在这里插入图片描述

2.3.3 问题处理

如果本地仓库配置错误会报下边的错误
在这里插入图片描述
分析：
maven工程运行先从本地仓库找jar包，本地仓库没有再从中央仓库找，上边提示downloading… 表示从中央仓库下载jar，由于本地没有联网，报错。

解决：
在maven安装目录的conf/setting.xml文件中配置本地仓库，参考：“maven仓库/配置本地仓库章节”。

3.Maven常用命令

3.1 常用命令

3.1.1 compile

compile是maven工程的编译命令，作用是将src/main/java下的文件编译为class文件输出到target目录下。
cmd进入命令状态，执行mvn compile，如下图提示成功：
在这里插入图片描述
查看 target目录，class文件已生成，编译完成

3.1.2 test

test是maven工程的测试命令 mvn test，会执行src/test/java下的单元测试类。
cmd执行mvn test执行src/test/java下单元测试类，下图为测试结果，运行1个测试用例，全部成功。
在这里插入图片描述

3.1.3 clean

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

3.1.4 package

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

3.1.5 install

install是maven工程的安装命令，执行install将maven打成jar包或war包发布到本地仓库。
从运行结果中，可以看出：
当后面的命令执行时，前面的操作过程也都会自动执行

3.1.6 Maven指令的生命周期

maven对项目构建过程分为三套相互独立的生命周期，请注意这里说的是“三套”，而且“相互独立”，这三套生命周期分别是：

Clean Lifecycle 在进行真正的构建之前进行一些清理工作。

Default Lifecycle 构建的核心部分，编译，测试，打包，部署等等。

Site Lifecycle 生成项目报告，站点，发布站点。

3.1.7 maven的概念模型

在这里插入图片描述
项目对象模型 (Project Object Model)：一个maven工程都有一个pom.xml文件，通过pom.xml文件定义项目的坐标、项目依赖、项目信息、插件目标等。
依赖管理系统(Dependency Management System)：通过maven的依赖管理对项目所依赖的jar 包进行统一管理。
比如：项目依赖junit4.9，通过在pom.xml中定义junit4.9的依赖即使用junit4.9，如下所示是junit4.9的依赖定义：

<!-- 依赖关系 -->
<dependencies>
<!-- 此项目运行使用junit，所以此项目依赖junit -->
<dependency>
<!-- junit的项目名称 -->
<groupId>junit</groupId>
<!-- junit的模块名称 -->
<artifactId>junit</artifactId>
<!-- junit版本 -->
<version>4.9</version>
<!-- 依赖范围：单元测试时使用junit -->
<scope>test</scope>
</dependency>

一个项目生命周期(Project Lifecycle)：使用maven完成项目的构建，项目构建包括：清理、编译、测试、部署等过程，maven将这些过程规范为一个生命周期，如下所示是生命周期的各各阶段：
在这里插入图片描述
maven通过执行一些简单命令即可实现上边生命周期的各各过程，比如执行mvn compile执行编译、执行mvn clean执行清理
一组标准集合：maven将整个项目管理过程定义一组标准，比如：通过maven构建工程有标准的目录结构，有标准的生命周期阶段、依赖管理有标准的坐标定义等。

插件(plugin)目标(goal)：maven 管理项目生命周期过程都是基于插件完成的。

3.2 idea开发maven项目

3.2.1 idea的maven配置

打开FileSettings配置maven
依据图片指示，选择本地maven安装目录，指定maven安装目录下conf文件夹中settings配置文件
在这里插入图片描述

3.2.2 idea中创建一个maven的web工程

idea中创建一个maven的web工程
在这里插入图片描述
选择idea提供好的maven的web工程模板

点击Next填写项目信息

在这里插入图片描述
点击Next，此处不做改动。
点击Next选择项目所在目录

点击Finish后开始创建工程，耐心等待，直到出现如下界面。

手动添加src/main/java目录，如下图右键main文件夹NewDirectory

创建一个新的文件夹命名为java 在这里插入图片描述
点击OK后，在新的文件夹java上右键Make Directory asSources Root

创建一个Servlet
src/java/main创建了一个Servlet，但报错

要解决问题，就是要将servlet-api-xxx.jar包放进来，作为maven工程应当添加servlet的坐标，从而导入它的jar

在pom.xml文件添加坐标
直接打开hello_maven工程的pom.xml文件，再添加坐标
在这里插入图片描述
添加jar包的坐标时，还可以指定这个jar包将来的作用范围。
每个maven工程都需要定义本工程的坐标，坐标是maven对jar包的身份定义，比如：入门程序的坐标定义如下：

<!--项目名称，定义为组织名+项目名，类似包名-->
<groupId>com.itheima</groupId>
<!-- 模块名称 -->
<artifactId>hello_maven</artifactId>
<!-- 当前项目版本号，snapshot为快照版本即非正式版本，release为正式发布版本 -->
<version>0.0.1-SNAPSHOT</version>
<packaging > ：打包类型
jar：执行package会打成jar包
war：执行package会打成war包

pom ：用于maven工程的继承，通常父工程设置为pom

坐标的来源方式
https://mvnrepository.com/repos/central
在这里插入图片描述

3.2.3 依赖范围

A依赖B，需要在A的pom.xml文件中添加B的坐标，添加坐标时需要指定依赖范围，依赖范围包括：

在这里插入图片描述

依赖范围由强到弱的顺序是：compile>provided>runtime>test

3.2.4 项目中添加的坐标

在这里插入图片描述

3.2.5 设置jdk编译版本

使用jdk1.8，需要设置编译版本为1.8，这里需要使用maven的插件来设置：
在pom.xml中加入：

<build> 
<plugins>
 <plugin>
  <groupId>org.apache.maven.plugins</groupId> 
  <artifactId>maven-compiler-plugin</artifactId> 
  <configuration> 
      <source>1.8</source> 
      <target>1.8</target>
      <encoding>UTF-8</encoding> 
  </configuration> 
   </plugin>
</plugins> 
</build>

3.2.6 编写servlet

在这里插入图片描述

3.2.7 编写jsp

在这里插入图片描述

3.2.8 在web.xml中配置servlet访问路径

在这里插入图片描述

3.2.9 添加tomcat7插件

在这里插入图片描述
此时点击idea最右侧Maven Projects，
就可以看到我们新添加的tomcat7插件
双击tomcat7插件下tomcat7:run命令直接运行项目

也可以直接点击如图按钮，手动输入tomc7:run命令运行项目

点击后弹出如下图窗口

3.2.10 运行结果

在这里插入图片描述

4.maven工程运行调试

4.1 端口占用处理

重新执行tomcat:run命令重启工程，重启之前需手动停止 tomcat，否则报下边的错误：
在这里插入图片描述

4.2 断点调试

点击如图所示选项
在这里插入图片描述
在弹出框中点击如图加号按钮找到maven选项

在弹出窗口中填写如下信息

完成后先Apply再OK结束配置后，可以在主界面找到我们刚才配置的操作名称。

如上图红框选中的两个按钮，左侧是正常启动，右侧是debug启动。

5.依赖传递

5.1 什么是依赖传递

先添加springmvc的核心依赖的坐标

<dependencies> 
  <dependency> 
    <groupId>org.springframework</groupId> 
    <artifactId>spring-webmvc</artifactId> 
    <version>4.2.4.RELEASE</version> 
  </dependency> 
</dependencies>

会发现出现除了spring-webmvc以外的其他jar。

因为我们的项目依赖spring-webmv.jar，而spring-webmv.jar会依赖spring-beans.jar等等，所以spring-beans.jar这些jar包也出现在了我们的maven工程中，这种现象我们称为依赖传递。从下图中可看到他们的关系：（请注意spring-beans的版本）
在这里插入图片描述

5.2 依赖冲突的解决

接着添加一个依赖
在这里插入图片描述
我们会发现这两个jar包同时都依赖了spring-beans

但是
spring-webmvc依赖spirng-beans-4.2.4，
spring-context依赖spring-beans-5.0.2，
但是发现spirng-beans-4.2.4加入到工程中

在这里插入图片描述
而我们希望spring-beans-5.0.2加入工程。这就造成了依赖冲突。

5.2.1 依赖调解原则

5.2.1.1 第一声明者优先原则

在pom文件定义依赖，先声明的依赖为准。
测试：
如果将上边spring-webmvc和spring-context顺序颠倒，系统将导入spring-beans-5.0.2。
分析：
由于spring-webmvc在前边以spring-webmvc依赖的spring-beans-5.0.2为准，所以最终
spring-beans-5.0.2添加到了工程中。

5.2.1.2 路径近者优先原则

例如：还是上述情况，spring-contex和spring-webmvc都会传递过来 spirng-beans，那如果直接把spring-beans的依赖直接写到pom文件中，那么项目就不会再使用其他依赖传递来的spring-beans，因为自己直接在pom中定义spring-beans要比其他依赖传递过来的路径要近。
在本工程中的pom中加入spirng-beans-5.0.2的依赖，根据路径近者优先原则，系统将导入spirng-beans-5.0.2：
在这里插入图片描述

5.2.2 排除依赖

比如在依赖spring-webmvc的设置中添加排除依赖，排除spring-beans，
下边的配置表示：依赖spring-webmvc，但排除spring-webmvc所依赖的spring-beans。
在这里插入图片描述

5.2.2 锁定版本

面对众多的依赖，有一种方法不用考虑依赖路径、声明优化等因素可以采用直接锁定版本的方法确定依赖构件的版本，版本锁定后则不考虑依赖的声明顺序或依赖的路径，以锁定的版本的为准添加到工程中，此方法在企业开发中常用。
在这里插入图片描述
还可以把版本号提取出来，使用标签设置成变量。

注意：在工程中锁定依赖的版本并不代表在工程中添加了依赖，如果工程需要添加锁定版本的依赖则需要单独添加<.dependencies><./dependencies>标签，如下：
在这里插入图片描述
上边添加的依赖并没有指定版本，原因是已在<.dependencyManagement>中锁定了版本，所以在<.dependency>下不需要再指定版本。

6. 定义pom.xml

maven工程首先要识别依赖，web工程实现SSM整合，需要依赖spring-webmvc5.0.2、 spring5.0.2、mybatis3.4.5等，在pom.xml添加工程如下依赖：
（在实际企业开发中会有架构师专门来编写pom.xml）

7.分模块构建工程

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

工程和模块的区别：
1.工程不等于完整的项目，模块也不等于完整的项目，一个完整的项目看的是代码，代码完整，就可以说这是一个完整的项目
和此项目是工程和模块没有关系。

2.工程天生只能使用自己内部资源，工程天生是独立的。后天可以和其他工程或模块建立关联关系。
模块天生不是独立的，模块天生是属于父工程的，模块一旦创建，所有父工程的资源都可以使用。

3.父子工程直接，子模块天生集成父工程，可以使用父工程所有资源。
子模块之间天生是没有任何关系的。

4.父子工程直接不用建立关系，继承关系是先天的，不需要手动建立。

5.平级直接的引用叫依赖，依赖不是先天的，依赖是需要后天建立的。

7.1需求

需求描述
在这里插入图片描述
理解继承和聚合
继承：是为了消除重复，如果将dao、service、web分开创建独立的工程则每个工程的pom.xml文件中的内容存在重复，比如：设置编译版本、锁定spring的版本的等，可以将这些重复的配置提取出来在父工程的pom.xml中定义。
聚合：项目开发通常是分组分模块开发，每个模块开发完成要运行整个工程需要将每个模块聚合在一起运行，比如：dao、service、web三个工程最终会打一个独立的war运行。

7.2 案例实现

在这里插入图片描述

7.2.1 maven-parent父模块

7.2.1.1 创建父工程

1、选择骨架创建父工程
在这里插入图片描述
2、填写坐标

3、确认使用的是本地仓库

5、注意代码所在的路径（默认）

6、设置项目的打包方式

在这里插入图片描述

7.2.1.2 定义pom.xml

在父工程的pom.xml中抽取一些重复的配置的，比如：锁定jar包的版本、设置编译版本等。

<?xml version="1.0" encoding="UTF-8"?>
<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.itheima</groupId>
    <artifactId>maven_day02_parent</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>maven_day02_dao</module>
        <module>maven_day02_service</module>
        <module>maven_day02_web</module>
    </modules>

    <!-- 统一管理jar包版本 -->
    <properties>
        <spring.version>5.0.2.RELEASE</spring.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <shiro.version>1.2.3</shiro.version>
        <mysql.version>5.1.6</mysql.version>
        <mybatis.version>3.4.5</mybatis.version>
        <spring.security.version>5.0.1.RELEASE</spring.security.version>
    </properties>

    <!-- 锁定jar包版本 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 项目依赖jar包 -->
    <dependencies>
        <!-- spring -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- log start -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
            <version>${spring.security.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>${spring.security.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-core</artifactId>
            <version>${spring.security.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-taglibs</artifactId>
            <version>${spring.security.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.9</version>
        </dependency>
    </dependencies>
    <!-- 添加tomcat7插件 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
            </plugin>
        </plugins>
    </build>

</project>

7.2.1.3 将父工程发布至仓库

父工程创建完成执行install将父工程发布到仓库方便子工程继承：
在这里插入图片描述

7.2.2 ssm_dao子模块

7.2.2.1 创建dao子模块

1、在父工程上右击创建maven模块：
在这里插入图片描述
2、选择“跳过骨架选择”：

3、填写模块名称

4、下一步，确定项目的目录

5、打包方式是jar

在这里插入图片描述

7.2.2.2 定义pom.xml

可继承父模块的内容

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <parent>
        <artifactId>maven_day02_parent</artifactId>
        <groupId>com.itheima</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>maven_day02_dao</artifactId>

    <distributionManagement>
        <repository>
            <id>releases</id>
            <url>http://localhost:8081/nexus/content/repositories/releases/</url>
        </repository>
        <snapshotRepository>
            <id>snapshots</id>
            <url>http://localhost:8081/nexus/content/repositories/snapshots/</url>
        </snapshotRepository>
    </distributionManagement>
</project>

7.2.2.3 dao代码

在这里插入图片描述

ItemsDao

public interface ItemsDao {
    public Items findById(Integer id);
}

Items

public class Items {
    private Integer id;
    private String name;
    private Double price;
    private String pic;
    private Date createtime;
    private String detail;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public String getPic() {
        return pic;
    }

    public void setPic(String pic) {
        this.pic = pic;
    }

    public Date getCreatetime() {
        return createtime;
    }

    public void setCreatetime(Date createtime) {
        this.createtime = createtime;
    }

    public String getDetail() {
        return detail;
    }

    public void setDetail(String detail) {
        this.detail = detail;
    }
}

ItemsDao.xml

<?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE mapper
                PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.ItemsDao">
    <select id="findById" parameterType="int" resultType="items">
        select * from items where id = #{id}
    </select>
</mapper>

applicationContext-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
			    http://www.springframework.org/schema/beans/spring-beans.xsd
			    http://www.springframework.org/schema/context
			    http://www.springframework.org/schema/context/spring-context.xsd
			    http://www.springframework.org/schema/aop
			    http://www.springframework.org/schema/aop/spring-aop.xsd
			    http://www.springframework.org/schema/tx
			    http://www.springframework.org/schema/tx/spring-tx.xsd
			    http://www.springframework.org/schema/mvc
			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--dao层配置文件开始-->
    <!--配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///maven"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--配置生产SqlSession对象的工厂-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--扫描pojo包，给包下所有pojo对象起别名-->
        <property name="typeAliasesPackage" value="com.itheima.domain"/>
    </bean>

    <!--扫描接口包路径，生成包下所有接口的代理对象，并且放入spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.itheima.dao"/>
    </bean>
    <!--dao层配置文件结束-->

</beans>

7.2.2.4 单元测试（未依赖整合前的测试）

1、首先在dao模块的pom.xml添加junit的依赖，添加时Scope选择 test
在这里插入图片描述
2、编写junit测试代码

7.2.2.5 把dao模块install到本地仓库

调过测试，install到本地仓库
在这里插入图片描述

7.2.3 ssm_service子模块

7.2.3.1 创建service子模块

方法同ssm_dao模块创建方法，模块名称为ssm_service。

7.2.3.2 定义pom.xml

ssm_service模块的pom.xml文件中需要继承父模块，ssm_service依赖ssm_dao模块.


<?xml version="1.0" encoding="UTF-8"?>
<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">
    <parent>
        <artifactId>maven_day02_parent</artifactId>
        <groupId>com.itheima</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>maven_day02_service</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.itheima</groupId>
            <artifactId>maven_day02_dao</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

7.2.3.3 service代码

在这里插入图片描述
ItemsService

public interface ItemsService {
    public Items findById(Integer id);
}

ItemsServiceImpl

@Service
public class ItemsServiceImpl implements ItemsService {

    @Autowired
    private ItemsDao itemsDao;

    public Items findById(Integer id) {
        return itemsDao.findById(id);
    }
}

applicationContext-service.xml
创建applicationContext-service.xml，此文件中定义的service。
<context:component-scan base-package=“cn.itcast.ssm”/>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
			    http://www.springframework.org/schema/beans/spring-beans.xsd
			    http://www.springframework.org/schema/context
			    http://www.springframework.org/schema/context/spring-context.xsd
			    http://www.springframework.org/schema/aop
			    http://www.springframework.org/schema/aop/spring-aop.xsd
			    http://www.springframework.org/schema/tx
			    http://www.springframework.org/schema/tx/spring-tx.xsd
			    http://www.springframework.org/schema/mvc
			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--service层配置文件开始-->

    <!--组件扫描配置-->
    <context:component-scan base-package="com.itheima.service"/>

    <!--aop面向切面编程，切面就是切入点和通知的组合-->
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--配置事务的通知-->
    <tx:advice id="advice">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--配置切面-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.itheima.service.impl.*.*(..))"/>
        <aop:advisor advice-ref="advice" pointcut-ref="pointcut"/>
    </aop:config>
    <!--service层配置文件结束-->





</beans>

7.2.3.4 Install到本地仓库

在这里插入图片描述

7.2.4 ssm_web子模块

7.2.4.1 创建web子模块

1、选择骨架创建web子模块
在这里插入图片描述
2、确认使用自己的本地仓库

3、填写模块名称

使用骨架创建web项目会花费些时间，请耐心等待
4、添加打包方式war

在这里插入图片描述

7.2.4.2 定义pom.xml

ssm_web模块的pom.xml文件中需要继承父模块，ssm_web依赖ssm_service模块,和springmvc的依赖


<?xml version="1.0" encoding="UTF-8"?>

<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">
    <parent>
        <artifactId>maven_day02_parent</artifactId>
        <groupId>com.itheima</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>maven_day02_web</artifactId>
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>com.itheima</groupId>
            <artifactId>maven_day02_service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

7.2.4.3 web代码

在这里插入图片描述
ItemsController

@Controller
@RequestMapping("/items")
public class ItemsController {

    @Autowired
    private ItemsService itemsService;

    @RequestMapping("/findDetail")
    public String findDetail(Model model){
        Items items = itemsService.findById(1);
        model.addAttribute("item", items);
        return "itemDetail";
    }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
			    http://www.springframework.org/schema/beans/spring-beans.xsd
			    http://www.springframework.org/schema/context
			    http://www.springframework.org/schema/context/spring-context.xsd
			    http://www.springframework.org/schema/aop
			    http://www.springframework.org/schema/aop/spring-aop.xsd
			    http://www.springframework.org/schema/tx
			    http://www.springframework.org/schema/tx/spring-tx.xsd
			    http://www.springframework.org/schema/mvc
			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <import resource="classpath:spring/applicationContext-dao.xml"/>
    <import resource="classpath:spring/applicationContext-service.xml"/>
</beans>

log4j.properties

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
			    http://www.springframework.org/schema/beans/spring-beans.xsd
			    http://www.springframework.org/schema/context
			    http://www.springframework.org/schema/context/spring-context.xsd
			    http://www.springframework.org/schema/aop
			    http://www.springframework.org/schema/aop/spring-aop.xsd
			    http://www.springframework.org/schema/tx
			    http://www.springframework.org/schema/tx/spring-tx.xsd
			    http://www.springframework.org/schema/mvc
			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--组件扫描-->
    <context:component-scan base-package="com.itheima.controller"/>

    <!--处理器映射器，处理器适配器-->
    <mvc:annotation-driven/>

    <!--视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--释放静态资源-->
    <mvc:default-servlet-handler/>


</beans>

web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">

  <!--编码过滤器-->
  <filter>
    <filter-name>encoding</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!--配置spring核心监听器-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!--重新指定spring配置文件的路径-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

  <!--springmvc的核心servlet-->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

itemDetail.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%>    
 
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body> 
	<form>
		<table width="100%" border=1>
			<tr>
				<td>商品名称</td>
				<td> ${item.name } </td>
			</tr>
			<tr>
				<td>商品价格</td>
				<td> ${item.price } </td>
			</tr>
			<tr>
				<td>生成日期</td>
				<td> <fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/> </td>
			</tr>
			<tr>
				<td>商品简介</td>
				<td>${item.detail} </td>
			</tr>
		</table>
	</form>
</body>
</html>

8.maven私服[了解]

公司在自己的局域网内搭建自己的远程仓库服务器，称为私服，私服服务器即是公司内部的maven远程仓库，每个员工的电脑上安装maven软件并且连接私服服务器，员工将自己开发的项目打成jar并发布到私服服务器，其它项目组从私服服务器下载所依赖的构件（jar）。
私服还充当一个代理服务器，当私服上没有jar包会从互联网中央仓库自动下载，如下图：
在这里插入图片描述