SpringMVC基础

SpringMVC基础

一，入门案例

1，Springmvc概述

• 和用户交互的组件（获取用户传递参数，响应数据给用户）

• 三层架构

  • 表现层：负责数据展示
  • 业务层：负责业务处理
  • 数据层：负责数据操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bJ5jalFW-1595503482967)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595122243122.png)]

• MVC（Model View Controller）：一种用于设计创建web应用程序表现层的模式
  • Model（模型）：数据模型，用于封装数据
  • View（视图）：页面视图，用于展示数据
  • Controller（控制器）：用于处理用户交互的调度器，用于根据用户需求处理程序逻辑

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Eb13tYNw-1595503482971)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595122521782.png)]

• SpringMVC是一种基于java实现MVC模型的轻量级web框架

2，入门案例的制作

• 入门案例工作流程分析

  • 服务器启动
    1. 服务器启动时会首先加载web.xml中的DispatcherServlet（Springmvc的核心控制器（总控，分发器））
    2. 读取spring-mvc.xml中的配置，加载所有Springmvc中的com.itheima包中所有标记为bean的类
    3. 读取bean中方法上方标注@RequestMapping的内容
  • 处理请求
    1. 当页面发请求时会被DispatcherServlet配置拦截所有请求 /
    2. 使用请求路径与所有加载的@RequestMapping的内容进行比对
    3. 执行对应的方法
    4. 根据方法的返回值在Webapp目录中查找对应的页面并展示

• 代码演示（工程师webapp）

• 导入坐标

• 
    <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>
  
    <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>
      <!--spring的坐标-->
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.9.RELEASE</version>
      </dependency>
      <!--spring web的坐标-->
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>5.1.9.RELEASE</version>
      </dependency>
      <!--springmvc的坐标-->
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.9.RELEASE</version>
      </dependency>
    
    </dependencies>
    
    <!--构建-->
    <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>
  

• 中央控制器的配置（在web.xml中），用于将请求转发到对应的具体业务处理器Controller中

• <?xml version="1.0" encoding="UTF-8"?>
  <web-app xmlns="http://java.sun.com/xml/ns/javaee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
  		  http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
           version="3.0">
      
      <!--解决中文乱码问题-->
      <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>
      
  
      <servlet><!--DispatcherServlet是springmvc的核心控制器(分发器)-->
          <servlet-name>DispatcherServlet</servlet-name>
          <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
          <init-param><!--初始化加载springmvc.xml，加载所有springmvc的bean-->
              <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>
  
  

• 创建springmvc的容器

• <?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: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
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/mvc
         http://www.springframework.org/schema/mvc/spring-mvc.xsd">
  
  
    
      <context:component-scan base-package="com.itheima"/>
  
  
          <!--核心控制器拦截的是所有请求，需要对静态资源请求进行放行，通过配置放行资源实现-->
          <!--<mvc:resources mapping="/img/**" location="/img/"/>-->
          <!--<mvc:resources mapping="/js/**" location="/img/"/>-->
          <!--<mvc:resources mapping="/css/**" location="/img/"/>-->
  
          <!--使用简化格式可以放行所有普通资源调用，不用像上面一一枚举-->
          <mvc:default-servlet-handler/>
          <mvc:annotation-driven/><!--记得加上这个注解驱动，才可以扫描除了放行静态资源的同时，接收到之外的请求-->
  
  </beans>
  

• 编写Controller（Servlet）

• package com.itheima.controller;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.RequestMapping;
  
  @Controller
  public class UserController {
      //设定当前方法的访问映射地址
      @RequestMapping("/save")
      //设置当前方法返回值类型为String，用于指定请求完成后跳转的页面
      public String save(String name){
          System.out.println("user mvc controller is running..."+name);
          //设置跳转的页面
          return "success.jsp";
      }
  
  }
  
  

3,SpringMVC技术架构图

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zlR0l7RR-1595503482973)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595130324387.png)]

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

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

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

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

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

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

• ⚫ SpringMVC 技术架构图

  ⚫ SpringMVC 六大核心组件

  ◆ DispatcherServlet

  ◆ HandlerMapping

  ◆ Handler

  ◆ HandlAdapter

  ◆ View Resolver

  ◆ View

• 404问题

  • 路径写错了
  • 没有加Controller注解
  • 没有扫描包（Spring-mvc.xml）
  • 没有加载配置文件（web.xml）

• 400问题

  • 请求的参数有问题

二，基本配置

1，常规配置（Controller加载控制，静态资源加载控制，中文乱码处理）

