【SSM框架】SpringMVC学习总结

SpringMVC概述

SpringMVC是一种基于Java的实现MVC设计模型的请求驱动类型的轻量级Web框架，属于SpringFrameWork的后续产品，已经融合在Spring Web Flow中。
SpringMVC已经成为目前最主流的MVC框架之一, 并粗随着Spring3.0 的发布，全面超越Struts2,成为最优秀的MVC框架。它通过一套注解, 让一个简单的Java类成为处理请求的控制器,而无须实现任何接口。同时它还支持RESTful编程风格的请求。

SpringMVC的执行流程

①用户发送请求至前端控制器DispatcherServlet.
②DispatcherServlet收到请求调用HandlerMapping处理器映射器。
③处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)， 生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet.
④DispatcherServlet调用HandlerAdapter处理器适配器。
⑤HandlerAdapter经过适配调用具体的处理器(Controller,也叫后端控制器)。
⑥Controller执行完成返回ModelAndView。
⑦HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet.
⑧DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
⑨ViewReslover解析后返回具体View，DispatcherServlet根据View进行渲染视图 (即将模型数据填充至视图中)DispatcherServlet响应用户。

SpringMVC快速入门

需求:客户端发起请求服务器端接收请求,执行逻辑并进行视图跳转。
开发步骤:
①导入SpringMVC相关坐标（spring-webmvc）
②配置SpringMVC核心控制器DispathcerServlet

<!--配置Spring-mvc的前端控制器-->
  <servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

③创建Controller类和视图页面
④使用注解配置Controller类中业务方法的映射地址
⑤配置SpringMVC核心文件spring-mvc.xml
⑥客户端发起请求测试

SpringMVC注解解析

@RequestMapping
作用:用于建立请求URL和处理请求方法之间的对应关系
位置:
●类上,请求URL的第一级访问目录。此处不写的话，就相当于应用的根目录
●方法上，请求URL的第二 级访问目录,与类上的使用@ReqquestMapping标注的一 级目录起组成访问虚拟路径
属性:
value:用于指定请求的URL。它和path属性的作用是一 样的
method:用于指定请求的方式
params:用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的-模- -样
例如:
params = {“accountName”},表示请求参数必须有accountName
params = {“money!100”},表示请求参数中money不能是100

@RequestMapping(value = "/quick",method = RequestMethod.GET,params = ("username"))//http://localhost:8080/user/quick?username=xxx
    public String save(){
        System.out.println("Controller save running...");
        return "success";
    }

视图解析器

SpringMvc有默认组件配置，默认组件都是Di spatcherServlet. properties配置文件中配置的,该配置文件地org/springframework/web/servlet/DispatcherServlet. properties,该文件中配置了默认的视图解析器，如下:
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
翻看该解析器源码，可以看到该解析器的默认设置，如下:
REDIRECT URI PREFIX = " redirect:" – 重定向前缀
FORWARD URL PREFIX =” forward:" --转发前缀(默认值)
prefix = “”;–视图名称前缀
suffix = “”;–视图名称后缀

	<!--配置内部资源视图解析器-->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

SpringMVC的相关组件

●前端控制器: DispatcherServlet
●处理器映射器: HandlerMapping
●处理器适配器: HandlerAdapter
●处理器: Handler
●视图解析器: View Resolver
●视图: View

SpringMVC的注解和配置

请求映射注解: @RequestMappingl
视图解析器配置:
REDIRECT URL PREFIX = “redirect:”
FORWARD_ URL_ PREFIX = "forward:’
prefix= ";
suffix= ";

	//重定向，默认转发
	@RequestMapping(value = "/quick")
    public String save(){
        System.out.println("Controller save running...");
        return "redirect:success.jsp";
    }

SpringMVC的数据响应方式

1. 页面跳转
   ●直接返回字符串

	@RequestMapping(value = "/quick",method = RequestMethod.GET,params = ("username"))//http://localhost:8080/user/quick?username=xxx
    public String save(){
        System.out.println("Controller save running...");
        return "success";
    }

●通过ModelAndView对象返回

	 @RequestMapping("/quick2")
    public ModelAndView save2(){
        System.out.println("Controller save running...");
        /*
            model: 模型，封装数据
            view： 视图，展示数据
        */
        ModelAndView modelAndView = new ModelAndView();
        //设置模型数据
        modelAndView.addObject("username","itcast");
        //设置视图名称
        modelAndView.setViewName("success");
        return modelAndView;
    }

    @RequestMapping("/quick3")
    public ModelAndView save3(ModelAndView modelAndView){
        modelAndView.addObject("username","hmyll");
        modelAndView.setViewName("success");
        return modelAndView;
    }

    @RequestMapping("/quick4")
    public String save4(Model model){
        model.addAttribute("username","hmyll");
        return "success";
    }

    @RequestMapping("/quick5")
    public String save5(HttpServletRequest request){
        request.setAttribute("username","hmyll");
        return "success";
    }

