SpringMVC

概述

SpringMVC是一种基于Java的实现MVC设计模型的请求驱动类型的轻量级Web框架,属于SpringFrameWork的后续产品,已经融合在Spring Web Flow 中。

快速入门

需求:客户端发起请求,服务端接收请求,执行逻辑并进行视图跳转

开发步骤:

  1. 导入SpringMVC坐标

    <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.2.9.RELEASE</version>
    </dependency>
  2. 配置SpringMVC核心控制器DispathcerServlet

    <!--配置SpringMVC的前端控制器-->
    <servlet>
     <servlet-name>DispatherServlet</servlet-name>
     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--启动时访问-->
     <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
     <servlet-name>DispatherServlet</servlet-name>
    <!--缺省值全访问控制器-->
     <url-pattern>/</url-pattern>
    </servlet-mapping>
  3. 创建Controller类和视图界面

  4. 使用注解配置Controller类中业务方法的映射地址

    //将此类放入Spring容器中
    @Controller
    public class UserController {
        //SpringMVC映射此类
        @RequestMapping("/quick")
        public String save(){
            System.out.println("Controller save Running~~~");
            //跳转界面
            return "success.jsp";
        }
    }
  5. 配置SpringMVC核心文件spring-mvc.xml

    <!--controller的组件扫描-->
    <context:component-scan base-package="controller"/>
SpringMVC组件解析
graph TD A[客户端] -->|1.请求| B[前端控制器DispatcherServlet] B -->|2.请求查询Handler| C[处理器映射器HandlerMapping] C -->|3.返回处理器执行链HandlerExecutionChain| B B -->|4.请求执行Handler| D[处理器适配器] D -->|5.请求| E[处理器Handler] E -->|6.响应| D D -->|7.返回ModelAndView| B B -->|8.请求视图解析器| F[视图解析器ViewResolver] F -->|9.返回视图View对象| B B -->|10.渲染视图| G[视图界面] B -->|11.响应| A
SpringMVC注解解析

@RequestMapping("地址")

用户建立URL域请求处理方法之间的关系,可以应用在类上或方法上

  • 类上:请求URL的第一级访问目录,此出不写就相当于根目录
  • 方法上:请求URL的第二级访问目录,与类上的使用@RequestMapping标注的一级目录一起组成访问虚拟路径

属性

  • value:用户指定请求的URL,它和path属性的作用是一样的
  • method:用于指定请求的方式
  • params:用于指定限制请求参数的条件,它支持简单的表达式,要求请求参数的key和value必须配置的一模一样
  • 例:
    • params = {"username"} ,表示请求参数必须有username
    • params = {"money!100"} ,表示请求参数中的money不能是100
//将此类放入Spring容器中
@Controller
public class UserController {
    //SpringMVC映射此类
    @RequestMapping("/quick")
    public String save(){
        System.out.println("Controller save Running~~~");
        //跳转界面
        return "success.jsp";
    }
}

return关键字:

  • 属性:
    • redirect:重定向 return "redirect:页面名"
    • forward:转发 return "forward:页面名"
  • 默认是转发(forward)
SpringMVC-XML配置
<!--配置内部资源配置解析器-->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
   <!--资源前缀:/jsp/success.jsp-->
   <property name="prefix" value="/jsp/" />
   <!--资源后缀:success.jsp ==> success-->
   <property name="suffix" value=".jsp" />
</bean>
SpringMVC数据响应

