SpringMVC小结

SpringMVC

• 体现在web层:
  • M:Model,模型层,用于封装数据(给客户端响应数据)
  • V:View,视图层,页面显示的内容(页面显示的技术,jsp,thymeleaf,freemaker)
  • C:Controller,控制层,和客户端交互进行控制(UserController)
• SpringMVC和Struts的对比
  - 共同点:
  - 都是表现层框架,都是基于MVC模型编写的
  - 底层都离不开原始的ServletAPI
  - 处理请求的机制都是一个核心控制器
  - 区别:
  - MVC的入口是Servlet,struts2是Filter
  - MVC是基于方法实际的,Struts2是基于类,每次执行会擦黄建一个动作类,所以MVC会比struts2快些
  - MVC使用更加简洁,还支持JSR303,处理ajax请求更方便
  - struts2的ognl表达式使页面的开发效率相比MVC更高些,执行效率没有比jstl提升,尤其是表单标签,远没有html执行效率高

一. 步骤概述

• 准备工作:

  • 1.创建maven项目,导入依赖: spring-webmvc,servlet-api,jsp-api
  • 2.准备页面

• 编写控制器Controller

  • 在com.user.controller里创建:xxxController
    • 把类声明成bean对象:@Controller
    • 在类里加方法,方法上加注释:@requestMapping(“虚拟访问的路径”)

• 提供配置

  • 提供springmvc.xml:开启组件扫描
  • 修改web.xml:配置前端控制器

• 功能测试

二. 相关配置

• springMVC的三大组件
  - HandlerMapping 处理器映射器
  - 作用:根据客户端请求的资源路劲.查找匹配的Controller及拦截器链
  - HandlerAdapter 处理器适配器
  - 作用:用于适配调用不同的Controller,得到模型和视图
  - ViewResolver 视图解析器
  - 作用:用于解析视图,根据视图路径找到真实视图,也就是页面

• springMVC的详细执行流程

  • 客户端发请求到 DIspatcherServlet
  • DispatcherServlet
    • 通过HandlerMapping处理器映射器,根据请求路径,查找匹配的Controller及拦截器
    • 得到要执行的Controller和拦截器(执行链)
  • DispatcherServlet
    • 通过HandlerAdapter处理器适配器,调用控制器Controller
    • 得到ModelAndView对象(model是要响应的数据对象,view是视图路径)
  • DispatcherServlet
    • 通过ViewResolver解析视图,得到真实视图(视图路径相应的页面)
    • 渲染视图(把model里的数据填充到view里)
  • 把最终渲染的结果,响应到客户端
  • 注: 需要我们去做的事情有:
    • 编写代码:
      • 编写Handler控制器,Controller
      • 编写view视图, 页面
    • 提供配置
      • 提供springmvc.xml配置文件
        • 开启组件扫描:<context:component-scan …/>
        • 其他配置
      • 修改web.xml配置文件
        - 用于配置DispatcherServlet核心控制器,读取spring配置文件
        - 其他配置

• 配置springmvc.xml

- 需要开启组件扫描
- 需要开启mvc的注解驱动：<mvc:annotation-driven/>
- 需要配置视图解析器
      <bean id="viewResolver" class="InternalResourceViewResolver的全限定类名">
      	<property name="prefix" value="路径的前缀"/>
          <property name="suffix" value="路径的后缀"/>
      </bean>
- 需要处理静态资源
      <mvc:default-servlet-handler/>

• 配置web.xml

<!--配置SpringMVC的前端控制器-->
<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--配置springmvc.xml路径-->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!--服务器启动时，就创建DispatcherServlet对象-->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <!--把前端控制器设置为 默认的处理器（覆盖Tomcat的默认处理器）-->
    <url-pattern>/</url-pattern>
</servlet-mapping>

• 配置Controller

@Controller//必须声明成bean对象
@RequestMapping("/demo1")
public class Demo02MappingController {

    @RequestMapping("/demo")
    public String demo(){
        System.out.println("demo......");
        return "success";
    }
}

• @requestMapping注解

  • 作用:通常用在Controller里,用于设置访问路径
  • 语法

    @RequestMapping(
    	value="访问路径",
        method=请求方式,
        params="请求参数"
    )
    

三. 获取请求数据

