Spring MVC入门程序基础配置

三层架构和MVC

1：三层架构

我们的开发架构一般都是基于两种形式：一种是 C/S 架构，也就是客户端/服务器，另一种是 B/S 架构，也就是浏览器服务器。在 JavaEE 开发中，几乎全都是基于 B/S 架构的开发。那么在 B/S 架构中，系统标准的三层架构包括：表现层、业务层、持久层。三层架构在我们的实际开发中使用的非常多。

①：表现层：

也就是我们常说的web层。它负责接收客户端请求，向客户端响应结果，通常客户端使用http协议请求web 层，web 需要接收 http 请求，完成http 响应。

表现层包括展示层和控制层：控制层负责接收请求，展示层负责结果的展示。

表现层依赖业务层，接收到客户端请求一般会调用业务层进行业务处理，并将处理结果响应给客户端。

表现层的设计一般都使用 MVC 模型。（MVC 是表现层的设计模型，和其他层没有关系）

②：业务层：

也就是我们常说的 service 层。它负责业务逻辑处理，和我们开发项目的需求息息相关。web 层依赖业务层，但是业务层不依赖 web 层。

业务层在业务处理时可能会依赖持久层，如果要对数据持久化需要保证事务一致性。（也就是我们说的，事务应该放到业务层来控制）

③：持久层：

也就是我们是常说的 dao 层。负责数据持久化，包括数据层即数据库和数据访问层，数据库是对数据进行持久化的载体，数据访问层是业务层和持久层交互的接口，业务层需要通过数据访问层将数据持久化到数据库中。通俗的讲，持久层就是和数据库交互，对数据库表进行曾删改查的。

2：MVC模型

MVC（Model View Controller）：是模型(model)－视图(view)－控制器(controller)的缩写，是一种用于设计创建 Web 应用程序表现层的模式。MVC 中每个部分各司其职。

2. Model：
　　数据模型，JavaBean的类，用来进行数据封装。
3. View：
　　指JSP、HTML用来展示数据给用户
4. Controller：
　　用来接收用户的请求，整个流程的控制器。用来进行数据校验等。

SpringMVC

SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架，属于 Spring FrameWork 的后续产品，已经融合在 Spring Web Flow 里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用 Spring 进行 WEB 开发时，可以选择使用 Spring的 Spring MVC 框架或集成其他 MVC 开发框架，如 Struts1(现在一般不用)，Struts2 等。

SpringMVC 已经成为目前最主流的 MVC 框架之一，并且随着 Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC 框架。它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持RESTful 编程风格的请求。·

Spring MVC入门程序

编写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>org.example</groupId>
    <artifactId>springmvc</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>10</maven.compiler.source>
        <maven.compiler.target>10</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--        spring核心类-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!--        spring mvc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!--        servlet-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--        jsp-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <!--    构建-->
    <build>
        <!--        设置插件-->
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <port>8777</port>
                    <path>/springmvc</path>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <packaging>war</packaging>
</project>

• tomcat7-maven-plugin：允许使用嵌入式 Tomcat 服务器运行应用程序。配置为在端口 8777 上运行，路径为 /springmvc。

<packaging>war</packaging>

• war：指定项目打包为 WAR（Web 应用程序归档）文件，适合部署在 Web 服务器上。

打包方式:

Maven 中的打包方式（Packaging）定义了项目最终的输出格式。常见的打包方式及其具体打包流程如下：

1. jar (Java Archive)

描述：将项目打包成一个 JAR 文件，适用于 Java 库或可执行的 Java 程序。 打包流程：

• Compile：编译源代码到 target/classes 目录。
• Resources：将资源文件（src/main/resources）复制到 target/classes 目录。
• Manifest：生成或合并 MANIFEST.MF 文件（包含元数据信息）。
• Package：将 target/classes 目录及 META-INF（包含 MANIFEST.MF）目录打包成一个 JAR 文件。

2. war (Web Application Archive)

描述：将项目打包成一个 WAR 文件，适用于 Web 应用程序，通常部署在 Servlet 容器（如 Tomcat）中。 打包流程：

• Compile：编译源代码到 target/classes 目录。
• Resources：将资源文件（src/main/resources）复制到 target/classes 目录。
• Web Resources：将 Web 资源文件（如 JSP、HTML、CSS、JS 等，位于 src/main/webapp）复制到 target/${artifactId} 目录。
• WEB-INF：创建 WEB-INF 目录，包含 web.xml 配置文件及依赖库（lib 目录）。
• Package：将 target/${artifactId} 目录及 WEB-INF 目录打包成一个 WAR 文件。

3. pom (Project Object Model)

描述：不生成可部署的文件，通常用于聚合或继承其他项目的配置。 打包流程：

• Aggregation：如果是聚合项目，则仅聚合子项目的构建结果。
• Inheritance：如果是父项目，则提供配置继承给子项目。

