13-SpringMVC入门案例

1- 三层架构和MVC

1.1 三层架构

#1.企业项目架构中，有两种常见的架构形式：
	1.1.C/S架构，即客户端/服务器
	1.2.B/S架构，即浏览器/服务器
	
#2.目前在J2EE项目中，几乎都基于B/S架构

#3.在B/S架构中，系统标准的三层结构包括：
	表现层（web）：与请求和响应相关
	业务层（service）：与业务需求相关
	持久层（dao）：与操作访问数据库相关

1.2 MVC模型

#1.MVC是一种表现层的设计模型。它的全名是Model(模型)-View（视图）-Control（控制器）：
	Model（模型）：模型指的是数据模型，与封装数据相关的都是模型。比如pojo、vo
	View（视图）：视图指的是展示数据，与页面相关的都是视图。比如html、jsp
	Control（控制器）：控制器指的是用户交互，接收用户请求，响应用户。比如servlet

#2. 作用
    MVC主要作用是降低了视图与业务逻辑间的双向偶合,MVC不是一种设计模式.
    MVC是一种架构模式。当然不同的MVC存在差异。

最典型的MVC就是JSP + servlet + javabean的模式。

​

1.3 创建Servlet工程

1.3.1 项目目录

​

1.3.2 父工程相关依赖

<?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>cn.guardwhy</groupId>
    <artifactId>springMVC</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>01_servlet</module>
    </modules>

    <!-- 集中定义依赖版本号 -->
    <properties>
        <!--spring版本-->
        <spring.version>5.2.9.RELEASE</spring.version>
    </properties>

    <!--引入依赖-->
    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--JSP-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>
        <!--servlet-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>
        <!--jsp-jstl-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!--测试依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
    
</project>

1.3.3 子工程依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>
        <artifactId>springMVC</artifactId>
        <groupId>cn.guardwhy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <artifactId>01_servlet</artifactId>
</project>

1.3.4 Servlet类

package cn.guardwhy.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloServlet extends HttpServlet {
    
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
    
        // 1. 取得参数
        String method = req.getParameter("method");
        if(method.equals("add")){
    
    
            req.getSession().setAttribute("msg", "执行了add方法");
        }
        if(method.equals("delete")){
    
    
            req.getSession().setAttribute("msg","执行了delete方法");
        }

        // 2.视图跳转
        req.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
    
        super.doPost(req, resp);
    }
}

1.3.5 编写Hello.jsp文件

在WEB-INF目录下新建一个jsp的文件夹，新建hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>guardwhy</title>
</head>
    <body>
        ${msg}
    </body>
</html>

1.3.6 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">
    <servlet>
        <!--注册Servlet-->
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>cn.guardwhy.servlet.HelloServlet</servlet-class>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/user</url-pattern>
    </servlet-mapping>
</web-app>

2- spring MVC

2.1 概述

Spring MVC是 Spring体系的轻量级Web MVC框架。
Spring MVC的核心Controller控制器，用于处理请求，产生响应。
Spring MVC基于Spring IOC容器运行，所有对象都被IOC管理。

2.2 在三层架构中的位置

​

2.3 springmvc优点

序号	优点	描述
1	清晰的角色划分	前端控制器（ DispatcherServlet） 、处理器映射器（ HandlerMapping） 、处理器适配器（ HandlerAdapter）、 视图解析器（ ViewResolver）、 后端控制器（ Controller）
2	与Spring 框架无缝集成	这是其它web框架不具备的
3	可扩展性好	可以很容易扩展，虽然几乎不需要
4	单元测试方便	利用 Spring 提供的 Mock 对象能够非常简单的进行 Web 层单元测试
5.	功能强大	RESTful、数据验证、格式化、本地化、主题等
6	jsp标签库	强大的 JSP 标签库，使 JSP 编写更容易

2.4 spring MVC 和Struts2比较

# 共同点：
    它们都是表现层框架，都是基于 MVC 模型编写的。
    它们的底层都离不开原始 ServletAPI。
    它们处理请求的机制都是一个核心控制器。
# 区别：
	Spring MVC 的入口是 Servlet, 而 Struts2是Filter。
	Spring MVC 是基于方法设计的，而 Struts2 是基于类，Struts2 每次执行都会创建一个动作类。所以Spring MVC 会稍微比Struts2快些。
	Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便。
	Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些，但执行效率并没有比JSTL提升，尤其是 struts2 的表单标签，远没有html 执行效率高。