2)写数据
●直接返回字符串
●返回对象或集合

   <!--配置处理器映射器-->
    <!--<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">-->
        <!--<property name="messageConverters">-->
            <!--<list>-->
                <!--<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>-->
            <!--</list>-->
        <!--</property>-->
    <!--</bean>-->

    <!--mvc的注解驱动-->
    <mvc:annotation-driven/>

    @RequestMapping("/quick6")
    public void save6(HttpServletResponse response) throws IOException {
        response.getWriter().print("hello!");
    }

    @RequestMapping("/quick7")
    @ResponseBody   //告知SpringMVC框架，不进行页面跳转，直接进行数据响应
    public String save7() throws IOException {
        return "hello! ddd";
    }

    @RequestMapping("/quick8")
    @ResponseBody   //告知SpringMVC框架，不进行页面跳转，直接进行数据响应
    public String save8() throws IOException {
        return "{\'username\':\'zhangsan\',\'age\',18}";
    }

    @RequestMapping("/quick9")
    @ResponseBody   //告知SpringMVC框架，不进行页面跳转，直接进行数据响应
    public String save9() throws IOException {
        User user = new User("lisi", 49);
        //使用json的格式转换工具将对象转化成为json格式的字符串返回
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(user);
        return json;
    }

    @RequestMapping("/quick10")
    @ResponseBody
    //期望SpringMVC自动将User转化成json格式的字符串
    public User save10() throws IOException {
        User user = new User("lisi", 50);
        return user;
    }

获得请求参数

客户端请求参数的格式是: name=value&name=vale…
服务器端要获得请求的参数,有时还需要进行数据的封装，SpringMVC 可以接收如下类型的参数:

基本类型参数

Controller中的业务方法的参数名称要与请求参数的name-致, 参数值会自动映射匹配。

	//http://localhost:8080/user/quick11?username=zhang&age=12
	@RequestMapping("/quick11")
    @ResponseBody
    public void save11(String username,int age) throws IOException {
        System.out.println(username);
        System.out.println(age);
    }

POJO类型参数

Controller中的业务方法的POJO参数的属性名与请求参数的name-致, 参数值会自动映射匹配。

	//http://localhost:8080/quick12?username=zhang&age=11
    @RequestMapping("/quick12")
    @ResponseBody
    public void save12(User user) throws IOException {
        System.out.println(user);
    }

数组类型参数

Controller中的业务方法数组名称与请求参数的name-致,参数值会自动映射匹配。

	//http://localhost:8080/quick13?str=1&str=2&str=3
    @RequestMapping("/quick13")
    @ResponseBody
    public void save13(String[] str) throws IOException {
        System.out.println(Arrays.asList(str));
    }

集合类型参数

获得集合参数时，要将集合参数包装到一一个POJO中才可以。

form表格形式

	<form action="${pageContext.request.contextPath}/user/quick14" method="post">
        <%--表明是User的对象--%>
        <input type="text" name="userList[0].username"><br>
        <input type="text" name="userList[0].age"><br>
        <input type="text" name="userList[1].username"><br>
        <input type="text" name="userList[1].age"><br>
        <input type="submit" name="提交">
    </form>

@RequestMapping("/quick14")
    @ResponseBody
    public void save14(VO vo) {
        System.out.println(vo);
    }

Ajax请求

1.引入jquary资源
2.xml配置引入静态资源（两种方式）

	<!--开发资源的访问 mapping:访问路径，location：资源地址-->
    <!--<mvc:resources mapping="/js/**" location="/js/"/>-->
    <!--<mvc:resources mapping="/img/**" location="/img/"/>-->

    <mvc:default-servlet-handler/>

3.jsp页面提交数据，ajax封装

<script src="${pageContext.request.contextPath}/js/jquary.js"></script>
   <script>
       var userList = new Array();
       userList.push({name:"zhang",age:18});
       userList.push({name:"li",age:28});

       $.ajax({
           type:"POST",
           url:"${pageContext.request.contextPath}/user/quick15",
           data:JSON.stringify(userList),
           contentType:"application/json;charset=utf-8"
       });
   </script>

4.输出数据

@RequestMapping("/quick15")
   @ResponseBody
   public void save15(@RequestBody List<User> userList){
       System.out.println(userList);
   }

请求数据乱码问题（filter）

当post请求时，数据会出现乱码,我们可以设置一个过滤器来进行编码的过滤。