• 接收表单参数

  1. 接收简单参数
     - 要求：表单项名称，要和 方法形参名称 相同 
         @RequestMapping("/p1")
         public String p1(String name, Integer age){
             
         }
  2. 接收日期类型
     - 配置日期类型转换器
       1. 创建一个Java类，实现Converter<S,T>接口，在convert方法里写转换的代码
       2. 注册类型转换器，在springmvc.xml里
           <mvc:annotation-driven conversion-service="conversionService"/>
           <bean id="conversionService" class="ConversionServiceFactoryBean的全限定类名">
           	<property name="converters">
                   <set>
                   	<bean class="类型转换器的全限定类名"/>
                   </set>
               </property>
           </bean>
     - Controller里直接接收
         @RequestMapping("/p2")
         public String p2(Date birthday){}
  3. 接收JavaBean
     - 要求：表单项的名称，要和 JavaBean的属性名 相同
         @RequestMapping("/p3")
         public String p3(User user){}
  4. 接收复杂JavaBean
     - 如果是给QueryVO的user属性提交数据，表单项名称user.属性名
     - 如果是给QueryVO的userList属性提交数据，表单项名称userList[索引].属性名
     - 如果是给QueryVO的userMap属性提交数据，表单项名称userMap['key'].属性名
         @RequestMapping("/p4")
         public String p4(QueryVO vo){} 
  

• 接收请求体

- 接收请求体：用注解@RequestBody加在方法参数上
- 参数是字符串类型，表示把请求体内容赋值给字符串

    @RequestMapping("/body1")
    public String body1(@RequestBody String body){
    }

- 实际开发中，通常是客户端以Ajax方式提交json格式的数据，服务端接收成JavaBean对象
  - 客户端
      $.ajax({
          url:"提交路径",
          data:JSON.stringify(json对象),
          type:"post",
          contentType:"application/json"
      });
  - 服务端 
      @RequestMapping("/body2")
      public String body2(@RequestBody User user){
          
      }
  - 注意：需要导入json转换工具包。SpringMVC默认使用的是jackson，我们需要提供jackson的依赖

• 接收请求头

  • @requestHeader

    • jsp

      <a href="${pageContext.request.contextPath}/demo04/header1">
          请求头1：RequestHeader注解
      </a><br>
      

    • 在Demo04RequestHeaderController里增加方法

      @RequestMapping("/header1")
      public String header1(@RequestHeader("User-Agent") String userAgent){
          System.out.println(userAgent);
          return "success";
      }
      

  • CookieValue

    • jsp

      <a href="${pageContext.request.contextPath}/demo04/header1">
          请求头1：RequestHeader注解
      </a><br>
      

    • 在Demo04RequestHeaderController里增加方法

      @RequestMapping("/header1")
      public String header1(@RequestHeader("User-Agent") String userAgent){
          System.out.println(userAgent);
          return "success";
      }
      

• PathVariable

  • RESTful编程风格

    • REST：Representational State Transfer，是一种编程风格，没有明确的标准。Spring提供的@PathVariable，是其支持RESTful风格的一个重要标志
    • 特点：
      • 资源Resources：每个资源有独一无二的URI
      • 表现Representation：资源呈现的形式。例如：文本可以呈现为html、json、xml等等
      • 状态转换State Transfer：使用HTTP协议的不同请求方式，表示对资源的不同的操作
    • 优点：结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多的网站采用
    • 示例：
      • URI：/user/1， 请求方式：HTTP GET， 表示获取id为1的用户
      • URI：/user/1， 请求方式：HTTP DELETE， 表示删除id为1的用户
      • URI：/user/1， 请求方式：HTTP PUT， 表示更新id为1的用户
      • URI：/user，请求方式：HTTP POST，表示新增用户

  • @PathVariable
    注解说明

    • 作用：Spring3.0提供的，用于获取请求路径中的值，需要配合@RequestMapping使用
    • 语法：@PathVariable(value=“占位符名称”, required=是否必须)
    • 作用位置：用在方法参数上，表示获取请求路径中占位符的值，赋值给方法参数
    • 例如：
      • 客户端请求：http://localhost:8080/mvc01/delete/100
      • @RequestMapping("/delete/{id}")：定义了占位符{id}
      • @PathVariable(“id”)：要获取占位符{id}位置的值100

    基于Ajax的RESTful编程

    • 浏览器不能直接支持RESTful风格编程
    • 浏览器请求只支持GET和POST方式，不支持PUT、DELETE等
    • 如果想了解，可使用一个过滤器HiddenHttpMethodFilter提供支持
    • Ajax支持RESTful风格编程，我们演示这一种方式

