知识点梳理

课堂讲义

1 SpringMVC 概述

1.1 三层架构-视频01

• 表现层：负责数据展示

• 业务层：负责业务处理

• 数据层：负责从数据库中获取数据

1.2 MVC 简介

MVC（Model View Controller）：一种用于设计Web应用程序表现层的模式。

• Model（模型）：数据模型，用于封装数据

• View（视图）：页面视图，用于展示数据(jsp, html)

• Controller（控制器）：处理用户交互的调度器，用于根据用户需求处理程序逻辑

  • Servlet

  • SpringMVC

1.3 SpringMVC

SpringMVC是一种基于Java实现MVC模型的轻量级Web框架

优点

• 自动封装参数

  

   

   

• 灵活性强

  

   

   

   

• 性能突出（相比现有的表现层框架：Struts2）

2 入门案例

2.1 入门案例制作-视频02

①导入SpringMVC相关坐标

<dependencies>
  <!-- servlet3.1规范的坐标 -->
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
  </dependency>
  <!--jsp坐标-->
  <dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.1</version>
    <scope>provided</scope>
  </dependency>
​
  <!--springmvc的坐标-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.9.RELEASE</version>
  </dependency>
​
</dependencies>

在pom.xml中添加tomcat7-maven-plugin插件，配置端口80、访问路径/、编码格式UTF-8

<build>
  <!--设置插件-->
  <plugins>
    <!--具体的插件配置-->
    <plugin>
      <groupId>org.apache.tomcat.maven</groupId>
      <artifactId>tomcat7-maven-plugin</artifactId>
      <version>2.1</version>
      <configuration>
        <port>80</port>
        <path>/</path>
        <uriEncoding>UTF-8</uriEncoding>
      </configuration>
    </plugin>
  </plugins>
</build>
<configuration>
    <port>80</port>
    <path>/</path>
    <uriEncoding>UTF-8</uriEncoding>
</configuration>
配置打包方式和编译版本：

<packaging>war</packaging>
​
<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <maven.compiler.source>1.8</maven.compiler.source>
  <maven.compiler.target>1.8</maven.compiler.target>
</properties>
②定义表现层业务处理器Controller，并配置成spring的bean（等同于Servlet）：@Controller

@Controller
public class UserController {
​
    public void save(){
        System.out.println("user mvc controller is running ...");
    }
}
在Spring MVC配置文件src\main\resources\spring-mvc.xml中添加包扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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">
    
    <!--扫描加载所有的控制类-->
    <context:component-scan base-package="com.itheima"/>
​
</beans>
③web.xml中配置SpringMVC核心控制器，用于将请求转发到对应的具体业务处理器Controller中

<?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_3_1.xsd"
         version="3.1">
​
<servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:spring-mvc.xml</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
    
</web-app>

④设定具体Controller中指定方法的访问路径@RequestMapping("/save")

//设定当前方法的访问映射地址
@RequestMapping("/save")
public void save(){
    System.out.println("user mvc controller is running ...");
}

⑤设置返回页面，默认路径：src\main\webapp

JSP页面头信息：设置编码格式

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

//设定当前方法的访问映射地址
@RequestMapping("/save")
//设置当前方法返回值类型为String，用于指定请求完成后跳转的页面
public String save(){
    System.out.println("user mvc controller is running ...");
    //设定具体跳转的页面
    return "success.jsp";
}

2.2 入门案例执行过程(理解)

• 服务器启动

  1. 加载web.xml中DispatcherServlet

  2. 读取spring-mvc.xml中的配置，加载所有com.itheima包中所有标记为bean的类

  3. 读取bean中方法上方标注@RequestMapping的内容

• 处理请求

  1. DispatcherServlet配置拦截所有请求 /

  2. 使用请求路径与所有加载的@RequestMapping的内容进行比对

  3. 执行对应的方法

  4. 根据方法的返回值在webapp目录中查找对应的页面并展示

2.3 SpringMVC 技术架构图(了解)-视频3

六大核心组件

