Spring MVC 01 搭建Spring MVC开发环境+入参/出参

Spring MVC 01

一、学习目标

1.1学习目标

1. 理解MVC设计模式 JSP+Servlet+JavaBean(dao+service)
2. 了解Spring MVC的架构以及请求处理流程
3. 会搭建Spring MVC开发环境
4. 理解Controller和View之间的映射关系
5. 掌握Controller和View之间参数传递
   1. 回顾jsp 怎么样实现页面传值？
   2. url、作用域
6. 掌握模型数据的处理

二、SpringMVC 简介

2.1Spring Web MVC是什么

• Spring MVC 是一种基于 Java 实现 Web MVC 设计模式的请求驱动类型的轻量级 Web 框架。

• 使用了 MVC 架构模式的思想，将 Web 层进行职责解耦，基于请求驱动指的就是使用请求-响应模型。目的就是帮助我们简化我们日常 Web 开发的。JavaBean—>Servlet—>JSP页面

• 在 传统的 Jsp/Servlet 技术体系中，如果要开发接口，一个接口对应一个 Servlet，会导致我们开发出许多 Servlet，使用 SpringMVC 可以有效的简化这一步骤。

• Spring Web MVC 也是服务到工作者模式的实现。

• Spring MVC前端控制器是 DispatcherServlet；

• 应用控制器可以拆为处理器映射器(Handler Mapping)进行处理器管理和视图解析器(View Resolver)进行视图管理；

• 页面控制器/动作/处理器为 Controller 接口（仅包含 ModelAndView handleRequest(request, response) 方法，也有人称作 Handler）的实现（也可以是任何的 POJO 类）；

• 支持本地化（Locale）解析、主题（Theme）解析及文件上传等；

• 提供了非常灵活的数据验证、格式化和数据绑定机制；

• 提供了强大的约定大于配置（惯例优先原则）的契约式编程支持。

三、Spring Web MVC作用

• 让我们能非常简单的设计出干净的 Web 层和薄薄的 Web 层；
• 进行更简洁的 Web 层的开发；
• 天生与 Spring 框架集成（如 IoC 容器、AOP 等）；
• 提供强大的约定大于配置的契约式编程支持；
• 能简单的进行 Web 层的单元测试；
• 支持灵活的 URL 到页面控制器的映射；
• 非常容易与其他视图技术集成，如 Velocity、FreeMarker 等等，因为模型数据不放在特定的 API 里，而是放在一个 Model 里（Map 数据结构实现，因此很容易被其他框架使用）；
• 非常灵活的数据验证、格式化和数据绑定机制，能使用任何对象进行数据绑定，不必实现特定框架的 API；
• 提供一套强大的 JSP 标签库，简化 JSP 开发；
• 支持灵活的本地化、主题等解析；
• 更加简单的异常处理；
• 对静态资源的支持；
• 支持 RESTful 风格

---

四、MVC模式

4.1MVC模式组成

如图所示JSP+Servlet+JavaBean的模式就是最典型的MVC模式，在这种模式下，应用程序的每个层级代码各司其职，结构非常清晰。

1. 视图(View)-对应组件：JSP或者HTML文件
2. 控制器(Controller)-对应组件：Servlet
3. 模型(Model)-对应组件：JavaBean(数据访问层+业务逻辑层)

1. 视图：负责格式化数据并将之呈现给用户，包括数据展示、数据验证、界面设计等功能。
2. 控制器：负责接收并转发请求，对请求进行处理后指派视图将响应的结果发送给客户端。
3. 模型：模型对象拥有很多的处理任务，是应用程序的主体部分，它负责业务逻辑的处理和实现对数据库的访问操作，也就是我们常说的JavaBean（包括 service、dao、pojo）.

4.2MVC结构流程图

JSP Model1

如图所示，阐述了MVC模式的三部分（模型、视图、控制器）的主要功能，并对各部分之间的调用关系进行了描述。

4.3JSP+Servlet+JavaBean

JSP Model2

