3.SpringMVC

SpringMVC

1. SpringMVC概述：

• Spring 为展现层提SpringMVC运行流程：

  • 所有请求，前端控制器（DispatcherServlet）收到请求，调用doDispatch进行处理

  • 根据HandlerMapping中保存的请求映射信息找到，处理当前请求的，处理器执行链（包含拦截器)

  • 根据当前处理器找到他的HandlerAdapter（适配器）

  • 拦截器的preHandle先执行

  • 适配器执行目标方法，并返回ModelAndView

  • ModelAttribute注解标注的方法提前运行

  • 执行目标方法的时候（确定目标方法用的参数）

    • 有注解
    • 没注解：

  • 看是否Model、Map以及其他的

  • 如果是自定义类型 1）、从隐含模型中看有没有，如果有就从隐含模型中拿 2）、如果没有，再看是否SessionAttributes标注的属性，如果是从Session中拿，如果拿不到会抛异常 3）、都不是，就利用反射创建对象

  • 拦截器的postHandle执行

  • 处理结果；（页面渲染流程）

    • 如果有异常使用异常解析器处理异常；处理完后还会返回ModelAndView
    • 调用render进行页面渲染
    • 1）、视图解析器根据视图名得到视图对象
    • 2）、视图对象调用render方法；
    • 3）、执行拦截器的afterCompletion；供的基于MVC 设计理念的优秀的 Web 框架，是目前最主流的MVC 框架之一

• Spring3.0 后全面超越 Struts2，成为最优秀的 MVC 框架

• Spring MVC 通过一套 MVC 注解，让 POJO 成为处理请求的控制器，而无须实现任何接口。

• 支持 REST 风格的 URL 请求

• 采用了松散耦合可插拔组件结构，比其他 MVC 框架更具扩展性和灵活性

2. HelloWorld

• 导包

  • SpringMVC是Spring的web模块，所有模块的运行都是依赖核心模块（IOC模块）

    • 核心容器模块

      

• web模块

• 配置

  • web.xml配置

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

  • SpringMVC.xml

    
    	<context:component-scan base-package="com.atguigu">context:component-scan>
    	
    	
    	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    		<property name="prefix" value="/WEB-INF/pages/">property>
    		<property name="suffix" value=".jsp">property>
    	bean>
    

  • Controller.java

    /**
     * 
     * 告诉springMVC这是一个处理器，可以处理请求
     * @Controller：标识哪个组件是控制器
     * @author 22007
     *
     */
    @Controller
    public class MyFirstController {
    	
    	/**
    	 *  /代表从当前项目下开始，处理当前项目下的hello请求
    	 */
    	@RequestMapping("/hello")
    	public String firstRequest(){
    		System.out.println("请求收到了。。。正在处理中");
    		return "success";
    	}
    	
    }
    

• 测试

3. helloWolrd细节

• 运行流程

  • 客户端点击链接会发送http://localhost:8080/springmvc/hello
  • 来到tomcat服务器；
  • SpringMVC的前端控制器收到所有请求；
  • 来看请求地址和@RequestMapping标注的哪个匹配，来找到到底使用哪个类的哪个方法
  • 前端控制器找到了目标处理器类和目标方法，直接利用返回执行目标方法
  • 方法执行完成以后会有一个返回值，SpringMVC认为这个返回值就是要去的页面地址
  • 拿到方法返回值以后，用视图解析器进行拼串得到完整的页面地址
  • 拿到页面地址，前端控制器帮我们转发到页面

• @RequestMapping

  • 这个注解告诉springMVC ，这个方法用来处理什么请求
  • 这个 / 是可以省略，即使省略了，也是默认从当前项目下开始
  • 习惯加上/比较好，如/hello

• 如果不指定springMVC配置文件的位置，也会默认去找一个文件，该文件就在/WEB-INF下创建一个名叫前端控制器名-servlet.xml

• 拦截地址的问题

  • 服务器的大web.xml中有一个DefaultServlet是url-pattern=/
  • 小web.xml是大web.xml的子类，会把大web.xml相同的部分覆盖掉
  • 我们的配置中前端控制器url-pattern=/,静态资源会来到DispatcherServlet（前端控制器）看哪个方法的RequestMapping是这个index.html
  • 为什么jsp又能访问，因为我们没有覆盖服务器中的JspServlet的配置
  • /* 直接就是拦截所有请求了，我们写/也是为了迎合后来Rest风格的URL地址

4. @RequestMapping注解

• RequestMapping注解写在类上时，为当前类的所有方法的请求地址指定一个基准路径

  //为当前类的所有方法的ing求地址指定一个基准路径
  @RequestMapping("/haha")
  @Controller
  public class MyFirstController {
  	/**
  	 *  /代表从当前项目下开始，处理当前项目下的hello请求
  	 */
  	@RequestMapping("/hello")
  	public String firstRequest(){
  		System.out.println("请求收到了。。。正在处理中");
  		return "success";
  	}
  }
  

• value：指定该方法的请求地址

• method：限定请求方式

  • HTTP协议中的所有请求方式：【GET】, HEAD, 【POST】, PUT, PATCH, DELETE, OPTIONS, TRACE
  • method=RequestMethod.POST：只接受这种类型的请求，默认是什么都可以；

• params：规定请求参数，params 和 headers支持简单的表达式：

• param1: 表示请求必须包含名为 param1 的请求参数

  eg：params={“username”}:发送请求的时候必须带上一个名为username的参数；没带都会404

• !param1: 表示请求不能包含名为 param1 的请求参数

  eg:params={"!username"}，发送请求的时候必须不携带上一个名为username的参数；带了都会404

• param1 != value1: 表示请求包含名为 param1 的请求参数，但其值不能为 value1

eg：params={“username!=123”}，发送请求的时候;携带的username值必须不是123(不带username或者username不是123)

• {“param1=value1”, “param2”}: 请求必须包含名为 param1 和param2 的两个请求参数，且 param1 参数的值必须为 value1

  eg:params={“username!=123”,“pwd”,"!age"}请求参数必须满足以上规则：请求的username不能是123，必须有pwd的值，不能有age

• headers：规定请求头；也和params一样能写简单的表达式

• consumes：只接受内容类型是哪种的请求，规定请求头中的Content-Type

• produces：告诉浏览器返回的内容类型是什么，给响应头中加上Content-Type:text/html;charset=utf-8

	/**
	 * RequestMapping的其他属性
	 * method属性设置请求方式
	 * 
	 */
	@RequestMapping(value="hello2",method=RequestMethod.GET,params={"username"},headers={"User-Agent=Mozilla/5.0 (Windows NT 6.3; WOW64; rv:34.0) Gecko/20100101 Firefox/34.0"})
	public String secondRequest(){
		System.out.println("secondRequest");
		return "success";
	}

5. @RequestMapping模糊匹配功能

• URL地址可以写模糊的通配符：

• ？：能替代任意一个字符

• *：能替代任意多个字符，和一层路径

• **：能替代多层路径

