一，springmvc基本概念

1.三层架构

开发架构一般基于两种形式，一种是c/s架构，也就是客户端服务器，另一种是b/s架构，也就是浏览器服务器。javaee的开发基本都是b/s架构。在b/s架构中，系统表转的三层架构包括：表现层，业务层，持久层。

表现层：web层。负责接收客户端请求，向客户端响应结果。

依赖于业务层，接受请求调用业务层进行业务处理，并将处理结果响应回客户端。
1.展示层：展示结果。
2.控制层：接受请求。
表现层的设计一般都是使用MVC设计模式。

业务层：service层。负责业务逻辑处理。

业务层可能会依赖于持久层，如果需要对数据持久化，需要保证事物的一致性。

持久层：dao层。负责数据持久化。

1.数据库：对数据进行持久化的载体。
2.数据访问层：业务层和持久层交互的接口
持久层就是和数据库交互，对数据库表进行增删改查。

2.MVC模型

MVC 全名是 Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，是一种软件设计规范，用于设计创建 Web 应用程序表现层的模式。

Model (模型) ：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件(包含数据和行为)，不过现在一般都分离开来：Value Object （数据Dao）和服务层（行为Service)。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。
View (视图) ：负责进行模型的展示，一般就是我们见到的用户界面（jsp或者html），客户想看到的东西。

业务逻辑，保存数据的状态。

Controller (控制器)：接收用户请求，委托给模型进行处理(状态改变)，处理完毕后把返回的

模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

显示页面。

扫描二维码关注公众号，回复： 11520630 查看本文章

最经典的MVC就是 JSP + Servlet + JavaBean的模式。

在这里插入图片描述

3.什么是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 编程风格的请求。

查看官方文档：https://docs.spring.io/spring/docs/5.1.17.RELEASE/spring-framework-reference/web.html#spring-web

4.springmvc和struts2的对比

共同点：

它们都是表现层框架，都是基于 MVC 模型编写的。
它们的底层都离不开原始 ServletAPI。
它们处理请求的机制都是一个核心控制器。

区别：

Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter。
Spring MVC 是基于方法设计的，而 Struts2 是基于类，Struts2 每次执行都会创建一个动作类。所以 Spring MVC 会稍微比 Struts2 快些。
Spring MVC 使用更加简洁，同时还支持 JSR303, 处理 ajax 的请求更方便。（JSR303 是一套 JavaBean 参数校验的标准，它定义了很多常用的校验注解，我们可以直接将这些注解加在我们 JavaBean 的属性上面，就可以在需要校验的时候进行校验了。)
Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些，但执行效率并没有比 JSTL 提升，尤其是 struts2 的表单标签，远没有 html 执行效率高。

5.为什么要学习springmvc呢

Spring MVC的特点：

轻量级，简单易学
高效，基于请求响应的MVC框架
与Spring兼容性好，无缝衔接
约定大于配置
功能强大：RESTFUL、数据验证、格式化、本地化、主题等
简洁灵活

Spring的web框架圄绕DispatcherServlet [调度Servlet ]设计。

DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解形式进行开发，十分简洁；
正因为SpringMVC好,简单,便捷,易学,天生和Spring无缝集成（使用SpringloC和Aop) ，使用约定优于配置。能够进行简单的junit测试。支持Restful风格、异常处理、本地化、国际化、数据验证、类型转换、拦截器等等…所以我们要学习。

6.中心控制器

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

在这里插入图片描述

7.Spring MVC的流程图

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

8.Spring MVC执行原理

在这里插入图片描述
上图为Spring MVC的一个较为完整的流程图，实线表示Spring MVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

简要分析执行流程

DispatcherServlet表示前置控制器，是整个Spring MVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。

我们假设请求的url为: http://localhost:8080/SpringMVC/hello
如上url拆分成三部分:
- http://localhost:8080服务器域名
- Spring MVC部署在服务器上的web站点
- hello表示控制器
通过分析，如上urI表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控

制器。

HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping，HandlerMapping根据请求url查找Handler。
HandlerExecution 表示具体的Handler，其主要作用是根据url查找控制器，如上url被查找控制器为：hello。
HandlerExecution 将解析后的信息传递给DispatcherServlet，如解析控制器映射等。
HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
Handler 让具体的Controller执行。
Controller将具体的执行信息返回给HandlerAdapter，如ModelAndView。
HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
DispatcherServlet 调用**视图解析器(ViewResolver)**来解析HandlerAdapter传递的逻辑视图
名。
视图解析器将解析的逻辑视图名传给DispatcherServlet。
DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
最终视图呈现给用户。

二，Springmvc入门

1.入门案例

1）基于实现接口方式

新建一个Moudle，添加web的支持。

确定导入了SpringMVC的依赖。

<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.9.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
  </dependency>
  <dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2</version>
  </dependency>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
  </dependency>
</dependencies>

配置web.xml，注册DispatcherServlet。

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

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

    <!-- 映射地址 -->
    <!--/ 匹配所有的请求：（不包括.jsp）-->
    <!--/*  匹配所有的请求：（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

编写SpringMVC的配置文件!名称: springmvc.xml : [servletname]-servlet.xml
说明，这里的名称要求是按照官方来的。

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

    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

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

编写我们要操作业务Controller，要么实现Controller接口，要么增加注解；需要返回一个
ModelAndView装数据封视图。

//我们在这里导入Controller接口
public class HelloController implements Controller {

    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv =new ModelAndView();
        //封装对象，放在ModelAndView中
        mv.addObject("msg","HelloSpringMVC!!!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello");
        return mv;
    }
}

将自己的类交给SpringIOC容器，注册bean。

<!--Handler-->
<bean id="/hello" class="com.kuang.controller.HelloController"/>

写要跳转的jsp页面，显示ModelandView存放的数据，以及我们的正常页面。

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

配置Tomcat启动测试

可能遇到的问题：访问出现404，排查步骤：

查看控制台输出，看一下是不是缺少了什么jar包。
如果jar保存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖。
重启Tomcat即可。

在这里插入图片描述

2）基于注解方式

操作步骤

新建一个web项目
导入相关jar包
编写web.xml，注册DispatcherServlet
编写springmvc配置文件
创建对应的控制类，Controller
完善前段视图和Controller之间的对应
测试运行

代码实现

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

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

    <!-- 映射地址 -->
    <!--/ 匹配所有的请求：（不包括.jsp）-->
    <!--/*  匹配所有的请求：（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

配置文件springmvc.xml

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

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

    <!--让springmvc 不处理静态资源-->
    <mvc:default-servlet-handler/>

    <!--开启注解支持-->
    <mvc:annotation-driven />

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

在视图解析器中我们把所有的视图都放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录的文件，客户端不能直接访问。

创建controller

@Controller
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/h1")
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","hello,SpringmvcAnnotation!!");
        //会被视图解析器处理
        return "hello";
    }
}

编写展示页面

<a href="hello/h1">testhello</a><br/>

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

由于maven可能存在资源过滤的问题，我们完善配置

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

2.入门案例流程分析

服务器启动，加载应用。读取web.xml中的配置创建spring容器并且初始化容器中的对象。从案例中可以发现创建的是HelloController和InternalResourceViewResolver，实际上远不止这些。
浏览器发送请求，经过前端控制器，被其捕获，他并不处理请求，只是根据路径的URL匹配有没有对应的，如果匹配到@RequestMapping中的内容，就转发。
转发到控制层执行对应的方法，该方法有一个返回值。
根据方法的返回值，记住视图解析器对象找到对应的视图结果。
渲染结果视图，响应浏览器。

3.案例中涉及的组件

DispatcherServlet：前端控制器

用户请求到达前端控制器，它就相当于 mvc 模式中的 c，dispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet 的存在降低了组件之间的耦合性。

HandlerMapping：处理器映射器

HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

Handler：处理器

开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由
Handler 对具体的用户请求进行处理。

HandlAdapter：处理器适配器

通过适配器对处理器进行执行，通过拓展适配器可以处理更多类型。

View Resolver：视图解析器

View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。

View：视图

SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView等。我们最常用的视图就是 jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

<mvc:annotation-driven>说明

在 SpringMVC 的各个组件中，处理器映射器、处理器适配器、视图解析器称为 SpringMVC 的三大组件。

使用 <mvc:annotation-driven>自动加载 RequestMappingHandlerMapping （处理映射器）和RequestMappingHandlerAdapter （处理适配器），可用在SpringMVC.xml 配置文件中使用<mvc:annotation-driven/>替代注解处理器和适配器的配置。

4.@RequestMapping

作用：用于映射url到控制器类或一个特定的处理程序方法。
出现位置：

类上：请求 URL 的第一级访问目录，便于模块化管理。
方法上：请求 URL 的第二级访问目录。

属性：
- value：用于指定请求的 URL。它和 path 属性的作用是一样的。
- method：用于指定请求的方式。post，get，put，delete。
- params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的 key 和 value 必须和配置的一模一样。

注意：以上四个属性只要出现 2 个或以上时，他们的关系是与的关系。

源码：

@Target({ElementType.TYPE, ElementType.METHOD})//可以加到类上和方法上
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {}

三，请求参数的绑定

1.绑定的机制

表单中请求参数都是基于 key=value 的。
SpringMVC 绑定请求参数的过程是通过把表单提交请求参数，作为控制器中方法参数进行绑的。

例如：
<a href="account/findAccount?accountId=10">查询账户</a>
	中请求参数是：accountId=10
/**
* 查询账户
* @return
*/
@RequestMapping("/findAccount")
public String findAccount(Integer accountId) {
	System.out.println("查询了账户。。。。"+accountId);
	return "success";
}

