Maven高级

学习目标

  1. 了解搭建私服的使用
  2. 理解传递依赖
  3. 掌握如何解决依赖版本冲突问题
  4. 能够使用maven构建SSM工程
  5. 学习使用maven分模块方式构建工程

1. 私服：私服的介绍

目标

理解私服的作用

仓库的介绍

Maven高级-指南参考 - 图1

仓库的概念

中央仓库

目前来说: https://repo1.maven.org/maven2/是真正的Maven中央仓库的地址，该地址内置在Maven的源码中其他的都是镜像。

什么是仓库镜像

如果仓库X可以提供仓库Y存储的所有内容，那么就可以认为X是Y的一个镜像，使用镜像可以提高项目构建效率。

仓库的索引

中央仓库带有索引文件以方便用户对其进行搜索，索引每周更新一次，中央仓库的索引有几十M。

黑名单

如果某个IP地址恶意的下载中央仓库内容，例如全公司100台机器使用同一个IP反复下载，这个IP（甚至是IP段）会进入黑名单，因此稍有规模的使用Maven时，应该用Nexus架设私服。

私服

有些公司不提供外网给项目组人员，因此就不能使用maven访问远程的仓库地址，所以很有必要在局域网里找一台有外网权限的机器，搭建nexus私服，然后开发人员连到这台私服上，这样的话就可以通过这台搭建了nexus私服的电脑访问maven的远程仓库。

Maven高级-指南参考 - 图2

2. 私服：私服的安装和启动

下载

Nexus的官网 https://www.sonatype.com/

  1. 选择导航菜单Products
    Maven高级-指南参考 - 图3
  2. 选择OSS Edition
    Maven高级-指南参考 - 图4

注：资料中已经下载latest-win64直接使用即可。

默认是使用jetty做为web容器

安装

  1. 在任意位置创建目录：nexus
  2. 解压到nexus目录下会出现两个目录，两个目录都有用
    Maven高级-指南参考 - 图5
  3. 安装路径下etc目录中nexus-default.properties文件保存有nexus基础配置信息，例如默认访问端口，nexus默认的端口号是8081
    Maven高级-指南参考 - 图6
  4. 安装路径下bin目录中nexus.vmoptions文件保存有nexus服务器启动对应的配置信息，例如默认占用内存空间
    Maven高级-指南参考 - 图7

启动

注：要保证JDK环境配置正确

  1. 进入以下目录
    Maven高级-指南参考 - 图8
  2. 输入cmd进入命令行
    Maven高级-指南参考 - 图9
  3. 可以输入nexus /?查看所有的参数，输入 /run在窗口下运行服务器
    Maven高级-指南参考 - 图10
  4. 如果弹出以下窗口，点允许访问 Maven高级-指南参考 - 图11
  5. 启动成功，默认是8081，不要关闭这个窗口，不然服务器就退出了
    Maven高级-指南参考 - 图12

访问

  1. 当Nexus启动后，可以在浏览器中输入：http://localhost:8081/可以看到以下页面
    Maven高级-指南参考 - 图13
  2. 点击右上角登录
    Maven高级-指南参考 - 图14
  3. 弹出以下对话框
    Maven高级-指南参考 - 图15
  4. 输入默认的帐号：admin，密码：在admin.password文件中找
    Maven高级-指南参考 - 图16
  5. 登录成功以后出现配置向导，直接点next
    Maven高级-指南参考 - 图17
  6. 修改密码，输入两次，建议都使用admin，不要忘记了
    Maven高级-指南参考 - 图18
  7. 允许匿名的账户登录
    Maven高级-指南参考 - 图19
  8. 配置完成
    Maven高级-指南参考 - 图20

3. 私服：仓库类别和配置

类别介绍

Maven高级-指南参考 - 图21

proxy：是远程仓库的代理。比如说在nexus中配置了一个central仓库的proxy，当用户向这个proxy请求一个组件，这个proxy就会先在本地查找，如果找不到的话，就会从远程仓库下载，然后返回给用户，相当于起到一个中转的作用。

Hosted：是宿主仓库，用户可以把自己的一些构件，deploy到hosted中，也可以手工上传构件到hosted里。比如说oracle的驱动程序，在central repository是获取不到的，就需要手动上传到hosted里。

Group：是仓库组，在maven里没有这个概念，是nexus特有的。目的是将上述多个仓库聚合，对用户暴露统一的地址，这样用户就不需要在pom中配置多个地址，只要统一配置group的地址就可以了。

注：公司内部通常只需关注hosted宿主仓库就可以了

修改配置

中央仓库的地址

Nexus的中央仓库，默认配置的是maven的中央仓库：https://repo1.maven.org/maven2/，为了提高速度可以配置成阿里云的中央仓库https://maven.aliyun.com/repository/central

  1. 选择中央仓库

Maven高级-指南参考 - 图22

  1. 修改地址：Remote storage的位置
    Maven高级-指南参考 - 图23
  2. 记得点最下面的保存按钮
    Maven高级-指南参考 - 图24

修改RELEASES为可以重复部署

因为下面要上传jar包到这个仓库RELEASES下

  1. 仓库选择Releases
    Maven高级-指南参考 - 图25
  2. 在Access Settings中选择Allow Redeploy，设置为可以重复部署
    Maven高级-指南参考 - 图26
  3. 点保存按钮
    Maven高级-指南参考 - 图27

4. 私服：上传项目到私服

  1. 配置本地仓库访问私服的权限，修改maven的conf/settings.xml配置文件，用户名和密码，复制如下片段到相应的位置，大约在111行。注意：密码要与你设置的密码相同
  1. <server>
  2.     <id>releases</id>
  3.     <username>admin</username>
  4.     <password>admin</password>
  5. </server>
  6. <server>
  7.     <id>snapshots</id>
  8.     <username>admin</username>
  9.     <password>admin</password>
  10. </server>
  1. 重新创建一个新的模块，配置要上传项目中的发布管理，添加如下代码段：

Maven高级-指南参考 - 图28

坐标如下：

Maven高级-指南参考 - 图29

  1. 在pom.xml文件中添加以下代码段
  1. <distributionManagement>
  2.       <repository>
  3.           <id>releases</id>
  4.         <url>http://localhost:8081/repository/maven-releases/</url>
  5.       </repository> 
  6.       <snapshotRepository>
  7.           <id>snapshots</id>
  8.         <url>http://localhost:8081/repository/maven-snapshots/</url>
  9.       </snapshotRepository> 
  10. </distributionManagement>

上面的url即仓库地址

  1. 执行deploy命令，上传项目到私服。

Maven高级-指南参考 - 图30

  1. 上传日志结果

Maven高级-指南参考 - 图31

  1. 去私服查看snapshots上传的结果