<!--配置全局过滤的filter-->
  <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>

参数绑定注解@requestParam

当请求的参数名称与Controller的业务方法参数名称不一致时， 就需要通过@RequestParam注解显示的绑定。
注解@RequestParam还有如下参数可以使用:
value:与请求参数名称
required: 此在指定的请求参数是否必须包括，默认是true,提交时如果没有此参数则报错
defaultValue: 当没有指定请求参数时,则使用指定的默认值赋值

//http://localhost:8080/user/quick16?name=zhangsan
//http://localhost:8080/user/quick16
@RequestMapping("/quick16")
@ResponseBody
public void save16(@RequestParam(value = "name",required = false,defaultValue = "incast") String username) {
    System.out.println(username);
}

获得Restful风格的参数

Restful是一种软件架构风格、设计风格,而不是标准，只是提供了一组设计原则和约束条件。 主要用于客户端和服务
器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制等。
Restful风格的请求是使用“url+ 请求方式”表示次请求目的的, HTTP协议里面四个表示操作方式的动词如下:
GET:用于获取资源
POST:用于新建资源.
PUT:用于更新资源.
DELETE: 用于删除资源.
例如:
/user/1 GET :得到id= 1的user
/user/1 DELETE: 删除id= 1的user
/user/1 PUT:更新id= 1的
user/user POST:新增user

	//http://localhost:8080/user/quick17/zhangsan
    @RequestMapping(value = "/quick17/{name}")
    @ResponseBody
    public void save17(@PathVariable(value = "name") String username) {
        System.out.println(username);
    }

自定义类型转换器

●SpringMVC 默认已经提供了一些常用的类型转换器, 例如客户端提交的字符串转换成int型进行参数设置。
●但是不是所有的数据类型都提供了转换器,没有提供的就需要自定义转换器，例如:日期类型的数据就需要自定义转换器。

提交的数据为格式date=2021/1/8不用手动编写转换器，框架自动转换；若格式为date=2021-1-8则需自定义类型转换器。

自定义类型转换器的开发步骤:
①定义转换器类实现Converter接口

import org.springframework.core.convert.converter.Converter;
public class DateConverter implements Converter<String, Date> {
    public Date convert(String datestr) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-mm-dd");
        Date date = null;
        try {
            date = format.parse(datestr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

②在配置文件中声明转换器

    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <list>
                <bean class="com.ithiema.converter.DateConverter"/>
            </list>
        </property>
    </bean>

③在 中用转换器

	<!--mvc的注解驱动-->
    <mvc:annotation-driven conversion-service="conversionService"/>

实现：

	//http://localhost:8080/user/quick18/?date=2021-1-8
    @RequestMapping(value = "/quick18")
    @ResponseBody
    public void save18(Date date) {
        System.out.println(date);
    }

获得请求头

@RequestHeader

使用@RequestHeader可以获得请求头信息，相当于web阶段学习的request.getHeader(name)
@RequestHeader注解的属性如下: .
●value: 请求头的名称
●required: 是否必须携带此请求头

@RequestMapping(value = "/quick20")
@ResponseBody
public void save20(@RequestHeader(value = "User-Agent",required = false)String user_agent) {
    System.out.println(user_agent);
}

@CookieValue

使用@CookieValue可以获得指定Cookie的值
@CookieValue注解的属性如下:
●value: 指定cookie的名称
●required: 是否必须携带此cookie

@RequestMapping(value = "/quick21")
@ResponseBody
public void save21(@CookieValue(value = "JSESSIONID")String jsessionid) {
   System.out.println(jsessionid);
}

文件上传

文件上传客户端3要素;

●表单项type= “file”
●表单的提交方式是post
●表单的enctype属性是多部分表单形式,及enctype= "multipart/form-data’

<form action="${pageContext.request.contextPath}/user/quick22" enctype="multipart/form-data">
   名称：<input type="text" name="name"/><br>
   文件：<input type="file" name="file"/><<br>
   <input type="submit" value="提交"/><br>
</form>

文件上传原理

●当form表单修改为多部分表单时,request.getParameter0将失效。
●enctype=“application/x-www-form-urlencoded” 时，form表单的正文内容格式是:key=value&key=value&key=value
●当form表单的enctype取值为Mutilpart/form-data时,请求正文内容就变成多部分形式:

@RequestMapping(value = "/quick22")
    @ResponseBody
    public void save22(String name,MultipartFile uploadFile) throws IOException {
        System.out.println(name);
        String originalFilename = uploadFile.getOriginalFilename();
        uploadFile.transferTo(new File("E:\\upload"+originalFilename));
    }

多文件上传

	<form action="${pageContext.request.contextPath}/user/quick22" method="post" enctype="multipart/form-data">
        名称：<input type="text" name="name"/><br>
        文件：<input type="file" name="uploadFile"/><<br>
        文件：<input type="file" name="uploadFile2"/><<br>
        <input type="submit" value="提交"/><br>
    </form>

    <form action="${pageContext.request.contextPath}/user/quick23" method="post" enctype="multipart/form-data">
        名称：<input type="text" name="name"/><br>
        文件：<input type="file" name="uploadFile"/><<br>
        文件：<input type="file" name="uploadFile"/><<br>
        <input type="submit" value="提交"/><br>
    </form>

	@RequestMapping(value = "/quick22")
    @ResponseBody
    public void save22(String name,MultipartFile uploadFile,MultipartFile uploadFile2) throws IOException {
        System.out.println(name);
        String originalFilename = uploadFile.getOriginalFilename();
        uploadFile.transferTo(new File("E:\\upload\\"+originalFilename));
        String originalFilename2 = uploadFile2.getOriginalFilename();
        uploadFile2.transferTo(new File("E:\\upload\\"+originalFilename2));
    }

    @RequestMapping(value = "/quick23")
    @ResponseBody
    public void save23(String name,MultipartFile[] uploadFile) throws IOException {
        System.out.println(name);
        for (MultipartFile multipartFile : uploadFile) {
            String originalFilename = multipartFile.getOriginalFilename();
            multipartFile.transferTo(new File("E:\\upload\\"+originalFilename));
        }
    }

SpringMVC拦截器

拦截器(interceptor) 的作用

Spring MVC的拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。
将拦截器按一定的顺序联结成一 条链, 这条链称为拦截器链(Interceptor Chain).在访问被拦截的方
法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体实现。

拦截器是快速入门

自定义拦截器很简单，只有如下三步:
①创建拦截器类实现HandlerInterceptor接口
②配置拦截器
③测试拦截器的拦截效果

@RequestMapping("target")
public ModelAndView target(){
     System.out.println("目标资源访问中。。。");
     ModelAndView modelAndView = new ModelAndView();
     modelAndView.addObject("name","hmyll");
     modelAndView.setViewName("index.jsp");
     return modelAndView;
 }

public class MyInterceptor2 implements HandlerInterceptor {

    //目标方法执行之前 执行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle2...");
        return true;//返回false代表不放行 返回true代表放行
    }

    //目标方法执行之前，视图返回之后 执行
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle2...");
    }

    //所有流程执行完毕之后 执行
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion2...");
    }
}