图中，控制器由Servlet担任，接收前端请求并调用JavaBean,相当于一个工作调度人员。

JavaBean实现了模型的功能，处理业务并操作访问数据库。视图由JSP实现，负责将处理的结果响应到浏览器呈现给用户。

1. Servlet ：接受前端请求并调用 JavaBean

2. JavaBean ：处理业务并操作数据库

3. JSP ：将处理结果响应到浏览器呈现给用户

4.4MVC模式的优缺点

MVC优点

1. MVC三个模块相互独立，松耦合架构
2. 多视图共享一个模型，大大提高代码的可重用性
3. 控制器提高了应用程序的灵活性和可配置性
4. 有利于软件工程化管理

MVC缺点

1. 增加了系统结构和实现的复杂性，不适合小型规模的项目
2. 视图层与模型之间需要控制器做中间的连接控制，所以效率较低

---

五、Spring MVC

5.1Spring MVC控制器

• 如图所示 Spring MVC框架用Controller替换JSP Model2模型中的Servlet
• Controller收到请求后，完成业务处理并用Model模型对象存储处理结果
• Controller调用相应的视图解析器View对处理结果进行视图渲染，最终客户端得到响应信息

5.2第一个Spring MVC程序

搭建步骤:

创建Web项目

1. 在父级项目的maven配置文件pom.xml中添加如下依赖包

<dependencies>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.13.2version>
        <scope>testscope>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-webmvcartifactId>
        <version>5.3.19version>
    dependency>
    <dependency>
        <groupId>javax.servletgroupId>
        <artifactId>javax.servlet-apiartifactId>
        <version>3.1.0version>
    dependency>
dependencies>

• 子项目pom.xml引用父级：

<parent>
	<artifactId>T133-Spring-MVCartifactId>
	<groupId>com.aidengroupId>
	<version>1.0-SNAPSHOTversion>
parent>

2. 创建HelloController类，实现Controller接口，并重写handleRequest方法

package com.aiden.controller;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;
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 httpServletRequest, 	HttpServletResponse httpServletResponse) throws Exception {
  		ModelAndView model=new ModelAndView();
  		model.addObject("msg","Study Spring MVC");//存储值
  		model.setViewName("hello");
  		return model;
	}
}

3. 添加application-context.xml配置文件，并添加如下配置：
   • 在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

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

<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter">bean>
 
<bean name="/hello" class="com.aiden.controller.HelloController"/>
 

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <property name="prefix" value="/WEB-INF/jsp/">property>
  <property name="suffix" value=".jsp">property>
bean>
beans>

4. 修改WEB-INF目录下web.xml文件，配置MVC分发器。

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0" >


<display-name>Archetype Created Web Applicationdisplay-name>


<servlet>
  <servlet-name>DispatcherServletservlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
  <init-param>
      <param-name>contextConfigLocationparam-name>
      <param-value>classpath:application-context.xmlparam-value>
  init-param>
  <load-on-startup>1load-on-startup>
servlet>
<servlet-mapping>
  <servlet-name>DispatcherServletservlet-name>
  <url-pattern>/url-pattern>
servlet-mapping>
web-app>

5. 项目结构图：

6. 在WEB-INF目录下的jsp文件中的hello.jsp添加如下代码：

<%--
User: Aiden
Date: 2021-12-16
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>





	
Hello ${msg}

7. 运行测试

---

5.3为什么要使用注解开发

问题：

• 如果有多个请求时，springmvc-servlet.xml中需要配置多个映射关系，并建立多个Controller来进行请求处理，实现繁琐，如何解决？

<bean name="/user" class="cn.cvs.controller.UserController"/>
<bean name="/supplier" class="cn.cvs.controller.SupplierController" />
……

分析：

• Spring提供了多种处理器映射的支持
  • org.springframework.web.servlet.handler.SimpleUrlHandlerMapping
  • org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping
  • …

解决方案

• 使用Spring MVC提供的一键式配置方法：，通过注解的方式进行开发

5.4使用注解开发Spring MVC

5.4.0基于注解开发的核心配置与所使用的注解