• DispatcherServlet：前端控制器， 是整体流程控制的中心，由其调用其它组件处理用户的请求， 有 效的降低了组件间的耦合性

• HandlerMapping：处理器映射器， 负责根据用户请求找到对应具体的Handler处理器

• Handler：处理器，业务处理的核心类，通常由开发者编写，描述具体的业务

• HandlrAdapter：处理器适配器，通过它对处理器进行执行

• View Resolver：视图解析器， 将处理结果生成View视图

• View：视图，最终产出结果， 常用视图如jsp、html

3 基本配置

3.1 常规配置-视频04

3.1.1 Controller加载控制

SpringMVC的处理器对应的bean必须按照规范格式开发，为避免加入无效的bean可通过bean加载过滤器进行包含设定或排除设定，表现层bean标注通常设定为@Controller

在spring-mvc.xml中添加包扫描过滤配置：

<context:component-scan base-package="com.itheima">
    <context:include-filter
                            type="annotation"
                            expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

3.1.2 静态资源加载

访问webapp目录下的图片：webapp\img\logo.png

1. 在spring-mvc.xml中添加静态资源映射

   <!--放行指定类型静态资源配置方式-->
   <mvc:resources mapping="/img/**" location="/img/"/>
   <mvc:resources mapping="/js/**" location="/js/"/>
   <mvc:resources mapping="/css/**" location="/css/"/>

    

2. 启动tomcat7-maven插件

   

    

    

    

3. 测试图片显示：http://localhost/img/logo.png

简写方式：在spring-mvc中添加如下配置

<!--SpringMVC提供的通用资源放行方式-->
<mvc:default-servlet-handler/>
​
<!--必须组合使用-->
<mvc:annotation-driven/>

3.1.3 字符集过滤器-中文乱码

SpringMVC提供专用的中文字符过滤器: CharacterEncodingFilter，用于处理中文乱码问题

配置在 web.xml 里面

<!--乱码处理过滤器，与Servlet中使用的完全相同，差异之处在于处理器的类由Spring提供-->

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

3.2 注解驱动-视频05

• 使用注解形式转化SpringMVC核心配置文件为配置类 ，实现WebMvcConfigurer接口

  替代resources\spring-mvc.xml

  @Configuration
  @ComponentScan(value = "com.itheima",includeFilters =
      @ComponentScan.Filter(type=FilterType.ANNOTATION,classes = {Controller.class})
      )
  @EnableWebMvc
  public class SpringMVCConfiguration implements WebMvcConfigurer{
  ​
      //注解配置通用放行资源的格式
      @Override
      public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
          configurer.enable();
      }
  }

   

  易错点：添加@EnableWebMvc注解

• 基于servlet3.0规范，自定义Servlet容器初始化配置类，加载SpringMVC核心配置类

  替代webapp\WEB-INF\web.xml

  public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
      //创建Servlet容器时，使用注解的方式加载SPRINGMVC配置类中的信息，并加载成WEB专用的                    //ApplicationContext对象
      //该对象放入了ServletContext范围，后期在整个WEB容器中可以随时获取调用
      @Override
      protected WebApplicationContext createServletApplicationContext() {
          AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
          ctx.register(SpringMVCConfiguration.class);
          return ctx;
      }
  ​
      //注解配置映射地址方式，服务于SpringMVC的核心控制器DispatcherServlet
      @Override
      protected String[] getServletMappings() {
          return new String[]{"/"};
      }
  ​
      @Override
      protected WebApplicationContext createRootApplicationContext() {
          return null;
      }
  ​
      //乱码处理作为过滤器，在servlet容器启动时进行配置，相关内容参看Servlet零配置相关课程
      @Override
      public void onStartup(ServletContext servletContext) throws ServletException {
          //调用父类的onStartup
          super.onStartup(servletContext);
          //1.创建字符集过滤器对象
          CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
          //2.设置使用的字符集
          characterEncodingFilter.setEncoding("UTF-8");
          //3.添加到容器（它不是ioc容器，而是ServletContainer）
          FilterRegistration.Dynamic registration =
                  servletContext.addFilter("characterEncodingFilter",
                          characterEncodingFilter);
          //4.添加映射
          registration.addMappingForUrlPatterns(
                  EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD,
                          DispatcherType.INCLUDE), false, "/*");
      }
  }

   

