SpringMVC简介及第一个MVC程序

SpringMVC

一. 关于SpringMVC

1.MVC

MVC是一种软件架构思想，将软件按照模型、视图、控制器来划分。

M: Model,模型层，指工程中的JavaBean,作用是处理数据

​ JavaBean分为两类：

​ ● 一类是实体类Bean: 专门存储业务数据的，如Student、user等。（属性—属性值—属性值）

​ ● 一类称为业务处理Bean: 指Server或Dao对象，专门用户处理业务逻辑和数据访问。（Service——>处理业务逻辑；Dao——>查询数据库实现持久化操作的）

V： View ,视图层， 指工程中的Html或者Jsp等页面，作用是与用户进行交互，展示数据。

C： Controller, 控制层， 指工程中的servlet, 作用是接受请求和响应浏览器。

MVC的工作流程: 用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕后将结果返回Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器。
 

2.Spring

1.Spring简介

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

Spring是一个开源框架，它由[Rod Johnson](https://baike.baidu.com/item/Rod Johnson)创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

IoC即Inversion of Control，反应过来就是控制反转。啥是控制反转啊？控制反转指的就是将对象的创建权反转给（交给）了Spring，其作用是实现了程序的解耦合。也可这样解释：获取对象的方式变了，对象创建的控制权不是"使用者"，而是"框架"或者"容器"。用更通俗的话来说，IoC就是指对象的创建，并不是在代码中用new操作new出来的，而是通过Spring进行配置创建的。

轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

 

2.Spring的7个模块

Spring框架由七个定义明确的模块组成：

Spring框架是一个分层的架构，由7个定义良好的模块组成。Spring模块构建在核心容器之上，核心容器定义了创建、配置和管理Bean的方式。

如果作为一个整体，这些模块为你提供了开发企业应用所需的一切。但你不必将应用完全基于Spring框架。你可以自由地挑选适合你的应用的模块而忽略其余的模块。

就像你所看到的，所有的Spring模块都是在核心容器之上构建的。容器定义了Bean是如何创建、配置和管理的——更多的Spring细节。当你配置你的应用时，你会潜在地使用这些类。但是作为一名开发者，你最可能对影响容器所提供的服务的其它模块感兴趣。这些模块将会为你提供用于构建应用服务的框架，例如AOP和持久性。

组成Spring框架的每个模块（或组件）都可以单独存在，或者与其他一个或者多个模块联合实现。每个模块的功能如下：

核心容器

这是Spring框架最基础的部分，它提供了依赖注入（DependencyInjection）特征来实现容器对Bean的管理。这里最基本的概念是BeanFactory，它是任何Spring应用的核心。BeanFactory是工厂模式的一个实现，它使用IoC将应用配置和依赖说明从实际的应用代码中分离出来。

Spring应用上下文（Context）模块**

核心模块的BeanFactory使Spring成为一个容器，而上下文模块使它成为一个框架。这个模块扩展了BeanFactory的概念，增加了对国际化（I18N）消息、事件传播以及验证的支持。

另外，这个模块提供了许多企业服务，例如电子邮件、JNDI访问、EJB集成、远程以及时序调度（scheduling）服务。也包括了对模版框架例如Velocity和FreeMarker集成的支持。

Spring的AOP模块

Spring在它的AOP模块中提供了对面向切面编程的丰富支持。这个模块是在Spring应用中实现切面编程的基础。为了确保Spring与其它AOP框架的互用性，Spring的AOP支持基于AOP联盟定义的API。AOP联盟是一个开源项目，它的目标是通过定义一组共同的接口和组件来促进AOP的使用以及不同的AOP实现之间的互用性。通过访问他们的站点，你可以找到关于AOP联盟的更多内容。

Spring的AOP模块也将元数据编程引入了Spring。使用Spring的元数据支持，你可以为你的源代码增加注释，指示Spring在何处以及如何应用切面函数。

JDBC抽象和DAO模块

使用JDBC经常导致大量的重复代码，取得连接、创建语句、处理结果集，然后关闭连接。Spring的JDBC和DAO模块抽取了这些重复代码，因此你可以保持你的数据库访问代码干净简洁，并且可以防止因关闭数据库资源失败而引起的问题。

这个模块还在几种数据库服务器给出的错误消息之上建立了一个有意义的异常层。使你不用再试图破译神秘的私有的SQL错误消息！

另外，这个模块还使用了Spring的AOP模块为Spring应用中的对象提供了事务管理服务。

Spring ORM(对象/关系映射集成模块)

对那些更喜欢使用对象/关系映射工具而不是直接使用JDBC的人，Spring提供了ORM模块。Spring并不试图实现它自己的ORM解决方案，而是为几种流行的ORM框架提供了集成方案，包括Hibernate、JDO和iBATIS SQL映射。Spring的事务管理支持这些ORM框架中的每一个也包括JDBC。

Spring的Web模块

Web上下文模块建立于应用上下文模块之上，提供了一个适合于Web应用的上下文。另外，这个模块还提供了一些面向服务支持。例如：实现文件上传的multipart请求，它也提供了Spring和其它Web框架的集成，比如Struts、WebWork。

Spring的MVC框架

Spring为构建Web应用提供了一个功能全面的MVC框架。虽然Spring可以很容易地与其它MVC框架集成，例如Struts，但Spring的MVC框架使用IoC对控制逻辑和业务对象提供了完全的分离。

通过策略接口，MVC框架变成为高度可配置的，MVC容纳了大量视图技术，其中包括JSP、Velocity、POI等。

它也允许你声明性地将请求参数绑定到你的业务对象中，此外，Spring的MVC框架还可以利用Spring的任何其它服务，例如国际化信息与验证。

 

3.Spring优点

• 低侵入式设计，代码的污染极低。
• 独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once，Run Anywhere的承诺。
• Spring的IoC容器降低了业务对象替换的复杂性，提高了组件之间的解耦。
• Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好的复用。
• Spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问。
• Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部。
   

4.Spring核心机制

1.管理Bean

程序主要是通过Spring容器来访问容器中的Bean，ApplicationContext是Spring容器最常用的接口，该接口有如下两个实现类：

• ClassPathXmlApplicationContext: 从类加载路径下搜索配置文件，并根据配置文件来创建Spring容器。
• FileSystemXmlApplicationContext: 从文件系统的相对路径或绝对路径下去搜索配置文件，并根据配置文件来创建Spring容器。

public class BeanTest{
    public static void main(String args[]) throws Exception{
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        Person p = ctx.getBean("person", Person.class);
        p.say();
    }
}

Spring容器中的Bean

对于开发者来说，开发者使用Spring框架主要是做两件事：①开发Bean；②配置Bean。对于Spring框架来说，它要做的就是根据配置文件来创建Bean实例，并调用Bean实例的方法完成"依赖注入"——这就是所谓IoC的本质

2.依赖注入

Spring框架的核心功能有两个：

• Spring容器作为超级大工厂，负责创建、管理所有的Java对象，这些Java对象被称为Bean。
• Spring容器管理容器中Bean之间的依赖关系，Spring使用一种被称为"依赖注入"的方式来管理Bean之间的依赖关系。

使用依赖注入，不仅可以为Bean注入普通的属性值，还可以注入其他Bean的引用。依赖注入是一种优秀的解耦方式，其可以让Bean以配置文件组织在一起，而不是以硬编码的方式耦合在一起。

链接：https://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html

 

5.Spring Boot与Spring Cloud

• Spring Boot 是 Spring 的一套快速配置脚手架，可以基于Spring Boot 快速开发单个微服务;
• Spring Cloud是基于Spring Boot实现的；
• Spring Boot专注于快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架；
• Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置 , Spring Cloud很大的一部分是基于Spring Boot来实现，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系。
• SpringBoot在SpringClound中起到了承上启下的作用，如果你要学习SpringCloud必须要学习SpringBoot。

 

3.SpringMVC

1.SpringMVC概念

SpringMVC是一个WEB框架，基于MVC的理念而设计，是目前最主流的MVC框架之一。SpringMVC是Spring的一个后续产品，是Spring的一个子项目。为Spring的MVC模块，是实现Web功能的模块。

——>是Spring为表述层开发提供的一整套完备的解决方案。在表述层框架经历过Struct、WebWork、Struct2等诸多产品的历代更迭之后，目前业界普遍选用SpringMVC作为JavaEE项目表述层开发的首选方案。

注：三层架构分为表述层（或表示层）、业务逻辑层、数据访问层（即持久层），表诉层表示前台页面和后台servlet（前台页面发送请求到我们的服务器中，我们的服务器中来使用我们的Servlet来接受请求、处理请求最终响应浏览器，SpringMVC就是处理这样一个过程的）。

这个过程：我们在浏览器中以不同的方式来发送一个请求（超链接、form表单提交等），发送请求之后我们根据请求地址来找到相对应的Servlet，当我们通过请求地址来匹配到Servlet之后我们就需要在Server中处理请求了。首先设置编码，设置编码的代码统一放在过滤器中——>获取请求参数——>调用Server来处理业务逻辑——>Server处理完之后会返回一个结果——>根据不同的处理结果来相应浏览器（若是查询操作，把数据放在指定的域对象中/若是登录操作，若成功，重定向跳转都登录成功页面；若失败，通过跳转转到再次跳转到我们的登录页面）。

框架是什么？

框架=配置文件+jar包

 

2.SpringMVC的特点

SpringMVC3.0之后的版本超越了Struts2,成为最优秀的web框架。
SpringMVC通过MVC注解，让POJO成为处理请求的控制器，而且它不需要实现任何额外的接口。
SpringMVC支持REST风格的URL请求。
SpringMVC和其他MVC框架相比，具有更高的灵活性和可扩展性。

SpringMVC的特点：

● 基于原生的Servlet ,通过功能强大的前端控制器DispatcherServlet，对请求和响应进行统一处理。（即本质就是一个Servlet,

​ 对Servlet进行了封装——>**前端控制器DispatcherSerlet **(由于对很多过程进行了封装，如获取请求参数的时候、往域对象放置的时候、转发和重定向的时候，这是DispatcherSerlet就会对这些操作进行统一处理)。

● 表述层细分领域需要解决的问题全方位覆盖、提供全面的解决方案。

● Spring家族的原生产品，与IOC容器等基础设置无缝对接

● 代码清新简洁、大幅度提高开发效率

● 内部组件化程度高、可插拔式式组件即插即用、想要什么功能配置相应的组件即可

● 性能卓著、尤其适合现代大型互联网项目的要求

 

4.Maven

链接1：https://www.runoob.com/maven/maven-tutorial.html （菜鸟教程）

链接2：https://baike.baidu.com/item/Maven/6094909?fr=aladdin（百度百科）

链接3：https://www.zhihu.com/question/20104186（知乎）

官网：https://maven.apache.org/

概念：

Maven项目管理对象模型（POM），可以通过一小段描述信息来管理项目的的构建，报告和文档的项目管理工具软件。基于项目对象模型（POM），Maven利用一个中央信息片段能管理一个项目的构建、报告和文档等步骤。Maven是一个项目管理工具，可以对Java项目进行构建、依赖管理。

Maven 主要功能：项目构建；项目依赖管理；软件项目持续集成；版本管理；项目的站点描述信息管理。

Maven 能够帮助开发者完成以下工作：

• 构建
• 文档生成
• 报告
• 依赖
• SCMs
• 发布
• 分发
• 邮件列表

Maven可以使构建项目更科学、更有可维护性、更加模块化、模块功能更加职能单一、做出来的项目更加具有可复用性等好处。

从技术上而言，Maven提供了一种思想让团队更科学的管理、构建项目。用配置文件的方式对项目的描述、名称、版本号、项目依赖等等信息进行描述。使之项目描述结构清晰，任何人接手的成本比较低。

在项目构建时，利用Maven的“约定大于配置”的思想，可以比Ant脚本构建项目省去不少配置文件的内容。而且一个项目可能依赖于其他的项目和第三方的组件才能顺利完成，Maven提供了仓库的概念，让这些依赖项放进仓库中，项目想要从仓库中去取，其他项目组也需要，OK，从仓库中去取，不必每个人去开源项目的站点去苦苦搜寻了。如此人员的成本、软件维护的成本、沟通的成本都降下来了。

链接：https://www.zhihu.com/question/20104186/answer/73797359

Maven——>一个jar包和已经和它有依赖关系的其他jar包——>不用去各个网站上去再下jar包了，也不同考虑他们之间的依赖关系了。

Maven是通过各种模式来创建的一个具有可视性、复用性、可维护性和完整性等特征的基础设施。即Maven希望将软件开发过程中的一些最佳实践和模式都整合和固定下来，将最佳实践固化成一个通用的项目管理方法，这样使用Maven进行开发时便能极大的方便开发。

构建就是软件项目生产的整个过程，包括：

• 文档和代码的生成（有些项目会使用代码自动生成工具，比如数据库访问代码的逆向工程）
• 代码的编译、测试和打包
• 打包好的代码进行分发或者部署

Maven——>将如上构建过程进行良好的定义。

Java——>整个生态中有无数的框架和API（通常以jar包的形式提供）——>项目开发管理这些jar包（很多，不方便）——>Maven——>自动做依赖管理（在pom文件里指定jar包的名称、版本号，Maven会自动下载）。

注：具体内容见菜鸟教程。

 

5.Servlet

1.Servlet 简介

Java Servlet 是运行在Web服务器或者应用服务器上的程序，它是作为来自Web或者其他HTTP客户端的请求和HTTP富服务器上的数据库或者应用程序之间的中间层。

Servlet（Server Applet），全称Java Servlet，未有中文译文。是用Java编写的服务器端程序。其主要功能在于交互式地浏览和修改数据，生成动态Web内容。狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况下，人们将Servlet理解为后者。

Servlet运行于支持Java的应用服务器中。从原理上讲，Servlet可以响应任何类型的请求，但绝大多数情况下Servlet只用来扩展基于HTTP协议的Web服务器。

最早支持Servlet标准的是JavaSoft的Java Web Server，此后，一些其它的基于Java的Web服务器开始支持标准的Servlet。

链接：https://www.zhihu.com/question/21416727/answer/233319801

使用Servlet可以收集来自网页的用户输入，呈现来自数据库或者其他源的记录，还可以动态创建网页。

Web服务器：将某个主机上的资源映射为一个URL供外界访问。

任何一个应用程序都包含如下三个步骤：

• 接收请求
• 处理请求
• 响应请求

其中接受请求和响应请求是共性功能，且没有差异性。访问淘宝和访问京东，都是接受taobao.com/brandNo=1，响应给浏览器的收拾JSON数据。于是大家把接受和响应两个步骤抽取成Web服务器。

由于处理请求的逻辑是不同的。没关系，抽取出来做成Servlet，交给程序员自己去写。随着后期互联网发展，出现了三层架构，所以出现了一些逻辑就从Servlet抽取出来，分担到Service和Dao。

由于Servlet并不擅长往浏览器输出HTML页面，所以出现了JSP。

等Spring家族出现以后，Servlet开始退居幕后，取而代之的是方便的SpringMVC。SpringMVC的核心组件DispactcherServlet其实就是一个Servlet。

Servlet 在 Web 应用程序中的位置:

2.Servlet 任务

Servlet 执行以下主要任务：

• 读取客户端（浏览器）发送的显式的数据。这包括网页上的 HTML 表单，或者也可以是来自 applet 或自定义的 HTTP 客户端程序的表单。
• 读取客户端（浏览器）发送的隐式的 HTTP 请求数据。这包括 cookies、媒体类型和浏览器能理解的压缩格式等等。
• 处理数据并生成结果。这个过程可能需要访问数据库，执行 RMI 或 CORBA 调用，调用 Web 服务，或者直接计算得出对应的响应。
• 发送显式的数据（即文档）到客户端（浏览器）。该文档的格式可以是多种多样的，包括文本文件（HTML 或 XML）、二进制文件（GIF 图像）、Excel 等。
• 发送隐式的 HTTP 响应到客户端（浏览器）。这包括告诉浏览器或其他客户端被返回的文档类型（例如 HTML），设置 cookies 和缓存参数，以及其他类似的任务。

 

3.Servlet工作流程

引用博主扬俊的小屋的动图，这个动图形象的展示了Servlet工作的流程

​

​ 工作模式：

• 客户端发送请求至服务器

• 服务器启动并调用Servlet，Servlet根据客户端请求生成响应内容并将其传给服务器

• 服务器将响应返回客户端

  具体如下：

1、客户端请求该 Servlet；

2、加载 Servlet 类到内存；

3、实例化并调用init()方法初始化该 Servlet；

4、service()（根据请求方法不同调用doGet() 或者 doPost()，此外还有doHead()、doPut()、doTrace()、doDelete()、doOptions()）；

5、destroy()；

6、加载和实例化 Servlet。这项操作一般是动态执行的。然而，Server 通常会提供一个管理的选项，用于在 Server 启动时强制装载和初始化特定的 Servlet；

7、Server 创建一个 Servlet的实例；

8、第一个客户端的请求到达 Server；

9、Server 调用 Servlet 的 init() 方法（可配置为 Server 创建 Servlet 实例时调用，在 web.xml 中 标签下配置 标签，配置的值为整型，值越小 Servlet 的启动优先级越高）；

10、一个客户端的请求到达 Server；

11、Server 创建一个请求对象，处理客户端请求；

12、Server 创建一个响应对象，响应客户端请求；

13、Server 激活 Servlet 的 service() 方法，传递请求和响应对象作为参数；

14、service() 方法获得关于请求对象的信息，处理请求，访问其他资源，获得需要的信息；

15、service() 方法使用响应对象的方法，将响应传回Server，最终到达客户端。service()方法可能激活其它方法以处理请求，如 doGet() 或 doPost() 或程序员自己开发的新的方法；

16、对于更多的客户端请求，Server 创建新的请求和响应对象，仍然激活此 Servlet 的 service() 方法，将这两个对象作为参数传递给它。如此重复以上的循环，但无需再次调用 init() 方法。一般 Servlet 只初始化一次(只有一个对象)，当 Server 不再需要 Servlet 时（一般当 Server 关闭时），Server 调用 Servlet 的 destroy() 方法。

 

4. Servlet 的主要类型

5.Serlvet使用方法

Servlet技术的核心是Servlet，它是所有Servlet类必须直接或者间接实现的一个接口。在编写实现Servlet的Servlet类时，直接实现它。在扩展实现这个这个接口的类时，间接实现它。

 

6.Serlvet工作原理

Servlet接口定义了Servlet与servlet容器之间的契约。这个契约是：Servlet容器将Servlet类载入内存，并产生Servlet实例和调用它具体的方法。但是要注意的是，在一个应用程序中，每种Servlet类型只能有一个实例。

用户请求致使Servlet容器调用Servlet的Service（）方法，并传入一个ServletRequest对象和一个ServletResponse对象。ServletRequest对象和ServletResponse对象都是由Servlet容器（例如TomCat）封装好的，并不需要程序员去实现，程序员可以直接使用这两个对象。

 
ServletRequest中封装了当前的Http请求，因此，开发人员不必解析和操作原始的Http数据。ServletResponse表示当前用户的Http响应，程序员只需直接操作ServletResponse对象就能把响应轻松的发回给用户。
 
对于每一个应用程序，Servlet容器还会创建一个ServletContext对象。这个对象中封装了上下文（应用程序）的环境详情。每个应用程序只有一个ServletContext。每个Servlet对象也都有一个封装Servlet配置的ServletConfig对象。

原文链接：https://blog.csdn.net/qq_19782019/article/details/80292110

 

6.Bean

1.Java面向对象，对象有方法和属性，那么就需要对象实例来调用方法和属性（即实例化）；

2.凡是有方法或者属性的类都需要实例化，这样才能具象化去使用这些方法和属性；

3.规律：凡是子类及带有方法或者属性的类都要加上注册Bean到Spring IOC的注解；

4.把Bean理解为类的代理人或代言人（实际上确实是通过反射、代理来实现的），这样它就能代表类有该拥有的东西了；

5、我们都在微博上@过某某，对方会优先看到这条信息，并给你反馈，那么在Spring中，你标识一个@符号，那么Spring就会来看看，并且从这里拿到一个Bean或者给出一个Bean

注解分为两类：

1.一类是使用Bean,即是把已经在XML文件中配置好的Bean拿来用，完成属性、方法的组装；比如@Autowired , @Resource，可以通过byTYPE（@Autowired）、byNAME（@Resource）的方式获取Bean；

2.一类是注册Bean,@Component , @Repository , @ Controller , @Service , @Configration这些注解都是把你要实例化的对象转化成一个Bean，放在IoC容器中，等你要用的时候，它会和上面的@Autowired , @Resource配合到一起，把对象、属性、方法完美组装。

1、凡是子类及带属性、方法的类都注册Bean到Spring中，交给它管理；

2、@Bean 用在方法上，告诉Spring容器，你可以从下面这个方法中拿到一个Bean

Spring容器中的Bean

对于开发者来说，开发者使用Spring框架主要是做两件事：①开发Bean；②配置Bean。对于Spring框架来说，它要做的就是根据配置文件来创建Bean实例，并调用Bean实例的方法完成"依赖注入"——这就是所谓IoC的本质。

 
 

二. Hello World

1.开发环境

IDE ：idea 2019.3

构建工具：maven 3

服务器：Tomcat9

视图渲染：Thymeleaf

Spring版本：Spring 5.3.1

 

2.具体实现

1.配置Maven

File——>Settings——>Build——>Build Tools——>Maven——>Bundled(Maven3)

2. 创建Maven工程

pom.xml 就是 maven 的配置文件，用以描述项目的各种信息。

a>添加web模块

b>打包方式：war

c>引入依赖

1. 基本配置

<?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>

• project - project 是 pom.xml 中描述符的根。
• modelVersion - modelVersion 指定 pom.xml 符合哪个版本的描述符。maven 2 和 3 只能为 4.0.0。
• 一般 jar 包被识别为： groupId:artifactId:version 的形式。

2.maven 坐标

在 maven 中，根据 groupId、artifactId、version 组合成 groupId:artifactId:version 来唯一识别一个 jar 包。

<!--    Maven工程坐标-->
<groupId>com.atguigu.mvc</groupId>
<artifactId>springMVC-rest</artifactId>
<version>1.0-SNAPSHOT</version>
<!--    配置打包方式，设置为war包-->
<packaging>war</packaging>

• groupId - 团体、组织的标识符。团体标识的约定是，它以创建这个项目的组织名称的逆向域名(reverse domain name)开头。一般对应着 java 的包结构。

• artifactId - 单独项目的唯一标识符。比如我们的 tomcat、commons 等。不要在 artifactId 中包含点号(.)。

• version - 一个项目的特定版本。

• maven 有自己的版本规范，一般是如下定义 major version、minor version、incremental version-qualifier ，比如 1.2.3-beta-01。要说明的是，maven 自己判断版本的算法是 major、minor、incremental 部分用数字比较，qualifier 部分用字符串比较，所以要小心 alpha-2 和 alpha-15 的比较关系，最好用 alpha-02 的格式。

• maven 在版本管理时候可以使用几个特殊的字符串 SNAPSHOT、LATEST、RELEASE。比如 1.0-SNAPSHOT。各个部分的含义和处理逻辑如下说明：

• • SNAPSHOT - 这个版本一般用于开发过程中，表示不稳定的版本。
  • LATEST - 指某个特定构件的最新发布，这个发布可能是一个发布版，也可能是一个 snapshot 版，具体看哪个时间最后。
  • RELEASE ：指最后一个发布版。

• packaging - 项目的类型，描述了项目打包后的输出，默认是 jar。常见的输出类型为：pom, jar, maven-plugin, ejb, war, ear, rar, par。

3.依赖配置

<!--    SpringMVC-->
<!--    当前工程的所有依赖-->
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.1</version>
    </dependency>

    <!--    日志-->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>

    <!--    ServletAPI-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>

    <!--    Spring5和Thymeleaf整合包-->
    <dependency>
        <groupId>org.thymeleaf</groupId>
        <artifactId>thymeleaf-spring5</artifactId>
        <version>3.0.12.RELEASE</version>
    </dependency>

</dependencies>

需要有网的环境，Maven自动下载jar包到仓库中去；需要添加jar包时直接将依赖添加到dependencies中去。Maven会自动导入依赖的依赖，即jar包所依赖的jar包。

根据GVA坐标找到本地仓库中的jar包（groupId、artifactId、version 组合成 groupId:artifactId:version 来唯一识别一个 jar 包。）

Maven有三种打包方式，默认打包方式为jar包。

• groupId, artifactId, version - 和基本配置中的 groupId、artifactId、version 意义相同。
• type - 对应 packaging 的类型，如果不使用 type 标签，maven 默认为 jar。
• scope - 此元素指的是任务的类路径（编译和运行时，测试等）以及如何限制依赖关系的传递性。有 5 种可用的限定范围：
• compile - 如果没有指定 scope 标签，maven 默认为这个范围。编译依赖关系在所有 classpath 中都可用。此外，这些依赖关系被传播到依赖项目。
• provided - 与 compile 类似，但是表示您希望 jdk 或容器在运行时提供它。它只适用于编译和测试 classpath，不可传递。
• runtime - 此范围表示编译不需要依赖关系，而是用于执行。它是在运行时和测试 classpath，但不是编译 classpath。
• test - 此范围表示正常使用应用程序不需要依赖关系，仅适用于测试编译和执行阶段。它不是传递的。
• system - 此范围与 provided 类似，除了您必须提供明确包含它的 jar。该 artifact 始终可用，并且不是在仓库中查找。
• systemPath - 仅当依赖范围是系统时才使用。否则，如果设置此元素，构建将失败。该路径必须是绝对路径，因此建议使用 propertie 来指定特定的路径，如\$ {java.home} / lib。由于假定先前安装了系统范围依赖关系，maven 将不会检查项目的仓库，而是检查库文件是否存在。如果没有，maven 将会失败，并建议您手动下载安装。
• optional - optional 让其他项目知道，当您使用此项目时，您不需要这种依赖性才能正常工作。
• exclusions - 包含一个或多个排除元素，每个排除元素都包含一个表示要排除的依赖关系的 groupId 和 artifactId。与可选项不同，可能或可能不会安装和使用，排除主动从依赖关系树中删除自己。

——>SpringMVCjar包及Spring所依赖的jar包：（实现SpringMVC和实现Spring一样，也是需要Spring基本模块的jar 包的，如aop模块、core模块等）

由于Maven的传递性，我们不必将所有需要的包全部配置依赖，而是配置最顶端的依赖，其他靠传递性导入。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wrH9rSSQ-1638367758315)(C:\Users\HeChenhui\AppData\Roaming\Typora\typora-user-images\image-20211124085132024.png)]