Maven高级-指南参考 - 图32

  1. 修改当前模块的坐标为RELEASE
    Maven高级-指南参考 - 图33
  2. 再次上传到私服
    Maven高级-指南参考 - 图34
  3. 查看上传的日志
    Maven高级-指南参考 - 图35
  4. 查看RELEASE仓库上传的结果
    Maven高级-指南参考 - 图36

5. 私服：从私服下载项目

目标

从私服下载资源

私服下载的配置

注：项目A必须是RELEASE版本才可以使用

  1. 假设上面的模块是A，创建另一个模块B 
    1. <groupId>com.itheima</groupId>
    2. <artifactId>heima-deploy-b</artifactId>
    3. <version>1.0-RELEASE</version>
  1. 依赖于上面的模块A 
    1. <dependencies>
    2. <dependency>
    3.     <groupId>com.itheima</groupId>
    4.     <artifactId>heima-deploy</artifactId>
    5.     <version>1.0-RELEASE</version>
    6. </dependency>
    7. </dependencies>
  1. 删除本地仓库中A模块的jar包
  2. 修改%MAVEN_HOME%\conf\setttings.xml文件，项目B是依赖于私服仓库中模块A
    注：后面还要再改回来，以后还是使用阿里云的镜像 
    1. <mirror>
    2. <id>nexus</id>
    3. <mirrorOf>*</mirrorOf>
    4. <url>http://localhost:8081/repository/maven-public/</url>
    5. </mirror>
  1. clean清除项目B，再complie编译一次
    Maven高级-指南参考 - 图37
  2. 可以看到日志信息是从本地仓库中下载
    Maven高级-指南参考 - 图38

改回阿里云远程仓库

注：接下来的学习还是要使用原来的配置，上面只是临时配置一下。

  1. <mirror>
  2.       <id>nexus</id>
  3.       <mirrorOf>*</mirrorOf>
  4.       <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
  5. </mirror>

6. 回顾：依赖范围

目标

  1. 依赖的作用
  2. 依赖范围

依赖范围

在maven中三种类路径

Maven高级-指南参考 - 图39

classpath范围 理解为
编译类路径 在main目录下起作用
测试类路径 在test目录下起作用
运行时类路径 在运行的过程中起作用，在target目录下

依赖范围

依赖范围 编译类路径 测试类路径 运行时类路径
compile (默认) Y Y Y
provided Y Y (不会打包到项目中)
runtime Y Y
test Y

7. 依赖：依赖传递

什么是依赖传递

概念：某个项目依赖了另一个项目，另一个项目中jar包会不会传递到这个项目中来

面试题

  1. 项目A依赖junit，依赖范围是test，项目B依赖项目A，问： 项目B对junit是否有依赖？
  2. 项目A依赖junit，依赖范围是compile，项目B依赖项目A，问： 项目B对junit是否有依赖？
  3. 项目A依赖junit，依赖范围是provided，项目B依赖项目A，问： 项目B对junit是否有依赖？
  4. 项目A依赖junit，依赖范围是runtime，项目B依赖项目A，问： 项目B对junit是否有依赖？

依赖传递

实验设计：两个项目

创建项目：maven_a

创建项目：maven_b

演示

  1. 项目A依赖junit，依赖范围是test，项目B依赖项目A，问： 项目B对junit是否有依赖？ 
    1. 没有
  1. 项目A依赖junit，依赖范围是compile，项目B依赖项目A，问： 项目B对junit是否有依赖？ 
    1. 有，产生依赖传递
  1. 项目A依赖junit，依赖范围是provided，项目B依赖项目A，问： 项目B对junit是否有依赖？ 
    1. 没有
  1. 项目A依赖junit，依赖范围是runtime，项目B依赖项目A，问： 项目B对junit是否有依赖？ 
    1. 有，产生依赖传递

小结

哪两种依赖范围会产生传递依赖？

  1. compile, runtime 在运行时中起作用中范围会产生依赖传递

8. 依赖：依赖可选和依赖排除【重点】

目标

  1. 什么是可选依赖和依赖排除
  2. 分别如何配置

依赖可选

前提是会产生依赖传递的两种情况

什么是可选依赖

  1. A项目依赖了junit
  2. B项目依赖了A项目
  3. 根据依赖传递特性，默认情况下B项目会依赖junit
  4. 我们可以在A项目通过可选依赖，让B项目不能依赖junit

配置方式

在A项目的依赖配置中，通过optional子标签进行配置。它有两个取值：

  • true：是可选依赖，不进行依赖传递
  • false：默认值，进行依赖传递。

我是A项目，由我决定要不要给你，我的地盘我做主

步骤

  1. 创建A项目，依赖于junit
  2. 创建B项目，依赖于项目A
  3. 在项目A中指定optional为true
  4. 查看项目B的依赖情况

依赖排除

什么是依赖排除

  1. A项目依赖了junit
  2. B项目依赖了A项目
  3. 根据依赖传递特性，默认情况下B项目会依赖junit
  4. 我们可以在B项目通过排除依赖，配置B项目不依赖junit

配置步骤

通过在B项目中配置 exclusions标签进行配置

  1. 在依赖A项目下的version标签下编写exclusions
  2. exclusions中每个exclusion是一个要排除的jar包
  3. 只需指定groupId和artifactId就可以了，不用指定version版本

你给我就要，我不是很没面子？我来决定要不要

代码

项目A的pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.itheima</groupId>
  8.     <artifactId>day51_02_A</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>junit</groupId>
  14.             <artifactId>junit</artifactId>
  15.             <version>4.12</version>
  16.             <scope>compile</scope>
  18.             <!-- 依赖可选，取值是true或false，这个包不会传递下去，我要决定给不给 -->
  19.             <!--<optional>true</optional>-->
  20.         </dependency>
  22.         <dependency>
  23.             <groupId>commons-io</groupId>
  24.             <artifactId>commons-io</artifactId>
  25.             <version>2.6</version>
  26.         </dependency>
  27.     </dependencies>
  28. </project>

项目B的pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.itheima</groupId>
  8.     <artifactId>day51_03_B</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <!--依赖于项目A-->
  13.         <dependency>
  14.             <groupId>com.itheima</groupId>
  15.             <artifactId>day51_02_A</artifactId>
  16.             <version>1.0-SNAPSHOT</version>
  18.             <!-- 依赖排除，我来决定要不要 -->
  19.             <exclusions>
  20.                 <!-- 可以设置多个 -->
  21.                 <exclusion>
  22.                     <!-- 要写排除的坐标，不用写version -->
  23.                     <groupId>junit</groupId>
  24.                     <artifactId>junit</artifactId>
  25.                 </exclusion>
  26.             </exclusions>
  27.         </dependency>
  28.     </dependencies>
  29. </project>

小结