响应方式:

  • 页面跳转

    • 直接返回字符串

      • 此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转

        return "success";

        <!--资源前缀:/jsp/success.jsp-->
        <property name="prefix" value="/jsp/" />
        <!--资源后缀:success.jsp ==> success-->
        <property name="suffix" value=".jsp" />

        转发资源地址:/jsp/success.jsp

    • 通过ModelAndView对象返回

      • ModelAndView

        //SpringMVC映射此类
        @RequestMapping("/quick1")
        public ModelAndView save1(){
           /*
             model:模型,封装数据
             view:视图,展示界面
           */
           ModelAndView modelAndView = new ModelAndView();
           //设置视图模型
           modelAndView.addObject("username","IMAU");
           //设置视图名,与return "success";功能一致
           modelAndView.setViewName("success");
           return modelAndView;
        }
      • ModelAndView参数型:参数会由SpringMVC框架注入

        //SpringMVC映射此类
        @RequestMapping("/quick2")
        public ModelAndView save2(ModelAndView modelAndView){
           modelAndView.addObject("username","IMAU");
           modelAndView.setViewName("success");
           return modelAndView;
        }
      • Model与String拼接型:参数会由SpringMVC框架注入

        //SpringMVC映射此类
        @RequestMapping("/quick3")
        public String save3(Model model){
           model.addAttribute("username","内蒙古农业大学");
           return "success";
        }
  • 回写数据

    • 直接返回字符串

      • 通过SpringMVC框架注入的Response对象,使用response.getWriter().print("")回写数据,此时不需要视图跳转,业务方法返回值为void

        //SpringMVC映射此类
        @RequestMapping("/quick5")
        public void save5(HttpServletResponse response) throws IOException {
          response.setContentType("text/html;charset=utf8");
          response.getWriter().print("Hello 内蒙古");
        }
      • 将字符串直接return返回,但此时需要通过@ResponseBody注解告知SpringMVC框架,方法返回的字符串不是跳转是直接在http响应体上返回

        //SpringMVC映射此类
        @ResponseBody //告诉SpringMVC框架不进行视图跳转,直接数据响应
        @RequestMapping("/quick6")
        public String save6() throws IOException {
           return "Hello 内蒙古";
        }
    • 返回对象或集合

      • 添加MVC注解驱动:会调用Jackson直接将对象转为json格式

        <!--mvc注解驱动-->
            <mvc:annotation-driven/>
      • 编写方法

        //SpringMVC映射此类
        @ResponseBody
        @RequestMapping("/quick8")
        public User save8() throws IOException {
          User user = new User();
          user.setName("iimau");
          user.setAge(20);
          //使用Jackson将对象转为json格式返回
          return user;
        }
SpringMVC获得请求数据

SpringMVC接收类型的参数

  • 基本类型参数

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

      http://localhost:8080/quick9?username=zhangsan&age=20

      //SpringMVC映射此类
      @ResponseBody
      @RequestMapping("/quick9")
      public void save9(String username,int age) throws IOException {
        System.out.println(username+":"+age);
      }
      
      zhangsan:20
  • POJO类型参数

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

      http://localhost:8080/quick10?username=lisi&age=30

      //SpringMVC映射此类
      @ResponseBody
      @RequestMapping("/quick10")
      public void save10(User user) throws IOException {
         System.out.println(user);
      }
      
      User{username='lisi', age=30}
  • 数组类型参数

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

      http://localhost:8080/quick11?strs=aaa&strs=bbb&strs=ccc

      //SpringMVC映射此类
      @ResponseBody
      @RequestMapping("/quick11")
      public void save11(String[] strs) throws IOException {
        System.out.println(Arrays.asList(strs));
      }
      
      [aaa, bbb, ccc]
  • 集合类型参数

    • 获得集合参数时,要将集合参数包装到POJO中才可以

      新建一个POJO包装集合

      public class Vo {
          private List<User> userList;
      
          public List<User> getUserList() {
              return userList;
          }
      
          public void setUserList(List<User> userList) {
              this.userList = userList;
          }
      
          @Override
          public String toString() {
              return "Vo{" +
                      "userList=" + userList +
                      '}';
          }
      }

      编写JSP文件

      <body>
          <form action="${pageContext.request.contextPath}/quick13" method="post">
              <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" value="提交">
          </form>
      </body>

      编写接收类

      @ResponseBody
      @RequestMapping("/quick13")
      public void save13(Vo vo) throws IOException {
         System.out.println(vo);
      }
      
      Vo{userList=[User{username='zhangsan', age=18}, User{username='wangwu', age=80}]}
    • 在使用ajax提交时,可以指定contentType为json形式,那么在方法参数位置使用@RequestBody可以直接接收集合数据而无需使用POJO进行包装

      <script>
        var userlist = new Array();
        userlist.push({username:"zhangsan",age:20})
        userlist.push({username:"lisi",age:40})
        $.ajax({
           type:"POST",
           url:"${pageContext.request.contextPath}/quick12",
           data:JSON.stringify(userlist),
           contentType:"application/json;charset=utf-8"
        });
      </script>
      //SpringMVC映射此类
      @ResponseBody
      @RequestMapping("/quick12")
      public void save12(@RequestBody List<User> userList) throws IOException {
         System.out.println(userList);
      }
      
      [User{username='zhangsan', age=20}, User{username='lisi', age=40}]
静态资源访问

