我把问烂了的⭐SpringMVC面试题⭐总结了一下（带答案，万字总结，精心打磨，建议收藏）

最新推荐文章于 2023-02-24 16:53:51 发布

Java程序鱼

最新推荐文章于 2023-02-24 16:53:51 发布

阅读量1.6w

点赞数 31

分类专栏：面试题专栏文章标签： springmvc 面试

本文链接：https://blog.csdn.net/qq_35620342/article/details/119965560

版权

面试题专栏专栏收录该内容

22 篇文章 211 订阅

订阅专栏

💂 个人主页: Java程序鱼

💬 如果文章对你有帮助，欢迎关注、点赞、收藏(一键三连)和订阅专栏

👤 微信号：hzy1014211086，想加入技术交流群的小伙伴可以加我好友，群里会分享学习资料、学习方法

序号	内容	链接地址
1	Java基础知识面试题	https://blog.csdn.net/qq_35620342/article/details/119636436
2	Java集合容器面试题	https://blog.csdn.net/qq_35620342/article/details/119947254
3	Java并发编程面试题	https://blog.csdn.net/qq_35620342/article/details/119977224
4	Java异常面试题	https://blog.csdn.net/qq_35620342/article/details/119977051
5	JVM面试题	https://blog.csdn.net/qq_35620342/article/details/119948989
6	Java Web面试题	https://blog.csdn.net/qq_35620342/article/details/119642114
7	Spring面试题	https://blog.csdn.net/qq_35620342/article/details/119956512
8	Spring MVC面试题	https://blog.csdn.net/qq_35620342/article/details/119965560
9	Spring Boot面试题	https://blog.csdn.net/qq_35620342/article/details/120333717
10	MyBatis面试题	https://blog.csdn.net/qq_35620342/article/details/119956541
11	Spring Cloud面试题	待分享
12	Redis面试题	https://blog.csdn.net/qq_35620342/article/details/119575020
13	MySQL数据库面试题	https://blog.csdn.net/qq_35620342/article/details/119930887
14	RabbitMQ面试题	待分享
15	Dubbo面试题	待分享
16	Linux面试题	待分享
17	Tomcat面试题	待分享
18	ZooKeeper面试题	待分享
19	Netty面试题	待分享
20	数据结构与算法面试题	待分享

文章目录

1.什么是Spring MVC？
2.Spring MVC的优点
3.Spring MVC关键组件？
4.什么是DispatcherServlet？
5.什么是Spring MVC框架的控制器？
6.Spring MVC的控制器是不是单例模式,如果是,有什么问题,怎么解决？
7.Spring MVC的工作流程？
8.MVC是什么？MVC设计模式的好处有哪些
9.注解原理是什么?
10.Spring MVC常用的注解有哪些？
12.@Controller注解的作用
13.@RequestMapping注解的作用
14.@ResponseBody注解的作用
15.@PathVariable和@RequestParam的区别
16.Spring MVC与Struts2区别
17.Spring MVC怎么样设定重定向和转发的？
18.Spring MVC Post中文乱码
19.Spring MVC 异常处理机制
20.如果在拦截请求中，我想拦截get方式提交的方法,怎么配置?
21.怎样在方法里面得到Request,或者Session？
22.请求参数接收
- 基本参数类型
- Pojo参数封装
- 包装Pojo对象类型
- List集合参数封装
- Spring MVC 自定义类型转换
23.Spring MVC 控制器返回值
- 普通字符串
- 转发字符串
- 重定向字符串
- 返回空
- ModelAndView
- 返回Java对象
- 返回JSON数据
24.怎么样把ModelMap里面的数据放入Session里面？
25.Spring MVC里面拦截器是怎么写的

1.什么是Spring MVC？

Spring MVC是一种基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，使用MVC架构模式的思想，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化我们日常开发，减少出错，方便组内开发人员之间的配合。

2.Spring MVC的优点

（1）可以支持各种视图技术,而不仅仅局限于JSP；

（2）与Spring框架集成（如IoC容器、AOP等）；

（3）清晰的角色分配：前端控制器(dispatcherServlet) , 请求到处理器映射（handlerMapping), 处理器适配器（HandlerAdapter), 视图解析器（ViewResolver）。

（4）支持各种请求资源的映射策略。

3.Spring MVC关键组件？

