学习一下 SpringCloud （一）-- 从单体架构到微服务架构、代码拆分（maven 聚合）
1、架构演变
一、系统架构、集群、分布式系统 简单理解
（1）什么是系统架构？html
【什么是系统架构？】
系统架构 描述了 在应用程序内部，如何根据 业务、技术、灵活性、可扩展性、可维护性 等因素，将系统划分红不一样的部分并使这些部分相互分工、协做，从而提升系统的性能。
【简单的理解：】
系统架构是 程序运行 的基石、其决定了程序是否能正确、有效的构建 以及 稳定的运行。
（2）集群前端
【什么是集群？】
计算机集群简称集群，是一种计算机系统，它经过一组松散集成的计算机软件或硬件链接起来、高度紧密地协做完成计算工做。
在某种意义上，他们能够被看做是一台计算机。
集群系统中的单个计算机一般称为节点，一般经过局域网链接（或者其它的链接方式）。
集群计算机一般用来改进单个计算机的计算速度或可靠性。
【简单的理解：】
经过多台计算机完成同一个工做，达到更高的效率。
两机或多机内容、工做过程等彻底同样。若是一台死机，另外一台能够起做用。
同一个业务，部署在多个服务器上(不一样的服务器运行一样的代码，干同一件事)。
（3）分布式系统java
【什么是分布式系统？】
分布式系统是一组计算机，经过网络相互链接，传递消息与通讯后，协调它们的行为而造成的系统。
组件之间彼此进行交互从而实现一个共同的目标。
【简单的理解：】
经过多台计算机相互做用完成一个工做，每一个计算机负责一个功能模块，将多个计算机组合起来从而完成一个大任务。
一个业务拆分为多个子业务，部署在不一样的服务器上(不一样的服务器，运行不一样的代码，为了同一个目的)。
注：
分布式与集群不冲突，能够存在分布式集群，即将一个项目拆分为不一样的功能模块后，对各个不一样的功能模块实现集群。
（4）架构演变
Dubbo 官网将系统架构分为 单体架构、垂直架构、分布式服务架构、流计算架构。
可参考：http://dubbo.apache.org/docs/v2.7/user/preface/background/
注：
下面的 系统演变过程 以此为 基础 进行展开，有不对的地方还望不吝赐教。mysql
二、系统架构须要考虑的因素（高可用、高并发、高性能）
（1）高可用性（High Availability）web
【高可用性：】
高可用性 指的是 尽可能缩短 维护操做（计划内）以及 系统故障（非计划内）而致使的停机时间，从而保证 系统 正常运行。
高可用性 具备高度 的容错性、恢复性。
注：
容错性 指的是 软件发生故障时 仍能正常运行的 能力。
恢复性 指的是 软件发生故障时 恢复到故障以前状态的 能力。
（2）高并发（High Concurrency）redis
【高并发性：】 高并发性 指的是 保证系统可以同时并行处理 不少请求。 经过 水平拓展 或者 垂直拓展的方式 能够提升系统高并发能力。 【垂直拓展：】 垂直拓展，提升当前系统的能力 以适应 需求。 又可分为两种： 1、提高硬件能力，强化 服务器硬件，好比：机械硬盘 更换为 固态硬盘，增长 CPU 核数、拓展系统内存 等。 二、提高软件能力，优化 软件性能，好比：使用缓存 减小磁盘 I/O 次数，优化代码使用的数据结构 从而减小响应时间等。 注： 单机性能提高仍是有限的，成本充足状况下，增长服务器的使用仍是比较合适的。 【水平拓展：】 水平拓展，也即 横向拓展，增长系统个数 以适应 需求，只须要增长服务器 的数量，就能够线性的增长系统的并发能力。 固然也不能一直增长服务器，服务器数量增多，维护、成本的压力也就上来了。 【高并发相关指标：】 响应时间（Response Time）：指的是 系统对 用户输入或者请求 进行处理并响应请求的时间。 吞吐量（Throughput）：指的是 系统单位时间内 处理请求的数量（吞吐量通常与响应时间成反比，即吞吐量越大，响应时间越短）。 每秒查询率（Query Per Second，QPS）：指的是 系统 每秒响应的请求数。 并发用户数：指的是 系统 某时刻支持 正常使用系统的用户数。
（3）高性能（High Performance）spring
【高性能：】
高性能 指的是 程序处理速度快、占用内存少、CPU 占用率低。
也即系统性能强悍、运算能力强、响应时间短。
三、架构演变 -- 单体应用架构（传统架构、三层架构、集群）
（1）传统架构sql
【背景：】
互联网开发早期，全部的 业务、功能模块 代码都写在一个项目中，而后 编译、打包并部署到容器（好比：Tomcat）中运行。
此时称为 All in One，即 全部模块代码均写在一块儿（好比：Servlet、JSP 等代码）、技术上不分层。
【优势：】
全部功能均在同一个应用程序中，因此只须要部署 一个应用程序便可，减小了 部署节点、以及成本。
【缺点（出现的问题）：】
代码可维护性差（全部代码均写在一个项目中，没有层次，相互调用复杂，不易修改）。
容错性差（代码写在 JSP 中，发生错误时 服务器可能直接宕机 且 用户能够直接看到 错误信息）。
并发量小。
（2）三层架构数据库
【背景：】
为了解决 传统架构 可维护性差、容错性差、并发量小 等问题，引入了 分层的概念。
分层 即 将代码 划分出 几个层级，每一个层级 干不一样的事，从而提升代码的可维护性。
那么如何分层呢？分几层呢？
在开发早期，全部的逻辑代码没有明显的区分，代码间相互调用、职责不清，页面逻辑、业务逻辑、数据库访问逻辑 等混合在一块儿，即一层架构，此时的代码维护、迭代工做确定无比麻烦。
随着时代的发展，数据库访问逻辑 被逐步的划分出来，但页面逻辑、业务逻辑 仍然混合在一块儿，即二层架构，此时简化了数据访问的操做，提升了系统的可维护性。
继续发展，从功能、代码组织的角度进行划分，将三种逻辑分开，也即三层架构出现。
【三层架构（MVC）：】
从功能、代码组织的角度出发，按系统不一样职责进行划分红三个层次：
表示层：关注 数据显示 以及 用户交互。
业务逻辑层：关注 业务逻辑处理。
数据访问层：关注 数据的存储与访问。
注：
此处的三层架构并不是 物理分层，而是逻辑上的分层（全部代码仍然在一个项目中进行 开发、编译、部署，还是单体架构）。
【优势：】
提升了可维护性。每一层的功能具体化，解决了系统间 相互调用复杂、职责不清的问题，有效下降了层与层间的依赖关系，下降了维护、迭代的成本。
MVC 分层开发，提升了系统的容错性。
服务器分离部署。数据库 以及 应用程序 能够部署在 不一样的服务器 上。
【缺点（出现的问题）：】
并发量仍然不高（随着用户访问量增长，单台应用服务器没法知足需求）。
（3）集群express
【背景：】
为了解决 三层架构 的并发量问题，引入了 集群的概念。
单台服务器不能知足需求，那么就使用 多台 服务器构成 集群 提供服务。
【优势：】
使用 多台服务器 构成集群 同时提供服务，提升了并发量。
提升了容错性（一台服务器挂了，还有其余服务器能够提供服务，保证程序的正常运行）。
【缺点（出现的问题）：】
用户的请求 发送给 哪台服务器？
如何保证请求能够 平均的发送给 各个服务器？
数据如何进行共享、缓存？
数据须要模糊查询时，如何提升数据库查询效率？
数据库访问压力如何解决？
数据量过大时，应该如何存储？
【解决：】
能够经过 Nginx 解决 请求的发送 以及 分发（负载均衡） 问题。
能够经过 Redis 解决 数据共享 以及 缓存 问题。
能够经过 ElacticSearch 解决 数据搜索 问题。
能够经过 MyCat 使用主从复制、读写分离，减轻数据库压力，经过分库分表 的方式，按照指定的方式存储数据。
（4）解决集群出现的问题
【问题一：】 用户 登陆并访问 服务器时，会产生一个 session，且伴随着用户访问的全过程 直至 用户关闭浏览器结束这次访问。 当一个服务器忽然宕机，若不对 session 进行处理，那么其 session 一定丢失，也即 用户须要从新 进行登陆等 一系列操做，用户体验感将极差。 那么 session 如何共享？也即 数据共享问题？ 【解决：】 方式一： 使用 Tomcat 广播 session，从而实现 session 共享。 每一个 tomcat 会在局域网中广播本身的 session 信息并监听其余 tomcat 广播的 session 信息，一旦 session 发生变化，其余的 tomcat 就能监听并同步 session。 注： 此方式只适用于 并发量小的 小项目。 并发量大时，好比用户量为 1000 万，那每一个服务器都须要广播、维护 session，那么将会致使服务器大量资源都用来处理 session，这样确定不适合大型项目。 方式二： 使用 Redis 存储 session，从而实现 session 共享。 使用 Redis 存储 session，当服务器须要使用 session 时，直接从 Redis 中获取，这样只须要关心 Redis 的维护便可，减轻了 服务器的压力。 同时，Redis 还能够用来进行 数据缓存，减小数据库访问次数（提升响应时间）。 注： 此方式适合于 大型的项目。 SpringBoot 整合 Redis 可参考：https://www.cnblogs.com/l-y-h/p/13163653.html#_label0
【问题二：】 使用集群，即存在多个服务器，一个用户请求 确定会被某一个服务器进行处理，此时就须要考虑 服务器 处理请求的问题了。 那么 用户的请求 发送给 哪台服务器处理？如何保证请求能够 平均的发送给 集群中的各个服务器？ 【解决：】 能够经过 Nginx 解决 请求的发送 以及 分发（负载均衡） 问题。 注： Nginx 反向代理、负载均衡等基本概念可参考：https://www.cnblogs.com/l-y-h/p/12844824.html#_label0
【问题三：】 经过上面介绍的 Nginx + Redis 的方式，提升了应用层的性能。 应用层问题解决了，数据库的访问压力怎么解决？如何提升数据库的负载能力？数据库数据量大时如何存储？ 【解决：】 采用读写分离、主从复制的方式，提升数据库负载能力。 采用 master-slave 方式，master 负责 进行增删改 等写操做，slave 进行 读操做，并经过主从复制的方式 将 master 数据同步到 slave 中。 设置多个 slave，从而提升数据库查询、负载能力。 采用分库分表的方式，进行数据存储。 注： 垂直拆分数据表：根据经常使用字段 以及 不经常使用字段 将数据表划分为多个表，从而减小单个表的数据大小。 水平拆分数据表：根据时间、地区 或者 业务逻辑进行拆分。 垂直拆分仍有局限性，水平拆分便于业务拓展。
【问题四：】
虽然进行了读写分离，数据量过大时，执行 模糊查询 的效率低。对于大型的网站（电商等），搜索是其核心模块，若一个查询执行半天才能返回结果，那么用户体验将是极差的。
那么如何提升查询的效率？
【解决：】
使用 搜索引擎技术，好比：ElacticSearch、solr。
（5）单体架构总结
【单体架构：】
单体架构，就是将全部 业务、功能模块 都写在一个项目中，编译、打包并部署到容器（好比：Tomcat）中运行。
应用程序、数据库 能够分开部署，能够经过部署 应用程序集群、数据库集群 的方式提升系统性能。
能简化 增删改查 工做的 数据访问框架（ORM） 也是提升系统性能的关键。
注：
随着业务扩大、需求增长，单体架构将会变得臃肿、耦合性高，可维护性、可扩展性、灵活性都在逐步下降，
难以知足业务快速迭代的需求，且成本不断攀升，单体架构的时代已成为过去。
【优势：】
开发、测试、部署简单，维护成本低。适用于 用户、数据 规模小的 项目。
经过拓展集群的方式 能够保证 高并发、高可用。
【缺点：】
可维护性、可拓展性差。（随着业务增长、功能迭代，代码会变得臃肿、耦合）
技术栈受限，且只能经过 拓展集群 的方式提升系统性能（维护成本高）。
协同开发不方便（存在修改相同业务代码的状况、致使冲突）。
四、架构演变 -- 垂直应用架构（水平拆分、垂直拆分）
（1）背景
上面介绍的 单体架构 已不能知足实际场景（拓展能力有限、代码臃肿），那么须要进行代码重构，对单体架构代码 进行拆分，那么如何进行拆分 能保证 高可用、高并发、高性能 呢？
前面也提到了 高并发 能够经过 垂直拓展、水平拓展 来实现，此处不妨也对单体架构的代码 进行 水平拆分 以及 垂直拆分。
注：
拓展 与 拆分 是两种概念。拓展是对外部改造，拆分是对内部改造。
垂直拓展：增长服务器硬件性能，提升服务器执行应用的能力。
水平拓展：增长服务器数量，多节点部署应用。
垂直拆分：根据业务 对 系统进行划分。
水平拆分：根据逻辑分层 对 系统进行划分（好比：先后端分离、MVC 分层）。
（2）水平拆分
水平拆分 根据 逻辑分层 对系统进行划分，将一个大的 单体应用程序 拆分红 多个小应用程序，每一个小应用程序 做为 单独的 jar 包，须要使用时，引入相关 jar 包便可。
【单体应用举例：】
现有一个 SSM 单体应用，如何进行水平拆分？
【水平拆分思路：】
按照逻辑分层对代码进行拆分，将 controller、service、dao 层分别抽取出来，并打成 jar 包，须要使用时 直接引入 jar 包便可。
【使用 Maven 聚合的方式能够演示：】
Step1：构建一个 ssm_parent 工程（父工程，聚合下面的子工程，pom）
Step2：构建一个 ssm_bean 工程（子工程，存放 实体类，jar）
Step3：构建一个 ssm_mapper 工程（子工程，存放持久层类以及接口，jar）
Step4：构建一个 ssm_service 工程（子工程，存放 业务逻辑层类以及接口，jar）
Step5：构建一个 ssm_controller 工程（子工程，存放 控制层类，war）
也即目录结构以下：
ssm_parent（pom）
ssm_bean（jar） 或者 ssm_pojo 名称随意取，见名知意 便可。
ssm_mapper（jar） 或者 ssm_dao
ssm_service（jar）
ssm_controller（war） 或者 ssm_web
注：
ssm_mapper 须要引入 ssm_bean.jar。
ssm_service 须要引入 ssm_mapper.jar。
ssm_controller 须要引入 ssm_service.jar。
能够经过 ssm_controller 或者 ssm_parent 启动项目。
【水平拆分优势：】
模块能够复用，减小代码冗余度。
代码分离部署，能够根据实际状况，增长 或者 减小 某些业务层的部署量。（好比：dao 层访问量过大，能够多部署几个 dao 服务减轻压力。单体应用则是总体部署，增大了服务器部署容量。）
【水平拆分缺点：】
各个模块业务仍然交互在一块儿，修改某个模块业务时，整个 jar 包（非修改模块）须要从新 测试 、部署，增长了 测试 与 维护 的压力。
（3）垂直拆分：
垂直拆分 是 根据 业务 对系统进行划分，将一个大的 单体应用程序 拆分红 若干个 互不相干的小应用程序（也即 垂直应用架构）。
每一个小应用程序 就是一个单独的 web 项目。
【单体应用举例：】
现有一个 SSM 单体应用，如何进行垂直拆分？
【垂直拆分思路：】
按照业务对代码进行拆分，好比：如今 SSM 中存在 后台管理业务、用户业务、菜单业务 等。
则将 这些业务 分别抽取出来，各自构成 web 工程。
【使用 Maven 聚合的方式能够演示：】
Step1：构建一个 ssm_parent 工程（父工程，聚合下面的子模块，pom）
Step2：构建一个 ssm_admin 模块（子模块，后台管理模块）
Step3：构建一个 ssm_user 模块（子模块，用户模块）
Step4：构建一个 ssm_menu 模块（子模块，菜单模块）
也即目录结构以下：
ssm_parent（pom）
ssm_admin
ssm_user
ssm_menu
【垂直拆分优势：】
提升了可维护性（需求变动时，修改对应的模块便可）。
提升了可拓展性（拓展业务时，增长新的模块便可，能够针对访问量 增大、减小 某个模块的部署量）。
提升了协同开发能力（不一样的团队能够开发 不一样的模块）。
【垂直拆分缺点：】
某个模块修改时（好比：页面频繁更换），须要对整个模块进行从新部署，增大了维护的难度。
随着业务模块增长，各模块间必然须要进行业务交互，模块交互问题又是一个头疼的问题。
（4）垂直应用架构总结
【垂直应用架构：】
垂直应用架构，按照业务将原来的 大单体应用 拆分红 若干个互不想干的 小单体应用。
用于加速前端页面开发的 web 框架（MVC）也是提升开发效率的关键。
【优势：】
系统间相互独立，极大地解决了 耦合问题。
能够针对不一样的业务进行 优化、能够针对不一样的业务搭建集群。
【缺点：】
使用集群时，负载均衡相对而言比较复杂，且拓展成本高、有瓶颈。
随着功能增长，模块随之增多，一些通用的服务、模块也会增多，代码冗余。
随着业务增长，应用之间不免会进行 数据交互，若某个应用端口、IP 变动，须要手动进行代码更改（增长维护成本）。
五、架构演变 -- 分布式服务架构、SOA 架构、微服务架构
（1）分布式服务架构
随着 垂直应用架构 模块增多，模块之间的交互不可避免，为了解决 这个问题，引出了 分布式服务架构，将 核心业务 抽取出来并独立部署，各服务之间经过 远程调用框架（PRC）进行通讯。
【分布式服务架构：】 分布式服务架构，按照业务 拆分红不一样的子业务，并独立部署在不一样的服务器上。 【垂直应用架构问题一：】 客户对页面要求变化大，每次修改后，都须要对应用从新部署，是比较麻烦的事情。 【解决：】 采用 先后端分离开发，将 界面 与 业务逻辑分开（水平拆分），此时只需关心界面的修改便可。 【垂直应用架构问题二：】 随着业务模块增长，各个模块必然会进行交互，如何交互？业务部署在不一样服务器上，该如何交互？ 【解决：】 采用 RPC/HTTP/HttpClient 框架进行远程服务调用。 【分布式架构问题：】 新架构的改变必然带来新的技术问题。好比： 分布式事务、分布式锁、分布式日志管理 等。 随之而来的就是 分布式服务治理中间件： Dubbo（RPC） 以及 SpringCloud（HTTP）。
（2）SOA 架构
随着 服务的 增多，若不对 服务进行管理，那么容易致使 服务资源浪费（好比：用户模块访问量大 只部署了 10 台服务器，而 菜单模块访问量小，却部署了 20 台服务器）、且服务间调用混乱（100 个服务相互调用若没有条理，那将是一件很是头疼的事情）。
为了提升 机器利用率 并 对服务进行管理，引出了 SOA 的概念。
注：
此处只是简单的介绍了下概念，详情请自行 谷歌、百度 了解（有时间再详细研究研究）。
【SOA：】 SOA 是 Service-Oriented Architecture 的简写，即 面向服务架构。 指的是 根据实际业务，将系统拆分红合适的、独立部署的服务，各服务相互独立，经过 调用中心 完成 各服务之间的 调用 以及 管理。 【缺点：】 依赖于 中心化服务发现机制。 SOA 采用 SOAP 协议（HTTP + XML），而 XML 报文存在大量冗余数据，影响传输效率。
（3）微服务
微服务是 基于 SOA 架构演变而来，去除了 SOA 架构中 ESB 消息总线，采用 HTTP + JSON（RESTful ）进行传输。其划分粒度比 SOA 更精细。
【微服务架构：】
微服务架构 指的是 将单个应用程序 划分为 若干个互不相干的小应用，每一个小应用都是一个服务，服务之间相互协调、配合，从而为用户提供最终价值。
每一个服务运行在独立的进程中，服务之间一般采用 轻量级的通讯机制（一般是基于 HTTP 的 RESTful API）,每一个服务均是基于 具体业务进行构建，并能够独立的 部署到生产环境中。
【本质：】
微服务的目的是有效的拆分应用（将功能分散到各个服务中，下降系统耦合度），实现敏捷开发 与 部署。
微服务关键点在于 系统要提供一套基础的架构，使得微服务能够独立部署、运行、升级，且各个服务 在结构 上松耦合，在功能上为一个统一的总体。
注：
统一指的是：统一的安全策略、统一的权限管理、统一的日志处理 等。
【优势：】
微服务每一个模块就等同于一个独立的项目，可使用不一样的开发技术，使开发模式更灵活。
每一个模块都有独立的数据库，能够选择不一样的存储方式。好比：redis、mysql。
微服务的拆分粒度 比 SOA 更精细，复用性更强（提升开发效率）。
【缺点：】
微服务过多，服务的管理成本将随之提升。
技术要求变高（分布式事务、分布式锁、分布式日志、SpringCloud、Dubbo 等一系列知识都须要学习）。
六、什么是 SpringCloud？
（1）相关地址：
【SpringCloud 官网地址：】 https://spring.io/projects/spring-cloud 【SpringCloud 中文文档：】 https://www.bookstack.cn/read/spring-cloud-docs/docs-index.md
（2）基本认识
Spring Cloud 是分布式微服务架构下的一站式解决方案，是各个微服务架构技术实现的集合体。
注：
Spring Boot 能够快速构建单个微服务。
Spring Cloud 将多个 Spring Boot 构建的微服务整合并管理起来，并提供一系列处理（好比：服务发现、配置管理、消息总线、负载均衡、断路器、数据监控等）。
七、微服务问题 以及 技术实现
（1）背景
SpringCloud 是解决 微服务架构 而存在的，其针对 微服务架构 一系列技术问题 都作出了相关实现，固然随着技术的进步，有些技术已经中止更新、维护了，逐步被新技术替代（学无止境）。
此处从总体上了解一下 SpringCloud 有哪些技术，后续再逐步深刻。
（2）微服务问题
【微服务相关问题：】
服务注册与发现、服务配置中心
服务调用、服务负载均衡
服务网关
服务熔断、服务降级
服务总线
...
（3）技术实现
【技术实现：】
服务注册与发现：
Eureka 中止维护了，不推荐使用。
ZooKeeper
Consul
Nacos 阿里开源的产品，推荐使用
服务配置中心：
Config
Nacos 推荐使用
服务调用、负载均衡:
Ribbon 中止更新了（维护状态），不推荐使用。
Loadbalancer 做为 Ribbon 的替代产品。
Feign 中止更新了（维护状态），不推荐使用
OpenFeign Spring 推出的 Feign 的替代产品（推荐使用）。
服务网关：
Zuul 中止维护了，不推荐使用。
Zuul2 还没出来（已经凉凉了）。
Gateway Spring 推出的替代产品（推荐使用）。
服务降级：
Hystrix 中止维护了，不推荐使用。
Resilience4j 替代产品，国外使用多。
Sentienl 替代产品，国内使用多（推荐使用）。
服务总线：
Bus
Nacos 推荐使用。
注：
Nacos 功能仍是比较强大的（能够替换多个组件），重点关注。
各个组件具体功能后续介绍，此处暂时略过。。。
（4）SpringCloud 版本选择
进入官网，能够查看到当前最新版本的 SpringCloud。
SpringCloud 是基于 SpringBoot 开发的，其历史版本与 SpringBoot 对应版本以下。
固然，仍是须要进入不一样版本的 SpringCloud （Reference Doc.）查看官方推荐配置。
2、代码拆分演示（maven 聚合）
一、构建普通的 web 项目
（1）基本说明
【项目基本说明：】 此项目仅供参考，不与数据库进行交互。 建立 ControllerA、ServiceA 表示业务 A。 建立 ControllerB、ServiceB 表示业务 B。 使用 IDEA 利用 maven 构建 SSM 项目 可参考： https://www.cnblogs.com/l-y-h/p/12030104.html 或者 https://www.cnblogs.com/l-y-h/p/14010034.html#_label0_3
（2）使用 IDEA 利用 maven 构建一个普通的 web 工程
可参考：http://www.javashuo.com/article/p-cxxckeyi-nx.html
Step1：建立一个 web 工程（选择 maven-archetype-webapp 模板，会自动生成 webapp 文件夹）
Step2：引入 依赖（Spring MVC）
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.8.RELEASE</version> </dependency> 【pom.xml（注意：<packaging>war</packaging> 是 war、非 pom）】 <?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>org.example</groupId> <artifactId>ssm</artifactId> <version>1.0-SNAPSHOT</version> <packaging>war</packaging> <name>ssm Maven Webapp</name> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>1.7</maven.compiler.source> <maven.compiler.target>1.7</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.8.RELEASE</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency> </dependencies> </project>
Step3：配置基本 web 环境（Spring、SpringMVC）
【web.xml】 <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1"> <!-- step1: 配置全局的参数，启动Spring容器 --> <context-param> <param-name>contextConfigLocation</param-name> <!-- 若没有提供值，默认会去找/WEB-INF/applicationContext.xml。 --> <param-value>classpath:applicationContext.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <!-- step2: 配置SpringMVC的前端控制器，用于拦截全部的请求 --> <servlet> <servlet-name>springmvcDispatcherServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <!-- 若没有提供值，默认会去找WEB-INF/*-servlet.xml。 --> <param-value>classpath:dispatcher-servlet.xml</param-value> </init-param> <!-- 启动优先级，数值越小优先级越大 --> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>springmvcDispatcherServlet</servlet-name> <!-- 将DispatcherServlet请求映射配置为"/"，则Spring MVC将捕获Web容器全部的请求，包括静态资源的请求 --> <url-pattern>/</url-pattern> </servlet-mapping> <!-- step3: characterEncodingFilter字符编码过滤器，放在全部过滤器的前面 --> <filter> <filter-name>characterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <!--要使用的字符集，通常咱们使用UTF-8(保险起见UTF-8最好)--> <param-name>encoding</param-name> <param-value>UTF-8</param-value> </init-param> <init-param> <!--是否强制设置request的编码为encoding，默认false，不建议更改--> <param-name>forceRequestEncoding</param-name> <param-value>false</param-value> </init-param> <init-param> <!--是否强制设置response的编码为encoding，建议设置为true--> <param-name>forceResponseEncoding</param-name> <param-value>true</param-value> </init-param> </filter> <filter-mapping> <filter-name>characterEncodingFilter</filter-name> <!--这里不能留空或者直接写 ' / ' ，不然可能不起做用--> <url-pattern>/*</url-pattern> </filter-mapping> <!-- step4: 配置过滤器，将post请求转为delete，put --> <filter> <filter-name>HiddenHttpMethodFilter</filter-name> <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class> </filter> <filter-mapping> <filter-name>HiddenHttpMethodFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> </web-app> 【applicationContext.xml】 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> <!-- step1: 配置包扫描方式。扫描全部包，可是排除Controller层 --> <context:component-scan base-package="com.lyh.ssm"> <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan> </beans> 【dispatcher-servlet.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: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/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"> <!-- step1: 配置Controller扫描方式 --> <!-- 使用组件扫描的方式能够一次扫描多个Controller,只需指定包路径便可 --> <context:component-scan base-package="com.lyh.ssm" use-default-filters="false"> <!-- 通常在SpringMVC的配置里，只扫描Controller层，Spring配置中扫描全部包，可是排除Controller层。 context:include-filter要注意，若是base-package扫描的不是最终包，那么其余包仍是会扫描、加载，若是在SpringMVC的配置中这么作，会致使Spring不能处理事务， 因此此时须要在<context:component-scan>标签上，增长use-default-filters="false"，就是真的只扫描context:include-filter包括的内容--> <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" /> </context:component-scan> <!-- step2: 配置视图解析器 --> <bean id="defaultViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/"/><!--设置JSP文件的目录位置--> <property name="suffix" value=".jsp"/> </bean> <!-- step3: 标准配置 --> <!-- 将springmvc不能处理的请求交给 spring 容器处理 --> <mvc:default-servlet-handler/> <!-- 简化注解配置，并提供更高级的功能 --> <mvc:annotation-driven /> </beans>
Step4：编写 基本 业务代码。
【ControllerA】 package com.lyh.ssm.controller; import com.lyh.ssm.service.ServiceA; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class ControllerA { @Autowired private ServiceA serviceA; @GetMapping("/testA") public String testContollerA() { return serviceA.testA(); } } 【ControllerB】 package com.lyh.ssm.controller; import com.lyh.ssm.service.ServiceB; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class ControllerB { @Autowired private ServiceB serviceB; @GetMapping("/testB") public String testControllerB() { return serviceB.testB(); } } 【ServiceA】 package com.lyh.ssm.service; import org.springframework.stereotype.Service; @Service public class ServiceA { public String testA() { return "test serviceA"; } } 【ServiceB】 package com.lyh.ssm.service; import org.springframework.stereotype.Service; @Service public class ServiceB { public String testB() { return "test serviceB"; } }
Step5：配置、启动 tomcat。
Step6：访问 testA()、testB()。正常访问 也即基本 web 工程已搭建完成。
二、水平拆分 web 项目
（1）基本说明
【水平拆分说明：】
将上面简单的 web 工程 作水平拆分，按照逻辑分层对代码进行拆分，
将 controller、service 层分别抽取出来，并作成 war 包或者 jar 包，须要时引入依赖便可。
【使用 Maven 聚合的方式能够演示：】
Step1：构建一个 ssm_parent 工程（父工程，聚合下面的子工程，pom）
Step2：构建一个 ssm_service 工程（子工程，存放 业务逻辑层类以及接口，jar）
Step3：构建一个 ssm_controller 工程（子工程，存放 控制层类，war）
也即目录结构以下：
ssm_parent（pom）
ssm_service（jar）
ssm_controller（war）
（2）使用 maven 聚合的方式进行水平拆分
Step1：使用 maven 建立一个父工程（maven-archetype-site-simple）。
删除 src 文件夹（无用文件夹），选择 maven-archetype-site-simple 目的是使 pom.xml 中 packaging 为 <packaging>pom</packaging>。
注：
模板随意选择，选择 maven-archetype-quickstart 亦可，保证 <packaging>pom</packaging>。
Step2：在 ssm_parent 上 右键 选择 建立 Module。
并使用 maven 模板（maven-archetype-quickstart）建立一个模块（ssm_service）。
Step3：将 普通 web 工程中 service 代码 抽取出来，并放入 ssm_service 中。
【ServiceA】 package com.lyh.ssm.service; import org.springframework.stereotype.Service; @Service public class ServiceA { public String testA() { return "test serviceA"; } } 【ServiceB】 package com.lyh.ssm.service; import org.springframework.stereotype.Service; @Service public class ServiceB { public String testB() { return "test serviceB"; } }
Step4：在 父工程（ssm_parent）或者 当前工程（ssm_service）中引入 SpringMVC 依赖包。
【SpringMVC 依赖:】
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.8.RELEASE</version>
</dependency>
Step5：在 ssm_parent 上 右键 选择 建立 Module。
并使用 maven 模板（maven-archetype-webapp）建立一个模块（ssm_controller）。
Step6：将普通 web 工程中 相关代码（controller、配置文件）抽取出来，放入 ssm_controller 中。
【ControllerA】 package com.lyh.ssm.controller; import com.lyh.ssm.service.ServiceA; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class ControllerA { @Autowired private ServiceA serviceA; @GetMapping("/testA") public String testContollerA() { return serviceA.testA(); } } 【ControllerB】 package com.lyh.ssm.controller; import com.lyh.ssm.service.ServiceB; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class ControllerB { @Autowired private ServiceB serviceB; @GetMapping("/testB") public String testControllerB() { return serviceB.testB(); } } 【applicationContext.xml】 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"> <!-- step1: 配置包扫描方式。扫描全部包，可是排除Controller层 --> <context:component-scan base-package="com.lyh.ssm"> <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan> </beans> 【dispatcher-servlet.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: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/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"> <!-- step1: 配置Controller扫描方式 --> <!-- 使用组件扫描的方式能够一次扫描多个Controller,只需指定包路径便可 --> <context:component-scan base-package="com.lyh.ssm" use-default-filters="false"> <!-- 通常在SpringMVC的配置里，只扫描Controller层，Spring配置中扫描全部包，可是排除Controller层。 context:include-filter要注意，若是base-package扫描的不是最终包，那么其余包仍是会扫描、加载，若是在SpringMVC的配置中这么作，会致使Spring不能处理事务， 因此此时须要在<context:component-scan>标签上，增长use-default-filters="false"，就是真的只扫描context:include-filter包括的内容--> <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" /> </context:component-scan> <!-- step2: 配置视图解析器 --> <bean id="defaultViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/"/><!--设置JSP文件的目录位置--> <property name="suffix" value=".jsp"/> </bean> <!-- step3: 标准配置 --> <!-- 将springmvc不能处理的请求交给 spring 容器处理 --> <mvc:default-servlet-handler/> <!-- 简化注解配置，并提供更高级的功能 --> <mvc:annotation-driven /> </beans> 【web.xml】 <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1"> <!-- step1: 配置全局的参数，启动Spring容器 --> <context-param> <param-name>contextConfigLocation</param-name> <!-- 若没有提供值，默认会去找/WEB-INF/applicationContext.xml。 --> <param-value>classpath:applicationContext.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <!-- step2: 配置SpringMVC的前端控制器，用于拦截全部的请求 --> <servlet> <servlet-name>springmvcDispatcherServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <!-- 若没有提供值，默认会去找WEB-INF/*-servlet.xml。 --> <param-value>classpath:dispatcher-servlet.xml</param-value> </init-param> <!-- 启动优先级，数值越小优先级越大 --> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>springmvcDispatcherServlet</servlet-name> <!-- 将DispatcherServlet请求映射配置为"/"，则Spring MVC将捕获Web容器全部的请求，包括静态资源的请求 --> <url-pattern>/</url-pattern> </servlet-mapping> <!-- step3: characterEncodingFilter字符编码过滤器，放在全部过滤器的前面 --> <filter> <filter-name>characterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <!--要使用的字符集，通常咱们使用UTF-8(保险起见UTF-8最好)--> <param-name>encoding</param-name> <param-value>UTF-8</param-value> </init-param> <init-param> <!--是否强制设置request的编码为encoding，默认false，不建议更改--> <param-name>forceRequestEncoding</param-name> <param-value>false</param-value> </init-param> <init-param> <!--是否强制设置response的编码为encoding，建议设置为true--> <param-name>forceResponseEncoding</param-name> <param-value>true</param-value> </init-param> </filter> <filter-mapping> <filter-name>characterEncodingFilter</filter-name> <!--这里不能留空或者直接写 ' / ' ，不然可能不起做用--> <url-pattern>/*</url-pattern> </filter-mapping> <!-- step4: 配置过滤器，将post请求转为delete，put --> <filter> <filter-name>HiddenHttpMethodFilter</filter-name> <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class> </filter> <filter-mapping> <filter-name>HiddenHttpMethodFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> </web-app>
Step7：在 ssm_controller 中引入 ssm_service.jar 包。
<dependency> <groupId>com.lyh.ssm</groupId> <artifactId>ssm_service</artifactId> <version>1.0-SNAPSHOT</version> </dependency>
Step8：使用 tomcat 启动 ssm_controller 工程，便可访问项目。
Step9：使用 tomcat7 插件来启动 maven 聚合工程。
【在父工程 pom.xml 中引入 tomcat7 插件】
<build>
<plugins>
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
</plugin>
</plugins>
</build>
三、垂直拆分 web 项目
（1）基本说明
【垂直拆分说明：】 将上面简单的 web 工程 作垂直拆分，按照业务对代码进行拆分， 将 业务A、业务 B 分别抽取出来，并作成独立的 war 包。 注： 若拆分后仍使用配置文件的方式进行项目构建，那么代码冗余将很是多。 因此通常均使用 SpringBoot 简化开发（约定 > 配置）。 【使用 Maven 聚合的方式能够演示：】 Step1：构建一个 ssm_parent 工程（父工程，聚合下面的子工程，pom） Step2：构建一个 ssm_serviceA 工程（子工程，存放 业务A，war） Step3：构建一个 ssm_serviceB 工程（子工程，存放 业务B，war） 也即目录结构以下： ssm_parent（pom） ssm_serviceA（war） ssm_serviceB（war）
（2）使用 maven 聚合的方式进行垂直拆分
此处 以 SpringBoot 做为项目构建的基础。
Step1：使用 maven 构建一个父工程 ssm_parent。
Step2：ssm_parent 项目上右键选择 New -> Module 并选择 Spirng Initializr。
使用 SpringBoot 建立 serviceA 项目。
Step3：从普通 web 工程中 抽取出 业务A 的代码放入 ssm_serviceA 中。
【ControllerA】 package com.lyh.ssm.aservice.controller; import com.lyh.ssm.aservice.service.ServiceA; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class ControllerA { @Autowired private ServiceA serviceA; @GetMapping("/testA") public String testContollerA() { return serviceA.testA(); } } 【ServiceA】 package com.lyh.ssm.aservice.service; import org.springframework.stereotype.Service; @Service public class ServiceA { public String testA() { return "test serviceA"; } }
Step4：修改 父工程（ssm_parent） 以及 当前工程（ssm_serviceA）pom.xml 并引入依赖。
修改 ssm_serviceA 的 <parent>，使其指向父工程（ssm_parent）。
在父工程中经过 <module> 管理 子工程。
在父工程中 经过 <dependencyManagement> 声明依赖、管理版本。
在子工程中 经过 <dependency> 引入须要的依赖。
【ssm_parent 的 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"> <modelVersion>4.0.0</modelVersion> <groupId>com.lyh.ssm</groupId> <artifactId>ssm_parent</artifactId> <version>1.0-SNAPSHOT</version> <packaging>pom</packaging> <modules> <module>ssm_serviceA</module> </modules> <properties> <java.version>1.8</java.version> <web.version>2.4.0</web.version> </properties> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>${web.version}</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <version>${web.version}</version> <scope>test</scope> </dependency> </dependencies> </dependencyManagement> </project> 【ssm_serviceA 的 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 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.lyh.ssm</groupId> <artifactId>ssm_parent</artifactId> <version>1.0-SNAPSHOT</version> </parent> <artifactId>aservice</artifactId> <name>ssm_serviceA</name> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> </project>
Step5：修改 ssm_serviceA 的配置文件（端口号、服务名等）
修改 application.properties 或者 application.yml 文件。
【application.yml】 server: port: 9000 spring: application: name: ssm_serviceA
Step6：同理，建立 SpingBoot 项目 ssm_serviceB，并从 普通 web 工程中 抽取 业务B 代码放入其中。一样修改 pom.xml（指向父工程，引入 web 依赖） 以及 配置文件。
【ControllerB】 package com.lyh.ssm.bservice.controller; import com.lyh.ssm.bservice.service.ServiceB; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class ControllerB { @Autowired private ServiceB serviceB; @GetMapping("/testB") public String testContollerB() { return serviceB.testB(); } } 【ServiceB】 package com.lyh.ssm.bservice.service; import org.springframework.stereotype.Service; @Service public class ServiceB { public String testB() { return "test serviceB"; } } 【ssm_serviceB 的 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 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.lyh.ssm</groupId> <artifactId>ssm_parent</artifactId> <version>1.0-SNAPSHOT</version> </parent> <artifactId>bservice</artifactId> <name>bservice</name> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> </project> 【application.yml】 server: port: 9010 spring: application: name: ssm_serviceB 【ssm_parent 的 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"> <modelVersion>4.0.0</modelVersion> <groupId>com.lyh.ssm</groupId> <artifactId>ssm_parent</artifactId> <version>1.0-SNAPSHOT</version> <packaging>pom</packaging> <modules> <module>ssm_serviceA</module> <module>ssm_serviceB</module> </modules> <properties> <java.version>1.8</java.version> <web.version>2.4.0</web.version> </properties> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>${web.version}</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <version>${web.version}</version> <scope>test</scope> </dependency> </dependencies> </dependencyManagement> </project>
Step7：经过两个项目的启动类 能够 分别启动两个项目。
或者 直接 mvn install 父工程（ssm_parent），而后执行打包好的 jar 包。
四、使用 maven 聚合的注意事项
（1）父工程的 pom.xml 文件
【聚合项目 父工程：】 使用 maven 建立聚合工程时，父工程中 使用 <packaging>pom</packaging> 指定类型为 pom。 父工程通常 用于进行 依赖声明 以及 版本控制。 注： 经过 <properties> 标签 以及 ${} 能够进行依赖（jar）版本的管理。 使用 <dependencyManagement> 标签能够进行依赖声明。 使用 <modules> 标签管理 子模块。 【父工程 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"> <modelVersion>4.0.0</modelVersion> <groupId>com.lyh.ssm</groupId> <artifactId>ssm_parent</artifactId> <version>1.0-SNAPSHOT</version> <packaging>pom</packaging> <modules> <module>ssm_serviceA</module> <module>ssm_serviceB</module> </modules> <properties> <java.version>1.8</java.version> <web.version>2.4.0</web.version> </properties> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>${web.version}</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <version>${web.version}</version> <scope>test</scope> </dependency> </dependencies> </dependencyManagement> </project>
（2）子工程的 pom.xml 文件
【聚合项目 子工程：】 使用 maven 建立子工程时，使用 <parent> 标签指定 父工程。 使用 <dependencies> 标签按需引入依赖，若父工程使用 <dependencyManagement> 进行版本控制，则子工程引入依赖时能够不指定版本 <version>（便于统一管理）。 【子工程 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 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.lyh.ssm</groupId> <artifactId>ssm_parent</artifactId> <version>1.0-SNAPSHOT</version> </parent> <artifactId>bservice</artifactId> <name>bservice</name> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> </project>
（3）<dependencyManagement> 与 <dependencies> 区别 <dependencyManagement> 通常出如今 父工程中，用于 声明依赖 以及 版本控制，可是并无真正引入依赖。 <dependencies> 是真正的引入依赖。 父工程中 使用 <dependencyManagement> 进行了版本控制，若子工程中 <dependencies> 引入依赖时使用 <version> 指定了版本，则以子工程的版本为主。若子工程中没有使用 <version>，则以父工程定义的 version 为主。
相关文章
- 1. 单体架构到微服务架构的拆分
- 2. springcloud微服务--单体架构分析
- 3. 从单体架构到微服务
- 4. 架构设计漫步：从单体架构、SOA到微服务
- 5. 微服务架构（一） 单体式架构和微服务架构
- 6. 单体架构、SOA、微服务架构
- 7. 从单体架构到微服务架构
- 8. 【JavaWeb】从单体架构到微服务架构
- 9. SpringCloud学习笔记（一）----微服务和微服务架构
- 10. 微服务实践（七）：从单体式架构迁移到微服务架构
- 更多相关文章...
- • Docker 架构 - Docker教程
- • 您已经学习了 XML Schema，下一步学习什么呢？ - XML Schema 教程
- • Spring Cloud 微服务实战(三) - 服务注册与发现
- • Kotlin学习（一）基本语法
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