• @Controller
  public class RequestMappingTest {
      
      @RequestMapping("/antTest01")
      public String antTest01(){
          System.out.println("antTest01...");
          return "success";
      }
      
      /**
       * ?匹配一个字符,0个多个都不行;
       *      模糊和精确多个匹配情况下，精确优先
       *
       * @return
       */
      @RequestMapping("/antTest0?")
      public String antTest02(){
          System.out.println("antTest02...");
          return "success";
      }
      
      /**
       *   *匹配任意多个字符
       * @return
       */
      @RequestMapping("/antTest0*")
      public String antTest03(){
          System.out.println("antTest03...");
          return "success";
      }
      
      /**
       *  *：匹配一层路径
       * @return
       */
      @RequestMapping("/a/*/antTest01")
      public String antTest04(){
          System.out.println("antTest04...");
          return "success";
      }
      
      @RequestMapping("/a/**/antTest01")
      public String antTest05(){
          System.out.println("antTest05...");
          return "success";
      }
      
      //路径上可以有占位符：  占位符 语法就是可以在任意路径的地方写一个{变量名}
      //   /user/admin    /user/leifengyang
      // 路径上的占位符只能占一层路径
      @RequestMapping("/user/{id}")
      public String pathVariableTest(@PathVariable("id")String id){
          System.out.println("路径上的占位符的值"+id);
          return "success";
      }
  

6. Rest

• Rest：系统希望以非常简洁的URL地址来发请求； 怎样表示对一个资源的增删改查用请求方式来区分

  • 原来写的

    • /getBook?id=1 ：查询图书
    • /deleteBook?id=1：删除1号图书
    • /updateBook?id=1:更新1号图书
    • /addBook ：添加图书

  • Rest风格的

    • Rest推荐； url地址这么起名； /资源名/资源标识符
    • /book/1 ：GET-----查询1号图书
    • /book/1 :PUT------更新1号图书
    • /book/1 :DELETE-----删除1号图书
    • /book :POST-----添加图书系统的URL地址就这么来设计即可；
    • 简洁的URL提交请求，以请求方式区分对资源操作；
    • 问题：从页面上只能发起两种请求，GET、POST；其他的请求方式没法使用；

• REST 介绍

  • REST：即 Representational State Transfer。（资源）表现层状态转化。是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用

  • 资源（Resources）：网络上的一个实体，或者说是网络上的一个具体信息。它可以是一段文本、一张图片、一首歌曲、一种服务，总之就是一个具体的存在。可以用一个URI（统一资源定位符）指向它，每种资源对应一个特定的 URI 。要获取这个资源，访问它的URI就可以，因此 URI 即为每一个资源的独一无二的识别符**。

  • **表现层（Representation）：**把资源具体呈现出来的形式，叫做它的表现层（Representation）。比如，文本可以用 txt 格式表现，也可以用 HTML 格式、XML 格式、JSON 格式表现，甚至可以采用二进制格式。

    状态转化（State Transfer）：每发出一个请求，就代表了客户端和服务器的一次交互过程。HTTP协议，是一个无状态协议，即所有的状态都保存在服务器端。因此，如果客户端想要操作服务器，必须通过某种手段，让服务器端发生**“状态转化”（State Transfer）。而这种转化是建立在表现层之上的，所以就是 “表现层状态转化**”**。**具体说，就是 HTTP 协议里面，四个表示操作方式的动词：**GET、POST、PUT、DELETE。它们分别对应四种基本操作：GET用来获取资源，**POST 用来新建资源，PUT **用来更新资源，DELETE 用来删除资源。

7. 使用Rest来构建一个增删改查系统；

• index.jsp

  页面地址：
  
  从页面发起PUT、DELETE形式的请求?Spring提供了对Rest风格的支持
  1）、SpringMVC中有一个Filter；他可以把普通的请求转化为规定形式的请求；配置这个filter;
  <filter>
          <filter-name>HiddenHttpMethodFilterfilter-name>
          <filter-class>org.springframework.web.filter.HiddenHttpMethodFilterfilter-class>
      filter>
      <filter-mapping>
          <filter-name>HiddenHttpMethodFilterfilter-name>
          <url-pattern>/*url-pattern>
      filter-mapping>
  2）、如何发其他形式请求？
      按照以下要求；1、创建一个post类型的表单 2、表单项中携带一个_method的参数，3、这个_method的值就是DELETE、PUT
   -->
  <a href="book/1">查询图书a><br/>
  <form action="book" method="post">
      <input type="submit" value="添加1号图书"/>
  form><br/>
  
  <form action="book/1" method="post">
      <input name="_method" value="delete"/>
      <input type="submit" value="删除1号图书"/>
  form><br/>
  
  <form action="book/1" method="post">
      <input name="_method" value="put"/>
      <input type="submit" value="更新1号图书"/>
  form><br/>
  
  

• 处理程序

  package com.atguigu.controller;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RequestMethod;
  
  @Controller
  public class BookController {
      /**
       * 处理查询图书请求
       * @param id
       * @return
       */
      @RequestMapping(value="/book/{bid}",method=RequestMethod.GET)
      public String getBook(@PathVariable("bid")Integer id) {
          System.out.println("查询到了"+id+"号图书");
          return "success";
      }
  
      /**
       * 图书删除
       * @param id
       * @return
       */
      @RequestMapping(value="/book/{bid}",method=RequestMethod.DELETE)
      public String deleteBook(@PathVariable("bid")Integer id) {
          System.out.println("删除了"+id+"号图书");
          return "success";
      }
  
      /**
       * 图书更新
       * @return
       */
      @RequestMapping(value="/book/{bid}",method=RequestMethod.PUT)
      public String updateBook(@PathVariable("bid")Integer id) {
          System.out.println("更新了"+id+"号图书");
          return "success";
      }
  
      @RequestMapping(value="/book",method=RequestMethod.POST)
      public String addBook() {
          System.out.println("添加了新的图书");
          return "success";
      }
  
  }
  

• web.xml

  <filter>
          <filter-name>HiddenHttpMethodFilterfilter-name>
          <filter-class>org.springframework.web.filter.HiddenHttpMethodFilterfilter-class>
      filter>
      <filter-mapping>
          <filter-name>HiddenHttpMethodFilterfilter-name>
          <url-pattern>/*url-pattern>
      filter-mapping>
  

• 源码：

  @Override
      protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
              throws ServletException, IOException {
       //获取表单上_method带来的值（delete\put）
          String paramValue = request.getParameter(this.methodParam);
       
       //判断如过表单是一个post而且_method有值
          if ("POST".equals(request.getMethod()) && StringUtils.hasLength(paramValue)) {
            //转为PUT、DELETE
              String method = paramValue.toUpperCase(Locale.ENGLISH);
            //重写了request.getMethod()；
              HttpServletRequest wrapper = new HttpMethodRequestWrapper(request, method);
  
            //wrapper.getMethod()===PUT；
              filterChain.doFilter(wrapper, response);
          }
          else {
               //直接放行
              filterChain.doFilter(request, response);
          }
      }
  

• 注意：高版本Tomcat；Rest支持有点问题

  

解决方案：

8. 请求参数

• package com.atguigu.controller;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.PrintWriter;
  
  import javax.servlet.ServletInputStream;
  import javax.servlet.ServletOutputStream;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.servlet.http.HttpSession;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.CookieValue;
  import org.springframework.web.bind.annotation.RequestHeader;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RequestParam;
  
  import com.atguigu.book.Book;
  
  @Controller
  public class HelloController {
  
      /**
       * request.getParameter("").....
       *
       * @return
       */
      @RequestMapping("/hello")
      public String handle01() {
          System.out.println("handle01...");
          return "success";
      }
  
      /**
       * SpringMVC如何获取请求带来的各种信息 默认方式获取请求参数： 直接给方法入参上写一个和请求参数名相同的变量。这个变量就来接收请求参数的值；
       * 带：有值，没带：null；
       *
       * @RequestParam：获取请求参数的；参数默认是必须带的；
       * @RequestParam("user")String username username =
       *                             request.getParameter("user")
       *
       *
       * @RequestParam("user")
       * @PathVariable("user")
       *                       /book/【{user}pathvariable】?【user=admin(requestparam)
       *                       】
       *
       *                       value:指定要获取的参数的key required:这个参数是否必须的
       *                       defaultValue:默认值。没带默认是null；
       *
       *
       * @RequestHeader：获取请求头中某个key的值； request.getHeader("User-Agent")；
       * @RequestHeader("User-Agent")String userAgent userAgent =
       *                                    request.getHeader("User-Agent")
       *                                    如果请求头中没有这个值就会报错； value() required()
       *                                    defaultValue()
       *
       * @CookieValue：获取某个cookie的值； 以前的操作获取某个cookie； Cookie[] cookies =
       *                            request.getCookies(); for(Cookie c:cookies){
       *                            if(c.getName().equals("JSESSIONID")){ String
       *                            cv = c.getValue(); } }
       * value()
       * required()
       * defaultValue()
       */
      @RequestMapping("/handle01")
      public String handle02(
              @RequestParam(value = "user", required = false, defaultValue = "你没带") String username,
              @RequestHeader(value = "AHAHA", required = false, defaultValue = "她也没带") String userAgent,
              @CookieValue(value="JSESSIONID",required=false)String jid) {
          System.out.println("这个变量的值：" + username);
          System.out.println("请求头中浏览器的信息：" + userAgent);
          System.out.println("cookie中的jid的值"+jid);
          return "success";
      }
  
      /**
       * 如果我们的请求参数是一个POJO；
       * SpringMVC会自动的为这个POJO进行赋值？
       * 1）、将POJO中的每一个属性，从request参数中尝试获取出来，并封装即可；
       * 2）、还可以级联封装；属性的属性
       * 3）、请求参数的参数名和对象中的属性名一一对应就行
       *
       *
       * 提交的数据可能有乱码：
       * 请求乱码：
       *         GET请求：改server.xml；在8080端口处URIEncoding="UTF-8"
       *         POST请求：
       *             在第一次获取请求参数之前设置
       *             request.setCharacterEncoding("UTF-8");
       *             自己写一个filter；SpringMVC有这个filter
       *
       * 响应乱码：
       *         response.setContentType("text/html;charset=utf-8")
       * @param book
       * @return
       */
      @RequestMapping("/book")
      public String addBook(Book book){
          System.out.println("我要保存的图书："+book);
          return "success";
      }
  
      /**
       * SpringMVC可以直接在参数上写原生API;
       *
       * HttpServletRequest
       * HttpServletResponse
       * HttpSession
       *
       *
       * java.security.Principal
       * Locale：国际化有关的区域信息对象
       * InputStream：
       *         ServletInputStream inputStream = request.getInputStream();
       * OutputStream：
       *         ServletOutputStream outputStream = response.getOutputStream();
       * Reader：
       *         BufferedReader reader = request.getReader();
       * Writer：
       *         PrintWriter writer = response.getWriter();
       *
       * @throws IOException
  
       *
       *
       */
      @RequestMapping("/handle03")
      public String handle03(HttpSession session,
              HttpServletRequest request,HttpServletResponse response) throws IOException {
          request.setAttribute("reqParam", "我是请求域中的");
          session.setAttribute("sessionParam", "额我是Session域中的");
  
          return "success";
      }
  
  }
  