依赖配置 配置元素
可选 <optional>true</optional>
排除 <exclusions><exclusion>坐标没有version</exclusion></exclusions>

9. 依赖：依赖冲突【重点】

目标

  1. 依赖冲突的三种情况
  2. 如何解决依赖冲突

情况1：两个直接依赖

问题

一个项目中同时配置了2份junit4.12和junit4.11不同的版本，项目最终会使用哪个junit的版本？

配置文件pom.xml

  1. <dependencies>
  2.     <!--默认是compile，会产生依赖传递-->
  3.     <dependency>
  4.         <groupId>junit</groupId>
  5.         <artifactId>junit</artifactId>
  6.         <version>4.12</version>
  7.     </dependency>
  9.     <dependency>
  10.         <groupId>junit</groupId>
  11.         <artifactId>junit</artifactId>
  12.         <version>4.11</version>
  13.     </dependency>
  14. </dependencies>

效果

Maven高级-指南参考 - 图40

结论

  1. 如果两个直接依赖：以下面配置的为准

情况2：一个直接依赖一个间接依赖

问题

A项目依赖junit4.12，B项目依赖junit4.11，B项目依赖于A项目，B项目使用哪个版本的junit？

配置文件

项目A的pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.itheima</groupId>
  8.     <artifactId>day51_02_A</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>junit</groupId>
  14.             <artifactId>junit</artifactId>
  15.             <version>4.12</version>
  16.             <scope>compile</scope>
  17.         </dependency>
  19.     </dependencies>
  20. </project>

项目B的pom.xml (junit4.12是间隔依赖，junit4.11是直接依赖)

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.itheima</groupId>
  8.     <artifactId>day51_03_B</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <!-- 直接依赖 -->
  13.         <dependency>
  14.             <groupId>junit</groupId>
  15.             <artifactId>junit</artifactId>
  16.             <version>4.11</version>
  17.         </dependency>
  19.         <!--依赖于项目A-->
  20.         <dependency>
  21.             <groupId>com.itheima</groupId>
  22.             <artifactId>day51_02_A</artifactId>
  23.             <version>1.0-SNAPSHOT</version>
  24.         </dependency>
  26.     </dependencies>
  27. </project>

效果

点这个按钮可看包的依赖情况

Maven高级-指南参考 - 图41

结论

  1. 如果一个间接依赖，一个直接依赖：以直接依赖为准

情况3：两个间接依赖

问题

spring-core包到底使用哪个？

  1. spring-aop 5.2.0间接依赖了spring-core和spring-beans
  2. spring-tx 4.2.8间接依赖了spring-core和spring-beans

如果版本不同使用哪个jar包

场景

在project_a 中，同时配置spring-aop 5.2.0和spring-tx 4.2.8

配置文件

spring-aop 5.2.0在上面效果

Maven高级-指南参考 - 图42

spring-tx 4.2.8在上面的效果

Maven高级-指南参考 - 图43

代码

  1. <!-- 两个间接依赖spring-core包 -->
  2. <dependency>
  3.     <groupId>org.springframework</groupId>
  4.     <artifactId>spring-context</artifactId>
  5.     <version>5.2.0.RELEASE</version>
  6. </dependency>
  8. <dependency>
  9.     <groupId>org.springframework</groupId>
  10.     <artifactId>spring-tx</artifactId>
  11.     <version>4.2.8.RELEASE</version>
  12. </dependency>

结论

  1. 如果2个间接依赖：以上面配置为准

小结

依赖冲突的三种情况 依赖如何处理的
1 两个直接依赖 以下面配置的为准
2 一个直接依赖一个间接依赖 以直接为准
3 两个间接依赖 以上面配置的为准

10. 多环境配置

多环境介绍

maven提供配置多种环境的设定，帮助开发者使用过程中快速切换环境

Maven高级-指南参考 - 图44

步骤

  1. 创建的maven工程，复制jdbc.properties到resources目录下
    Maven高级-指南参考 - 图45
  2. 修改jdbc.properties中的jdbc.url=${jdbc.url} 
    1. jdbc.driverClassName=com.mysql.jdbc.Driver
    2. jdbc.url=${jdbc.url}
    3. jdbc.username=root
    4. jdbc.password=root
  1. 在pom.xml中profiles下配置三个不同的环境：开发，生产，测试
  2. 在profile的properties中分别指定不同的jdbc.url属性值
  3. 分别选择不同的profile

  4. 指定resource的目录地址和开启替换的参数 ```xml <?xml version=”1.0” encoding=”UTF-8”?> <project xmlns=”http://maven.apache.org/POM/4.0.0“

    1.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.0.0

    com.itheima multi-env

    1.0-SNAPSHOT env_dev jdbc:mysql://127.0.0.1:3306/ssm true env_pro jdbc:mysql://127.2.2.2:3306/ssm env_test jdbc:mysql://127.3.3.3:3306/ssm ${basedir}/src/main/resources true 

  3. 7.  运行package命令，查看target中的jar包中jdbc.properties中的url是否不同 ![](assets/image-20210917110405664.png#crop=0&crop=0&crop=1&crop=1&id=M32Qe&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)  
  4. 8.  也可以使用命令行方式执行

mvn 指令 –P 环境定义id

  1. <br />![](assets/image-20210917110636412.png#crop=0&crop=0&crop=1&crop=1&id=PQBE4&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
  3. <a name="3acccac8"></a>
  4. # 11. 继承与聚合：介绍
  6. <a name="73e82552-5"></a>
  7. ## 目标
  9. 1. 分模块创建项目的好处
  10. 2. 理解继承与聚合的概念
  12. <a name="ef636c63"></a>
  13. ## 三种不同的实现方式
  15. <a name="bc32a18c"></a>
  16. ### 方式一：传统开发
  18. 项目中包含企业所有业务的统一系统, 如下：
  20. ![](assets/image-20200224151215253.png#crop=0&crop=0&crop=1&crop=1&id=QTtBq&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)<br />特点：传统开发方式是将这些业务集中在1个web项目中, 缺点是代码量大, 业务插拔不方便 。
  22. <a name="fdb67ce7"></a>
  23. ### 方式二：模块开发
  25. 特点： 模块化开发业务清晰, 维护方便, 业务插拔较简单, 缺点是各模块间 仍然存在依赖 。
  27. ![](assets/image-20200603162301006.png#crop=0&crop=0&crop=1&crop=1&id=p4sZN&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
  28. <a name="667285e3"></a>
  29. ### 方式三：微服务
  31. 特点：将各个业务拆分成多个独立的系统，如下：
  33. ![](assets/image-20200224152214033.png#crop=0&crop=0&crop=1&crop=1&id=DVD8P&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
  35. 注：今天使用第二种方式
  37. <a name="7ef1bb26"></a>
  38. ## 传统项目与分模块构件项目区别
  40. ![](assets/image-20200629192858681.png#crop=0&crop=0&crop=1&crop=1&id=fKBCG&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
  41. <a name="3cdd7893"></a>
  42. ## 分模块创建项目好处
  44. 1. 项目架构一目了然，更清晰
  45. 2. 有利于团队合作开发，不同的成员开发一个模块
  46. 3. 代码的可维护性更强
  47. 4. 更方便重用，例如：所有的工具类都写到一个utils工程中，不仅当前项目可以用，其他项目也可以用。
  49. <a name="4df71bef"></a>
  50. ## 继承的作用
  52. 1.  父项目： 
  53.    1.  抽取所有项目公用的配置和插件 
  54.    1.  锁定当前项目中各个子项目依赖的版本 
  55. 2.  子项目：<br />继承父项目，父项目的公用的配置就可以直接使用了 
  57. <a name="e00e4808"></a>
  58. ## 聚合的作用
  60. 主要是为了聚合各个子模块，作为一个整体运行，这样就实现了分模块构建项目而运行的时候是一个整体项目。
  62. **聚合与继承通常是一起使用的**
  64. <a name="d7df58c7"></a>
  65. ## 小结：聚合与继承的作用
  67. ![](assets/image-20200904172432469.png#crop=0&crop=0&crop=1&crop=1&id=I3QKa&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
  68. <a name="675500c5"></a>
  69. # 12. 继承与聚合：案例演示【重点】
  71. <a name="73e82552-6"></a>
  72. ## 目标
  74. 演示项目的继承与聚合
  76. 1. 创建父项目project_parent
  77. 2. 创建子项目project_entity
  79. <a name="f610ae8c"></a>
  80. ## 实现步骤
  82. <a name="0879c556"></a>
  83. ### 第1步：创建父项目project_parent
  85. 1.  创建父模块，指定父模块的坐标 ![](assets/image-20200629213025855.png#crop=0&crop=0&crop=1&crop=1&id=CrOGM&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)   
  86. 2.  指定模块的名字，模块根目录，模块文件所在位置 ![](assets/image-20200629213112393.png#crop=0&crop=0&crop=1&crop=1&id=qGsl9&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)  
  87. 3.  因为父项目中不需要编写Java代码，所以src目录可以删除，只保留pom.xml配置文件。<br />![](assets/image-20200629213406375.png#crop=0&crop=0&crop=1&crop=1&id=PQfJS&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
  88. 4.  在父项目的pom.xml中添加junit的依赖包 
  89. ```xml
  90. <!--添加junit的依赖包-->
  91. <dependencies>
  92.     <dependency>
  93.         <groupId>junit</groupId>
  94.         <artifactId>junit</artifactId>
  95.         <version>4.12</version>
  96.     </dependency>
  97. </dependencies>