• 删除spring-mvc.xml、web.xml（不能同时有注解和web.xml两套配置）

• 启动项目测试

4 请求

4.1 普通类型参数传参-视频06

在UserController中添加如下方法：

1.参数名与Controller中的方法参数名保持一致 http://localhost/requestParam1?name=itheima&age=14

@RequestMapping("/requestParam1")
public String requestParam1(String name ,String age){
    System.out.println("name="+name+",age="+age);
    return "page.jsp";
}

2.@RequestParam 的使用  类型：形参注解  位置：方法形参前方  作用：绑定请求参数与对应处理方法形参间的关系

http://localhost/requestParam2?userName=Jock

@RequestMapping("/requestParam2")
public String requestParam2(@RequestParam(
                            name = "userName",
                            required = true,
                            defaultValue = "itheima") String name){
    System.out.println("name="+name);
    return "page.jsp";
}

4.2 POJO类型参数传参-视频07

1.当POJO中使用简单类型属性时， 参数名称与POJO类属性名保持一致，SpringMVC自动封装参数

访问URL： http://localhost/requestParam3?name=itheima&age=14

Controller

@RequestMapping("/requestParam3")
public String requestParam3(User user){
    System.out.println(user);
    return "page.jsp";
}

POJO类：易错点：POJO类中的参数添加set方法

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 +
                '}';
    }
}

SpringMVC自动参数封装原始写法如下：

User user = new User();
user.setName(request.getParameter("name"));
int age = Integer.parseInt(request.getParameter("age"));
user.setAge(age);

2.参数冲突 当POJO类型属性与其他形参出现同名问题时，将被同时赋值 访问URL： http://localhost/requestParam4?name=itheima&age=14&minAge=12

@RequestMapping("/requestParam4")
public String requestParam4(User user,String age){
    System.out.println("user.age="+user.getAge()+",age="+age);
    return "page.jsp";
}

使用@RequestParam注解进行区分

@RequestMapping("/requestParam4")
public String requestParam4(User user, @RequestParam("minAge") int age) {
    System.out.println("user=" + user + ",age=" + age);
    return "page.jsp";
}

3.POJO中的对象属性

当POJO中出现对象属性时，参数名称与对象层次结构名称保持一致 访问URL： http://localhost/requestParam5?address.province=beijing

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

    private Address address;
    
    //生成get，set方法
}
public class Address {
    private String province;
    private String city;
    private String address;
    
    //生成get，set方法
}

@RequestMapping("/requestParam5")
public String requestParam5(User user){
    System.out.println("user.address="+user.getAddress().getProvince());
    return "page.jsp";
}

4.POJO中有简单的集合类型参数时，属性名写多个即可 访问URL：http://localhost/requestParam6?nick=Jock1&nick=Jockme&nick=zahc

private List<String> nick;
//http://localhost/requestParam6?nick=Jock1&nick=Jockme&nick=zahc
@RequestMapping("/requestParam6")
public String requestParam6(User user) {
    System.out.println(user);
    return "page.jsp";
}

5.当POJO中有复杂的集合类型参数时，参数名称与对象层次结构保持一致，使用数组格式描述集合中对象的位置

访问URL：http://localhost/requestParam7?addresses[0].city=beijing&addresses[1].province=hebei

private List<Address> addresses;
//http://localhost/requestParam7?addresses[0].city=beijing&addresses[1].province=hebei
@RequestMapping("/requestParam7")
public String requestParam7(User user){
    System.out.println("user.addresses="+user.getAddresses());
    return "page.jsp";
}

6.当POJO中出现Map时，参数名称与对象层次结构名称保持一致，使用映射格式描述集合中对象的位置

访问URL：http://localhost/requestParam8?addressMap['job'].city=beijing&addressMap['home'].province=henan