• 解决字符编码

  
  
  	<filter>
  		<filter-name>CharacterEncodingFilterfilter-name>
  		<filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
  		
  		<init-param>
  			<param-name>encodingparam-name>
  			<param-value>UTF-8param-value>
  		init-param>
  		<init-param>
  			
  			<param-name>forceEncodingparam-name>	
  			<param-value>trueparam-value>
  		init-param>
  		
  	filter>
  	<filter-mapping>
  		<filter-name>CharacterEncodingFilterfilter-name>
  		<url-pattern>/*url-pattern>
  	filter-mapping>
  

9. 数据输出

/**
 * SpringMVC出过在方法上传入原生API数据外，还可以
 * 1）、可以在方法处出入Map、或者Model或者ModelMap
 *  Map，Model，ModelMap：最终都是BindingAwareModelMap在工作；
 *      相当于给BindingAwareModelMap中保存的东西都会被放在请求域中；
 *
 *      Map(interface(jdk))      Model(interface(spring)) 
 *          ||                          //
 *          ||                         //
 *          \/                        //
 *      ModelMap(clas)               //
 *                  \\              //
 *                   \\            //
 *                  ExtendedModelMap
 *                          ||
 *                          \/
 *                  BindingAwareModelMap
 *                   * 2）、方法的返回值可以变为ModelAndView类型；
 * 			既包含视图信息（页面地址）也包含模型数据（给页面带的数据）；
 * 			而且数据是放在请求域中；
 * 			request、session、application；
 * 			
 * 3）、SpringMVC提供了一种可以临时给Session域中保存数据的方式；
 * 	使用一个注解	@SessionAttributes(只能标在类上)
 * 	@SessionAttributes(value="msg"):
 * 		给BindingAwareModelMap中保存的数据，或者ModelAndView中的数据，
 * 		同时给session中放一份；
 * 		value指定保存数据时要给session中放的数据的key；
 * 
 * 	value={"msg"}：只要保存的是这种key的数据，给Session中放一份
 * 	types={String.class}：只要保存的是这种类型的数据，给Session中也放一份
 * 
 *  后来推荐@SessionAttributes就别用了，可能会引发异常；
 * 			给session中放数据请使用原生API；
 * @author 22007
 *
 */

@SessionAttributes(value={"msg","haha"},types={String.class})
@Controller
public class OutputController {
	
	@RequestMapping("/hello01")
	public String test01(Map<String,Object> map){
		map.put("msg1", "你好");
		return "success";
	}
	
	@RequestMapping("/hello02")
	public String test02(Model model){
		model.addAttribute("msg1", "你好那么好");
		return "success";
	}
	
	@RequestMapping("/hello03")
	public String test03(ModelMap modelMap){
		modelMap.addAttribute("msg1", "你好那么好");
		return "success";
	}
	
	/**
	 * 返回值时ModelAndView可以为页面携带数据
	 * 
	 */
	@RequestMapping("/hello04")
	public ModelAndView test04(){
        //之前的返回值我们就叫视图名；视图名视图解析器是会帮我们最终拼串得到页面的真实地址；
        //ModelAndView mv = new ModelAndView("success");
        ModelAndView mv = new ModelAndView();
        mv.setViewName("success");
        mv.addObject("msg", "你好哦！");
        return mv;
	}
}

10. ModelAttribute：使用场景：

• 1）页面：

• dao：全字段更新。没带的字段会在数据库中更新为null；

• /**
   * 测试ModelAttribute注解；
   * 使用场景：书城的图书修改为例；
   * 1）页面端；
   *      显示要修改的图书的信息，图书的所有字段都在
   * 2）servlet收到修改请求，调用dao；
   *      String sql="update bs_book set title=?,
   *                  author=?,price=?,
   *                  sales=?,stock=?,img_path=?
   *              where id=?";
   * 3）实际场景？
   *      并不是全字段修改；只会修改部分字段，以修改用户信息为例；
   *      username  password  address;
   *      1）、不修改的字段可以在页面进行展示但是不要提供修改输入框；
   *      2）、为了简单，Controller直接在参数位置来写Book对象
   *      3）、SpringMVC为我们自动封装book；（没有带的值是null）
   *      4）、如果接下来调用了一个全字段更新的dao操作；会将其他的字段可能变为null；
   *          sql = "update bs_book set"
   *          if(book.getBookName()){
   *              sql +="bookName=?,"
   *          }
   *          if(book.getPrice()){
   *              sql +="price=?"
   *          }
   *
   * 4）、如何能保证全字段更新的时候，只更新了页面携带的数据；
   *      1）、修改dao；代价大？
   *      2）、Book对象是如何封装的？
   *          1）、SpringMVC创建一个book对象，每个属性都有默认值，bookName就是null；
   *              1、让SpringMVC别创建book对象，直接从数据库中先取出一个id=100的book对象的信息
   *              2、Book [id=100, bookName=西游记, author=张三, stock=12, sales=32, price=98.98]
   *
   *          2）、将请求中所有与book对应的属性一一设置过来；
   *              3、使用刚才从数据库取出的book对象，给它 的里面设置值；（请求参数带了哪些值就覆盖之前的值）
   *              4、带了的字段就改为携带的值，没带的字段就保持之前的值
   *          3）、调用全字段更新就有问题；
   *              5、将之前从数据库中查到的对象，并且封装了请求参数的对象。进行保存；
   *
   * @author lfy
   */
  @Controller
  public class ModelAttributeTestController {
      
      private Object o1;
      private Object o2;
      
      private Object b1;
      private Object b2;
      
      //bookDao.update(book);
      //Book [id=100, bookName=null, author=张三, stock=12, sales=32, price=98.98]
      /**
       *      String sql="update bs_book set bookName=?,
                      author=?,price=?,
                      sales=?,stock=?,img_path=?
                  where id=?";
       */
      /**
       * 可以告诉SpringMVC不要new这个book了我刚才保存了一个book；
       * 哪个就是从数据库中查询出来的；用我这个book?@ModelAttribute("haha")
       *
       * 
       * 同都是BindingAwareModelMap
       * @param book
       * @return
       */
      @RequestMapping("/updateBook")
      public String updateBook(@ModelAttribute("haha")Book book,Map<String, Object> model){
          o2 = model;
          b2  = book;
          Object haha = model.get("haha");
          //System.out.println("传入的model："+model.getClass());
          System.out.println("o1==o2?"+(o1 == o2));
          System.out.println("b1==b2?"+(b1 == b2)+"-->"+(b2 == haha));
          
          System.out.println("页面要提交过来的图书信息："+book);
          return "success";
      }
      
      /**
       * 1）、SpringMVC要封装请求参数的Book对象不应该是自己new出来的。
       *      而应该是【从数据库中】拿到的准备好的对象
       * 2）、再来使用这个对象封装请求参数
       *
       * @ModelAttribute：
       *      参数：取出刚才保存的数据
       *      方法位置：这个方法就会提前于目标方法先运行；
       *          1)我们可以在这里提前查出数据库中图书的信息
       *          2)将这个图书信息保存起来（方便下一个方法还能使用）
       *
       * 参数的map：BindingAwareModelMap
       */
      @ModelAttribute
      public void hahaMyModelAttribute(Map<String, Object> map){
          
          Book book = new Book(100, "西游记", "吴承恩", 98, 10, 98.98);
          System.out.println("数据库中查到的图书信息是："+book);
          map.put("haha", book);
          b1 = book;
          o1 = map;
          System.out.println("modelAttribute方法...查询了图书并给你保存起来了...他用的map的类型："+map.getClass());
      }
  }
  
  