基于注解的处理器

<mvc:annotation-driven />

一键式配置，通过注解的方式进行Spring MVC开发

<context:component-scan base-package="com.aiden.controller"/>

• @Controller ：将该类注入到Spring容器并将其定义为一个控制器

• @RequestMapping ：通过请求URL进行映射

---

5.4.1Spring核心配置文件

<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
    https://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc
    https://www.springframework.org/schema/mvc/spring-mvc.xsd">
 
 
 <context:component-scan base-package="com.aiden.controller">context:component-scan>
 
 <mvc:default-servlet-handler>mvc:default-servlet-handler>
 
 <mvc:annotation-driven>mvc:annotation-driven>
 
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
     <property name="prefix" value="/WEB-INF/jsp/">property>
     <property name="suffix" value=".jsp">property>
 bean>
 
beans>

5.4.2控制器 HelloController

package com.aiden.controller;

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

/**
 * 第一个Spring MVC控制器
 */
@Controller
@RequestMapping("/hello")
public class HelloController {

 /**
   * 重写父类方法
   * @return
   * @throws Exception
   */
 @RequestMapping("/hello")
 public String hello() throws Exception {
     System.out.println("Spring MVC框架搭建成功。");
     //跳转到hello页面
     return "hello";
 }
}

5.4.3视图(View) hello.jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


 


我的第一个SpringMVC程序,运行成功啦！

真实访问路径：localhost:8080/项目名/控制器名/动作方法名/

http://localhost:8080/mvc02/hello/hello

5.4.4在浏览器中测试运行

---

六、 Spring MVC注解实现小结

6.1Spring MVC注解实现过程与步骤

1、新建一个web maven项目

2、pom.xml中引入所需要的的依赖jar包

3、编写WEB_INF目录下的web.xml , 注册前端控制器DispatcherServlet

4、编写SpringMVC核心配置文件 springmvc-servlet.xml

5、创建控制器controller包——>创建对应的控制类XxxController

6、在控制器类上添加@Controller注解和@RequestMapping("/hello")注解

7、编写控制器中用于处理请求的动作方法

8、在动作方法上添加@RequestMapping("/hello")

9、最后完善前端视图和Controller之间的对应

10、测试运行调试:http://localhost:8080/mvc02/hello/hello

---

七、Spring MVC请求处理流程

7.1Spring MVC请求处理流程

八、Spring MVC体系结构

8.1Spring MVC体系结构3-1

8.2Spring MVC体系结构3-2

DispatcherServlet(前端控制器)

• Spring MVC最核心的类
• web.xml中配置

Handler(处理器)

• 对应MVC中的C (Controller层)
• 作用：实际处理请求
• 标注了@RequestMapping的所有方法都可以看做是一个Handler

ModelAndView

• 模型对象信息
• 逻辑视图名

8.3Spring MVC体系结构3-3

HandlerMapping(处理器映射器)

• BeanNameUrlHandlerMapping(默认)
  • 将请求URL映射到同名的控制器Bean上
• DefaultAnnotationHandlerMapping / RequestMappingHandlerMapping
  • 将请求映射到标注@RequestMapping注解的控制器和处理方法上

HandlerAdapter(适配器)

• AnnotationMethodHandlerAdapter
  • RequestMappingHandlerAdapter

ViewResolver(视图解析器)

• InternalResourceViewResolver

---

九、 Spring MVC框架特点

9.1Spring MVC框架特点

1. 角色划分清晰
2. 配置功能灵活
3. 大量的控制器接口和实现类
4. 可灵活选择View层实现技术
5. 支持国际化
6. 面向接口编程
7. 功能丰富

---

十、@RequestMapping注解

10.1@RequestMapping注解

• 不仅可以作用于控制器的方法上，还可以标注到控制器类上
• 映射规则
  • 通过请求URL进行映射
  • 通过请求方法进行映射
  • GET
  • POST

@RequestMapping(value="/view", method=RequestMethod.GET)

• @GetMapping:用于处理Get请求
• @PostMapping：用于处理Post请求