第2步：创建子项目project_child

  1. 在project_parent模块下点右键，创建子模块 Maven高级-指南参考 - 图46
  2. 指定子模块的名字，注：模块根目录和位置都在父模块的下一级目录
    Maven高级-指南参考 - 图47

  3. 父项目的pom.xml文件变化：可以看到子模块的聚合信息

    1. 父模块或聚合模块的打包类型是pom
    2. 可以通过modules看出当前是一个聚合项目，它聚合了哪些模块 ```xml <?xml version=”1.0” encoding=”UTF-8”?> 4.0.0

    com.itheima day51_04_parent 1.0-SNAPSHOT

    pom day51_05_child 

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

    ```

  4. 子项目的pom.xml文件：可以看到继承于父模块的信息

    1. 包含parent标签：指定父模块的坐标
    2. 包含当前模块的坐标信息 ```xml <?xml version=”1.0” encoding=”UTF-8”?> com.itheima day51_04_parent 1.0-SNAPSHOT
    4.0.0 day51_05_child 

  2. 5.  子模块中继承了父模块中的依赖包 ![](assets/image-20200629215923959.png#crop=0&crop=0&crop=1&crop=1&id=iWUA2&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)   
  4. <a name="76711877"></a>
  5. # 13. 继承与聚合：父模块版本锁定【重点】
  7. <a name="69fa3701"></a>
  8. ## 作用
  10. 版本锁定，统一维护组件的版本
  12. <a name="1bc21f7e"></a>
  13. ## dependencyManagement元素
  15. > 作用：一旦在父项目中使用了版本锁定，就是统一控制各个组件的版本。
  16. >  
  17. > 如果子项目继承父项目，父项目中版本锁定的包子项目是**不能**直接使用的。
  18. >  
  19. > 如果要使用，需要在子项目添加依赖，但不需要指定版本号。
  20. >  
  21. > 注：父项目中版本锁定的jar包，子项目中可以使用，也可以不使用
  24. <a name="52b36576-2"></a>
  25. ## 步骤
  27. 1. 在父项目中pom.xml 
  28.    1. 在dependencies的上一级配置dependencyManagement
  29.    1. 配置依赖于junit
  30.    1. 配置依赖spring-context
  31. 2. 此时在子项目pom.xml中并没有依赖任何包 
  32.    1. 在子项目需要再配置一次依赖spring-context，子项目中不需要指定版本version，这时子项目中就有了依赖包了
  33.    1. 因为没有配置junit，所以junit的包并没有继承下来
  35. <a name="06e004ef-2"></a>
  36. ## 代码
  38. 父项目的pom.xml
  40. ```xml
  41. <!--使用版本锁定-->
  42. <dependencyManagement>
  43.     <!--添加junit的依赖包-->
  44.     <dependencies>
  45.         <dependency>
  46.             <groupId>junit</groupId>
  47.             <artifactId>junit</artifactId>
  48.             <version>4.12</version>
  49.         </dependency>
  51.         <!-- 依赖spring的包 -->
  52.         <dependency>
  53.             <groupId>org.springframework</groupId>
  54.             <artifactId>spring-context</artifactId>
  55.             <version>5.2.0.RELEASE</version>
  56.         </dependency>
  57.     </dependencies>
  58. </dependencyManagement>

子项目的pom.xml

  1. <dependencies>
  2.     <!-- 不需要指定版本，因为版本已经锁定 -->
  3.     <dependency>
  4.         <groupId>junit</groupId>
  5.         <artifactId>junit</artifactId>
  6.     </dependency>
  8. </dependencies>

效果

Maven高级-指南参考 - 图48

小结

  1. 父项目如果进行了版本锁定，子项目可以有选择的使用哪些包，可以使用父项目中的包，也可以不使用
  2. 统一整个项目的版本

14. 分模块构建项目1：父项目和聚合项目【重点】

目标

使用分模块方式构建SSM项目

分析

Maven高级-指南参考 - 图49

需求

实现查询所有的用户和他的订单信息

无条件查询

Maven高级-指南参考 - 图50

条件查询