11. SpringMVC源码

• DispatcherServlet继承树

• doDispatch()方法

  protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
          HttpServletRequest processedRequest = request;
          HandlerExecutionChain mappedHandler = null;
          boolean multipartRequestParsed = false;
          WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
          try {
              ModelAndView mv = null;
              Exception dispatchException = null;
              try {
                 //1、检查是否文件上传请求
                  processedRequest = checkMultipart(request);
                  multipartRequestParsed = processedRequest != request;
                  // Determine handler for the current request.
                 //2、根据当前的请求地址找到那个类能来处理；
                  mappedHandler = getHandler(processedRequest);
  
                 //3、如果没有找到哪个处理器（控制器）能处理这个请求就404，或者抛异常
                  if (mappedHandler == null || mappedHandler.getHandler() == null) {
                      noHandlerFound(processedRequest, response);
                      return;
                  }
  
                  // Determine handler adapter for the current request.
                 //4、拿到能执行这个类的所有方法的适配器；（反射工具AnnotationMethodHandlerAdapter）
                  HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
                  // Process last-modified header, if supported by the handler.
                  String method = request.getMethod();
                  boolean isGet = "GET".equals(method);
                  if (isGet || "HEAD".equals(method)) {
                      long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                      if (logger.isDebugEnabled()) {
                          String requestUri = urlPathHelper.getRequestUri(request);
                          logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);
                      }
                      if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                          return;
                      }
                  }
                  if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                      return;
                  }
                  try {
                      // Actually invoke the handler.处理（控制）器的方法被调用
                      //控制器（Controller），处理器（Handler）
                      //5、适配器来执行目标方法；将目标方法执行完成后的返回值作为视图名，设置保存到ModelAndView中
                      //目标方法无论怎么写，最终适配器执行完成以后都会将执行后的信息封装成ModelAndView
                      mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                  }
                  finally {
                      if (asyncManager.isConcurrentHandlingStarted()) {
                          return;
                      }
                  }
                  applyDefaultViewName(request, mv);//如果没有视图名设置一个默认的视图名；
                  mappedHandler.applyPostHandle(processedRequest, response, mv);
              }
              catch (Exception ex) {
                  dispatchException = ex;
              }
              //转发到目标页面；
              //6、根据方法最终执行完成后封装的ModelAndView；转发到对应页面，而且ModelAndView中的数据可以从请求域中获取
              processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
          }
          catch (Exception ex) {
              triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
          }
          catch (Error err) {
              triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
          }
          finally {
              if (asyncManager.isConcurrentHandlingStarted()) {
                  // Instead of postHandle and afterCompletion
                  mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                  return;
              }
              // Clean up any resources used by a multipart request.
              if (multipartRequestParsed) {
                  cleanupMultipart(processedRequest);
              }
          }
      }
  

12. 视图解析器

• forward与redirect

  @Controller
  public class HelloController {
  	
  	@RequestMapping("/hello")
  	public String hello(){
  		return "success";
  	}
  	
  	/**
  	 * forward转发到一个页面
  	 *  /hello.jsp,就是指转发到当前项目下的hello.jsp
  	 *  一定要加上/，如果不加/就是相对路径，容易出现问题
  	 *  forward:/hello.jsp
  	 *  forward:不会有视图解析器拼串
  	 */
  	
  	@RequestMapping("/handle01")
  	public String handle01(){
  		System.out.println("handle01");
  		return "forward:/handle.jsp";
  	}
  	
  	@RequestMapping("/handle02")
  	public String handle02(){
  		System.out.println("handle02");
  		return "forward:/handle01";
  	}
  	
  	/**
  	 * 重定向到hello.jsp页面
  	 * 转发 ：forword:转发的路径
  	 * 重定向：redirect重定向的路径，相当于
  	 * 	response.sendRedirect("/hello.jsp")
  	 * 原生的servlet重定向/需要加上项目名才能成功
  	 * 而视图解析器会为/hello.jsp自动拼接上项目名 
  	 */
  	@RequestMapping("/handle03")
  	public String handle03(){
  		System.out.println("handle03");
  		return "redirect:/index.jsp";
  	}
  	
  	@RequestMapping("/handle04")
  	public String handle04(){
  		System.out.println("handle04");
  		return "redirect:/handle03";
  	}
  	
  }
  