注意：@RequestMapping 映射的请求信息必须保证全局唯一

package cn.cvs.controller;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
 * 第一个Spring MVC控制器
 */
@Controller
@RequestMapping(value = "/hello")
public class HelloController {

    Logger logoer = Logger.getLogger(HelloController.class);

    @RequestMapping(value = "/hello")
    public String hello() throws Exception {
        logoer.info("我的第一个SpringMVC程序，运行成功啦！");
        return "hello";// 跳转到hello页面
    }

    @RequestMapping(value = "/hello2")
    public String hello2() throws Exception {
        logoer.info("hello控制器下的另一个接口！");
        return "hello";
    }
}

package cn.cvs.controller;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
 * 供货商模块
 */
@Controller
@RequestMapping(value = "/supplier")
public class SupplierController {
    	private Logger log = Logger.getLogger(SupplierController.class);
    	// 查询供货商
    	@RequestMapping(value = "/view")
    	public String view() {
        	log.info("查询供货商详情");
        	return null;
    	}
}

package cn.cvs.controller;

import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import javax.servlet.http.HttpServletRequest;

/**
 * 用户模块
 */
@Controller
@RequestMapping(value = "/user")
public class UserController {

    private Logger log = Logger.getLogger(UserController.class);
    /**
     * 查询用户详情
     */
   @RequestMapping(value = "/view")
    public String view() {
        log.info("查询用户详情");
        return null;
    }
    /**
     * 查询用户详情
     */
    //@RequestMapping(value = "/view", method = RequestMethod.GET)
    //@GetMapping(value = "/view")
    @GetMapping("/view")
    public String view() {
        log.info("查询用户详情");
        return null;
    }
    /**
     * 保存用户信息
     */
    // @RequestMapping(value = "/save", method = RequestMethod.POST)
    @PostMapping("save")
    public String save() {
        log.info("保存用户信息");
        return null;
    }
}

---

十一、入参/出参处理

11.1入参处理

• @RequestParam
  • name：参数名称
  • value：参数值
  • required：是否必须的参数
  • defaultValue：默认值

@RequestMapping("/hello2")
public String hello2(@RequestParam(value="userName",required=false) String realName) throws Exception {
	//……代码省略
}

package cn.cvs.controller;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * 第一个Spring MVC控制器
*/
 @Controller
@RequestMapping(value = "/hello")
public class HelloController {

 	Logger logoer = Logger.getLogger(HelloController.class);
   
 	@RequestMapping("/hello")
   	public String hello(@RequestParam String realName) throws Exception {
       //public String hello(@RequestParam(required = false) String realName) throws Exception {
     		logoer.info("你好【" + realName +"】欢迎来到Spring MVC课堂。");
        // 跳转到hello页面
        	return "hello";
    }
   
 @RequestMapping("/hello2")
    public String hello2(
            @RequestParam(value = "userName") String realName) throws Exception {
        logoer.info("你好【" + realName +"】欢迎来到Spring MVC课堂。");
        // 跳转到hello页面
        return "hello";
    }
   }

---

11.2出参处理 问题分析

问题：

• 如何将模型数据传递给视图？

分析：

• Spring MVC提供了多种方式输出模型数据
  • 使用ModelAndView对象
  • 使用Model对象
  • 使用Map对象

11.3出参处理 ModelAndView

ModelAndView

• 包含模型数据信息和视图信息

常用方法：

1. 添加模型数据

ModelAndView addObject(String attributeName,Object attributeValue);
ModelAndView addAllObjects(Map<String,?> modelMap);

2. 设置视图

void setView(View view);
void setViewName(String viewName);

---

package cn.cvs.controller;
import cn.cvs.pojo.SysUser;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

import java.util.Map;