前端控制器：DispatcherServlet（不需要程序员开发）,由框架提供，在web.xml中配置。
作用：接收请求，响应结果，相当于转发器，中央处理器。
处理器映射器：HandlerMapping(不需要程序员开发),由框架提供。
作用：根据请求的url查找Handler(处理器/Controller)，可以通过XML和注解方式来映射。
处理器适配器：HandlerAdapter(不需要程序员开发),由框架提供。
作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler。
处理器：Handler(也称之为Controller，需要工程师开发)。
注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler。
作用：接受用户请求信息，调用业务方法处理请求，也称之为后端控制器。
视图解析器：ViewResolver(不需要程序员开发)，由框架提供。
作用：进行视图解析，把逻辑视图名解析成真正的物理视图。
视图：View(需要前端工程师开发)。
作用：把数据展现给用户的页面，View是一个接口，实现类支持不同的View技术（Jsp、Freemarker、Pdf等）

4.什么是DispatcherServlet？

Spring的MVC框架是围绕DispatcherServlet来设计的，它用来处理所有的HTTP请求和响应。

5.什么是Spring MVC框架的控制器？

控制器提供一个访问应用程序的行为，此行为通常通过服务接口实现。控制器解析用户输入并将其转换为一个由视图呈现给用户的模型。Spring用一个非常抽象的方式实现了一个控制层，允许用户创建多种用途的控制器。

6.Spring MVC的控制器是不是单例模式,如果是,有什么问题,怎么解决？

答：是单例模式,所以在多线程访问的时候有线程安全问题,不要用同步,会影响性能的,解决方案是在控制器里面不能写字段。

7.Spring MVC的工作流程？

在这里插入图片描述
①用户发送请求到服务器，如果路径和我们配置的前端控制器映射路径匹配，服务器就将请求转交给前端控制器处理。
② DispatcherServlet收到请求调用HandlerMapping处理器映射器（定义了请求到处理器之间的映射）（其实最后用的是RequestMappingHandlerMapping，他是HandlerMapping子类的实现，HandlerMapping有个抽象方法getHandler，可以获取处理器调用链）。
③ 处理器映射器根据请求url找到具体的处理器，生成处理器对象及跟这个处理器相关的拦截器(二者组成HandlerExecutionChain处理器调用链 ),并将其一并返回给DispatcherServlet。
④DispatcherServlet通过HandlerAdapter处理器适配器（表单数据类型的校验、数据类型的转换都是处理器适配器做的，最终他会调用目标方法）调用处理器。
理解：DispatcherServlet通过HandlerAdapter处理器适配器（表单数据类型的校验、数据类型的转换都是处理器适配器做的，最终他会调用目标方法）调用处理器。
⑤执行处理器(也就是Controller，也叫后端控制器)。
⑥Controller执行完成返回ModelAndView。
⑦HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
⑧DispatcherServlet(调用处理视图方法，如果有异常就用异常解析器处理HandlerExceptionResolver，若没异常进行渲染视图)将ModelAndView传给ViewReslover视图解析器。
⑨ViewReslover解析后返回具体View。
⑩DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。
⑪DispatcherServlet对用户进行响应。

8.MVC是什么？MVC设计模式的好处有哪些

三层架构：
1）界面层，用于显示数据和接收用户输入的数据，为用户提供一种交互式操作的界面
2）业务逻辑层，它的关注点主要集中在业务规则的制定、业务流程的实现等与业务需求有关的系统设计
3）数据访问层，其功能主要是负责数据库的访问

MVC架构：
1）Model：模型，将传输数据封装成一个完整的载体（Model）
2）View：视图，html、jsp等
3）Controller：控制器

两者区别：
很多人容易把三层模式与MVC模式混淆，三层与MVC的最不同的地方在于三层是没有Controller控制器的概念。虽然同样是架构级别的，三层与MVC相同的地方在于他们都有一个表现层，但是他们不同的地方在于其他的两个层。MVC没有把业务的逻辑访问看成两个层，这是采用三层架构或MVC搭建程序最主要的区别。当然了，在三层中也提到了Model概念，但是三层架构中Model的概念与MVC中Model的概念是不一样的，“三层” 中典型的Model层是以实体类构成的，而MVC里，则是由业务逻辑与访问数据组成的。

MVC设计模式的好处

分层设计，实现了业务系统各个组件之间的解耦，有利于业务系统的可扩展性，可维护性。
有利于系统的并行开发，提升开发效率。

9.注解原理是什么?

注解本质是一个继承了Annotation的特殊接口，其具体实现类是Java运行时生成的动态代理类。我们通过反射获取注解时，返回的是Java运行时生成的动态代理对象。通过代理对象调用自定义注解的方法，会最终调用AnnotationInvocationHandler的invoke方法。该方法会从memberValues这个Map中索引出对应的值。而memberValues的来源是Java常量池。

10.Spring MVC常用的注解有哪些？

@RequestMapping：是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

@RequestBody：注解实现接收http请求的json数据，将json转换为java对象。

@ResponseBody：注解实现将conreoller方法返回对象转化为json对象响应给客户。

12.@Controller注解的作用

在Spring MVC 中，控制器Controller 负责处理由DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model 返回给对应的View 进行展示。在Spring MVC 中提供了一个非常简便的定义Controller 的方法，你无需继承特定的类或实现特定的接口，只需使用@Controller 标记一个类是Controller ，然后使用@RequestMapping 和@RequestParam 等一些注解用以定义URL 请求和Controller 方法之间的映射，这样的Controller 就能被外界访问到。此外Controller 不会直接依赖于HttpServletRequest 和HttpServletResponse 等HttpServlet 对象，它们可以通过Controller 的方法参数灵活的获取到。

@Controller 用于标记在一个类上，使用它标记的类就是一个Spring MVC Controller 对象。分发处理器将会扫描使用了该注解的类的方法，并检测该方法是否使用了@RequestMapping 注解。@Controller 只是定义了一个控制器类，而使用@RequestMapping 注解的方法才是真正处理请求的处理器。单单使用@Controller 标记在一个类上还不能真正意义上的说它就是Spring MVC 的一个控制器类，因为这个时候Spring 还不认识它。那么要如何做Spring 才能认识它呢？这个时候就需要我们把这个控制器类交给Spring 来管理。有两种方式：

在Spring MVC 的配置文件中定义MyController 的bean 对象。
在Spring MVC 的配置文件中告诉Spring 该到哪里去找标记为@Controller 的Controller 控制器。

13.@RequestMapping注解的作用

@RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

@RequestMapping常用属性
（1）value属性

指定控制器的方法URI

@Controller
@RequestMapping("/hello")
public class HelloController{
    @RequestMapping("/hello.do")
    public void hello(HttpServletRequest request,HttpServletResponse response) throws IOException {
        response.getWriter().write("www.baidu.com");
    }
}

如果类和方法上都指定value值，那么方法的最终方法路径为：http://localhost:8080/hello/hello.do

（2）method属性

指定请求的method类型，可以接受GET,POST,PUT,DELETE等

@RequestMapping(value = "/hello.do",method = RequestMethod.GET)
public void hello(HttpServletRequest request,HttpServletResponse response) throws IOException {
     response.getWriter().write("www.baidu.com");
}

（3）consumes、produces属性

consumes：指定处理请求的提交内容类型（Content-Type），例如application/json, text/html;
produces：指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回。

@RequestMapping(value = "/hello.do",consumes = "application/json",produces = "application/json")
public void hello(HttpServletRequest request,HttpServletResponse response) throws IOException {
    response.getWriter().write("www.baidu.com");
}

（4）params、headers属性

params：指定request中必须包含某些参数值，才让该方法处理。
headers：指定request中必须包含某些指定的header值，才能让该方法处理请求。

params示例：

@RequestMapping(value = "/hello.do",params = "id=10")
public void hello(HttpServletRequest request,HttpServletResponse response) throws IOException {
   response.getWriter().write("www.baidu.com");
}

headers示例：

@RequestMapping(value = "/hello.do",headers = "Referer=http://www.baidu.com/")
public void hello(HttpServletRequest request,HttpServletResponse response) throws IOException {
   response.getWriter().write("www.baidu.com");
}

14.@ResponseBody注解的作用

作用：该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。

使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用；

15.@PathVariable和@RequestParam的区别

@PathVariable是spring3.0的一个新功能：接收请求路径中占位符的值

@Controller
@RequestMapping("hello")
public class HelloController {
    /**
     * 占位符映射
     * 语法：@RequestMapping(value= user/{userId}/{userName}”)
     * 请求路径：http://localhost:8080/hello/show/1/world
     * @param id
     * @param name
     * @return
     */
    @RequestMapping("show/{id}/{name}")
    public ModelAndView test(@PathVariable("id") Long id ,@PathVariable("name") String name){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","占位符映射：id:"+id+";name:"+name);
        mv.setViewName("hello");
        return mv;
    }
}

@RequestParam：将请求参数绑定到你控制器的方法参数上（是SpringMVC中接收普通参数的注解）

@Controller
@RequestMapping("hello")
public class HelloController {
 
    /**
     * 接收普通请求参数
     * http://localhost:8080/hello/show?name=hello
     * url参数中的name必须要和@RequestParam("name")一致
     * @return
     */
    @RequestMapping("show")
    public ModelAndView test(@RequestParam("name")String name){
        ModelAndView mv = new ModelAndView();
        mv.setViewName("hello");
        mv.addObject("msg", "接收普通的请求参数：" + name);
        return mv;
    }
}

16.Spring MVC与Struts2区别

Struts2是类级别的拦截，一个类对应一个request上下文，SpringMVC是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应,所以说从架构本身上SpringMVC就容易实现restful url,而struts2的架构实现起来要费劲，因为Struts2中Action的一个方法可以对应一个url，而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了。
由上边原因，SpringMVC的方法之间基本上独立的，独享request response数据，请求数据通过参数获取，处理结果通过ModelMap交回给框架，方法之间不共享变量，而Struts2搞的就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的，这不会影响程序运行，却给我们编码读程序时带来麻烦，每次来了请求就创建一个Action，一个Action对象对应一个request上下文。
由于Struts2需要针对每个request进行封装，把request，session等servlet生命周期的变量封装成一个一个Map，供给每个Action使用，并保证线程安全，所以在原则上，是比较耗费内存的。
拦截器实现机制上，Struts2有以自己的interceptor机制，SpringMVC用的是独立的AOP方式，这样导致Struts2的配置文件量还是比SpringMVC大。
SpringMVC的入口是servlet，而Struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。
SpringMVC集成了Ajax，使用非常方便，只需一个注解@ResponseBody就可以实现，然后直接返回响应文本即可，而Struts2拦截器集成了Ajax，在Action中处理时一般必须安装插件或者自己写代码集成进去，使用起来也相对不方便。
SpringMVC验证支持JSR303，处理起来相对更加灵活方便，而Struts2验证比较繁琐，感觉太烦乱。
Spring MVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高（当然Struts2也可以通过不同的目录结构和相关配置做到SpringMVC一样的效果，但是需要xml配置的地方不少）。
设计思想上，Struts2更加符合OOP的编程思想， SpringMVC就比较谨慎，在servlet上扩展。
SpringMVC开发效率和性能高于Struts2。
SpringMVC可以认为已经100%零配置。

17.Spring MVC怎么样设定重定向和转发的？

/**
 * 实现转发
 */
@RequestMapping("/hello1.action")
public String hello1(HttpServletRequest request){
    request.setAttribute("name", "cjj");
    return "forward:hello.action";
}

/**
 * 实现重定向
 */
@RequestMapping("/hello2.action")
public String hello2(HttpServletRequest request){
    request.setAttribute("name", "cjj");
    return "redirect:/hello.action";
}

18.Spring MVC Post中文乱码

在Spring MVC表单如果是Post方法提交中文内容时，会出现乱码，效果如下：
在这里插入图片描述

这时我们可以配置Spring MVC提供字符编码过滤器来解决问题。

<!--字符编码过滤器-->
<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>

注意：要记得加上encoding参数，并设置为UTF-8

19.Spring MVC 异常处理机制

在控制器的方法发生异常后，默认情况会显示Tomcat的500页面，这种用户体验并不好。如果我们在每个控制器方法自行捕获异常，显然又太繁琐。有没有好的异常处理办法呢？有的，就是Spring MVC的全局异常处理机制。Spring MVC提供了两种全局异常处理机制：

定义异常类，实现HandlerExceptionResolver接口
定义异常类，使用@ControllerAdvice+@ExceptionHandler注解

下面看看实现步骤。

（1）编写控制器，模拟异常

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public String upload(HttpSession session, HttpServletResponse response) throws Exception {
        //模拟异常
        int i = 100/0;
        return "success";
    }
}

（2）编写全局异常处理类

全局异常类编写方式一

/**
 * 方式一：自定义异常处理类
 */
public class MyCustomException1 implements HandlerExceptionResolver{
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
        ModelAndView mv = new ModelAndView();
        mv.addObject("errorMsg",e.getMessage());
        mv.setViewName("error");
        return mv;
    }
}

这种写法，我们需要实现HandlerExceptionResolver接口，然后实现resolveException方法，编写处理异常逻辑。

全局异常类编写方式二

/**
 * 方式二：自定义异常处理类
 */
@ControllerAdvice
public class MyCustomException2{

    @ExceptionHandler
    public ModelAndView handlerError(Exception e){
        ModelAndView mv = new ModelAndView();
        mv.setViewName("error");
        mv.addObject("errorMsg",e.getMessage());
        return mv;
    }

}

第二种写法，直接在类上使用@ControllerAdvice，在异常处理方法上添加@ExceptionHandler注解。这种做法底层是AOP思想。

（3）配置全局异常处理类
方式一：

<!--创建自定义异常处理对象-->
<bean class="com.exception.MyCustomException1"/>

方式二：

<!--创建自定义异常处理对象-->
<bean class="com.exception.MyCustomException2"/>

（4）运行测试

访问控制器方法，发生异常后经过全局异常处理类，跳转到error.jsp页面
在这里插入图片描述

20.如果在拦截请求中，我想拦截get方式提交的方法,怎么配置?

@RequestMapping(value = "/hello.do",method = RequestMethod.GET)
public void hello(HttpServletRequest request,HttpServletResponse response) throws IOException {
     response.getWriter().write("www.baidu.com");
}

21.怎样在方法里面得到Request,或者Session？

@Controller
public class TestController {
	// Spring MVC会把request、session对象传入
    @RequestMapping("/test")
    public void test(HttpServletRequest request,HttpSession session) {
        ......
    }
}

22.请求参数接收

Spring MVC支持对多种类型的请求参数进行封装

基本类型
Pojo对象类型
包装Pojo对象类型
List集合类型
Map集合类型

基本参数类型

（1）设计表单页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
</head>
<body>
<h2>基本类型参数封装</h2>
<form action="/param.do">
    用户名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交">
</form>
</body>
</html>

（2）编写控制器接收参数

@Controller
public class ParamController {

    @RequestMapping("/param.do")
    public String save(@RequestParam("name") String name,
                       @RequestParam("age") Integer age){
        System.out.println("用户名："+name);
        System.out.println("年龄："+age);
        return "success";
    }
}

这里要注意的是，控制器接收参数的形参名称必须和表单的name属性保持一致，否则会接收失败！

（3）springmvc.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:mvc="http://www.springframework.org/schema/mvc"
       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/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">

    <!-- 1.扫描Controller的包-->
    <context:component-scan base-package="com.controller"/>

    <!-- 2.配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 2.1 页面前缀 -->
        <property name="prefix" value="/pages/"/>
        <!-- 2.2 页面后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 3.创建处理器适配器和处理器映射器-->
    <mvc:annotation-driven/>
</beans>

Pojo参数封装

之前我们接收参数的时候都是定义一个个的基本类型来接收，这样比较繁琐，Spring MVC提供了使用Pojo（或者称为JavaBean）类型来封装请求参数。

（1）设计表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
</head>
<body>
<h2>Pojo类型参数封装</h2>
<form action="/param.do" method="post">
    用户名：<input type="text" name="username"><br>
    年龄：<input type="text" name="age"><br>
    <input type="submit" value="提交">
</form>
</body>
</html>

（2）设计User对象封装表单数据

/**
 * 用于封装表单数据
 */
public class User {
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

（3）编写Controller

@Controller
public class ParamController {

    @RequestMapping("/param.do")
    public String save(User user){
        System.out.println("用户名："+user.getName());
        System.out.println("年龄："+user.getAge());
        return "success";
    }
}

（4）springmvc.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:mvc="http://www.springframework.org/schema/mvc"
       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/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">

    <!-- 1.扫描Controller的包-->
    <context:component-scan base-package="com.controller"/>

    <!-- 2.配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 2.1 页面前缀 -->
        <property name="prefix" value="/pages/"/>
        <!-- 2.2 页面后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 3.创建处理器适配器和处理器映射器-->
    <mvc:annotation-driven/>
</beans>

包装Pojo对象类型

在Spring MVC的应用过程中，我们在后端经过需要将表单数据封装在一个包装Pojo类型中，所谓包装Pojo类型，就是Pojo对象中包含另一个Pojo对象，如下所示：

public class User {
    private String username;
    private Integer age;
    private Address address;//封装地址信息
}

（1）设计表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
</head>
<body>
<h2>包装Pojo类型参数封装</h2>
<form action="/param.do" method="post">
    用户名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    省份：<input type="text" name="address.province"><br>
    城市：<input type="text" name="address.city"><br>
    <input type="submit" value="提交">
</form>
</body>
</html>

注意：这里封装用户的地址信息，name为address.province这种写法，这代表把数据封装到User对象->Address对象的province属性中。

（2）设计包装Pojo对象
Address对象：

public class Address {
    private String province;
    private String city;

    public String getProvince() {
        return province;
    }
    public void setProvince(String province) {
        this.province = province;
    }
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "province='" + province + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

User对象：

public class User {
    private String username;
    private Integer age;
    private Address address;//封装地址信息

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
    
	public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address +
                '}';
    }
}

List集合参数封装

在之前Spring MVC使用包装Pojo类型一文中，我们是一个Address对象来接收一个地址信息，如果有多个地址信息怎么呢？这时我们可以使用List集合来封装。

（1）设计表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
</head>
<body>
<h2>List集合类型参数封装</h2>
<form action="/param.do" method="post">
    用户名：<input type="text" name="username"><br>
    年龄：<input type="text" name="age"><br>
    省份1：<input type="text" name="address[0].province"><br>
    城市1：<input type="text" name="address[0].city"><br>
    省份2：<input type="text" name="address[1].province"><br>
    城市2：<input type="text" name="address[1].city"><br>
    <input type="submit" value="提交">
</form>
</body>
</html>

注意：这里的name比较特殊：address[0].province，代表给User对象->List

集合->第一个Address对象的province属性赋值

（2）设计Pojo对象

Address对象：

public class Address {
    private String province;
    private String city;

    public String getProvince() {
        return province;
    }
    public void setProvince(String province) {
        this.province = province;
    }
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "province='" + province + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

User对象：

public class User {
    private String name;
    private Integer age;

    private List<Address> address;//这里使用List集合接收表单多个地址信息

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
    
	public List<Address> getAddress() {
        return address;
    }
    public void setAddress(List<Address> address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address +
                '}';
    }

}

（3）编写Controller

@Controller
public class ParamController {

    @RequestMapping("/param.do")
    public String save(User user){
        System.out.println("用户名："+user.getUsername());
        System.out.println("年龄："+user.getAge());
        //遍历所有地址信息
        for(Address addr:user.getAddress()){
            System.out.println(addr);
        }
        return "success";
    }
}

（4）springmvc.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:mvc="http://www.springframework.org/schema/mvc"
       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/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">

    <!-- 1.扫描Controller的包-->
    <context:component-scan base-package="com.controller"/>

    <!-- 2.配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 2.1 页面前缀 -->
        <property name="prefix" value="/pages/"/>
        <!-- 2.2 页面后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 3.创建处理器适配器和处理器映射器-->
    <mvc:annotation-driven/>
</beans>

Spring MVC 自定义类型转换

Spring MVC默认情况下可以对基本类型进行类型转换，例如可以将String转换为Integer,Double,Float等。但是Spring MVC并不能转换日期类型（java.util.Date），如果希望把字符串参数转换为日期类型，必须自定义类型转换器。接下来讲解如何自定义类型转换器。

（1）设计表单

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
</head>
<body>
<h2>自定义类型转换</h2>
<form action="/param.do" method="post">
    用户名：<input type="text" name="username"><br>
    生日：<input type="text" name="birthday"><br>
    <input type="submit" value="提交">
</form>
</body>
</html>

（2）设计Pojo

User对象：

public class User {
    private String name;
    private Date birthday;//这里接收的是java.util.Date类型

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", birthday=" + birthday +
                '}';
    }
}

（3）编写日期类型转换器

public class StringToDateConverter implements Converter<String,Date>{
    @Override
    public Date convert(String source) {
        Date date = null;
        try {
            //使用SimpleDateFormat对页面字符串日期转换为java.util.Date类型
            date = new SimpleDateFormat("yyyy-MM-dd").parse(source);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

注意：Spring MVC的自定义类型转换器必须实现Converter接口

（4）配置自定义类型转换器

<?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:mvc="http://www.springframework.org/schema/mvc"
       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/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">

    <!-- 1.扫描Controller的包-->
    <context:component-scan base-package="com.controller"/>

    <!-- 2.配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 2.1 页面前缀 -->
        <property name="prefix" value="/pages/"/>
        <!-- 2.2 页面后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 3.创建处理器适配器和处理器映射器-->
    <mvc:annotation-driven conversion-service="conversionService"/>

    <!--4.配置自定义类型转换器-->
    <!--4.1 创建类型转换器对象-->
    <bean id="stringToDateConverter" class="com.converter.StringToDateConverter"/>

    <!--4.2 把新建的类型转换器对象加入到工厂中-->
    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <ref bean="stringToDateConverter"/>
            </set>
        </property>
    </bean>
</beans>

（5）编写Controller

@Controller
public class ParamController {

    @RequestMapping("/param.do")
    public String save(User user){
        System.out.println("用户名："+user.getUsername());
        System.out.println("生日："+user.getBirthday());
        return "success";
    }
}

23.Spring MVC 控制器返回值

Spring MVC的控制器方法返回值可以支持多种写法，每种写法的场景和效果都不一样。下面分别来看看每种返回值的使用。

普通字符串
转发字符串
重定字符串
void
ModelAndView
Java对象
JSON数据

普通字符串

返回普通字符串这种情况比较常见，主要用在我们处理完业务逻辑后，需要跳转到应用的其他页面。

代码示例：

/**
 * 1)字符串 - 普通字符串（代表页面名称，不是完整路径，最后经过视图解析器的解析）
 *    优势：写法简单
 *    劣势：只能转发到视图解析器指定的特定目录
 */
@RequestMapping("/string")
public String string(){
    System.out.println("普通字符串....");
    //这里返回页面名称，必须经过视图解析器解析的！！！
    return "index";
}

转发字符串

普通字符串，只能转发到视图解析器指定前缀的目录下的页面，如果想转发到视图解析器目录以外的页面，这时可以使用转发字符串的写法。

代码示例

/**
 * 2)字符串 - 转发字符串
 *     转发字符串格式：
 *        forward:完整页面的路径      例如：forward:/pages/index.jsp
 *
 *    优势：更加灵活，可以转到本项目下的任何页面，可以传递request域对象数据
 *    劣势：写法稍复杂
 */
@RequestMapping("/forward")
public String forward(){
    System.out.println("转发字符串....");
    return "forward:/index.html";
}

重定向字符串

如果希望使用重定向的方式跳转页面，这时可以使用重定向字符串完成。

代码示例：

/**
 * 3)字符串 - 重定向字符串
 *     重定向字符串格式：
 *        redirect:完整页面的路径      例如：redirect:/pages/index.jsp
 *
 *    优势：很灵活，可以重定向到项目内和项目以外的页面
 *    劣势：写法稍复杂，不能转发requesy域对象数据
 */
@RequestMapping("/redirect")
public String redirect(){
    System.out.println("重定向字符串....");
    return "redirect:http://www.baidu.com";
}

返回空

一般我们在文件下载的时候，就不需要控制器方法返回任何内容，所以设置为void即可。

代码示例：

/**
 * 4）返回void
 *    用于文件下载
 */
@RequestMapping("/void")
public void returnVoid(HttpServletResponse response){
    System.out.println("void....");

    //模拟文件下载
    //1.读取需要下载的文件
    File file = new File("e:/spring.jpg");

    //2.构建文件输入流
    try {
        InputStream in = new FileInputStream(file);

        //3.获取文件输出流（从response对象获取）
        OutputStream out = response.getOutputStream();

        //4.边读边写
        byte[] buf = new byte[1024];
        int len = 0;

        while( (len = in.read(buf))!=-1  ){ 
            out.write(buf,0,len);
        }

        //5.流资源关闭
        out.close();
        in.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return;
}

ModelAndView

Spring MVC提供了ModelAndView对象，该对象既可以存储数据到request域，也可以设置视图。其实Spring MVC任何处理器适配器最终执行完控制器后，都会返回ModelAndView对象。所以这是一个比较底层的对象。

代码示例：

/**
 * 5)ModelAndView: 封装了Model数据和视图数据的对象
 */
@RequestMapping("/mv")
public ModelAndView mv(){
    ModelAndView mv = new ModelAndView();
    //设置模型数据
    mv.addObject("model","一点教程网");
    //设置视图数据
    mv.setViewName("index");
    return mv;
}

返回Java对象

这里返回的Java对象，可能是普通JavaBean，也可以是List或Map集合等。一般希望把控制器的返回Java对象转换为Json字符串，才需要返回Java对象。

返回JSON数据

我们在开发中后端经常需要接受来自于前端传递的Json字符串数据，怎么把Json字符串转换为Java对象呢？后端也经常需要给前端返回Json字符串，怎么把Java对象数据转换为Json字符串返回呢？接下来我们看看如何使用@RequestBody和@ResponseBody注解。

（1）导入jackson支持包

Spring MVC默认是无法实现Json数据转换功能的，需要额外导入Jackson包来支持Json数据转换。

pom.xml配置：

<!-- jackson支持包 -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-core</artifactId>
  <version>2.9.5</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>2.9.5</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.5</version>
</dependency>

（2）页面传递Json到后端

编写json.jsp，使用jQuery实现ajax异步请求后端Controller，同时发送Json字符串对象

json.jsp内容如下：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <script src="/js/jquery-3.3.1.min.js"></script>
</head>
<body>
<script>
    //页面加载完毕
    $(function(){
        //点击按钮，发送post请求，传递json参数
        $("#btn").click(function(){
            $.ajax({
                //设置请求类型
                type:'post',
                //请求路径
                url:'/json',
                //传递json参数
                data: '{"id":268,"name":"小红","age":18}',
                //指定参数类型（如果json参数格式，必须设置为json类型）
                contentType: 'application/json;charset=utf-8',
                //该方法接收后台返回的数据格式
                dataType: 'json',
                //处理方法
                success:function(result){
                    alert(result.id+'--'+result.name+'--'+result.age);
                }

            });
        });
    });

</script>

<input type="button" value="演示Json字符串与Java对象转换" id="btn">
</body>
</html>

（3）后端处理Json数据

编写JsonController，这里用到两个关键注解@RequestBody和@ResponseBody。

@RequestBody：完成页面Json字符串转换为后端Java对象
@ResponseBody：完成后端Java对象转换为前端Json字符串

JsonController代码如下：

@Controller
public class JsonController {

    /**
     * 1) 接收前台传递json字符串格式 @RequestBody: 把json字符串转为Java对象
     * 2) 后台Java对象转换json字符串： @ResponseBody
     */
    @RequestMapping("/json")
    @ResponseBody
    public User json(@RequestBody User user){
        System.out.println("前端发送的数据："+user);
        //后台返回json字符串给前端
        user.setId(368);
        user.setName("小苍");
        user.setAge(20);
        return user;
    }
}

User对象：

public class User {
    private Integer id;
    private String name;
    private Integer age;
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

（4）springmvc.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:mvc="http://www.springframework.org/schema/mvc"
       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/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">

    <!-- 1.扫描Controller的包-->
    <context:component-scan base-package="com.controller"/>

    <!-- 2.配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 2.1 页面前缀 -->
        <property name="prefix" value="/pages/"/>
        <!-- 2.2 页面后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 3.创建处理器适配器和处理器映射器-->
    <mvc:annotation-driven/>

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

24.怎么样把ModelMap里面的数据放入Session里面？

答：可以在类上面加上@SessionAttributes注解,里面包含的字符串就是要放入session里面的key。

25.Spring MVC里面拦截器是怎么写的

有两种写法,一种是实现HandlerInterceptor接口，另外一种是继承适配器类，接着在接口方法当中，实现处理逻辑；然后在Spring MVC的配置文件中配置拦截器即可：


<mvc:interceptors>
    
    <bean id="myInterceptor" class="com.action.MyHandlerInterceptor"></bean>
    
    <mvc:interceptor>
       <mvc:mapping path="/modelMap.do" />
       <bean class="com.action.MyHandlerInterceptorAdapter" />
    </mvc:interceptor>
</mvc:interceptors>