private Map<String,Address> addressMap;
@RequestMapping("/requestParam8")
//http://localhost/requestParam8?addressMap['job'].city=beijing&addressMap['home'].province=henan
public String requestParam8(User user){
    System.out.println("user.addressMap="+user.getAddressMap());
    return "page.jsp";
}

4.3 数组与集合类型参数传参-视频08

1.数组类型参数

请求参数名与处理器方法形参名保持一致

访问URL： http://localhost/requestParam9?nick=Jockme&nick=zahc

@RequestMapping("/requestParam9")
public String requestParam9(String[] nick){
    System.out.println(nick[0]+","+nick[1]);
    return "page.jsp";
}

2.集合类型参数

需要使用@RequestParam("name")定义参数名 访问URL： http://localhost/requestParam10?nick=Jockme&nick=zahc

@RequestMapping("/requestParam10")
public String requestParam10(@RequestParam("nick") List<String> nicks) {
    System.out.println(nicks);
    return "page.jsp";
}

注意：

• 使用@RequestParam注解

• url中的参数名和@RequestParam中的保持一致

4.4 类型转换器-视频09

表单中的年龄age：String->int

SpringMVC对接收的数据进行自动类型转换，该工作通过Converter接口实现

• 标量转换器  StringToBooleanConverter String→Boolean  ObjectToStringConverter Object→String  StringToNumberConverterFactory String→Number（ Integer、 Long等）  NumberToNumberConverterFactory Number子类型之间(Integer、 Long、 Double等)  StringToCharacterConverter String→java.lang.Character  NumberToCharacterConverter Number子类型(Integer、 Long、 Double等)→java.lang.Character  CharacterToNumberFactory java.lang.Character→Number子类型(Integer、 Long、 Double等)  StringToEnumConverterFactory String→enum类型  EnumToStringConverter enum类型→String  StringToLocaleConverter String→java.util.Local  PropertiesToStringConverter java.util.Properties→String  StringToPropertiesConverter String→java.util.Properties

• 集合、数组相关转换器  ArrayToCollectionConverter 数组→集合（ List、 Set）  CollectionToArrayConverter 集合（ List、 Set） →数组  ArrayToArrayConverter 数组间  CollectionToCollectionConverter 集合间（ List、 Set）  MapToMapConverter Map间  ArrayToStringConverter 数组→String类型  StringToArrayConverter String→数组， trim后使用“,”split  ArrayToObjectConverter 数组→Object  ObjectToArrayConverter Object→单元素数组  CollectionToStringConverter 集合（ List、 Set） →String  StringToCollectionConverter String→集合（ List、 Set）， trim后使用“,”split  CollectionToObjectConverter 集合→Object  ObjectToCollectionConverter Object→单元素集合

• 默认转换器  ObjectToObjectConverter Object间  IdToEntityConverter Id→Entity  FallbackObjectToStringConverter Object→String

• SpringMVC对接收的数据进行自动类型转换，该工作通过Converter接口实现 http://localhost/requestParam11?date=2020/09/07

  

   

   

   

4.5 日期类型格式转换

• 第一种方式：声明自定义的转换格式并覆盖系统转换格式

  <!--1.设定格式类型Converter，注册为Bean，受SpringMVC管理-->
  <bean id="conversionService"
      class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
      <!--2.自定义Converter格式类型设定，该设定使用的是同类型覆盖的思想-->
      <property name="formatters">
          <!--3.使用set保障相同类型的转换器仅保留一个，避免冲突-->
          <set>
              <!--4.设置具体的格式类型-->
              <bean class="org.springframework.format.datetime.DateFormatter">
                  <!--5.类型规则-->
                  <property name="pattern" value="yyyy-MM-dd"/>
              </bean>
          </set>
      </property>
  </bean>
  
  <!--5.启用自定义Converter-->
  <mvc:annotation-driven conversion-service="conversionService"/>
  //第一种方式：声明自定义的转换格式并覆盖系统转换格式
  //http://localhost/requestParam11?date=2020-09-07
  @RequestMapping("/requestParam11")
  public String requestParam11(Date date){
      System.out.println(date);
      return "page.jsp";
  }

   

  http://localhost/requestParam11?date=2020-09-07