3- Spring MVC 执行原理

3.1 前端控制器

Spring的web框架围绕**DispatcherServlet**设计。 DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。
Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

​

3.2 SpringMVC的原理

当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制
器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图
渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

​

3.3 SpringMVC执行原理

实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

​

3.4 执行流程

1、DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。
假设请求的url为 : http://localhost:8080/SpringMVC/success

如上url拆分成三部分：http://localhost:8080服务器域名，SpringMVC部署在服务器上的web站点。success表示控制器.
通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。

2、HandlerMapping为处理器映射。

DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。

3、HandlerExecutionChain表示具体的Handler(处理器)

其主要作用是根据url查找控制器，如上url被查找控制器为：success。

4、HandlerExecutionChain将解析后的信息传递给DispatcherServlet,如解析控制器映射等。

5、HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。

6、Handler让具体的Controller执行。

7、Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。

8、HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。

9、DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。

10、视图解析器将解析的逻辑视图名传给DispatcherServlet。

11、DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

12、最终视图呈现给用户。

4- 入门案例

4.1 项目目录(原理版)

4.1.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">
    <parent>
        <artifactId>SpringMVC</artifactId>
        <groupId>cn.guardwhy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <artifactId>01_springMVC_servlet</artifactId>
</project>

4.1.2 配置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">

    <!--1.注册DispatcherServlet-->
    <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>
        <!--启动级别-1-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--/ 匹配所有的请求；（不包括.jsp）-->
    <!--/* 匹配所有的请求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

4.1.3 操作业务Controller

package cn.guardwhy.controller;
/**
 * springMVC入门原理案例: 需要返回一个ModelAndView，装数据，封视图
 */
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloController implements Controller {
    
    
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
    
    
        //1. 创建ModelAndView模型和视图
        ModelAndView mv = new ModelAndView();
        
        //2. 封装对象，放在ModelAndView中。
        mv.addObject("msg","HelloSpringMVC!");
        
        //3.封装要跳转的视图，放在ModelAndView中.
        mv.setViewName("success"); // /WEB-INF/jsp/success.jsp
        return mv;
    }
}

4.1.4 编写SpringMVC的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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">

    <!-- 处理映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

    <!--处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

    <!--视图解析器:DispatcherServlet给他的ModelAndView
        1、获取ModelAndView的数据
        2.解析ModelAndView的视图名字
        3、拼接视图名字,找到对应的视图 /WEB-INF/jsp/success.jsp
        4.将数据渲染到这个视图上。
    -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--注册bean,将类提交给springIOC容器来管理-->
    <bean id="/success" class="cn.guardwhy.controller.HelloController"/>
</beans>

4.1.5 跳转的jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>guardwhy</title>
</head>
    <body>
        ${msg}
    </body>
</html>

4.1.6 执行结果

​

4.1.7 出现错误

访问出现404，项目模块中缺少相关依赖

​

4.2 项目目录(注解版)

4.2.1 添加父工程相关依赖

<build>
    <!--处理资源导出问题-->
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

4.2.2 配置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">

    <!--1.注册DispatcherServlet-->
    <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>
        <!--启动级别-1-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--所有的请求都会被springmvc拦截-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

4.2.3 操作业务Controller

• @Controller是为了让Spring IOC容器初始化时自动扫描到。
• @RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/HelloController/success。
• 方法中声明Model类型的参数是为了把Action中的数据带到视图中。
• 方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/success.jsp。

package cn.guardwhy.controller;

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

/**
 * springMVC入门原理案例(注解版本)
 */
@Controller
@RequestMapping("/HelloController")

public class HelloController {
    
    
    //真实访问地址 : 项目名/HelloController/success
    @RequestMapping("/success")
    public String sayHello(Model model){
    
    
        // 1.向模型中添加属性，可以在页面中取出渲染
        model.addAttribute("msg", "hello, SpringMVC");
        //2. web-inf/jsp/success.jsp
        return "success";
    }
}

4.2.4 SpringMVC的配置文件

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


    <!--1.自动扫描包,让指定包下的注解生效,由IOC容器统一管理-->
    <context:component-scan base-package="cn.guardwhy.controller"/>

    <!--2.让Spring MVC处理静态资源-->
    <mvc:default-servlet-handler/>

    <!--3.支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系,要想使@RequestMapping注解生效必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
    -->
    <mvc:annotation-driven/>

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