2.支持的数据类型

基本类型参数：包括基本类型和 String 类型。
POJO 类型参数：包括实体类，以及关联的实体类。
数组和集合类型参数：包括 List 结构和 Map 结构的集合（包括数组）

SpringMVC 绑定请求参数是自动实现的，但是要想使用，必须遵循使用要求。

使用要求

如果是基本类型或者 String 类型：

要求我们的参数名称必须和控制器中方法的形参名称保持一致。(严格区分大小写)

如果是 POJO 类型，或者它的关联对象：

要求表单中参数名称和 POJO 类的属性名称保持一致。并且控制器方法的参数类型是 POJO 类型。

如果是集合类型，有两种方式：

方式一：要求集合类型的请求参数必须在 POJO 中。在表单中请求参数名称要和 POJO 中集合属性名称相同。

给 List 集合中的元素赋值，使用下标。给 Map 集合中的元素赋值，使用键值对。

方式二：接收的请求参数是 json 格式数据。需要借助一个注解实现。

注意：

它还可以实现一些数据类型自动转换。
如遇特殊类型转换要求，需要我们自己编写自定义类型转换器。

代码示例

<form action="success/getBean" method="post">
  id:  <input type="text" name="id"/><br/>
   name: <input type="text" name="user.name"/><br/>
    age:<input type="text" name="user.age"/><br/>
    <input type="submit" value="submit"/><br/>
</form>

<form method="post" action="success/getCollection">
    name:  <input type="text" name="list[0].name"/><br/>
    age: <input type="text" name="list[1].age"/><br/>
    name: <input type="text" name="map[0].name"/><br/>
    age: <input type="text" name="map[1].age"/><br/>
    <input type="submit" value="submit"/>
</form>

/**
 * 参数绑定1:
 * bean中包含bean
*/
@RequestMapping("/getBean")
public String getBean(Person person){
  System.out.println("getBean()...");
  System.out.println(person);
  return "success";
}

/**
 * 参数绑定2
 * 集合类型
*/
@RequestMapping("/getCollection")
public String getList(MyCollection collection){
  System.out.println("getList()....");
  System.out.println(collection);
  return "success";
}