Maven高级-指南参考 - 图51

准备数据库环境

代码

  1. CREATE DATABASE maven_adv IF NOT EXISTS;
  3. USE maven_adv;
  5. -- 用户名
  6. CREATE TABLE `user` (
  7.      uid INT PRIMARY KEY AUTO_INCREMENT,
  8.      `name` VARCHAR(20) NOT NULL,
  9.      sex CHAR(1) DEFAULT '男',
  10.      phone VARCHAR(20)
  11. );
  13. INSERT INTO `user` (`name`,sex,phone) VALUES ('张小敏','女','13923454567'), ('李强','男','18712321234'),('邹家俊','男','16233425678');
  15. SELECT * FROM `user`;
  17. -- 订单表
  18. CREATE TABLE `order` (
  19.     oid INT PRIMARY KEY AUTO_INCREMENT,
  20.     address VARCHAR(100) COMMENT '订单地址',
  21.     total DOUBLE COMMENT '金额',
  22.     uid INT,
  23.     FOREIGN KEY(uid) REFERENCES `user`(uid)
  24. );
  26. -- 一个用户下多个订单
  27. INSERT INTO `order` (address,total,uid) VALUES ('广东省汕头市', 3200,1),('湖南省株洲市', 250,1),('广西省柳州市', 1200,2),('广州市海珠区', 78,2),('海南省海口市', 605,3);
  29. -- 查询所有订单
  30. SELECT * FROM `order`;
  32. -- 查询用户和订单
  33. SELECT * FROM `user` u INNER JOIN `order` o ON u.uid = o.uid;

查询结果

Maven高级-指南参考 - 图52

表关系如下

Maven高级-指南参考 - 图53

创建父项目

  1. 创建项目ssm_parent
  2. 删除src目录
    Maven高级-指南参考 - 图54
  3. pom.xml文件如下 
  1.     <!--统一管理依赖包版本-->
  2.     <properties>
  3.         <!-- 指定编码 -->
  4.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  5.         <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
  6.         <!--spring 版本-->
  7.         <spring.version>5.2.10.RELEASE</spring.version>
  8.         <!-- log4j日志包版本 -->
  9.         <slf4j.version>1.7.7</slf4j.version>
  10.         <!-- jstl标签版本 -->
  11.         <jstl.version>1.2</jstl.version>
  12.         <!--servlet版本-->
  13.         <servlet.version>3.1.0</servlet.version>
  14.         <!--jsp版本-->
  15.         <jsp.version>2.0</jsp.version>
  16.         <!-- mybatis版本号 -->
  17.         <mybatis.version>3.5.0</mybatis.version>
  18.         <!--mysql驱动版本-->
  19.         <mysql.version>5.1.30</mysql.version>
  20.         <!-- mybatis-spring整合包版本 -->
  21.         <mybatis.spring.version>1.3.1</mybatis.spring.version>
  22.         <!--druid版本-->
  23.         <druid.version>1.0.29</druid.version>
  24.         <!-- aspectj版本号 -->
  25.         <aspectj.version>1.6.12</aspectj.version>
  26.         <!--json-->
  27.         <jackson.version>2.9.8</jackson.version>
  28.         <!--lombok-->
  29.         <lombok.version>1.18.6</lombok.version>
  30.         <!-- junit -->
  31.         <junit.version>4.12</junit.version>
  32.     </properties>
  34.     <dependencies>
  35.         <!--spring依赖包-->
  36.         <dependency>
  37.             <groupId>org.springframework</groupId>
  38.             <artifactId>spring-context</artifactId>
  39.             <version>${spring.version}</version>
  40.         </dependency>
  41.         <!-- spring mvc包 -->
  42.         <dependency>
  43.             <groupId>org.springframework</groupId>
  44.             <artifactId>spring-webmvc</artifactId>
  45.             <version>${spring.version}</version>
  46.         </dependency>
  47.         <!--spring jdbc包-->
  48.         <dependency>
  49.             <groupId>org.springframework</groupId>
  50.             <artifactId>spring-jdbc</artifactId>
  51.             <version>${spring.version}</version>
  52.         </dependency>
  53.         <!--aspectj包-->
  54.         <dependency>
  55.             <groupId>org.aspectj</groupId>
  56.             <artifactId>aspectjweaver</artifactId>
  57.             <version>${aspectj.version}</version>
  58.         </dependency>
  59.         <!--servlet依赖-->
  60.         <dependency>
  61.             <groupId>javax.servlet</groupId>
  62.             <artifactId>javax.servlet-api</artifactId>
  63.             <version>${servlet.version}</version>
  64.         </dependency>
  65.         <!-- mybatis核心包 -->
  66.         <dependency>
  67.             <groupId>org.mybatis</groupId>
  68.             <artifactId>mybatis</artifactId>
  69.             <version>${mybatis.version}</version>
  70.         </dependency>
  71.         <!-- mybatis-spring整合包 -->
  72.         <dependency>
  73.             <groupId>org.mybatis</groupId>
  74.             <artifactId>mybatis-spring</artifactId>
  75.             <version>${mybatis.spring.version}</version>
  76.         </dependency>
  77.         <!-- mysql数据库依赖 -->
  78.         <dependency>
  79.             <groupId>mysql</groupId>
  80.             <artifactId>mysql-connector-java</artifactId>
  81.             <version>${mysql.version}</version>
  82.         </dependency>
  83.         <!--数据库连接池druid-->
  84.         <dependency>
  85.             <groupId>com.alibaba</groupId>
  86.             <artifactId>druid</artifactId>
  87.             <version>${druid.version}</version>
  88.         </dependency>
  89.         <!-- log4j包 -->
  90.         <dependency>
  91.             <groupId>org.slf4j</groupId>
  92.             <artifactId>slf4j-log4j12</artifactId>
  93.             <version>${slf4j.version}</version>
  94.         </dependency>
  96.         <!--json包-->
  97.         <dependency>
  98.             <groupId>com.fasterxml.jackson.core</groupId>
  99.             <artifactId>jackson-databind</artifactId>
  100.             <version>${jackson.version}</version>
  101.         </dependency>
  103.         <!--lombok-->
  104.         <dependency>
  105.             <groupId>org.projectlombok</groupId>
  106.             <artifactId>lombok</artifactId>
  107.             <version>${lombok.version}</version>
  108.         </dependency>
  110.         <!--spring-test测试包-->
  111.         <dependency>
  112.             <groupId>org.springframework</groupId>
  113.             <artifactId>spring-test</artifactId>
  114.             <version>${spring.version}</version>
  115.             <scope>test</scope>
  116.         </dependency>
  117.         <dependency>
  118.             <groupId>junit</groupId>
  119.             <artifactId>junit</artifactId>
  120.             <version>${junit.version}</version>
  121.             <scope>test</scope>
  122.         </dependency>
  124.     </dependencies>