两种方式:

  • <mvc:resources mapping="" location="" />
    • mapping:服务端找资源的地址
    • location:资源所在目录
  • <mvc:default-servlet-handler/>
    • 在提交时SpringMVC帮你找静态资源,如果找不到,会交给原有容器进行查找
请求数据乱码问题

使用过滤器进行编码的过滤

<!--配置全局过滤器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注解显示的绑定

参数:

  • value:请求参数名称
  • required:在指定的请求参数是否必须包括,默认是true,如果参数没有value则报错
  • defaultValue:当没有指定请求参数时,则使用默认值复制

请求参数:http://localhost:8080/quick14?name=zhangsan

@ResponseBody
@RequestMapping("/quick14")
public void save14(@RequestParam("name") String username) throws IOException {
   System.out.println(username);
}

zhangsan

请求参数:http://localhost:8080/quick14

@ResponseBody
@RequestMapping("/quick14")
public void save14(@RequestParam(value = "name",required = false,defaultValue = "lisi") String username) throws IOException {
   System.out.println(username);
}

lisi
获得Restful风格的参数

Restful是一种架构风格、设计风格,而不是标准,只是提供了一组设计原则和约束条件。主要用于客户端和服务器交互类的软件,基于这个风格设计的软件可以更简洁,更有层次,更容易实现缓存机制

Restful风格的请求是使用URL+请求方式表示一次性达到目的,HTTP协议里面四个表示操作方式的动词如下:

  • GET:用于获取资源
  • POST:用于新建资源
  • PUT:用于更新资源
  • DELETE:用于删除资源

在SpringMVC中可以使用占位符进行参数绑定,/user/1可以写成/user/{id},占位符{id}映射的就是1的值,在业务方法中我们可以使用@PathVariable注解进行占位符的匹配获取工作,注意:占位符的名字必须与@PathVariable的一致

请求URL:http://localhost:8080/quick15/zhangsan

@ResponseBody
@RequestMapping("/quick15/{name}")
public void save15(@PathVariable("name") String username) throws IOException {
  System.out.println(username);
}

zhangsan
自定义类型转换器