• 解决全局中文乱码

  • 在web.xml中，配置过滤器CharacterEncodingFilter

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

四. 数据的响应方式

• 页面跳转并传递数据
  • 方法返回字符串的形式
  • 方法返回ModelAndView对象的形式
• 直接响应数据,通常是给ajax引擎返回数据
  • 直接响应字符串
  • 返回对象或者集合(json格式)

页面跳转并传递数据

• 页面跳转

  • 直接返回逻辑试图名称
    <property name="prefix", value="/">
<property name="suffix" value=".jsp">

       @RequestMapping("/quick")
       public String quick(){
             return "success";
       }
    

  • 返回带有前缀的物理视图

    • 请求转发:forward:/success.jsp
    • 重定向:redirect:/success.jsp
    • 注:如果带有forward或者redirect.路径必须是真实路径

        @Controller
        @RequestMapping("/demo01")
        public class Demo01ResponseController {
    
           @RequestMapping("/forward1")
           public String forward1(){
               System.out.println("请求转发跳转：由视图解析器拼接成真实路径");
               return "success";
           }
       
           @RequestMapping("/forward2")
           public String forward2(){
               System.out.println("请求转发跳转：forward前缀 + 真实路径");
       
               //带有forward前缀的字符串，表示请求转发跳转
               return "forward:/success.jsp";
           }
    
           @RequestMapping("/redirect")
           public String redirect(){
               System.out.println("重定向跳转：redirect前缀 + 真实路径");
       
               //带有redirect前缀的字符串，表示重定向跳转
               return "redirect:/success.jsp";
           }
       	}
    

• 请求转发并传递数据
  ModelAndView说明

  • ModelAndView是SpringMVC提供的组件之一，其中

    • Model，模型，用于封装数据（相当于放到了request域中）
    • View，视图，用于展示数据

  • 如果我们设置了视图名称，并且封装了数据模型，SpringMVC会：

    • 把Model的数据放到request域对象中，然后请求转发到指定的视图
    • 我们可以视图页面中获取数据显示出来.

  • 示例:

    • 自己在方法里创建ModelAndView对象，设置视图名称和数据，返回ModelAndView对象

        public ModelAndView m1(){
           ModelAndView  mav = new ModelAndView();
           mav.setViewName("视图名称");
           mav.addObject("数据key", 数据值);
           return mav;
        }
    

    • 让框架提供ModelAndView对象，我们设置视图名称和数据，返回ModelAndView对象

        public ModelAndView m1(ModelAndView mav){
    	    mav.setViewName("视图名称");
    	    mav.addObject("数据key", 数据值);
    	    return mav;
    	}
    

    • 让框架提供Model对象，我们返回视图名称

        public String m1(Model model){
    	    model.addAttribute("数据key", 数据值);
    	    return "success";
    	}
    

直接返回响应数据

• 响应字符串

  @RequestMapping("/text")
  @ResponseBody
  public String text(){
      return "要响应的字符串";
  }
  

  • 注:如果响应的是中文字符串,即使配置了CharacterEncodingFilter.也会有乱码

    • 因为使用@ResponseBody响应普通字符串时，走了SpringMVC的StringHttpMessageConverter进行字符串处理，默认采用的是iso-8859-1，所以乱码
    • 解决办法:在springmvc.xml里配置:

      <!--开启mvc的注解驱动-->
      <mvc:annotation-driven>
          <mvc:message-converters>
              <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                  <property name="defaultCharset" value="utf-8"/>
                  <property name="supportedMediaTypes">
                      <set>
                          <value>text/plain;charset=utf-8</value>
                          <value>text/html;charset=utf-8</value>
                          <value>application/json;charset=utf-8</value>
                      </set>
                  </property>
              </bean>
          </mvc:message-converters>
      </mvc:annotation-driven>
      

• 响应json格式

  • 需要导入jackson-databind依赖
  • 需要开启MVC的注解驱动

    @RequestMapping("/json")
    @ResponseBody
    public User json(){
        return new User();
    }
    

五. ModelAttribute和SessionAttribute

ModelAttribute注解

• 作用:在本次请求中共享数据

• 语法:@ModelAttribute

• 作用位置:用在方法上

  • 在每个控制器@RequestMapping方法执行之前，都会先执行被@ModelAttribute标记的方法
  • 会把方法返回值/参数值封装到Model对象中（本质是放到了request域对象中）