15. 分模块构建项目2：实体类，持久层【重点】

目标

  1. 创建实体类子模块
  2. 持久层子模块
  3. 业务层子模块

创建父工程

  1. 创建实体类ssm_entity工程
    Maven高级-指南参考 - 图55
  2. 结构如下 Maven高级-指南参考 - 图56
  3. 创建用户实体类 
  1. package com.itheima.entity;
  3. import lombok.Data;
  5. @Data
  6. public class User {
  7.     private Integer uid;
  8.     private String name;
  9.     private char sex;
  10.     private String phone;
  11. }
  1. 创建订单实体类，订单类中包含了用户类
  1. package com.itheima.entity;
  3. import lombok.Data;
  5. /**
  6.  * 一个订单对应一个用户
  7.  */
  8. @Data
  9. public class Order {
  10.     private Integer oid;
  11.     private String address;
  12.     private Double total;
  13.     private User user;  //包含了用户对象，查询订单对象，可以获取到用户对象的属性
  14. }

持久层步骤

  1. 创建ssm_dao项目
  2. 添加依赖： ssm_entity项目
  3. 编写dao接口
  4. 编写查询用户和订单的方法
    1. 方法提供address地址做为参数
    2. 使用XML的配置方式
  5. 创建实体类映射配置文件
    注：在resources下创建目录名要使用/，而不是点号 Maven高级-指南参考 - 图57
    1. 使用表连接查询用户表和订单表的信息
    2. 创建resultMap，指定id和type属性。
      注：需要在applicationContext.xml中SqlSessionFactoryBean配置别名typeAliasesPackage
    3. 创建子元素result，指定属性：user.uid，映射的列是uid
    4. 创建子元素result，指定属性：user.name，映射的列是name
    5. 创建子元素result，指定属性：user.sex，映射的列是sex
    6. 创建子元素result，指定属性：user.phone，映射的列是phone
    7. 查询的结果指定为上面的resultMap

实现

  1. 创建ssm_dao项目
    Maven高级-指南参考 - 图58

  2. 添加依赖： ssm_entity 

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5. <parent>
    6.     <artifactId>ssm_parent</artifactId>
    7.     <groupId>com.itheima</groupId>
    8.     <version>1.0-SNAPSHOT</version>
    9. </parent>
    10. <modelVersion>4.0.0</modelVersion>
    12. <artifactId>ssm_dao</artifactId>
    14. <!-- 依赖于entity -->
    15. <dependencies>
    16.     <dependency>
    17.         <groupId>com.itheima</groupId>
    18.         <artifactId>ssm_entity</artifactId>
    19.         <version>1.0-SNAPSHOT</version>
    20.     </dependency>
    21. </dependencies>
    22. </project>
  1. 编写dao接口，查询所有的用户和订单信息。注：Order不要导错了 ```java package com.itheima.dao;

import com.itheima.entity.Order; import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface OrderDao { /**

  1.  * 查询所有的订单和用户
  2.  */
  3. List<Order> findUserAndOrder(@Param("address") String address);

}

  3. 4.  编写XML配置文件，查询所有的用户和订单 
  4.    1. 配置映射对象
  5.    1. 将order对象中user属性创建映射关系
  6.    1. 查询订单所有的用户和订单
  7. ```xml
  8. <?xml version="1.0" encoding="UTF-8" ?>
  9. <!DOCTYPE mapper
  10.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  11.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  12. <mapper namespace="com.itheima.dao.OrderDao">
  14.     <!-- 创建一个实体映射关系 -->
  15.     <resultMap id="orderMap" type="com.itheima.entity.Order">
  16.         <result property="user.uid" column="uid"/>
  17.         <result property="user.name" column="name"/>
  18.         <result property="user.sex" column="sex"/>
  19.         <result property="user.phone" column="phone"/>
  20.     </resultMap>
  22.     <!-- 查询用户和订单 -->
  23.     <select id="findUserAndOrder" resultMap="orderMap">
  24.         SELECT * FROM `user` u INNER JOIN `order` o ON u.uid = o.uid
  25.     </select>
  26. </mapper>

16. 分模块构建项目2：业务层

步骤

  1. 创建项目：ssm_service
  2. 添加dao层的依赖：ssm_dao
  3. 编写service接口：查询所有用户和订单
  4. 编写service实现类：调用DAO查询

实现

  1. 创建项目：ssm_service
    Maven高级-指南参考 - 图59
    结构
    Maven高级-指南参考 - 图60

  2. 添加dao层的依赖：ssm_dao ```xml <?xml version=”1.0” encoding=”UTF-8”?> <project xmlns=”http://maven.apache.org/POM/4.0.0“

    1.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    1. <artifactId>ssm_parent</artifactId>
    2. <groupId>com.itheima</groupId>
    3. <version>1.0-SNAPSHOT</version>

    4.0.0 ssm_service com.itheima ssm_dao 1.0-SNAPSHOT 

  3. 3.  编写配置类<br />JdbcConfig 
  4. ```java
  5. package com.itheima.config;
  7. @PropertySource("classpath:jdbc.properties")  //加载属性文件
  8. public class JdbcConfig {
  10.     @Value("${jdbc.username}")
  11.     private String username;
  13.     @Value("${jdbc.password}")
  14.     private String password;
  16.     @Value("${jdbc.url}")
  17.     private String url;
  19.     @Value("${jdbc.driverClassName}")
  20.     private String driverClassName;
  22.     /**
  23.      * 创建数据源，放到容器中
  24.      */
  25.     @Bean
  26.     public DataSource dataSource() {
  27.         DruidDataSource dataSource = new DruidDataSource();
  28.         dataSource.setUsername(username);
  29.         dataSource.setPassword(password);
  30.         dataSource.setUrl(url);
  31.         dataSource.setDriverClassName(driverClassName);
  32.         return dataSource;
  33.     }
  35.     /**
  36.      * 创建事务管理器
  37.      */
  38.     @Bean
  39.     public DataSourceTransactionManager transactionManager(DataSource dataSource) {
  40.         return new DataSourceTransactionManager(dataSource);
  41.     }
  42. }