开发步骤:

  • 定义转换器类实现Converter接口

    //Converter<R,T> R:待转换的类型 T:想转换的类型
    public class DateConverter implements Converter<String, Date> {
        @Override
        public Date convert(String dateStr) {
            //使用SimpleDateFormat进行格式转换
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-dd-mm");
            Date date = null;
            try {
                //调用parse方法
                date = simpleDateFormat.parse(dateStr);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            //返回date
            return date;
        }
    }
  • 在配置文件中声明转换器

    <!--声明转换器-->
    <bean id="converService" class="org.springframework.context.support.ConversionServiceFactoryBean">
       <property name="converters">
           <list>
               <bean class="converter.DateConverter"/>
           </list>
        </property>
    </bean>
  • <annotation-driven>中引用转换器

    <mvc:annotation-driven conversion-service="converService"/>
获取请求头

@RequestHeader

使用@RequestHeader获得请求头信息

  • value:请求头名称
  • required:是否必须携带此请求头
@ResponseBody
@RequestMapping("/quick17")
public void save17(@RequestHeader(value = "User-Agent",required = true) String Header) throws IOException {
    System.out.println(Header);
}

Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.102 Safari/537.36

@CookieValue

获得指定的Cookie值

  • value:指定Cookie的名称
  • required:是否必须携带此Cookie
@ResponseBody
@RequestMapping("/quick18")
public void save18(@CookieValue(value = "JESSIONID") String jessionID) throws IOException {
   System.out.println(jessionID);
}
文件上传

文件上传三要素

  • 表单项type="file"
  • 表单提交方式为"POST"
  • 表单的enctype属性是多部分表单形式,及enctype="multipart/form-data"
<body>
    <form action="${pageContext.request.contextPath}/quick19" method="post" enctype="multipart/form-data">
        名称<input type="text" name="username"><br>
        文件<input type="file" name="upload"><br>
        <input type="submit" value="提交">
    </form>
</body>

单文件上传步骤

  • 导入fileupload和io坐标

  • 配置文件上传解析器

    <!--配置文件上传解析器-->
    <bean class="org.springframework.web.multipart.commons.CommonsMultipartResolver" id="resolver">
       <property name="defaultEncoding" value="UTF-8"/>
       <!--上传文件总大小-->
       <property name="maxUploadSize" value="500000"/>
    </bean>
  • 编写文件上传代码

    参数名称必须与表单name一致

    @ResponseBody
    @RequestMapping("/quick19")
    public void save19(String username, MultipartFile upload) throws IOException {
        //获得上传文件名称
        String filename = upload.getOriginalFilename();
        //保存文件
        upload.transferTo(new File("E:\\"+filename));
    }

多文件上传:服务端使用MultipartFile[]数组接收即可

SpringMVC拦截器

相当于Filter,用于对处理器进行预处理和后处理

  • 拦截器和过滤器的区别

    区别 过滤器 拦截器
    使用范围 是servlet规范的一部分,任何JavaWeb工程都能使用 是SpringMVC框架自己的,只有SpringMVC框架的工程才能使用
    拦截范围 在url-pattern中配置了/*之后,可以拦截所有访问的资源 只会拦截访问的控制器方法,如果访问的是jsp、html、css、image、js是不会拦截的
  • 快速入门

    1. 创建拦截器实现HandlerInterceptor接口

      public class MyInterceptor implements HandlerInterceptor {
          //在目标方法执行前执行
          @Override
          public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
              String username = request.getParameter("username");
              if (username.equals("zhangsan"))
              {
                  return true;
              }
              else {
                  request.getRequestDispatcher(request.getContextPath()+"jsp/list.jsp").forward(request,response);
              }
              //true:放行 false:不放行
              return false;
          }
      
          //在目标方法执行之后,视图返回之前执行
          @Override
          public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
              modelAndView.addObject("username","内蒙古大学");
          }
      
          //整个流程都执行完毕后执行
          @Override
          public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
              System.out.println("after....");
          }
      }
    2. 配置拦截器

      <mvc:interceptors>
        <mvc:interceptor>
           <!--对那些资源执行拦截操作-->
           <mvc:mapping path="/**"/>
              <bean class="interceptor.MyInterceptor"/>
           </mvc:interceptor>
      </mvc:interceptors>
    3. 测试拦截器的拦截效果

  • 拦截器方法说明

    方法名 说明
    preHandle() 方法在请求处理之前调用,返回值为false时表示请求结束,后面的方法都不会执行,当为true的时候,会继续调用下一个Interceptor的preHandle方法
    postHandle() 该方法是在当前请求进行处理之后被调用,前提是preHandle返回值为true,且在DispatcherServlet进行视图返回渲染之前被调用,所以可以处理ModelAndView对象进行操作
    afterCompletion() 该方法在整个请求结束后执行
SpringMVC异常处理机制
  • 异常分类:预期异常、运行时异常

  • 处理异常的两种方式

    • SimpleMappingExceptionResolver:简单异常处理器
    • HandlerExceptionResolver:自定义异常处理器
  • 简单异常处理器

    //强制转换错误
    @ResponseBody
    @RequestMapping("/ex2")
    public void ex2(){
      Object str = "Zhang";
      Integer a = (Integer)str;
    }
    //除0错误
    @ResponseBody
    @RequestMapping("/ex1")
    public void ex1(){
      int i = 1/0;
    }
    <!--配置异常处理-->
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver" >
       <!--默认异常,value为跳转的界面-->
       <property name="defaultErrorView" value="error" />
       <!--设置指定异常,Map形式可以设置多个-->
       <property name="exceptionMappings">
          <map>
             <entry key="java.lang.ClassCastException" value="CastError"/>
          </map>
       </property>
    </bean>
  • 自定义异常处理器

    • 创建异常处理器类实现HandleExceptionResolver

      instanceof严格来说是Java中的一个双目运算符,用来测试一个对象是否为一个类的实例

      public class MyException implements HandlerExceptionResolver {
          /*
              参数:Exception:异常对象
              返回值:ModelAndView:跳转到错误视图信息
           */
          @Override
          public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
              ModelAndView modelAndView = new ModelAndView();
              /*
                  instanceof 严格来说是Java中的一个双目运算符,用来测试一个对象是否为一个类的实例
               */
              if (e instanceof ClassCastException){
                  modelAndView.addObject("info","强制转换错误");
              }
              modelAndView.setViewName("error");
              return modelAndView;
          }
      }
    • 配置异常处理器

      <!--自定义异常处理-->
      <bean class="resolver.MyException"/>
    • 编写异常页面

Last modification:October 9th, 2020 at 05:36 pm
如果觉得我的文章对你有用,请随意赞赏