• Controller加载控制

  • Springmvc的处理器对应的bean必须按照规范格式开发，避免加入无效的bean，表现层bean标注通常设定为@Controller

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

    //上面的xml配置也可以用这样的注解来实现(一样的效果)
    @ComponentScan(
    value="com.itheima",
    excludeFilters = 
    	@ComponentScan.Filter(
    		type= FilterType.ANNOTATION,
    		classes=Controller.class) 
    )
    

• 静态资源的加载

  • 核心控制器拦截的是所有请求，需要对静态资源请求进行放行，通过配置放行资源实现(简化模式放行所有普通资源，不需要一一枚举)，

  • 这里最重要的是加上注解驱动支持

  • <mvc:default-servlet-handler />
      <mvc:annotation-driven/>
    

• 中文乱码处理

  • springmvc提供专用的中文字符过滤器，用于处理乱码问题（写在web.xml中）

    <filter> 
        <filter-name>characterEncodingFilter</filter-name> 
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param> 
            <param-name>encoding</param-name> <param-value>UTF-8</param-value>
    	</init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    

  • tomcat插件uri编码配置

  •  <!--构建-->
        <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>
    

2，注解驱动

• 纯注解模式：使用竹节形式转化springnvc核心配置文件为配置类

• 核心控制器类（代替Springmvc.xml）

• package com.itheima.config;
  import org.springframework.context.annotation.ComponentScan;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.context.annotation.FilterType;
  import org.springframework.stereotype.Controller;
  import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
  import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
  import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  //用这个配置类替换调spring-mvc.xml
  @Configuration
  @ComponentScan(value = "com.itheima",includeFilters =
       @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
  
  )
  public class SpringMVCConfiguration implements WebMvcConfigurer {
  //    @Override
  //    public void addResourceHandlers(ResourceHandlerRegistry registry) {
  //        registry.addResourceHandler("/img/**").addResourceLocations("/img/");
  //        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
  //        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
  //    }
  
      @Override
      public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
          configurer.enable();
      }
  }
  
  

• 替换web.xml

• package com.itheima.config;
  
  import org.springframework.web.context.WebApplicationContext;
  import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
  import org.springframework.web.filter.CharacterEncodingFilter;
  import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;
  
  import javax.servlet.DispatcherType;
  import javax.servlet.FilterRegistration;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletException;
  import java.util.EnumSet;
  
  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;
      }
  
      @Override
      public void onStartup(ServletContext servletContext) throws ServletException {
          super.onStartup(servletContext);
          CharacterEncodingFilter cef=new CharacterEncodingFilter();
          cef.setEncoding("UTF-8");
          FilterRegistration.Dynamic registration = servletContext.addFilter("characterEncodingFilter", cef);
          registration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST,DispatcherType.FORWARD,DispatcherType.INCLUDE),false,"/*");
  
      }
  }
  
  

• 最后删了web.xml和springmvc.xml就行了，其他和入门案例一样。只是把配置文件替换调为注解而已

三，请求

1，普通类型参数传参

• Springnvc将传递的参数封装到处理器方法的形参中，达到快速访问参数的目的

• 地址栏放问写的参数名要与方法形参名保持一致

• UserController控制器

• @Controller
  public class UserController {
      //方法传递普通类型参数，数量任意，类型必须匹配
      //地址栏访问携带的参数名要和处理器方法的形参名保持一致
      //http://localhost/requestParam1?name=itheima
      //http://localhost/requestParam1?name=itheima&age=14
      @RequestMapping("/requestParam1")
      public String requestParam1(String name,int age){
          System.out.println(name+","+age);
          return "page.jsp";
      }
  
      //方法传递普通类型参数，使用@RequestParam参数匹配URL传参中的参数名称与方法形参名称，绑定请求携带参数与对应处理方法形参间的关系
      //http://localhost/requestParam2?userName=Jock
      @RequestMapping("/requestParam2")
      public String requestParam2(@RequestParam(value = "userName",required = true) String name){
          System.out.println(name);
          return "page.jsp";
      }
  }
  

2，POJO类型(实体类对象eg：user)参数传参

• 当pojo中使用简单类型属性时，参数名称与pojo类属性名保持一致。

•  //方法传递POJO类型参数，URL地址中的参数作为POJO的属性直接传入对象
      //http://localhost/requestParam3?name=Jock&age=39
      @RequestMapping("/requestParam3")
      public String requestParam3(User user){
          System.out.println(user);
          return "page.jsp";
      }
    
      //当方法参数中具有POJO类型参数与普通类型参数嘶，URL地址传入的参数不仅给POJO对象属性赋值，也给方法的普通类型参数赋值，也就是会被同时赋值，建议使用@Request Param注解进行区分
      //http://localhost/requestParam4?name=Jock&age=39
      @RequestMapping("/requestParam4")
      public String requestParam4(User user,int age){
          System.out.println("user="+user+",age="+age);
          return "page.jsp";
      }
  