<mvc:interceptors>
   <mvc:interceptor>
       <mvc:mapping path="/**"/>
       <bean class="com.aynu.intercepor.MyInterceptor"/>
   </mvc:interceptor>
   <mvc:interceptor>
       <mvc:mapping path="/**"/>
       <bean class="com.aynu.intercepor.MyInterceptor2"/>
   </mvc:interceptor>
</mvc:interceptors>

SpringMVC异常处理

异常处理的思路

系统中异常包括两类:预期异常和运行时异常RuntimeException,前者通过捕获异常从而获取异常信息，后
者主要通过规范代码开发、测试等手段减少运行时异常的发生。
系统的Dao、Service、 Controller出现都通过throws Exception向.上抛出，最后由SpringMVC前端控制器交
由异常处理器进行异常处理，如下图:
在这里插入图片描述

简单异常处理器SimpleMappingExceptionResolver

SpringMVC已经定义好了该类型转换器,在使用时可以根据项目情况进行相应异常与视图的映射配置

 @RequestMapping(value = "/show")
public String show() throws FileNotFoundException, MyException {
    System.out.println("show running......");
    //demoService.show1();
    //demoService.show2();
    //demoService.show3();
    //demoService.show4();
    demoService.show5();
    return "index";
}

 <!--配置异常处理器-->
 <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
     <!--<property name="defaultErrorView" value="error"/>-->
     <property name="exceptionMappings">
         <map>
             <entry key="java.lang.ClassCastException" value="error1"/>
             <entry key="com.itheima.exception.MyException" value="error2"/>
         </map>
     </property>
 </bean>

自定义异常处理步骤

①创建异常处理器类实现HandlerExceptionResolver
②配置异常处理器
③编写异常页面
④测试异常跳转

public class MyExceptionResolver implements HandlerExceptionResolver {
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
        ModelAndView modelAndView = new ModelAndView();
        if(e instanceof ClassCastException){
            modelAndView.addObject("info","类转换异常");
        }else if(e instanceof MyException){
            modelAndView.addObject("info","自定义异常");
        }
        modelAndView.setViewName("error");
        return modelAndView;
    }
}

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