/**
 * 第一个Spring MVC控制器
*/
@Controller
@RequestMapping(value = "/hello")
public class HelloController {

Logger logoer = Logger.getLogger(HelloController.class);

/**
     * 使用ModelAndView传递数据
     * @param realName
     * @return
     * @throws Exception
*/
@RequestMapping("/hello")
public ModelAndView hello(@RequestParam String realName) throws Exception {
  logoer.info("你好【" + realName +"】欢迎来到Spring MVC课堂。");
  ModelAndView modelAndView = new ModelAndView();
  modelAndView.addObject("realName", realName);
  modelAndView.setViewName("hello");
  return modelAndView;
}

/**
     * 使用Model传递数据
     * @param model
     * @param realName
     * @return
     * @throws Exception
*/
@RequestMapping("/hello2")
public String hello2(Model model
      , @RequestParam String realName) throws Exception {
  logoer.info("你好【" + realName +"】欢迎来到Spring MVC课堂。");
  model.addAttribute("realName", realName);
  model.addAttribute(realName);
  SysUser sysUser = new SysUser();
  sysUser.setRealName(realName);
  model.addAttribute("currentUser", sysUser);
  model.addAttribute(sysUser);
  return "hello";
}

/**
     * 使用Model传递JavaBean
     * @param map
     * @param realName
     * @return
     * @throws Exception
*/
@RequestMapping("/hello3")
public String hello3(Map<String, Object> map
      , @RequestParam String realName) throws Exception {
  logoer.info("你好【" + realName +"】欢迎来到Spring MVC课堂。");
  map.put("realName", realName);
  return "hello";
}
}

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>



	
	


	
我的第一个SpringMVC程序，运行成功啦！
	
realName(key:realName) --> ${realName}
	
realName(key:string) --> ${string}
	
realName(key:currentUser) --> ${currentUser.realName}
	
realName(key:sysUser) --> ${sysUser.realName}

11.4出参处理 Mode

• Model
  1. 处理方法的入参为Model类型
  2. 数据结构：Map类型
  3. 常用方法：添加模型数据

Model.addAttribute(String attributeName, Object attributeValue);

• 注意： 在Model中增加模型数据，若不指定key，则默认使用对象的类型作为key

package cn.cvs.controller;
import cn.cvs.pojo.SysUser;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

import java.util.Map;


/**
 * 第一个Spring MVC控制器
 */
@Controller
@RequestMapping(value = "/hello")
public class HelloController {

    Logger logoer = Logger.getLogger(HelloController.class);

    /**
     * 使用ModelAndView传递数据
     * @param realName
     * @return
     * @throws Exception
     */
    @RequestMapping("/hello")
    public ModelAndView hello(@RequestParam String realName) throws Exception {
        logoer.info("你好【" + realName +"】欢迎来到Spring MVC课堂。");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("realName", realName);
        modelAndView.setViewName("hello");
        return modelAndView;
    }

    /**
     * 使用Model传递数据
     * @param model
     * @param realName
     * @return
     * @throws Exception
     */
    @RequestMapping("/hello2")
    public String hello2(Model model
            , @RequestParam String realName) throws Exception {
        logoer.info("你好【" + realName +"】欢迎来到Spring MVC课堂。");
        model.addAttribute("realName", realName);
        model.addAttribute(realName);
        SysUser sysUser = new SysUser();
        sysUser.setRealName(realName);
        model.addAttribute("currentUser", sysUser);
        model.addAttribute(sysUser);
        return "hello";
    }

    /**
     * 使用Model传递JavaBean
     * @param map
     * @param realName
     * @return
     * @throws Exception
     */
    @RequestMapping("/hello3")
    public String hello3(Map<String, Object> map
            , @RequestParam String realName) throws Exception {
        logoer.info("你好【" + realName +"】欢迎来到Spring MVC课堂。");
        map.put("realName", realName);
        return "hello";
    }
}

11.5出参处理 Map

• Map
  • 使用方法和Model一样
• 作为Spring MVC的标准用法，推荐使用Model

package cn.cvs.controller;
import cn.cvs.pojo.SysUser;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

import java.util.Map;


/**
 * 第一个Spring MVC控制器
*/
 @Controller
@RequestMapping(value = "/hello")
public class HelloController {

 Logger logoer = Logger.getLogger(HelloController.class);
   