• 第二种方式日期类型格式转换（常用）  名称： @DateTimeFormat  类型： 形参注解、成员变量注解  位置：形参前面 或 成员变量上方  作用：为当前参数或变量指定类型转换规则  范例： http://localhost/requestParam12?date=1999-09-09

  @RequestMapping("/requestParam11")
  public String requestParam11(@DateTimeFormat(pattern = "yyyy-MM-dd") Date date) {
      System.out.println(date);
      return "page.jsp";
  }

   

   

  配置注解驱动支持

  <mvc:annotation-driven />  

   

  如果POJO中有Date类型：http://localhost/requestParam11?name=zhangsan&birthday=1999-09-09

  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date birthday;
  @RequestMapping("/requestParam11")
  public String requestParam13(User user) {
      System.out.println(user);
      return "page.jsp";
  }

   

   

4.6 自定义类型转换器(了解)-视频10

1. 自定义类型转换器，实现Converter接口

   //自定义类型转换器，实现Converter接口，接口中指定的泛型即为最终作用的条件
   //本例中的泛型填写的是String，Date，最终出现字符串转日期时，该类型转换器生效
   public class MyDateConverter implements Converter<String, Date> {
       //重写接口的抽象方法，参数由泛型决定
       public Date convert(String source) {
           DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
           Date date = null;
           //类型转换器无法预计使用过程中出现的异常，因此必须在类型转换器内部捕获，不允许抛出，框架无法预计此类异常如何处理
           try {
               date = df.parse(source);
           } catch (ParseException e) {
               e.printStackTrace();
           }
           return date;
       }
   }

    

2. 指定转换前与转换后的类型，spring-mvc.xml

   <!--1.将自定义Converter注册为Bean，受SpringMVC管理-->
   <bean id="myDateConverter" class="com.itheima.converter.MyDateConverter"/>
   <!--2.设定自定义Converter服务bean-->
   <bean id="conversionService"
         class="org.springframework.context.support.ConversionServiceFactoryBean">
       <!--3.注入所有的自定义Converter，该设定使用的是同类型覆盖的思想-->
       <property name="converters">
           <!--4.set保障同类型转换器仅保留一个，去重规则以Converter<S,T>的泛型为准-->
           <set>
               <!--5.具体的类型转换器-->
               <ref bean="myDateConverter"/>
           </set>
       </property>
   </bean>

    

3. 通过注册自定义转换器，将该功能加入到SpringMVC的转换服务ConverterService中

   <!--开启注解驱动，加载自定义格式化转换器对应的类型转换服务-->
   <mvc:annotation-driven conversion-service="conversionService"/>

    

4. 在Controller中调用： http://localhost/requestParam12?date=1999-09-09

   @RequestMapping("/requestParam12")
   public String requestParam12(Date date){
       System.out.println(date);
       return "page.jsp";
   }

    

    

4.7 请求映射-视频11

4.7.1 方法注解

名称： @RequestMapping  类型： 方法注解  位置：处理器类中的方法定义上方  作用：绑定请求地址与对应处理方法间的关系  范例：  访问路径：http://localhost/requestURL1

@Controller
public class UserController {
    
    @RequestMapping("requestURL1")
    public String requestURL1() {
        return "page.jsp";
    }
}

常用属性（了解）

@RequestMapping(
    value="/requestURL3", //设定请求路径，与path属性、 value属性相同
    method = RequestMethod.GET, //设定请求方式
    params = "name", //设定请求参数条件
    headers = "content-type=text/*", //设定请求消息头条件
    consumes = "text/*", //用于指定可以接收的请求正文类型（MIME类型）
    produces = "text/*" //用于指定可以生成的响应正文类型（MIME类型）
)
public String requestURL3() {
    return "/page.jsp";
}

4.7.2 类注解

名称： @RequestMapping  类型： 类注解  位置：处理器类定义上方  作用：为当前处理器中所有方法设定公共的访问路径前缀  范例：  访问路径： http://localhost/user/requestURL2