SessionAttribute注解

• 作用：用于在方法之间共享数据（相当于会话技术的session）。

• 作用位置：用在控制器类上，@SessionAttributes(value={}, types={Integer.class})

  • value：要会话共享的数据名称，从当前Model里找到对应名称的数据，放到session里
  • types：要会话共享的数据类型，从当前Model里找到对应名称的数据，放到session里

• 说明：

  • 用在控制器Controller类上@SessionAttributes：
    • 每次请求方法之前，从session中获取@SessionAttributes声明的数据，放到当前Model中
    • 每次请求方法之后
      • 如果SessionStatus.setComplate()了：
        • 把@SessionAttributes中声明的数据，从session中清除
      • 否则：
        • 把当前Model中的、被@SessionAttributes声明的数据，放到session中

• 示例:

  • JSP

    <a href="${pageContext.request.contextPath}/demo01/login">
        登录：把登录的User存储到会话中
    </a><br>
    
    <a href="${pageContext.request.contextPath}/demo01/getLoginUser">
        获取当前登录用户的姓名
    </a><br>
    
    <a href="${pageContext.request.contextPath}/demo01/login">
        退出：结束会话
    </a><br>
    

  • Controller

    /**
     * sessionAttributes注解：会话共享数据
     *
     * 在Controller类上增加注解SessionAttributes，声明要会话共享的数据
     * SpringMVC会把当前Controller里，每个请求的Model里，符合条件的数据进行会话共享
    
    @Controller
    @RequestMapping("/demo01")
    @SessionAttributes("loginUser")
    public class Demo04SessionAttrController {
    
        /**
         * 模拟登录功能。登录成功后得到一个User对象
         * @param model  登录成功后，把User对象存储到Model里。<br>
         *               因为Controller上的SessionAttributes声明了：要把loginUser进行会话共享，所以loginUser会被放到session对象中
         */
        @RequestMapping("/login")
        public String login(Model model){
            User user = new User();
            user.setId(1);
            user.setName("张三");
            user.setAge(20);
            model.addAttribute("loginUser", user);
    
            return "success";
        }
    
        @RequestMapping("/getLoginUser")
        public String getLoginUser(ModelMap modelMap){
            User user = (User) modelMap.get("loginUser");
            System.out.println("当前登录的用户是：" + user);
            return "success";
        }
    
        @RequestMapping("/logout")
        public String logout(SessionStatus status){
            System.out.println("退出登录");
            status.setComplete();
            return "success";
        }
    }
    

六.文件上传

文件上传的三要素：满足这三要素，才可能上传文件的内容

- 表单里必须有<input type="file">文件选择框
- 表单的提交方式必须是POST
- 表单的enctype属性值必须是：multipart/for-data

• 传统文件上传

  1. 增加导入依赖：commons-fileupload
  2. 创建页面，里边的表单要符合文件上传三要素：
  	   - 必须是POST提交
  	   - 必须有input type="file"
  	   - form标签的enctype属性值必须是multipart/form-data
  3. 创建Controller的方法
         @RequestMapping("/upload")
         public String upload(MultipartFile file){
             file.transferTo(new File("保存路径"));
             return "success";
         }
  4. 在springmvc.xml里配置文件解析器
         <bean id="multipartResolver" class="CommonsMultipartResolver全限定类名">
             <!-- 文件上传的最大尺寸。单位是字节，值-1表示不限制 -->
         	<property name="maxUploadSize" value="-1"/>
         </bean>   
  

• 跨服务器文件上传

  1. 准备一个文件服务器（模拟）
     1. 准备一个Tomcat，修改端口：保证端口不冲突
     2. 在Tomcat的webapps里创建一个文件夹：用于保存文件的
     3. 修改Tomcat的conf/web.xml，把其中DefaultServlet的初始化参数readonly设置为false
     4. 把Tomcat启动
  2. 编写代码，实现跨服务器文件上传
     1. 增加导入依赖：jersey-client
     2. 创建页面，要符合文件上传的三要素
     3. 在Controller里创建方法
         @RequestMapping("/upload")
         public String upload(MultipartFile file){
             //1.替换文件名称，保证没有中文 
             
             //2.使用jersey把文件的数据，推送保存到文件服务器上
             Client client = Client.create();
             WebResource resource = client.resource("http://ip:port/files/" + 文件名称);
             resouce.put(file.getBytes());
             
             return "success";
         }
  3. 配置文件解析器
  