 /**
     * 使用ModelAndView传递数据
     * @param realName
     * @return
     * @throws Exception
  */
    @RequestMapping("/hello")
    public ModelAndView hello(@RequestParam String realName) throws Exception {
        logoer.info("你好【" + realName +"】欢迎来到Spring MVC课堂。");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("realName", realName);
        modelAndView.setViewName("hello");
        return modelAndView;
    }
   
 /**
     * 使用Model传递数据
     * @param model
     * @param realName
     * @return
     * @throws Exception
  */
    @RequestMapping("/hello2")
    public String hello2(Model model
            , @RequestParam String realName) throws Exception {
        logoer.info("你好【" + realName +"】欢迎来到Spring MVC课堂。");
        model.addAttribute("realName", realName);
        model.addAttribute(realName);
        SysUser sysUser = new SysUser();
        sysUser.setRealName(realName);
        model.addAttribute("currentUser", sysUser);
        model.addAttribute(sysUser);
        return "hello";
    }
   
 /**
     * 使用Model传递JavaBean
     * @param map
     * @param realName
     * @return
     * @throws Exception
  */
    @RequestMapping("/hello3")
    public String hello3(Map<String, Object> map
            , @RequestParam String realName) throws Exception {
        logoer.info("你好【" + realName +"】欢迎来到Spring MVC课堂。");
        map.put("realName", realName);
        return "hello";
    }
   }

---

十二、视图解析器

12.1视图解析器 ViewResolver

ViewResolver

• Spring MVC 框架在完成请求处理工作后会返回一个ModelAndView对象，其中包含视图逻辑名和数据模型。对于那些返回值是String或其他类型的接口，Spring MVC 框架也会在内部将他们装配成一个ModelAndView对象，这需要借助视图解析器（ViewResolver）实现。

• ViewResolver 是SpringMVC框架处理视图的重要接口，通过它可以将控制器返回的逻辑视图名解析成一个真正的试图对象。真正的视图对象可以多种多样，常见的如 JSP视图、FreeMarker、Velocity等模板技术的试视图，还有 JSON、 XML、 PDF 等各种数据格式的视图。

• Spring MVC框架默认提供了多种视图解析器，所有的视图解析器都实现了ViewResolver接口如下图所示

• 将逻辑视图名与JSP等视图技术进行匹配

• InternalResourceViewResolver 最常用的视图解析器 通常用于处理JSP和JSTL 等视图。
• 它会把返回的视图名称解析为InternalResourceView对象，该对象会把控制器接口返回的模型属性都放在对应的请求作用域中,然后通过RequestDispatcher 在服务器端把请求转发到目标URL。
• 在springmv.-servlet.xml中的配置代码如下。

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<property name="prefix" value="/WEB-INF/jsp/" />
	<property name="suffix" value=".jsp" />
bean>

• 下图中以跳转登录页面接口为例，控制器中该接口返回的字符串为 “login”, InternalResourceViewResolver 视图解析器会按配置文件中定义好的后缀，对返回的逻辑视图名进行拼接，最终形成 “/WEB-INF/jsp/login.jsp” 的形式

---

十三、本章总结

13.1总结思维图

---

十四、常见错误

14.1常见问题1

【IDEA】创建maven项目，webapp没有被标识，无法识别

问题描述

• 新建maven项目模块后，webapp目录未被标识，也就是没有小蓝点的图标显示。

解决方法

• 点击“File”下的“Project Strucure”，在弹出的框中，选中“Modules”下的项目名称，点击“+”号，在弹出框中选择“Web”。

• 修改“Name”为“webapp”，接下来配置web的路径，上方的路径选择到“web.xml”为止，下方的路径选择到“webapp”为止，最后保存就可以了。

14.2常见问题2

1. 在jsp页面添加 isELIgnored="false"，EL是关闭的，必须手动打开

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"  isELIgnored="false"%>

2. 更改web.xml文件（推荐使用）

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0" >
   
   <display-name>Archetype Created Web Applicationdisplay-name>
   
   web-app>