@Controller
@RequestMapping("/user")
public class UserController {
    
    //带有类映射地址访问格式，需要将类映射地址作为前缀添加在实际映射地址的前面
    //最终返回的页面如果未设定绝对访问路径，将从类映射地址所在目录中查找
    //http://localhost/user/requestURL2     （注意：要配合类上定义的路径使用）
    @RequestMapping("/requestURL2")
    public String requestURL2() {
        return "page.jsp";
    }
}  

5 响应

5.1 页面跳转-视频12

两种跳转方式：转发和重定向，区别在于：转发forward后地址栏不会变化

• 转发（默认），服务器跳转

@RequestMapping("/showPage1")
public String showPage1() {
    System.out.println("user mvc controller is running ...");
    return "forward:page.jsp";
}

• 重定向，客户端跳转

@RequestMapping("/showPage2")
public String showPage2() {
System.out.println("user mvc controller is running ...");
return "redirect:page.jsp";
}

5.2 页面访问快捷设定

InternalResourceViewResolver：展示页面的保存位置通常固定且结构相似的，可以设定通用的访问路径，简化页面配置格式

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

public String showPage3() {
    return "page";
}

设置之后，默认使用forward，不能再添加forward和redirect

注意：如果未设定了返回值，使用void类型，则默认使用访问路径作页面地址的前缀和后缀

//最简页面配置方式，使用访问路径作为页面名称，省略返回值

@RequestMapping("/showPage5")
public void showPage5() {
    System.out.println("user mvc controller is running ...");
}

5.3 带数据页面跳转-视频13

• 方式一：使用HttpServletRequest类型形参进行数据传递

  http://localhost/showPageAndData1

  @RequestMapping("/showPageAndData1")
  public String showPageAndData1(HttpServletRequest request) {
      request.setAttribute("name","SpringMVC入门案例");
      request.setAttribute("price",66.66d);
      return "page";
  }

   

• 方式二：使用Model类型形参进行数据传递

  http://localhost/showPageAndData2

  @RequestMapping("/showPageAndData2")
  public String showPageAndData2(Model model) {
      model.addAttribute("name","itheima");
      
      Book book = new Book();
      book.setName("SpringMVC入门实战");
      book.setPrice(66.6d);
      
      model.addAttribute("book",book);
      return "page";
  }

   

• 最佳实践方式三：使用ModelAndView类型形参进行数据传递，将该对象作为返回值传递给调用者

  http://localhost/showPageAndData3

  //使用ModelAndView形参传递参数，该对象还封装了页面信息
  @RequestMapping("/showPageAndData3")
  public ModelAndView showPageAndData3(ModelAndView modelAndView) {
      //ModelAndView mav = new ModelAndView();    替换形参中的参数
      Book book  = new Book();
      book.setName("SpringMVC入门案例");
      book.setPrice(66.66d);
      //添加数据的方式，key对value
      modelAndView.addObject("book",book);
      //添加数据的方式，key对value
      modelAndView.addObject("name","Jockme");
      //设置页面的方式，该方法最后一次执行的结果生效
      modelAndView.setViewName("page");
      //返回值设定成ModelAndView对象
      return modelAndView;
  }

   

5.4 返回JSON数据-视频14

添加jackson依赖：

<!--json相关坐标3个-->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-core</artifactId>
  <version>2.9.0</version>
</dependency>

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.0</version>
</dependency>

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>2.9.0</version>
</dependency>

• 方式一：基于response返回数据的简化格式，返回JSON数据

  //使用jackson进行json数据格式转化
  @RequestMapping("/showData3")
  public String showData3() throws JsonProcessingException {
      Book book  = new Book();
      book.setName("SpringMVC入门案例");
      book.setPrice(66.66d);
  
      ObjectMapper om = new ObjectMapper();
      return om.writeValueAsString(book);
  }

   