<scope>provided</scope>

依赖范围：我们在什么地方使用我们的jar包，provided——>已被提供，即当前服务器中已经提供了Servlet的jar包；

当前Web工程打成War包之后，这些所依赖的jar包都被放在WebApp——>WEB-INF——>leb目录中；若依赖范围是provided，则这个jar包是不会放入leb目录中的，这时这个jar包由服务器提供。

 

3.配置web.xml

1.创建Webapp目录

main——>新建——>目录（命名：Webapp)

xml——>可拓展标记语言

创建完之后还需要一个web.xml; web.xml是我们web工程的入口配置文件，这个配置文件里面我们可以注册Serlvet、注册过滤器、注册监听器。

创建web.xml

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hyBbiV3q-1638367758318)(file:///D:\A\Down\QQ\2309042147\Image\C2C{PWWQC1PNXFZ6_BI4V0_ENI.png)]

项目结构——>web——> 右侧 + 号 ——>修改文件目录——>确定——>应用——>ok

 

2.配置web.xml

注册SpringMVC的前端控制器DispatcherServlet

a>默认配置方式

在此配置作用下，SpringMVC的配置文件默认位于WEB-INF下，默认名称为-servlet.xml,例如，以下配置所对应SpringMVC的配置文件位于WEB-INF下，文件名为springMVC-servlet.xml

 <!--    配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理-->
      <servlet>
          <servlet-name>springMVC</servlet-name>
          <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      </servlet>

      <servlet-mapping>
          <servlet-name>springMVC</servlet-name>
          <url-pattern>/</url-pattern>
      <!--  设置springMVC的核心控制器所能请求的请求路径
            / 所匹配的请求可以是/login或.html或.js或.css方式的请求路径
            但是/不能匹配.jsp请求路径的请求(处理其请求的Servlet位于服务器中)
       -->
      </servlet-mapping>

springMVC的核心控制器所能请求的请求路径 / 所匹配的请求可以是/login或.html或.js或.css方式的请求路径
但是/不能匹配.jsp请求路径的请求（处理其请求的Servlet位于服务器中)