MybatisConfig
jdbc.properties
log4j.properties
SpringConfig

  1. 编写service接口：查询所有用户和订单
    方法的查询参数是字符串的地址 ```java package com.itheima.service;

import com.itheima.entity.Order;

import java.util.List;

public interface OrderService { /**

  1.  * 查询所有用户的订单
  2.  */
  3. List<Order> findUserAndOrder(String address);

}

  3. 5.  编写service接口实现：调用DAO查询 
  4.    1. 添加@Service注解，添加到Spring容器
  5.    1. 使用@Autowared注解，从容器中注入Dao的实现类
  6.    1. 在方法中调用DAO对象查询记录
  7.    1. 使用注解式事务
  8. ```java
  9. package com.itheima.service.impl;
  11. import com.itheima.dao.OrderDao;
  12. import com.itheima.entity.Order;
  13. import com.itheima.service.OrderService;
  14. import org.springframework.beans.factory.annotation.Autowired;
  15. import org.springframework.stereotype.Service;
  17. import java.util.List;
  19. @Service
  20. public class OrderServiceImpl implements OrderService {
  22.     @Autowired
  23.     private OrderDao orderDao;
  25.     /**
  26.      * 查询所有用户的订单
  27.      * @param address
  28.      */
  29.     @Override
  30.     public List<Order> findUserAndOrder(String address) {
  31.         return orderDao.findUserAndOrder(address);
  32.     }
  33. }
  1. 测试类 ```java package com.itheima.test;

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = SpringConfig.class) public class OrderTest {

  1. @Autowired
  2. private OrderService orderService;
  4. @Test
  5. public void testFindOrder() {
  6.     List<Order> orders = orderService.findUserAndOrder("");
  7.     orders.forEach(System.out::println);
  8. }

}

  3. <a name="844393f7-1"></a>
  4. ## 查询结果
  6. ![](assets/image-20211107210429401.png#crop=0&crop=0&crop=1&crop=1&id=tcjaF&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
  8. <a name="e3f5fa89"></a>
  9. # 17. 分模块构建项目3：表现层子模块【重点】
  11. <a name="73e82552-9"></a>
  12. ## 目标
  14. 创建web层子模块
  16. ![](assets/image-20211107175856160.png#crop=0&crop=0&crop=1&crop=1&id=uQLwt&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
  18. <a name="52b36576-4"></a>
  19. ## 步骤
  21. 1.  创建maven模块：ssm_web<br />![](assets/image-20211107210705096.png#crop=0&crop=0&crop=1&crop=1&id=G0HNc&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
  22. 2.  修改pom.xml中包的类型为war，并且刷新![](assets/image-20211107210734166.png#crop=0&crop=0&crop=1&crop=1&id=v1TQm&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
  23. ```xml
  24. <?xml version="1.0" encoding="UTF-8"?>
  25. <project xmlns="http://maven.apache.org/POM/4.0.0"
  26.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  27.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  28.     <parent>
  29.         <artifactId>ssm-parent</artifactId>
  30.         <groupId>com.itheima</groupId>
  31.         <version>1.0-SNAPSHOT</version>
  32.     </parent>
  33.     <modelVersion>4.0.0</modelVersion>
  35.     <artifactId>ssm-web</artifactId>
  37.     <packaging>war</packaging>
  39.     <dependencies>
  40.         <dependency>
  41.             <groupId>com.itheima</groupId>
  42.             <artifactId>ssm-service</artifactId>
  43.             <version>1.0-SNAPSHOT</version>
  44.         </dependency>
  45.     </dependencies>
  47. </project>
  1. 将java工程转成web工程 Maven高级-指南参考 - 图61
    为OK以后
    Maven高级-指南参考 - 图62
    点Yes
    Maven高级-指南参考 - 图63
  2. 选择上面的添加web.xml
    Maven高级-指南参考 - 图64
  3. 选择正确的目录结构： scr\main\webapp\WEB-INF\web.xml
    Maven高级-指南参考 - 图65
  4. 结构如下，完成
    Maven高级-指南参考 - 图66

实现

  1. SpringMvcConfig ```java package com.itheima.config;

import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Configuration @ComponentScan({“com.itheima.controller”, “com.itheima.config”}) //扫描控制器 @EnableWebMvc //开启json转换 public class SpringMvcConfig { }

  3. 5.  启动时加载的配置类 
  4. ```java
  5. package com.itheima.config;
  7. import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
  9. /**
  10.  * tomcat启动的时候自动加载的配置类
  11.  */
  12. public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
  13.     /**
  14.      * 加载Spring的配置类，父容器
  15.      * @return
  16.      */
  17.     @Override
  18.     protected Class<?>[] getRootConfigClasses() {
  19.         return new Class[]{SpringConfig.class};
  20.     }
  22.     /**
  23.      * 加载SpringMVC的配置类，子容器
  24.      * @return
  25.      */
  26.     @Override
  27.     protected Class<?>[] getServletConfigClasses() {
  28.         return new Class[]{SpringMvcConfig.class};
  29.     }
  31.     @Override
  32.     protected String[] getServletMappings() {
  33.         return new String[]{"/"};
  34.     }
  35. }

18. SSM案例：显示所有订单

目标

Maven高级-指南参考 - 图67

静态资源

  1. 复制静态资源
    Maven高级-指南参考 - 图68
  2. 静态资源放行 
  1. package com.itheima.config;
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
  5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
  7. @Configuration
  8. public class SpringMvcSupport extends WebMvcConfigurationSupport {
  10.     /**
  11.      * 把静态资源放行
  12.      */
  13.     @Override
  14.     protected void addResourceHandlers(ResourceHandlerRegistry registry) {
  15.         System.out.println("静态资源放行");
  16.         registry.addResourceHandler("/css/**").addResourceLocations("/css/");
  17.         registry.addResourceHandler("/js/**").addResourceLocations("/js/");
  18.         registry.addResourceHandler("/**").addResourceLocations("/");
  19.     }
  20. }
  1. 建议部署到tomcat中运行，注：是部署ssm_web项目到tomcat中，而不是部署ssm_parent项目

注：分模块构建中使用tomcat插件运行有时会出现找不到jar包的情况

Maven高级-指南参考 - 图69

Maven高级-指南参考 - 图70

代码

如果部署运行出现找不到类，则在父工程上打包一次

Maven高级-指南参考 - 图71

控制器代码

  1. package com.itheima.controller;
  3. import com.itheima.entity.Order;
  4. import com.itheima.service.OrderService;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.RestController;
  9. import java.util.List;
  11. @RestController
  12. @RequestMapping("/order")
  13. public class OrderController {
  15.     @Autowired
  16.     private OrderService orderService;
  18.     /**
  19.      * 查询用户和订单
  20.      */
  21.     @RequestMapping("/find")
  22.     public List<Order> find(String address) {
  23.         return orderService.findUserAndOrder(address);
  24.     }
  25. }

页面测试