3.请求参数乱码问题

 <!-- 编码过滤器,必须放在web.xml最上面，防止缓存 -->
  <filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <!-- 此处/*代表过滤所有请求 -->
  </filter-mapping>

4.关于静态资源处理

在 springmvc 的配置文件中可以配置，静态资源不过滤：

<!-- location 表示路径，mapping 表示文件，**表示该目录下的文件以及子目录的文件 -->
<mvc:resources location="/css/" mapping="/css/**"/>
<mvc:resources location="/images/" mapping="/images/**"/>
<mvc:resources location="/js/" mapping="/js/**"/>

或者：
<!--让springmvc 不处理静态资源-->
<mvc:default-servlet-handler/>

5.关于get请求

tomacat 对 GET 和 POST 请求处理方式是不同的，GET 请求的编码问题，要改 tomcat 的 server.xml

配置文件，如下：

<Connector connectionTimeout="20000" port="8080"
protocol="HTTP/1.1" redirectPort="8443"/>
改为：
<Connector connectionTimeout="20000" port="8080"
protocol="HTTP/1.1" redirectPort="8443"
useBodyEncodingForURI="true"/>

如果遇到 ajax 请求仍然乱码，请把：useBodyEncodingForURI="true"改为URIEncoding="UTF-8"即可。

6.自定义类型转换器

自定义类型转换不是用在与数据库交互，而是用在前后端交互。

举个例子：
假如前段传来的日期格式：2017-02-21能封装成功；但是假如前段传来的是：2017/02/21呢？

代码如下

jsp页面

<form action="success/date" method="post">
    <input type="text" name="date"/><br/>
    <input type="submit" value="submit"/>
</form>

转换器类

public class StringToDate implements Converter<String, Date> {
    @Override
    public Date convert(String s) {
        if (s==null||"".equals(s)){
            throw new RuntimeException("输入不能为空");
        }
        try {
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            return format.parse(s);
        } catch (Exception e) {
            throw new ClassCastException("类型转换异常");
        }
    }
}

自定义类型转换器

spring 配置类型转换器的机制是，将自定义的转换器注册到类型转换服务中去。

<!--自定义类型转换-->
<!-- 配置类型转换器工厂 -->
    <bean id="conversionServiceFactoryBean" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <!-- 给工厂注入一个新的类型转换器 -->
        <property name="converters">
            <set><!-- 配置自定义类型转换器 -->
                <bean class="com.atguigu.utils.StringToDate"></bean>
            </set>
        </property>
    </bean>
<mvc:annotation-driven conversion-service="conversionServiceFactoryBean"/>

控制器

/**
 * 自定义数据类型转换
 * 1.编写类型转换类，实现 Converter 接口，该接口有两个泛型。
 * 2.配置文件中配置转换器,并在注解支持里面注册。
 * 3.控制层参数列表传入转换类
*/
@RequestMapping("/date")
public String getDate(Date date){
  System.out.println(date.toString());
  return "success";
}

7.使用servletAPI对象作为方法参数

springMVC 还支持使用原始 ServletAPI 对象作为控制器方法的参数。

支持原始 ServletAPI 对象有：

    /**
     * 获取原生ServletAPI
     */
    @RequestMapping("/getServlet")
    public String getServlet(HttpServletRequest request, HttpServletResponse response){
        System.out.println("getServlet()...");
        return "success";
    }

<a href="success/getServlet">getServlet</a><br/>

如果有收获！！！希望老铁们来个三连，点赞、收藏、转发。
创作不易，别忘点个赞，可以让更多的人看到这篇文章，顺便鼓励我写出更好的博客

springmvc入门案例 | 流程图分析 | 请求参数绑定

一，springmvc基本概念

1.三层架构

2.MVC模型

3.什么是springmvc

4.springmvc和struts2的对比

5.为什么要学习springmvc呢

6.中心控制器

7.Spring MVC的流程图

8.Spring MVC执行原理

二，Springmvc入门

1.入门案例

1）基于实现接口方式

2）基于注解方式

操作步骤

代码实现

2.入门案例流程分析

3.案例中涉及的组件

4.@RequestMapping

三，请求参数的绑定

1.绑定的机制

2.支持的数据类型

使用要求

代码示例

3.请求参数乱码问题

4.关于静态资源处理

5.关于get请求

6.自定义类型转换器

代码如下

7.使用servletAPI对象作为方法参数

猜你喜欢