• 自定义视图解析器

  • View

    /**
     * 自定义视图
     * @author lfy
     *
     */
    public class MyView implements View{
    
    	/**
    	 * 返回的数据的内容类型
    	 */
    	@Override
    	public String getContentType() {
    		// TODO Auto-generated method stub
    		return "text/html";
    	}
    
    	@Override
    	public void render(Map<String, ?> model, HttpServletRequest request,
    			HttpServletResponse response) throws Exception {
    		// TODO Auto-generated method stub
    		System.out.println("之前保存的数据："+model);
    		response.setContentType("text/html");
    		List<String> vn = (List<String>) model.get("video");
    		response.getWriter().write("哈哈
    即将展现精彩内容
    ");
    		for (String string : vn) {
    			response.getWriter().write("下载"+string+".avi
    ");
    		}
    		response.getWriter().write(""
    				+ "");
    	}
    
    }
    

  • MyMeiNVViewResolver

    public class MyMeiNVViewResolver implements ViewResolver,Ordered{
    
    	private Integer order = 0;
    	
    	@Override
    	public View resolveViewName(String viewName, Locale locale)
    			throws Exception {
    		// TODO Auto-generated method stub
    		//根据视图名返回视图对象
    		/**
    		 * 	meinv:/gaoqing  meinv:/dama
    			forward:/login.jsp
    		 */
    		if(viewName.startsWith("meinv:")){
    			return new MyView();
    		}else{
    			//如果不能处理返回null即可
    			return null;
    		}
    	}
    
    	/**
    	 * 
    	 */
    	@Override
    	public int getOrder() {
    		// TODO Auto-generated method stub
    		return order;
    	}
    	
    	//改变视图解析器的优先级
    	public void setOrder(Integer order){
    		this.order = order;
    	}
    
    }
    

  • MyViewResovlerController

    @Controller
    public class MyViewResovlerController {
    	
    	@RequestMapping("/handleplus")
    	public String handleplus(Model model){
    		//meinv:/gaoqing  meinv:/dama
    		//forward:/login.jsp
    		List<String> vname = new ArrayList<String>();
    		List<String> imgname = new ArrayList<String>();
    		vname.add("佟老师");
    		vname.add("飞哥");
    		imgname.add("萌萌");
    		
    		model.addAttribute("video", vname);
    		model.addAttribute("imgs", imgname);
    		
    		return "meinv:/gaoqing";
    	}
    
    }
    

  • springmvc配置器

    	
    	<bean class="com.atguigu.view.MyMeiNVViewResolver">
    		<property name="order" value="1">property>
    	bean>
    

• jstlView支持便捷国际化

  • 导包导入了jstl的时候会自动创建为一个jstlView；可以快速方便的支持国际化功能；

  • 可以支持快速国际化；

    javaWeb国际化步骤；

    • 得到一个Locale对象；
    • 使用ResourceBundle绑定国际化资源文件；
    • 使用ResourceBundle.getString(“key”)；获取到国际化配置文件中的值；
    • web页面的国际化，fmt标签库来做； fmt:setLocale fmt:message

    有了JstlView以后；

    • 让Spring管理国际化资源就行

          
          <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
              
              <property name="basename" value="i18n">property>
          bean>
      

    • 直接去页面使用fmt:message；

      <fmt:message key="welcomeinfo"/>
      h1>
      <form action="">
          <fmt:message key="username"/>:<input /><br/>
          <fmt:message key="password"/>:<input /><br/>
          <input type="submit" value='"loginBtn"/>'/>
      form>
      

      i18n_zh_CN.properties

      welcomeinfo=\u6B22\u8FCE\u6765\u5230\u5C1A\u7845\u8C37
      username=\u7528\u6237\u540D
      password=\u5BC6\u7801
      loginBtn=\u767B\u9646
      

      i18n_en_US.properties

      welcomeinfo=WELCOME TO ATGUIGU
      username=USERNAME
      password=PASSWORD
      loginBtn=LOGIN
      

• mvc:view-controller将请求映射到一个页面

	
	<mvc:view-controller path="/toLoginPage" view-name="login"/>
	
	<mvc:annotation-driven>mvc:annotation-driven>

13. ResultFulCRUD

• 利用SpringMVC做一个CRUD（增删改查）符合Rest风格的；

  • C：Create：创建
  • R：Retrieve：查询
  • U：Update：更新
  • D：Delete：删除
  • 数据库：保存数据；使用Map，List保存数据之类

• web.xml配置

  	<servlet>
  		<servlet-name>springDispatcherServletservlet-name>
  		<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
  		<init-param>
  			<param-name>contextConfigLocationparam-name>
  			<param-value>classpath:springmvc.xmlparam-value>
  		init-param>
  		<load-on-startup>1load-on-startup>
  	servlet>
  
  	
  	<servlet-mapping>
  		<servlet-name>springDispatcherServletservlet-name>
  		<url-pattern>/url-pattern>
  	servlet-mapping>
  	
  	
  	<filter>
  		<filter-name>CharacterEncodingFilterfilter-name>
  		<filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
  		<init-param>
  			<param-name>encodingparam-name>
  			<param-value>UTF-8param-value>
  		init-param>
  		<init-param>
  			<param-name>forceEncodingparam-name>
  			<param-value>trueparam-value>
  		init-param>
  	filter>
  	<filter-mapping>
  		<filter-name>CharacterEncodingFilterfilter-name>
  		<url-pattern>/*url-pattern>
  	filter-mapping>
  	
  	
  	<filter>
  		<filter-name>HiddenHttpMethodFilterfilter-name>
  		<filter-class>org.springframework.web.filter.HiddenHttpMethodFilterfilter-class>
  	filter>
  	<filter-mapping>
  		<filter-name>HiddenHttpMethodFilterfilter-name>
  		<url-pattern>/*url-pattern>
  	filter-mapping>
  web-app>
  

• springmvc.xml

      
  	<context:component-scan base-package="com.atguigu">context:component-scan>
  	
  	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  		<property name="prefix" value="/WEB-INF/pages/">property>
  		<property name="suffix" value=".jsp">property>
  	bean>
  	
  	
  	<mvc:default-servlet-handler/>
  	
  	<mvc:annotation-driven>mvc:annotation-driven>
  

• Controller

  @Controller
  public class EmployeeController {
  	
  	@Autowired
  	EmployeeDao employeeDao;
  	
  	@Autowired
  	DepartmentDao departmentDao;  
  	
  	/**
  	 * 查询所有员工
  	 * @return
  	 */
  	@RequestMapping("/emps")
  	public String getEmps(Model model){
  		Collection<Employee> all=employeeDao.getAll();
  		model.addAttribute("emps", all);
  		return "list";
  	}
  	
  	/**
  	 * 处理去添加员工页面的
  	 */
  	@RequestMapping("/toaddpage")
  	public String toAddPage(Model model){
  		//1.先取出所有部门
  		Collection<Department> departments=departmentDao.getDepartments();
  		//2.添加到model中
  		model.addAttribute("depts", departments);
  		model.addAttribute("employee", new Employee(null,"lisi","[email protected]",1,departmentDao.getDepartment(105)));
  		return "add";
  	}
  	
  	/**
  	 * 添加员工数据
  	 * 
  	 */
  	@RequestMapping(value="/emp",method=RequestMethod.POST)
  	public String addEmp(Employee employee){
  		System.out.println(employee);
  		employeeDao.save(employee);
  		//返回列表页面,直接重定向查询所有员工请求
  		return "redirect:/emps";
  	}
  	
  	/**
  	 * 查询员工，来到页面回显
  	 */
  	@RequestMapping(value="/emp/{id}",method=RequestMethod.GET)
  	public String getEmp(@PathVariable("id")Integer id,Model model){
  		//1.查出员工信息
  		Employee employee=employeeDao.get(id);
  		//2.放在请求域中
  		model.addAttribute("employee",employee);
  		//3.查出部门信息放在隐含模型中
  		Collection<Department> departments=departmentDao.getDepartments();
  		model.addAttribute("depts", departments);
  		return "edit";
  	}
  	
  	/**
  	 * 删除用户信息
  	 * @return
  	 */
  	@RequestMapping(value="/emp/{id}",method=RequestMethod.DELETE)
  	public String deleteEmp(@PathVariable("id")Integer id){
  		employeeDao.delete(id);
  		return "redirect:/emps";
  	}
  	
  	/**
  	 * 员工数据修改
  	 * @param employee
  	 * @return
  	 */
  	
  	@RequestMapping(value="/emp/${id}",method=RequestMethod.PUT)
  	public String updateEmp(Employee employee){
  		System.out.println("要修改的员工："+employee);
  		employeeDao.save(employee);
  		return "redirect:/emps";
  	}
  	
  	
  	@ModelAttribute
  	public void myModelAttribute(
  			@RequestParam(value="id",required=false)Integer id,Model model){
  		if(id!=null){
  			Employee employee=employeeDao.get(id);
  			model.addAttribute("employee", employee);
  			System.out.println("要修改的员工："+employee);
  		}
  		System.out.println("haha");
  	}
  	
  }
  

• index.jsp

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

• add.jsp

  <%@ page language="java" contentType="text/html; charset=UTF-8"
      pageEncoding="UTF-8"%>
  <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
  <%@taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
  
  
  
  
  
  
  
  
  添加员工
  <%-- 
  
  	lastName:
  
  	email:
  
  	gender:
  	男：
  	女：
  
  	部门：
  	
  		
  			
  			${deptItem.departmentName}
  			
  	
  	
  
  	
   --%>
  
  
  
  
  <%request.setAttribute("ctp", request.getContextPath());%>
  
  
  	
  	lastName:
  	email:
  	gender:男
  	女
  
  	
  	dept:
  	
  
  
  
  
  

• list.jsp

  <%@ page language="java" contentType="text/html; charset=UTF-8"
      pageEncoding="UTF-8"%>
  <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
  
  
  
  <%
  	pageContext.setAttribute("ctp", request.getContextPath());
  %>
  
  
  
  
  
  
  员工列表
  
  		
  
  	
  
  		
  ID
  		
  latName
  		
  email
  		
  gender
  		
  departmentName
  		
  EDIT
  		
  DELETE
  	
  	
  
  		
  ${emp.id}
  		
  ${emp.lastName}
  		
  ${emp.email}
  		
  ${emp.gender==0?"女":"男"}
  		
  ${emp.department.departmentName}
  		
  
  			edit
  		
  		
  
  			delete
  		
  		
  	
  
  添加员工
  
  	
  
  
  
  
  

• editjsp

  <%@ page language="java" contentType="text/html; charset=UTF-8"
      pageEncoding="UTF-8"%>
  <%@taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
  
  
  
  
  
  
  
  
  
  <%pageContext.setAttribute("ctp", request.getContextPath());%>
  员工修改页面
  
  	
  	   
  	 
  	lastName:
  	email:
  	gender:男
  	女
  
  	
  	dept:
  	
  
  
  ${ctp}/emp/${employee.id}
  
  
  

14. 数据绑定

• 数据绑定流程

  • Spring MVC 主框架将 ServletRequest 对象及目标方法的入参实例传递给 WebDataBinderFactory 实例，以创建 DataBinder 实例对象
  • DataBinder 调用装配在 Spring MVC 上下文中的 ConversionService 组件进行数据类型转换、数据格式化工作。将 Servlet 中的请求信息填充到入参对象中
  • 调用 Validator 组件对已经绑定了请求消息的入参对象进行数据合法性校验，并最终生成数据绑定结果 BindingData 对象
  • Spring MVC 抽取 BindingResult 中的入参对象和校验错误对象，将它们赋给处理方法的响应入参

• 数据绑定步骤

  • 自定义的转换器

    /**
     * 两个返回
     * 
     * S：Source T：Target 将s转为t
     * 
     * @author lfy
     * 
     */
    public class MyStringToEmployeeConverter implements Converter<String, Employee> {
    
    	@Autowired
    	DepartmentDao departmentDao;
    	
    	/**
    	 * 自定义的转换规则
    	 */
    	@Override
    	public Employee convert(String source) {
    		// TODO Auto-generated method stub
    		// [email protected]
    		System.out.println("页面提交的将要转换的字符串" + source);
    		Employee employee = new Employee();
    		if (source.contains("-")) {
    			String[] split = source.split("-");
    			employee.setLastName(split[0]);
    			employee.setEmail(split[1]);
    			employee.setGender(Integer.parseInt(split[2]));
    			employee.setDepartment(departmentDao.getDepartment(Integer.parseInt(split[3])));
    		}
    		return employee;
    	}
    }
    
    

  • Springmvc.xml配置

    	    
        <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
            
            <property name="converters">
                <set>
                    <bean class="com.atguigu.component.MyStringToEmployeeConverter">bean>
                set>
            property>
        bean>
        
        <mvc:annotation-driven conversion-service="conversionService">mvc:annotation-driven>
    

  • 控制器

    	/**
    	 * 发送的请求是什么？
    	 * 
    	 * [email protected]
    	 * 
    	 * @RequestParam("empinfo")Employee employee; Employee employee =
    	 *                                  request.getParameter("empinfo");
    	 * 
    	 *                                  可以通过写一个自定义类型的转换器让其工作；
    	 * @param employee
    	 * @return
    	 */
    	@RequestMapping("/quickadd")
    	public String quickAdd(@RequestParam("empinfo") Employee employee) {
    		System.out.println("封装：" + employee);
    		employeeDao.save(employee);
    		return "redirect:/emps";
    	}
    

  • 页面

15. 数据格式化

• 日期格式化

  • 在bean中添加注解

    	@DateTimeFormat(pattern="yyyy-MM-dd")
    	private Date birth;
    

  • springmvc.xml中设置格式化器

        
        <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
            
            <property name="converters">
                <set>
                    <bean class="com.atguigu.component.MyStringToEmployeeConverter">bean>
                set>
            property>
        bean>
    

• 数字格式化同理

  	//为了显示方便
  	@NumberFormat(pattern="#,###.##")
  	private Double salary;
  

16. 数据校验

• JSR 303 是 Java 为 Bean 数据合法性校验提供的标准框架，它已经包含在 JavaEE 6.0 中

• JSR 303 通过在 Bean 属性上标注类似于 @NotNull、@Max 等标准的注解指定校验规则，并通过标准的验证接口对 Bean 进行验证

  

• 进行数据校验的步骤

  • 导入数据校验的包（ 有几个带el的jar不导入；tomcat中有；如果tomcat的版本是 7.0以下；tomcat7.0以上el表达式比较强大； 如果是7.0以下将带el的几个jar放在tomcat的 lib文件夹下；）

        核心校验包
        hibernate-validator-5.0.0.CR2.jar
    	hibernate-validator-annotation-processor-5.0.0.CR2.jar
    	依赖包
        classmate-0.8.0.jar
    	jboss-logging-3.1.1.GA.jar
    	validation-api-1.1.0.CR1.jar
    

  • 加上校验注解

    	@NotEmpty
    	@Length(min=6,max=18)
    	private String lastName;
    
    	@Email
    	private String email;
    	//1 male, 0 female
    	private Integer gender;
    	
    	private Department department;
    	
    	//@Past:必须是一个过去的时间
    	//@@Future:必须是未来的时间
    	@DateTimeFormat(pattern="yyyy-MM-dd")
    	@Future
    	private Date birth;
    

  • 在SpringMVC封装对象的时候，告诉SpringMVC这个javaBean需要校验

    	public String addEmp(@Valid Employee employee){
    

  • 给需要校验的javaBean后面紧跟一个BindingResult。这个BindingResult就是封装前一个bean的校验结果；

    	public String addEmp(@Valid Employee employee,BindingResult bindingResult)
    

  • 根据不同的校验结果决定接下来做什么

    		//获取是否有校验错误
    		boolean hasErrors=bindingResult.hasErrors();
    		if(hasErrors){
    			System.out.println("有校验错误");
    			return "add";
    		}else{
    			System.out.println(employee);
    			employeeDao.save(employee);
    			//返回列表页面,直接重定向查询所有员工请求
    			return "redirect:/emps";
    		}
    

  • 来到页面使用form:errors取出错误信息即可；

    	lastName:
    
    	email:
    
    

  • 如果是在普通的表单里，则将获取到的错误放进请求域中即可

    	Map<String,Object> errorsMap=new HashMap<String,Object>();
    		if(hasErrors){
    			
    		List<FieldError> errors=bindingResult.getFieldErrors();
    		for(FieldError fieldError : errors){
    			System.out.println("错误消息提示："+fieldError.getDefaultMessage());
    			System.out.println("错误的字段是："+fieldError.getField());
    			System.out.println(fieldError);
    			System.out.println("---------------");
    			errorsMap.put(fieldError.getField(), fieldError.getDefaultMessage());
    		}
    		model.addAttribute("errorInfo", errorsMap);
    		return "add";
    		}
    

    	lastName:--->${errorInfo.lastName}
    
    

• 国际化错误消息处理

  • 每一个字段发生错误以后，都会有自己的错误代码；国际化文件中错误消息的key必须对应一个错误代码

     codes
         [
              Email.employee.email,      校验规则.隐含模型中这个对象的key.对象的属性
              Email.email,                       校验规则.属性名
              Email.java.lang.String,      校验规则.属性类型
              Email
        ];
    

    • 如果是隐含模型中employee对象的email属性字段发生了@Email校验错误，就会生成 Email.employee.email;
    • Email.email：所有的email属性只要发生了@Email错误；
    • Email.java.lang.String,:只要是String类型发生了@Email错误
    • Email：只要发生了@Email校验错误；

  • 先编写国际化配置文件

  

• 让SpringMVC管理国际化资源文件；

      <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
          <property name="basename" value="errors">property>
      bean>
  

• 来到页面取值

• 高级国际化 动态传入消息参数；

{0}：永远都是当前属性名；{1}、{2}

• 实际上在获取时直接在注解中加message就好

17. SpringMVC使用ajax

• 导包

jackson-annotations-2.1.5.jar

jackson-core-2.1.5.jar

jackson-databind-2.1.5.jar

• 写配置

  @Controller
  public class AjaxTestController {
  	
  	@Autowired
  	EmployeeDao dao;
  	/**
  	 * 将返回的数据放在响应体中
  	 * 如果是对象，jackson包自动将对象转为json格式
  	 */
  	@ResponseBody
  	@RequestMapping("/getalljax")
  	public Collection<Employee> ajaxGetAll(){
  		Collection<Employee> all=dao.getAll();
  		return all;
  	}
  }
  
  

• 测试

  
  ajax请求
  
  
  
  
  
  
  

@Controller
public class AjaxTestController {
	
	@Autowired
	EmployeeDao employeeDao;
	
	/**
	 * SpringMVC文件下载；
	 * 
	 * @param request
	 * @return
	 * @throws Exception
	 */
	@RequestMapping("/download")
	public ResponseEntity<byte[]> download(HttpServletRequest request) throws Exception{
		
		//1、得到要下载的文件的流；
		//找到要下载的文件的真实路径
		ServletContext context = request.getServletContext();
		String realPath = context.getRealPath("/scripts/jquery-1.9.1.min.js");
		FileInputStream is = new FileInputStream(realPath);
		
		byte[] tmp = new byte[is.available()];
		is.read(tmp);
		is.close();
		
		//2、将要下载的文件流返回
		HttpHeaders httpHeaders = new HttpHeaders();
		httpHeaders.set("Content-Disposition", "attachment;filename="+"jquery-1.9.1.min.js");
		
		return new ResponseEntity<byte[]>(tmp, httpHeaders, HttpStatus.OK);
	}
	
	/**
	 * 将返回数据放在响应体中
	 * 
	 * ResponseEntity：响应体中内容的类型
	 * @return
	 */
	//@ResponseBody
	@RequestMapping("/haha")
	public ResponseEntity<String> hahah(){
		
		MultiValueMap<String, String> headers = new HttpHeaders();
		String body = "
success
";
		headers.add("Set-Cookie", "username=hahahaha");
		
		return new ResponseEntity<String>(body , headers, HttpStatus.OK);
	}
	
	/**
	 * 如果参数位置写HttpEntity  str;
	 * 比@RequestBody更强，可以拿到请求头；
	 *  @RequestHeader("")
	 * 
	 * @param str
	 * @return
	 */
	@RequestMapping("/test02")
	public String test02(HttpEntity<String>  str){
		System.out.println(str);
		return "success";
	}
	
	/**
	 * 
	 */
	@RequestMapping("/test01")
	public String test01(@RequestBody String str){
		System.out.println("请求体："+str);
		return "success";
	}
	
	/**
	 *  @RequestBody:请求体；获取一个请求的请求体
	 *  @RequestParam:
	 *  
	 *  @ResponseBody：可以把对象转为json数据，返回给浏览器
	 *  
	 *  @RequestBody：接受json数据，封装为对象
	 * @return
	 */
	@RequestMapping("/testRequestBody")
	public String testRequestBody(@RequestBody Employee employee){
		System.out.println("请求体："+employee);
		return "success";
	}
	
	/**
	 * 将返回的数据放在响应体中；
	 * 如果是对象，jackson包自动将对象转为json格式
	 * @return
	 */
	@ResponseBody
	@RequestMapping("/getallajax")
	public Collection<Employee> ajaxGetAll(){
		Collection<Employee> all = employeeDao.getAll();
		return all;
	}

}

18. 文件上传

• 文件上传表单准备

  ${msg}
  
  	用户头像：
  
  	用户头像：
  
  	用户头像：
  
  	用户头像：
  
  	用户名：
  	
  
  

• 导包

  commons-fileupload-1.2.1.jar
  commons-io-2.0.jar
  

• 只要在SpringMVC配置文件中，编写一个配置，配置文件上传解析器

  	
  	
  	<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  		<property name="maxUploadSize" value="#{1024*1024*20}">property>
  		
  		<property name="defaultEncoding" value="utf-8">property>
  	bean>
  

• 4.文件上传请求处理，在处理器方法上写一个@RequestParam(“headerimg”)MultipartFile file

  @Controller
  public class FileUploadController {
  	
  	@RequestMapping("/upload")
  	public String upload(@RequestParam(value="username",required=false)String username,
  				@RequestParam("headimg")MultipartFile[] file,
  				Model model){
  		System.out.println("上传文件的信息");
  		//System.out.println("文件的名字："+file.getName());
  		//System.out.println("文件的名字："+file.getOriginalFilename());
  		
  		//文件保存
  		for(MultipartFile multipartFile:file){
  			if(!multipartFile.isEmpty()){
  				try {
  					multipartFile.transferTo(new File("D:\\"+multipartFile.getOriginalFilename()));
  					model.addAttribute("msg", "文件上传成功");
  				} catch (Exception e) {
  					model.addAttribute("msg", "文件上传失败了");
  					e.printStackTrace();
  				}
  			}
  		}	
  		return "forward:/index.jsp";
  	}
  }
  

19. 拦截器

• SpringMVC提供了拦截器机制，允许运行目标方法之前进行一些拦截工作，或者目标方法运行之后进行一些其他处理；

  • Filter：javaWeb
  • HandlerInterceptor：SpringMVC

  • preHandle：在目标方法运行之前调用；返回boolean；return true；(chain.doFilter())放行； return false；不放行
  • postHandle：在目标方法运行之后调用：目标方法调用之后
  • afterCompletion：在请求整个完成之后；来到目标页面之后；chain.doFilter()放行；资源响应之后；
    

• 拦截器的使用步骤

  • 继承接口实现拦截器功能

    /**
     * 1、实现HandlerInterceptor接口
     * 2、在SpringMVC配置文件中注册这个拦截器的工作；
     * 		配置这个拦截器来拦截哪些请求的目标方法；
     * 
     *
     */
    public class MyFirstInterceptor implements HandlerInterceptor {
    
    	/**
    	 * 目标方法运行之前运行
    	 */
    	@Override
    	public boolean preHandle(HttpServletRequest request,
    			HttpServletResponse response, Object handler) throws Exception {
    		System.out.println("MyFirstInterceptor...preHandle...");
    		return true;
    	}
    
    	@Override
    	public void postHandle(HttpServletRequest request,
    			HttpServletResponse response, Object handler,
    			ModelAndView modelAndView) throws Exception {
    		System.out.println("MyFirstInterceptor...postHandle...");
    	}
    
    	@Override
    	public void afterCompletion(HttpServletRequest request,
    			HttpServletResponse response, Object handler, Exception ex)
    			throws Exception {
    		System.out.println("MyFirstInterceptor...afterCompletion");
    	}
    
    }
    

  • springmvc.xml进行配置

    	
    	<mvc:interceptors>
    		
    		<bean class="com.atguigu.controller.MyFirstInterceptor">bean>
    		
    		<mvc:interceptor>
    			
    			<mvc:mapping path="/test01"/>
    			<bean class="com.atguigu.controller.MySecondInterceptor">bean>
    		mvc:interceptor>
    	mvc:interceptors>
    

  • 测试

    @Controller
    public class InterceptorTestController {
    	@RequestMapping("/test01")
    	public String test01(){
    		System.out.println("test01....");
    		//int i =10/0;
    		return "success";
    	}
    }
    

  • 单个拦截器的运行流程：正常运行流程； 拦截器的preHandle------目标方法-----拦截器postHandle-----页面-------拦截器的afterCompletion;

  • 多个拦截器的运行流程：写在前面的先运行，但

    • 流程：filter的流程；

    • 拦截器的preHandle：是按照顺序执行拦截器的

    • postHandle：是按照逆序执行拦截器的

    • afterCompletion：是按照逆序执行；

    • 已经放行了的拦截器的afterCompletion总会执行；

    • MyFirstInterceptor...preHandle...
      MySecondInterceptor...preHandle...
      test01....
      MySecondInterceptor...postHandle...
      MyFirstInterceptor...postHandle...
      success.jsp....
      MySecondInterceptor...afterCompletion...
      MyFirstInterceptor...afterCompletion
      

  • 单个拦截器流程
    

• 多个拦截器流程
  

• 有异常的情况

• 什么时候用Filter什么时候用拦截器？如果某些功能；需要其他组件配合完成，我们就使用拦截器；其他情况可以写filter；

20. 异常处理

• ExceptionHandler处理局部异常

  	/**
  	 * 告诉SpringMVC这个方法专门处理这个类发生的异常 1、给方法上随便写一个Exception，用来接受发生的异常
  	 * 2、要携带异常信息不能给参数位置写Model； 3、返回ModelAndView就行了；
  	 * 4、如果有多个@ExceptionHandler都能处理这个异常，精确优先 5、全局异常处理与本类同时存在，本类优先；
  	 */
  	@ExceptionHandler(value = { Exception.class })
  	public ModelAndView handleException01(Exception exception) {
  		System.out.println("本类的：handleException01..." + exception);
  		//
  		ModelAndView view = new ModelAndView("myerror");
  		view.addObject("ex", exception);
  		// 视图解析器拼串
  		return view;
  	}
  

• ExceptionHandler处理全局异常

  /**
   * 集中处理所有异常
   * @author lfy
   * 
   * 1、集中处理所有异常的类加入到ioc容器中
   * 2、@ControllerAdvice专门处理异常的类
   */
  @ControllerAdvice
  public class MyJiZhongException {
  	
  	@ExceptionHandler(value={ArithmeticException.class})
  	public ModelAndView handleException01(Exception exception){
  		System.out.println("全局的：handleException01..."+exception);
  		//
  		ModelAndView view = new ModelAndView("myerror");
  		view.addObject("ex", exception);
  		//视图解析器拼串
  		return view;
  	}
  	
  	@ExceptionHandler(value={Exception.class})
  	public ModelAndView handleException02(Exception exception){
  		System.out.println("全局的：handleException02..."+exception);
  		//
  		ModelAndView view = new ModelAndView("myerror");
  		view.addObject("ex", exception);
  		//视图解析器拼串
  		return view;
  	}
  
  }
  

• @ResponseStatus;给自定义异常上标注的

  @ResponseStatus(reason="用户被拒绝登陆",value=HttpStatus.NOT_ACCEPTABLE)
  public class UserNameNotFoundException extends RuntimeException {
  
  	private static final long serialVersionUID = 1L;
  	
  }
  

• DefaultHandlerExceptionResolver:判断是否SpringMVC自带的异常

  try {
              if (ex instanceof NoSuchRequestHandlingMethodException) {
                  return handleNoSuchRequestHandlingMethod((NoSuchRequestHandlingMethodException) ex, request, response,
                          handler);
              }
              else if (ex instanceof HttpRequestMethodNotSupportedException) {
                  return handleHttpRequestMethodNotSupported((HttpRequestMethodNotSupportedException) ex, request,
                          response, handler);
              }
              else if (ex instanceof HttpMediaTypeNotSupportedException) {
                  return handleHttpMediaTypeNotSupported((HttpMediaTypeNotSupportedException) ex, request, response,
                          handler);
              }
              else if (ex instanceof HttpMediaTypeNotAcceptableException) {
                  return handleHttpMediaTypeNotAcceptable((HttpMediaTypeNotAcceptableException) ex, request, response,
                          handler);
              }
              else if (ex instanceof MissingServletRequestParameterException) {
                  return handleMissingServletRequestParameter((MissingServletRequestParameterException) ex, request,
                          response, handler);
              }
              else if (ex instanceof ServletRequestBindingException) {
                  return handleServletRequestBindingException((ServletRequestBindingException) ex, request, response,
                          handler);
              }
              else if (ex instanceof ConversionNotSupportedException) {
                  return handleConversionNotSupported((ConversionNotSupportedException) ex, request, response, handler);
              }
              else if (ex instanceof TypeMismatchException) {
                  return handleTypeMismatch((TypeMismatchException) ex, request, response, handler);
              }
              else if (ex instanceof HttpMessageNotReadableException) {
                  return handleHttpMessageNotReadable((HttpMessageNotReadableException) ex, request, response, handler);
              }
              else if (ex instanceof HttpMessageNotWritableException) {
                  return handleHttpMessageNotWritable((HttpMessageNotWritableException) ex, request, response, handler);
              }
              else if (ex instanceof MethodArgumentNotValidException) {
                  return handleMethodArgumentNotValidException((MethodArgumentNotValidException) ex, request, response, handler);
              }
              else if (ex instanceof MissingServletRequestPartException) {
                  return handleMissingServletRequestPartException((MissingServletRequestPartException) ex, request, response, handler);
              }
              else if (ex instanceof BindException) {
                  return handleBindException((BindException) ex, request, response, handler);
              }
              else if (ex instanceof NoHandlerFoundException) {
                  return handleNoHandlerFoundException((NoHandlerFoundException) ex, request, response, handler);
              }
          }
          catch (Exception handlerException) {
              logger.warn("Handling of [" + ex.getClass().getName() + "] resulted in Exception", handlerException);
          }
          return null;
      }
  

• SimpleMappingExceptionResolver：通过配置的方式进行异常处理

  	<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
  		
  		<property name="exceptionMappings">
  			<props>
  				
  				<prop key="java.lang.NullPointerException">myerrorprop>
  			props>
  		property>
  		
  		<property name="exceptionAttribute" value="ex">property>
  	bean>
  

• 几种异常的运行顺序

  

21. SpringMVC处理流程

• 所有请求，前端控制器（DispatcherServlet）收到请求，调用doDispatch进行处理

• 根据HandlerMapping中保存的请求映射信息找到，处理当前请求的，处理器执行链（包含拦截器）

• 根据当前处理器找到他的HandlerAdapter（适配器）

• 拦截器的preHandle先执行

• 适配器执行目标方法，并返回ModelAndView

  • ModelAttribute注解标注的方法提前运行

  • 执行目标方法的时候（确定目标方法用的参数）

    • 有注解

    • 没注解：

      • 看是否Model、Map以及其他的

      • 如果是自定义类型

        • 从隐含模型中看有没有，如果有就从隐含模型中拿
        • 如果没有，再看是否SessionAttributes标注的属性，如果是从Session中拿，如果拿不到会抛异常
        • 都不是，就利用反射创建对象

• 拦截器的postHandle执行

• 处理结果；（页面渲染流程）

  • 如果有异常使用异常解析器处理异常；处理完后还会返回ModelAndView

  • 调用render进行页面渲染

    • 视图解析器根据视图名得到视图对象
    • 视图对象调用render方法

  • 执行拦截器的afterCompletion；

• 流程图

22. SpringMVC与Spring整合

• SpringMVC和Spring整合的目的；分工明确；SpringMVC的配置文件就来配置和网站转发逻辑以及网站功能有关的（视图解析器，文件上传解析器，支持ajax，xxx）；Spring的配置文件来配置和业务有关的（事务控制，数据源，xxx）；

  <import resource="spring.xml"/>：可以合并配置文件；
  
  

• Spring管理业务逻辑组件；

      <context:component-scan base-package="com.atguigu">
          <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
          <context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
      context:component-scan>
  

• SpringMVC管理控制器组件；

      <context:component-scan base-package="com.atguigu" use-default-filters="false">
          <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
          <context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
      context:component-scan>
  

• Spring是一个父容器，SpringMVC是一个子容器；子容器还可以引用父容器的组件；父容器不能引用子容器的组件；

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Md8geypC-1597504590212)(F:\markdown\ssm\Spring\image\Image [56].png)]