Maven高级-指南参考 - 图72
页面代码

  1. <!DOCTYPE html>
  2. <html lang="zh-CN">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1">
  7.     <title>查询所有联系人</title>
  9.     <!-- 1. 导入CSS的全局样式 -->
  10.     <link href="css/bootstrap.min.css" rel="stylesheet">
  11.     <!-- 2. jQuery导入，建议使用1.9以上的版本 -->
  12.     <script src="js/jquery-3.3.1.js"></script>
  13.     <!-- 3. 导入bootstrap的js文件 -->
  14.     <script src="js/bootstrap.min.js"></script>
  16.     <script src="js/vue.js"></script>
  17.     <script src="js/axios.js"></script>
  18.     <style type="text/css">
  19.         tr, th {
  20.             text-align: center;
  21.         }
  22.     </style>
  23. </head>
  24. <body>
  25. <div class="container">
  26.     <div class="row">
  27.         <div class="col-md-4">
  28.             <h3>用户和订单列表</h3>
  29.         </div>
  31.         <div class="col-md-8">
  32.             <div class="input-group" style="padding-top: 15px">
  33.                 <div class="input-group">
  34.                     <input type="text" id="address" name="address" class="form-control" placeholder="输入查询的地址">
  35.                     <span class="input-group-btn">
  36.                         <button class="btn btn-primary" type="button" onclick="findAll()">查询订单</button>
  37.                       </span>
  38.                 </div>
  39.             </div>
  40.         </div>
  41.     </div>
  42.     <div class="row">
  43.         <div class="col-md-12">
  44.             <table border="1" class="table table-striped table-bordered table-hover table-condensed">
  45.                 <tr class="info">
  46.                     <th>编号</th>
  47.                     <th>姓名</th>
  48.                     <th>性别</th>
  49.                     <th>电话</th>
  50.                     <th>地址</th>
  51.                     <th>金额</th>
  52.                 </tr>
  53.                 <tbody id="orderBody">
  54.                 <tr v-for="(order,index) in orderData">
  55.                     <td>{{index+1}}</td>
  56.                     <td>{{order.user.name}}</td>
  57.                     <td>{{order.user.sex}}</td>
  58.                     <td>{{order.user.phone}}</td>
  59.                     <td>{{order.address}}</td>
  60.                     <td>{{order.total}}</td>
  61.                 </tr>
  62.                 </tbody>
  63.             </table>
  64.         </div>
  65.     </div>
  67. </div>
  69. </div>
  70. </body>
  71. <script type="text/javascript">
  72.     new Vue({
  73.         el: ".container",
  74.         data: {
  75.             orderData: []
  76.         },
  77.         methods: {
  78.             //查询所有订单
  79.             findAll() {
  80.                 axios.get("/order/find").then(resp => {
  81.                     this.orderData = resp.data;
  82.                 });
  83.             }
  84.         },
  85.         created() {
  86.             this.findAll();
  87.         }
  89.     });
  90. </script>
  92. </html>

19. SSM案例：完成订单的模糊查询

目标

Maven高级-指南参考 - 图73

Maven高级-指南参考 - 图74

步骤

修改OrderDao.xml中的配置

  1. 判断address如果不为空，而且也不为空串，则做为where条件拼接在查询语句的后面
  2. 模糊查询使用 "%"#{address}"%"

注：mybatis中如果使用if等表达式时，方法上的参数要使用@Param(“address”)注解，否则会出现异常。

代码

OrderDao.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  5. <mapper namespace="com.itheima.dao.OrderDao">
  7.     <!-- 创建一个实体映射关系 -->
  8.     <resultMap id="orderMap" type="com.itheima.entity.Order">
  9.         <result property="user.uid" column="uid"/>
  10.         <result property="user.name" column="name"/>
  11.         <result property="user.sex" column="sex"/>
  12.         <result property="user.phone" column="phone"/>
  13.     </resultMap>
  15.     <!-- 查询用户和订单 -->
  16.     <select id="findUserAndOrder" resultMap="orderMap">
  17.         SELECT * FROM `user` u INNER JOIN `order` o ON u.uid = o.uid
  18.         <if test="address!=null and address!=''">
  19.             where address like "%"#{address}"%"
  20.         </if>
  21.     </select>
  22. </mapper>

页面代码

  1. <!DOCTYPE html>
  2. <html lang="zh-CN">
  3. <head>
  4.     <meta charset="utf-8">
  5.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1">
  7.     <title>查询所有联系人</title>
  9.     <!-- 1. 导入CSS的全局样式 -->
  10.     <link href="css/bootstrap.min.css" rel="stylesheet">
  11.     <!-- 2. jQuery导入，建议使用1.9以上的版本 -->
  12.     <script src="js/jquery-3.3.1.js"></script>
  13.     <!-- 3. 导入bootstrap的js文件 -->
  14.     <script src="js/bootstrap.min.js"></script>
  16.     <script src="js/vue.js"></script>
  17.     <script src="js/axios.js"></script>
  18.     <style type="text/css">
  19.         tr, th {
  20.             text-align: center;
  21.         }
  22.     </style>
  23. </head>
  24. <body>
  25. <div class="container">
  26.     <div class="row">
  27.         <div class="col-md-4">
  28.             <h3>用户和订单列表</h3>
  29.         </div>
  31.         <div class="col-md-8">
  32.             <div class="input-group" style="padding-top: 15px">
  33.                 <div class="input-group">
  34.                     <input type="text" v-model="address" class="form-control" placeholder="输入查询的地址">
  35.                     <span class="input-group-btn">
  36.                         <button class="btn btn-primary" type="button" @click="findAll()">查询订单</button>
  37.                       </span>
  38.                 </div>
  39.             </div>
  40.         </div>
  41.     </div>
  42.     <div class="row">
  43.         <div class="col-md-12">
  44.             <table border="1" class="table table-striped table-bordered table-hover table-condensed">
  45.                 <tr class="info">
  46.                     <th>编号</th>
  47.                     <th>姓名</th>
  48.                     <th>性别</th>
  49.                     <th>电话</th>
  50.                     <th>地址</th>
  51.                     <th>金额</th>
  52.                 </tr>
  53.                 <tbody id="orderBody">
  54.                 <tr v-for="(order,index) in orderData">
  55.                     <td>{{index+1}}</td>
  56.                     <td>{{order.user.name}}</td>
  57.                     <td>{{order.user.sex}}</td>
  58.                     <td>{{order.user.phone}}</td>
  59.                     <td>{{order.address}}</td>
  60.                     <td>{{order.total}}</td>
  61.                 </tr>
  62.                 </tbody>
  63.             </table>
  64.         </div>
  65.     </div>
  67. </div>
  69. </div>
  70. </body>
  71. <script type="text/javascript">
  72.     new Vue({
  73.         el: ".container",
  74.         data: {
  75.             orderData: [],
  76.             address: ''
  77.         },
  78.         methods: {
  79.             //查询所有订单
  80.             findAll() {
  81.                 axios.get("/order/find?address=" + this.address).then(resp => {
  82.                     this.orderData = resp.data;
  83.                 });
  84.             }
  85.         },
  86.         created() {
  87.             this.findAll();
  88.         }
  90.     });
  91. </script>
  93. </html>