4. maven-plugin

描述：将项目打包成一个 Maven 插件。 打包流程：

• Compile：编译插件的源代码到 target/classes 目录。
• Resources：将资源文件复制到 target/classes 目录。
• Manifest：生成或合并 MANIFEST.MF 文件（包含插件元数据信息）。
• Package：将 target/classes 目录及 META-INF（包含 MANIFEST.MF 和 maven/plugin.xml）目录打包成一个 JAR 文件。

5. ejb (Enterprise JavaBean)

描述：将项目打包成一个 EJB 文件，适用于 Java EE 应用程序。 打包流程：

• Compile：编译源代码到 target/classes 目录。
• Resources：将资源文件复制到 target/classes 目录。
• Manifest：生成或合并 MANIFEST.MF 文件。
• Package：将 target/classes 目录及 META-INF 目录打包成一个 JAR 文件。

6. ear (Enterprise Archive)

描述：将项目打包成一个 EAR 文件，适用于包含多个模块的企业级应用程序。 打包流程：

• Modules：将子模块（如 JAR、WAR、EJB）编译和打包。
• Resources：将资源文件复制到 target 目录。
• META-INF：创建 META-INF 目录，包含 application.xml 配置文件。
• Package：将各模块及 META-INF 目录打包成一个 EAR 文件。

7. rar (Resource Adapter Archive)

描述：将项目打包成一个 RAR 文件，适用于 Java EE 连接器模块。 打包流程：

• Compile：编译源代码到 target/classes 目录。
• Resources：将资源文件复制到 target/classes 目录。
• Manifest：生成或合并 MANIFEST.MF 文件。
• Package：将 target/classes 目录及 META-INF 目录打包成一个 RAR 文件。

配置前端控制器（DispatcherServlet）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_4_0.xsd>"
         version="4.0">
    <!-- 配置spring mvc的前端控制器 -->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 配置初始化参数 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <!-- 应用加载时创建 -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!-- 配置URL映射-->
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

配置处理器映射信息和视图解析器spring-mvc.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:xsi="<http://www.w3.org/2001/XMLSchema-instance>"
       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>">

    <!-- 配置spring mvc要扫描的包 -->
    <context:component-scan base-package="com.itheima.controller"/>

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

</beans>

• 组件扫描：通过 <context:component-scan>，Spring MVC 会扫描 com.itheima.controller 包中的所有组件，并将它们注册到 Spring 容器中。
• 视图解析器：通过配置 InternalResourceViewResolver，将逻辑视图名解析为实际的 JSP 文件路径。这样，当控制器方法返回视图名时，Spring MVC 能够正确找到并渲染对应的 JSP 页面。

创建处理器类FirstController.java

package com.itheima.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class FirstController {
    @RequestMapping("/firstController")
    public String sayHello() {
        System.out.println("访问到FirstController");
        return "success";
    }
}

• @RequestMapping("/firstController")：映射 HTTP 请求路径 /firstController 到该方法 sayHello。当客户端访问 /firstController 路径时，会调用此方法。
• public String sayHello()：定义了一个处理请求的方法。
  • System.out.println("访问到FirstController");：在控制台输出一条消息，用于调试或日志记录。
  • return "success";：返回一个字符串 "success" 作为视图名。根据之前配置的视图解析器，这个视图名将被解析为 /WEB-INF/pages/success.jsp。

创建视图页面success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Success Page</title>
</head>
<body>
<h2>Success!</h2>
</body>
</html>

项目的运行流程

1. 客户端请求：当客户端发送一个请求到 /firstController 时，Spring MVC 将该请求映射到 sayHello 方法。
2. 方法执行：
   • 执行 System.out.println("访问到FirstController");，在控制台输出 "访问到FirstController"。
   • 返回字符串 "success"。
3. 视图解析：
   • Spring MVC 的视图解析器会将视图名 "success" 解析为具体的 JSP 文件路径 /WEB-INF/pages/success.jsp。
4. 生成响应：视图解析器将解析后的 JSP 文件渲染成 HTML，并返回给客户端浏览器。

Spring MVC 工作流程

1. 用户请求: 用户在浏览器中访问 URL（例如 http://localhost:8777/springmvc/firstController）。
2. 前端控制器 (DispatcherServlet): web.xml 文件配置了 DispatcherServlet，该 Servlet 将拦截所有请求。
3. 处理请求:
   • DispatcherServlet 根据 URL 和注解配置，找到相应的控制器（如 FirstController）。
   • 调用控制器方法 sayHello。
4. 返回视图名称: 控制器方法返回视图名称 "success"。
5. 视图解析器:
   • 根据视图名称，视图解析器将视图名称转换为实际视图文件路径（如 /WEB-INF/pages/success.jsp）。
6. 渲染视图: DispatcherServlet 将视图文件渲染为 HTML 并返回给用户。