y：异常全类名；value：要去的页面视图名； -->

  			myerror
  		
  	
  	
  	
  

* 几种异常的运行顺序

[外链图片转存中...(img-RopC0YPb-1597504590210)]

21. SpringMVC处理流程

• 所有请求，前端控制器（DispatcherServlet）收到请求，调用doDispatch进行处理

• 根据HandlerMapping中保存的请求映射信息找到，处理当前请求的，处理器执行链（包含拦截器）

• 根据当前处理器找到他的HandlerAdapter（适配器）

• 拦截器的preHandle先执行

• 适配器执行目标方法，并返回ModelAndView

  • ModelAttribute注解标注的方法提前运行

  • 执行目标方法的时候（确定目标方法用的参数）

    • 有注解

    • 没注解：

      • 看是否Model、Map以及其他的

      • 如果是自定义类型

        • 从隐含模型中看有没有，如果有就从隐含模型中拿
        • 如果没有，再看是否SessionAttributes标注的属性，如果是从Session中拿，如果拿不到会抛异常
        • 都不是，就利用反射创建对象

• 拦截器的postHandle执行

• 处理结果；（页面渲染流程）

  • 如果有异常使用异常解析器处理异常；处理完后还会返回ModelAndView

  • 调用render进行页面渲染

    • 视图解析器根据视图名得到视图对象
    • 视图对象调用render方法

  • 执行拦截器的afterCompletion；

• 流程图

  [外链图片转存中…(img-yIdgPSKY-1597504590211)]

22. SpringMVC与Spring整合

• SpringMVC和Spring整合的目的；分工明确；SpringMVC的配置文件就来配置和网站转发逻辑以及网站功能有关的（视图解析器，文件上传解析器，支持ajax，xxx）；Spring的配置文件来配置和业务有关的（事务控制，数据源，xxx）；

  <import resource="spring.xml"/>：可以合并配置文件；
  
  

• Spring管理业务逻辑组件；

      <context:component-scan base-package="com.atguigu">
          <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
          <context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
      context:component-scan>
  

• SpringMVC管理控制器组件；

      <context:component-scan base-package="com.atguigu" use-default-filters="false">
          <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
          <context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
      context:component-scan>
  

• Spring是一个父容器，SpringMVC是一个子容器；子容器还可以引用父容器的组件；父容器不能引用子容器的组件；