• 复杂pojo类型参数

• 当pojo中出现对象属性时，参数名称与对象层次结构名称保持一致

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ptpebSFU-1595503482975)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595247001465.png)]

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BrefzVFz-1595503482978)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595247041140.png)]

• 控制器中接着写

• //使用对象属性名.属性名的对象层次结构可以为POJO中的POJO类型参数属性赋值
      //http://localhost/requestParam5?address.city=beijing
      @RequestMapping("/requestParam5")
      public String requestParam5(User user){
          System.out.println(user.getAddress().getCity());
          return "page.jsp";
      }
  
      //通过URL地址中同名参数，可以为POJO中的集合属性进行赋值，集合属性要求保存简单数据
      //http://localhost/requestParam6?nick=Jock1&nick=Jockme&nick=zahc
      @RequestMapping("/requestParam6")
      public String requestParam6(User user){
          System.out.println(user);
          return "page.jsp";
      }
  

• 当pojo中出现List属性时，保存对象数据，参数名称要与对象层次节后名称保持一致，使用数组格式描述集合中对象的位置

• 当pojo中出现Map，保存对象数据，参数名称要和对象层次结构名称保持一致，使用映射格式描述集合中对象的位置

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eWyZF9p4-1595503482980)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595247307379.png)]

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BaNU4TTe-1595503482981)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595247424412.png)]

• 上面控制器中接着写

•  //POJO中List对象保存POJO的对象属性赋值，使用[数字]的格式指定为集合中第几个对象的属性赋值
      //http://localhost/requestParam7?addresses[0].city=beijing&addresses[1].province=hebei
      @RequestMapping("/requestParam7")
      public String requestParam7(User user){
          System.out.println(user.getAddresses());
          return "page.jsp";
      }
      //POJO中Map对象保存POJO的对象属性赋值，使用[key]的格式指定为Map中的对象属性赋值
      //http://localhost/requestParam8?addressMap['job'].city=beijing&addressMap['home'].province=henan
      @RequestMapping("/requestParam8")
      public String requestParam8(User user){
          System.out.println(user.getAddressMap());
          return "page.jsp";
      }
  

3，数组与集合类型参数传参

• 数组类型参数：请求携带参数名要与处理器方法形参名保持一致，且请求参数数量要大于一个。

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2vzv5gwi-1595503482982)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595257867022.png)]

• 集合类型参数：保存简单类型数据，请求参数名与处理器方法形参名保持一致，且请求参数数量大于一个。

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X8koCfV9-1595503482982)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595258085612.png)]

•   //方法传递普通类型的数组参数，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";
      }
    
      //方法传递保存普通类型的List集合时，无法直接为其赋值，需要使用@RequestParam参数对参数名称进行转换
      //http://localhost/requestParam10?nick=Jockme&nick=zahc
      @RequestMapping("/requestParam10")
      public String requestParam10(@RequestParam("nick") List<String> nick){
          System.out.println(nick);
          return "page.jsp";
      }
  

4，类型转换器

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

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x4qjeOwH-1595503482985)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595258315006.png)]

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-05RzwOLG-1595503482986)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595258341759.png)]

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

• eg：日期自动转换

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HMo6mmjx-1595503482988)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595258588258.png)]

• 日期类型格式转换（简化版）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MnFLdoCp-1595503482989)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595258739097.png)]

• 就是说这个简化版，还要额外开启一个注解驱动支持

5，自定义类型转换器

• 自定义类型转换器，实现Converter接口，并且制定转换前转换后的类型

• package com.itheima.converter;
  
  import org.springframework.core.convert.converter.Converter;
  
  import java.text.DateFormat;
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.Date;
  //自定义类型转换器，实现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;
      }
  }
  
  

• 然后配置文件中开启自定义Converter

• <?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"/>
      
      <mvc:annotation-driven conversion-service="conversionService"/>
      <!--自定义类型转换器-->
      <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
          <!--覆盖类型转换器定义规则，该规则是一个set集合，对类型转换器来说是追加和替换的思想，而不是覆盖整体格式化转换器-->
          <property name="converters">
              <set>
                  <!--添加自定义的类型转换器，会根据定义的格式覆盖系统中默认的格式-->
                  <!--当前案例中是将String转换成Date的类型转换器进行了自定义，所以添加后，系统中原始自带的String——>Date的类型转换器失效-->
                  <bean class="com.itheima.converter.MyDateConverter"/>
              </set>
          </property>
      </bean>
   </beans>   
  

6，请求映射

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dMQ1tL4m-1595503482990)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595289665293.png)]

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wVaEP63i-1595503482992)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595289694266.png)]

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oVZ8v6Rj-1595503482995)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595289722614.png)]

• 上面控制器接着写

• //无类映射地址访问格式
      //http://localhost/requestURL1
      @RequestMapping("/requestURL1")
      public String requestURL1(){
          return "page.jsp";
      }
  
      //带有类映射地址访问格式，需要将类映射地址作为前缀添加在实际映射地址的前面，因为类上方加了@RequestMapping("/user")注解
      //最终返回的页面如果未设定绝对访问路径，将从类映射地址所在目录中查找
      //http://localhost/user/requestURL2     （注意：要配合类上定义的路径使用）
      @RequestMapping("/requestURL2")
      public String requestURL2(){
          return "/page.jsp";
      }
  
      //@RequestMapping参数，一个路径参数，6个访问限定性参数（了解）
      @RequestMapping(value="/requestURL3",params = "name")
      public String requestURL3(){
          return "page.jsp";
      }
  

四，响应

1，页面跳转

2，带数据页面跳转

3，返回json数据

• 代码演示

• 控制器

• package com.itheima.controller;
  
  import com.fasterxml.jackson.core.JsonProcessingException;
  import com.fasterxml.jackson.databind.ObjectMapper;
  import com.itheima.domain.Book;
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.RequestBody;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.ResponseBody;
  
  import javax.servlet.http.HttpServletResponse;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  @Controller
  public class AccountController {
      //使用原生response对象响应数据
      @RequestMapping("/showData1")
      public void showData1(HttpServletResponse response) throws IOException {
          response.getWriter().write("message");
      }
  
      //使用@ResponseBody将返回的结果作为响应内容，而不是让他去找响应的页面名称
      @RequestMapping("/showData2")
      @ResponseBody//将返回的结果作为响应内容
      public String showData2(){
          return "{'name':'Jock'}";
      }
  
      //使用jackson进行json数据格式转化
      @RequestMapping("/showData3")
      @ResponseBody
      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注解驱动，在spring-mvc.xml中写注解驱动，
      // 对标注@ResponseBody注解的控制器方法进行结果转换，由于返回值为引用类型，自动调用jackson提供的类型转换器进行格式转换
      @RequestMapping("/showData4")
      @ResponseBody
      public Book showData4() {
          Book book  = new Book();
          book.setName("SpringMVC入门案例");
          book.setPrice(66.66d);
          return book;
      }
  
      //转换集合类型数据
      @RequestMapping("/showData5")
      @ResponseBody
      public List showData5() {
          Book book1  = new Book();
          book1.setName("SpringMVC入门案例");
          book1.setPrice(66.66d);
  
          Book book2  = new Book();
          book2.setName("SpringMVC入门案例");
          book2.setPrice(66.66d);
  
          ArrayList al = new ArrayList();
          al.add(book1);
          al.add(book2);
          return al;
      }
  
  }
  
  

• 配置文件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"/>
  
      <!--开启springmvc注解驱动，对@ResponseBody的注解进行格式增强，追加其类型转换的功能，具体实现由MappingJackson2HttpMessageConverter进行-->
      <mvc:annotation-driven/>
      <mvc:default-servlet-handler/>
  </beans>
  

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yQYlJtFE-1595503482998)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595423764981.png)]

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4LtINhTf-1595503482999)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595423804235.png)]

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2zZWNkz4-1595503483000)(E:\每日讲课笔记\Spring\springMVCmd笔记\img\1595423845638.png)]

4，Servlet相关接口—Servlet相关接口替换方案

ation=“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"/>

  <!--开启springmvc注解驱动，对@ResponseBody的注解进行格式增强，追加其类型转换的功能，具体实现由MappingJackson2HttpMessageConverter进行-->
  <mvc:annotation-driven/>
  <mvc:default-servlet-handler/>

```

• [外链图片转存中…(img-yQYlJtFE-1595503482998)]

• [外链图片转存中…(img-4LtINhTf-1595503482999)]

• [外链图片转存中…(img-2zZWNkz4-1595503483000)]

4，Servlet相关接口—Servlet相关接口替换方案

• 建议形参中直接写HttpServletrequest，HttpServletresponse，然后直接调用里面的方法就行