4.2.5 创建视图层

在WEB-INF/ jsp目录中创建hello.jsp,视图可以直接取出并展示从Controller带回的信息。可以通过EL表示取出Model中存放的值，或者对象。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>springMVC</title>
</head>
<body>
    ${msg}
</body>
</html>

4.2.6 执行结果

​

4.3 控制器Controller

• 控制器复杂提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现。
• 控制器负责解析用户的请求并将其转换为一个模型。
• 在Spring MVC中一个控制器类可以包含多个方法，在Spring MVC中，对于Controller的配置方式有很多种

4.3.1 项目目录

​

4.3.2 操作业务Controller

package cn.guardwhy.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Controller详解
 */
public class TestController1 implements Controller {
    
    

    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest,
                                      HttpServletResponse httpServletResponse) throws Exception {
    
    
        // 1.返回一个模型视图对象
        ModelAndView mv = new ModelAndView();
        // 2.封装对象，放在ModelAndView中。
        mv.addObject("msg", "TestController1");
        // 3. 封装跳转的视图
        mv.setViewName("test");
        return mv;
    }
}

4.3.3 SpringMVC的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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">

    <!--注册bean,将类提交给springIOC容器来管理-->
    <bean id="/test1" class="cn.guardwhy.controller.TestController1"/>

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

4.3.4 创建视图层

在WEB-INF/ jsp目录中创建hello.jsp,视图可以直接取出并展示从Controller带回的信息。可以通过EL表示取出Model中存放的值，或者对象。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>guardwhy</title>
</head>
<body>
    ${msg}
</body>
</html>

4.3.5 执行结果

​

4.3.6 注意

• 实现接口Controller定义控制器是较老的办法。
• 缺点是：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller。定义的方式比较麻烦。

4.4 使用注解@Controller

4.4.1 操作业务Controller

package cn.guardwhy.controller;

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

/**
 * 注解形式
 */
@Controller
public class TestController2 {
    
    
    // 映射访问路径
    @RequestMapping("/test2")
    public String Test(Model model){
    
    
        // 自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg", "ControllerTest2");
        return "test";
    }
}

4.4.2 SpringMVC的配置文件

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd 
        http://www.springframework.org/schema/context 
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 -->
    <context:component-scan base-package="cn.guardwhy.controller"/>

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

4.4.3 执行结果

​

4.5 RequestMapping

4.5.1 @RequestMapping

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。为了测试结论更加准确

4.5.2 注解在方法上

package cn.guardwhy.controller;

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

@Controller
public class TestController3 {
    
    
    @RequestMapping("/test3")

    public String Test3(Model model){
    
    
        // 自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg", "ControllerTest3");
        return "test";
    }
}

​

4.5.3 同时注解类与方法

package cn.guardwhy.controller;

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

@Controller
@RequestMapping("/guardwhy")
public class TestController3 {
    
    
    @RequestMapping("/test3")

    public String Test3(Model model){
    
    
        // 自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg", "ControllerTest3");
        return "test";
    }
}

​

4.6 RestFul风格

4.6.1 项目目录

​

4.6.2 概念

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

4.6.3 作用

资源：互联网所有的事物都可以被抽象为资源
资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。分别对应 添加、 删除、修改、查询。

4.6.4 控制器(Controller)

package cn.guardwhy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * RestFul风格入门案例
 */
@Controller
public class RestFulController {
    
    
    // 1.访问映射路径
    @RequestMapping(value = "/commit/{a}/{b}", method = RequestMethod.GET)
    public String test1(@PathVariable int a, @PathVariable String b, Model model){
    
    
        // 返回结果集
        String res = a + b;
        model.addAttribute("msg", "结果返回值1:" + res);
        return "success";
    }

    // post方法
    @PostMapping("/commit/{a}/{b}")
    public String test2(@PathVariable int a, @PathVariable String b, Model model){
    
    
        // 返回结果集
        String res = a + b;
        model.addAttribute("msg", "结果返回值2:" + res);
        return "success";
    }
}

4.6.5 视图层

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>post提交</title>
</head>
<body>
    <form action="commit/1/6" method="post">
        <input type="submit" value="提交">
    </form>
</body>
</html>

4.6.6 执行结果

4.6.7 总结

Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE。

所有的地址栏请求默认都会是 HTTP GET 类型的。
组合注解:

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping