💂 个人主页: 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？

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>