七.异常处理

异常处理的思路

• 系统中的异常分为两类：

  • 预期异常，通过try…catch捕获异常，从而获取异常信息
  • 运行时异常RuntimeException，通过规范代码开发、测试等手动，减少运行时异常的发生

• 系统开发中处理异常的思路：

  • dao异常通常抛给Service
  • Service异常通常抛给Controller
  • Controller把异常抛给前端控制器
  • 由前端控制器把异常交给异常处理器进行处理

• 自定义异常处理器

  • 准备异常页面

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>异常</title>
    </head>
    <body>
    异常的默认页面 ${msg}
    </body>
    </html>
    

  • 创建自定义异常处理器

    public class MyExceptionResolver implements HandlerExceptionResolver {
        @Override
        public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.setViewName("error");
            if (ex instanceof NullPointerException) {
                //如果是空指针异常，可以做针对性处理。通常不需要
                modelAndView.addObject("msg", "空指针异常了");
            }else if(ex instanceof ClassCastException){
                //如果是类型转换异常，可以做针对性处理。通常不需要
                modelAndView.addObject("msg", "类型转换异常了");
            }
            return modelAndView;
        }
    }
    

  • 在springmvc.xml中配置异常处理器

    <bean class="com.itheima.resolver.MyExceptionResolver"/>
    

• 简单异常处理器

  • 准备异常页面error.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>异常</title>
    </head>
    <body>
    异常的默认页面
    </body>
    </html>
    

  • 在springmvc.xml中配置

    <!--配置简单异常处理器-->
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <!--配置默认的错误视图-->
        <property name="defaultErrorView" value="error"/>
        <!--配置异常与视图的映射-->
        <property name="exceptionMappings">
            <map>
                <!--类转换异常，显示视图error页面-->
                <entry key="java.lang.ClassCastException" value="error"/>
                <!--空指针异常，显示视图error页面-->
                <entry key="java.lang.NullPointerException" value="error"/>
            </map>
        </property>
    </bean>
    

八. 拦截器

介绍

• 什么是拦截器

  • SpringMVC中的拦截器，相当于web开发中的过滤器Filter，用于对Controller进行预处理和后处理
  • 多个拦截器形成的一条链，称为拦截器链（Interceptor chain）
    • 当访问被拦截的方法或字段时，拦截器链中的拦截器就会按照之前定义的顺序被调用
  • 拦截器也是AOP思想的具体实现

• 拦截器和过滤器的区别

  区别	过滤器	拦截器
  使用范围	是Servlet规范的一部分，任何Javaweb项目都可以使用	是SpringMVC自己的，只有使用了SpringMVC框架，才可以使用拦截器
  拦截范围	配置了urlPatterns="/*"之后，可以对所有要访问的资源进行拦截	只会拦截访问的控制器方法，如果访问的是JSP、HTML、CSS、图片或者js时，不拦截
  拦截精度	只能拦截某个请求，不能对Servlet里某个方法进行拦截	可以精细到拦截Controller里的某个方法

• 创建maven项目,准备SpringMVC环境

• 创建控制器DemoController,准备一个目标方法show()

  @Controller
  public class DemoController {
      @RequestMapping("/show")
      public ModelAndView show(ModelAndView modelAndView){
          System.out.println("目标方法show().....");
          modelAndView.addObject("username", "tom");
          modelAndView.setViewName("success");
          return modelAndView;
      }
  }
  

• 创建一个Java类，实现HandlerInterceptor接口

  • 重写接口的方法，共三个方法：preHandle, postHandle, afterCompletion

  public class MyInterceptor implements HandlerInterceptor {
      //在Controller的方法被调用之前执行
      @Override
      public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
          System.out.println("preHandle");
          return true;
      }
  
      //在Controller的方法被调用之后，视图渲染之前执行
      @Override
      public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
          System.out.println("postHandle");
      }
  
      //在Controller的方法执行完毕之后，再执行
      @Override
      public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
          System.out.println("afterCompletion");
      }
  }
  

• 在springmvc.xml中配置拦截器

      <!--配置拦截器-->
      <mvc:interceptors>
          <mvc:interceptor>
              <mvc:mapping path="/**"/>
              <bean class="com.user.terceptor.MyInterceptor/>
          </mvc:interceptor>
      </mvc:interceptors>