b>拓展配置方式

可通过init-param标签设置SpringMVC配置文件的位置和名称，通过load-on-startup标签设置SpringMVC前端控制器DispacherServlet的初始化时间。

 <!--    配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理-->
      <servlet>
          <servlet-name>springMVC</servlet-name>
          <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
          
          <!--  配置SpringMVC配置文件的位置和名称     -->
          <init-param>
              <param-name>contextConfigLocation</param-name>
              <param-value>classpath:springMVC.xml</param-value>
          </init-param>
          
          <!--将前端控制器DispatcherServlet初始化时间提前到服务器启动时-->
          <load-on-startup>1</load-on-startup>
      </servlet>

      <servlet-mapping>
          <servlet-name>springMVC</servlet-name>
          <url-pattern>/</url-pattern>
      <!--  设置springMVC的核心控制器所能请求的请求路径
            / 所匹配的请求可以是/login或.html或.js或.css方式的请求路径
            但是/不能匹配.jsp请求路径的请求（处理其请求的Servlet位于服务器中），
            因此可以避免在访问jsp页面时，该请求被DispatcherServlet处理，从而找不到页面
            /*则能够匹配所有请求，例如在使用过滤器时，若需要对所有的请求进行过滤，就需要使用/*的写法
       -->
      </servlet-mapping>

新建Spring.xml文件：resources——>新建——>XML Configuration File——>Spring Config

为什么要配置web.xml：当前浏览器发送的请求要统一交给前端控制器DispatcherServlet来处理，而前端控制器本质为一个Ser

vlet，而我们要想通过Servlet处理请求我们就必须在web.xml中进行注册。在注册是我们通过init-param配置SpringMVC配置文件的位置和名称；通过load-on-startup将前端控制器的初始化时间提前到服务器启动时；我们前端控制器DispatcherServlet所能处理的请求路径是我们上下文路径下所有的请求路径。

 

4.创建请求控制器

由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要创建处理具体请求的类，即请求控制器。

请求控制器每一个处理请求的方法成为控制器方法。

因为SpringMVC的控制器由一个POJO（普通的java类担任），因此需要通过@Controller注解将其标识为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在。

//配置控制器，采用注解+扫描的方式
//把这个类作为IoC容器组件的时候它才能是一个控制器
@Controller
//通过如上注解进行标识
//通过扫描springMVC才知道这个类是一个控制器，才可以将这个类中的方法作为控制器的方法
//然后来处理我们的请求和响应
public class HelloController {
}

把一个类标识为IoC容器组件的注解一共为4个：

@Compontent——>把当前类标识为普通组件

@Controller——>把类标识成控制层组件

@Cervice——>表示成业务层组件

@Repository——>标识为持久层组件

 

5.创建springMVC的配置文件

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

    <!-- 配置Thymeleaf视图解析器 -->
    <!-- 配置Thymeleaf视图解析器为ThymeleafViewResolver-->
    <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <!-- 视图解析器优先级；视图解析器可以设置多个  -->
        <property name="order" value="1"/>
        <!-- 解析视图所用的编码  -->
        <property name="characterEncoding" value="UTF-8"/>
        <!-- 当前的一个模板 -->
        <property name="templateEngine">
            <!-- 通过内部Bean来为属性templateEngine赋值  -->
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                <property name="templateResolver">
                    <!-- 为属性templateResolver赋值；解析当前视图的一个策略  -->
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                        <!-- 视图前缀 -->
                        <property name="prefix" value="/WEB-INF/templates/"/>
                        <!-- 视图后缀 -->
                        <property name="suffix" value=".html"/>
                        <!-- 在解析的视图名称前面加上视图前缀和视图后缀，就可以跳转到我们需要解析的页面  -->
                        <!-- 模板模型，使用HTML5  -->
                        <property name="templateMode" value="HTML5"/>
                        <!-- 页面编码，UTF-8  -->
                        <property name="characterEncoding" value="UTF-8" />
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rJjL01J6-1638367758320)(C:\Users\HeChenhui\AppData\Roaming\Typora\typora-user-images\image-20211124153558118.png)]

创建的类前面有个图标，它表示这个类的对象已经交给IoC容器来管理。

 

6.测试HelloWorld

a>实现对首页的访问

在请求控制器中创建处理请求的方法

//配置控制器，采用注解+扫描的方式
//把这个类作为IoC容器组件的时候它才能是一个控制器
@Controller
//通过如上注解进行标识
//通过扫描springMVC才知道这个类是一个控制器，才可以将这个类中的方法作为控制器的方法
//然后来处理我们的请求和响应
public class HelloController {

    // "/" ——>WEB-INF/templates/index.html

    // 添加请求映射的注解，将当前的请求和控制器方法来创建映射关系
    // 当遇到 / 类型时 ，即执行如下方法，返回相应的值到视图解析器中（如index），经视图解析器处理跳转到相应的页面
    // @RequestMapping注解：处理请求和控制器方法之间的映射关系
    // @RequestMapping:注解的Value属性可以通过请求地址匹配请求，/表示的当前工程的上下文路径
    //localhost:8080/SpringMVC/
    @RequestMapping (value = "/")
    public String index(){
        return "index";
    }
}

在浏览器中运行结果如下：

控制台信息如下：

DEBUG org.thymeleaf.TemplateEngine - [THYMELEAF] TEMPLATE ENGINE INITIALIZED
16:24:28.660 [http-nio-8080-exec-1] DEBUG org.springframework.web.servlet.DispatcherServlet - Completed 200 OK
16:24:29.589 [http-nio-8080-exec-4] DEBUG org.springframework.web.servlet.DispatcherServlet - GET "/SpringMVC/", parameters={}
16:24:29.589 [http-nio-8080-exec-4] DEBUG org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping - Mapped to com.atguigu.mvc.controller.HelloController#index()
16:24:29.595 [http-nio-8080-exec-4] DEBUG org.springframework.web.servlet.DispatcherServlet - Completed 200 OK

b>通过超链接跳转到指定页面

在主页index.html中设置超链接:

跳转方式：转发

<!DOCTYPE html>
<html lang="en"xmlns:th="http:www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
<h1>首页</h1>
<a th:href="@{/target}">访问目标页面target.html</a>
</body>
</html>

//以 / 开头的为绝对路径，而绝对路径又分为浏览器解析的和服务器解析的
//超链接中的路径就是浏览器解析的，此时 / 表示的不是上下文路径访问，
//它表示的是从localhost:8080下访问，因此少一个上下文路径，但是添加上下文路径太过麻烦
//因此用Thymeleaf语言，th: @{ } ——>检测到是绝对路径，自动添加上下文路径。

请求控制器的中创建处理请求的方法

   @RequestMapping (value = "/target")
    public String toTarget(){
        return "target";
    }

浏览器运行结果如下：

 

7.总结

浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器，将请求地址和控制器中@RequestMapping注解的value属性值进行匹配，若匹配成功，该注解所标识的控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视图所对应页面。

本文为对B站尚硅谷SpringMVC课程（杨博超老师）及其他内容整理所得