• 方法二：使用SpringMVC提供的消息类型转换器将对象与集合数据自动转换为JSON数据：

  @ResponseBody

  //使用SpringMVC注解驱动，对标注@ResponseBody注解的控制器方法进行结果转换，由于返回值为引用类型，自动调用jackson提供的类型转换器进行格式转换
  @RequestMapping("/showData4")
  //响应正文
  @ResponseBody
  public Book showData4() {
      Book book  = new Book();
      book.setName("SpringMVC入门案例");
      book.setPrice(66.66d);
      return book;
  }

   

  开启注解驱动

  <!--开启springmvc注解驱动，对@ResponseBody的注解进行格式增强，追加其类型转换的功能，具体实现由MappingJackson2HttpMessageConverter进行-->
  <mvc:annotation-driven/>
  底层使用的转换类：MappingJackson2HttpMessageConverter
  
  <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
            </list>
        </property>
  </bean>
   

   

5.5 返回中文字符串（扩展）

@RequestMapping("/showData6")
@ResponseBody 
public String showData2() {
    //return "{'name':'Jock', age : 10}";
    return "我是中文";
}

在spring-mvc.xml中配置编码格式

<!--开启springmvc注解驱动，对@ResponseBody的注解进行格式增强，
    追加其类型转换的功能，具体实现由MappingJackson2HttpMessageConverter进行-->
<mvc:annotation-driven>
    <mvc:message-converters>
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8" />
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

6 Servlet相关接口(了解)

6.1 Servlet相关接口-视频15

1. HttpServletRequest

2. HttpServletResponse

3. HttpSession

4. Head

5. Cookie

6. Session

HttpServletRequest / HttpServletResponse / HttpSession

• SpringMVC提供访问原始Servlet接口API的功能，通过形参声明即可

  @RequestMapping("/servletApi")
  public String servletApi(HttpServletRequest request, HttpServletResponse response,
                           HttpSession session) {
      System.out.println(request);
      System.out.println(response);
      System.out.println(session);
      request.setAttribute("name","itheima");
      System.out.println(request.getAttribute("name"));
      return "page.jsp";
  }

   

• Head数据获取

   名称： @RequestHeader  类型： 形参注解  位置：处理器类中的方法形参前方  作用：绑定请求头数据与对应处理方法形参间的关系  范例：

  @RequestMapping("/headApi")
  public String headApi(@RequestHeader("Accept-Language") String head){
      System.out.println(head);
      return "page.jsp";
  } 

   

• Cookie数据获取

   名称： @CookieValue  类型： 形参注解  位置：处理器类中的方法形参前方  作用：绑定请求Cookie数据与对应处理方法形参间的关系  范例：

  @RequestMapping("/cookieApi")
  public String cookieApi(@CookieValue("JSESSIONID") String jsessionid){
      System.out.println(jsessionid);
      return "page.jsp";
  } 

   

• Session数据获取

   名称： @SessionAttribute  类型： 形参注解  位置：处理器类中的方法形参前方  作用：绑定请求Session数据与对应处理方法形参间的关系  范例：

  @RequestMapping("/sessionApi")
  public String sessionApi(@SessionAttribute("name") String name){
      System.out.println(name);
      return "page.jsp";
  }  

   

• 通过注解设置Session数据（了解）

   名称： @SessionAttributes  类型： 类注解  位置：处理器类上方  作用：声明放入session范围的变量名称，适用于Model类型数据传参  范例：

  @Controller
  @SessionAttributes(names={"name"})
  public class ServletController {
      @RequestMapping("/setSessionData2")
      public String setSessionDate2(Model model) {
          model.addAttribute("name", "Jock2");
          return "page.jsp";
      }
  }  

   

6.2 注解式参数数据封装实现方法

• 数据的来源不同，对应的处理策略要进行区分

  • Head

  • Cookie

  • Session

• SpringMVC使用策略模式进行处理分发

  • 顶层接口： HandlerMethodArgumentResolver
    顶层接口： HandlerMethodArgumentResolver

  • 

     

     

  • Header实现类：RequestHeaderMapMethodArgumentResolver 

  • 

     

     

  • Cookie实现类：ServletCookieValueMethodArgumentResolver