SpringMVC 温习笔记(二)springMVC框架

超、凢脫俗 2022-10-25 04:38 319阅读 0赞

什么是springMVC

springMVC是一款基于java实现的MVC设计模式的请求驱动类型的轻量级web框架，属于SpringFrameWork的后续产品，已经融合在SpringWebFlow中。SpringMVC是目前最为流行的前端框架之一，在Spring3.0发布之后，全面超越了Struct2框架，成为最优秀的MVC框架。他让一个简单的java类成为处理请求的控制器，而无需实现任何借口，同时还支持RESTful编程风格的请求。

图解springMVC执行原理

springMVC框架基本思想

springMVC开发步骤图解
此处值得一提的是springMVC框架他工作要点在于抽取的baseServlet这个模块，而struts2则工作在filter模块中，上述图片是直接采用传智播客老师讲义上的图片，仅供学习讨论。

springMVC使用要点

首先需要导入dependency，导入的jar包需要参考上一小结案例，保持一致即可。
依赖

  1. <dependency>
  2.        <groupId>mysql</groupId>
  3.        <artifactId>mysql-connector-java</artifactId>
  4.        <version>5.1.32</version>
  5.    </dependency>
  6.    <dependency>
  7.        <groupId>c3p0</groupId>
  8.        <artifactId>c3p0</artifactId>
  9.        <version>0.9.1.2</version>
  10.    </dependency>
  11.    <dependency>
  12.        <groupId>com.alibaba</groupId>
  13.        <artifactId>druid</artifactId>
  14.        <version>1.1.10</version>
  15.    </dependency>
  16.    <dependency>
  17.        <groupId>junit</groupId>
  18.        <artifactId>junit</artifactId>
  19.        <version>4.12</version>
  20.        <scope>test</scope>
  21.    </dependency>
  22.    <dependency>
  23.        <groupId>commons-fileupload</groupId>
  24.        <artifactId>commons-fileupload</artifactId>
  25.        <version>1.3.3</version>
  26.    </dependency>
  28.    <dependency>
  29.        <groupId>org.springframework</groupId>
  30.        <artifactId>spring-context</artifactId>
  31.        <version>5.0.5.RELEASE</version>
  32.    </dependency>
  33.    <dependency>
  34.        <groupId>org.springframework</groupId>
  35.        <artifactId>spring-test</artifactId>
  36.        <version>5.0.5.RELEASE</version>
  37.    </dependency>
  38.    <dependency>
  39.        <groupId>org.springframework</groupId>
  40.        <artifactId>spring-web</artifactId>
  41.        <version>5.0.5.RELEASE</version>
  42.    </dependency>
  43.    <dependency>
  44.        <groupId>org.springframework</groupId>
  45.        <artifactId>spring-webmvc</artifactId>
  46.        <version>5.0.5.RELEASE</version>
  47.    </dependency>
  48.    <dependency>
  49.        <groupId>javax.servlet</groupId>
  50.        <artifactId>javax.servlet-api</artifactId>
  51.        <version>3.0.1</version>
  52.        <scope>provided</scope>
  53.    </dependency>
  54.    <dependency>
  55.        <groupId>javax.servlet.jsp</groupId>
  56.        <artifactId>javax.servlet.jsp-api</artifactId>
  57.        <version>2.2.1</version>
  58.        <scope>provided</scope>
  59.    </dependency>

web.xml配置文件。

  1. <!--配置springMVC的前端控制器-->
  2.     <servlet>
  3.         <servlet-name>DispatcherServlet</servlet-name>
  4.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  5.         <init-param>
  6.             <param-name>contextConfigLocation</param-name>
  7.             <param-value>classpath:springMVC.xml</param-value>
  8.         </init-param>
  9.         <load-on-startup>1</load-on-startup>
  10.     </servlet>
  11.     <servlet-mapping>
  12.         <servlet-name>DispatcherServlet</servlet-name>
  13.         <url-pattern>/</url-pattern>
  14.     </servlet-mapping>

notes:
(1)此处的dispatcherServlet就相当于上一小结的ContextLoaderListener类的效用相似。
(2)此外的init-param标签相当于上一小结中context-param，该参数用来设置springMVC配置文件的参数。
springMVC配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  3.     <!--扫描controller-->
  4.     <context:component-scan base-package="com.feitian.component.web.controller"/>
  6. </beans>

在配置文件中只需要注明扫描controller包，并将其纳入容器中即可。
controller 包。
如果只想扫描web包，还有一种写法如下所示:

  1. <context:component-scan base-package="com.feitian">
  2.     <!--表示扫描包含controller注解的服务-->
  3.     <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
  4. </context:component-scan>

UserController类:

  1. @Controller
  2. /*@RequestMapping("/userController")*/
  3. public class UserController { 
  4.     @RequestMapping("/save")
  5.     public String save(){ 
  6.         System.out.println("controller save are running");
  7.         return "success.jsp";
  8.     }
  9. }

springMVC框架执行流程

在这里插入图片描述
上图是tomcat中springMVC执行的简要流程，接下来看看springMVC详细步骤。
在这里插入图片描述
在项目中也可对内部资源视图解析器进行手动配置：
springMVC配置文件

  1. <!--扫描controller-->
  2.     <!--<context:component-scan base-package="com.feitian.component.web.controller"/>-->
  3.     <context:component-scan base-package="com.feitian">
  4.         <!--表示扫描包含controller注解的服务-->
  5.         <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
  6.     </context:component-scan>
  8.     <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  9.         <property name="prefix" value="/jsp/"/>
  10.         <property name="suffix" value=".jsp"/>
  11.     </bean>

controller写法

  1. @Controller
  2. @RequestMapping("/userController")
  3. public class UserController { 
  4.     @RequestMapping("/save")
  5.     public String save(){ 
  6.         System.out.println("controller save are running");
  7.         //return "/jsp/success";
  8.         return  "success";
  9.     }
  10. }

notes: 在手动修改InternalResourceViewResolver时，suffix 和prefix 的配置使得我们在返回视图时省略了”.jsp”和”/jsp/“。

springMVC 回写数据

页面跳转方式

字符串返回方式

转发过程:
在这里插入图片描述
在转真个转发过程中配置了viewResolver后，就对配置的各个环境组装，组装后将完整的解析器返回给前端控制器。
重定向过程:

  1. return  "redirect:/jsp/success.jsp";

重定向过程及是一个重新请求的过程。

ModelAndView返回方式

  1. //1.以新建ModelAndView 变量的方式返回
  2.     @RequestMapping("/save02")
  3.     public ModelAndView save02(){ 
  4.         System.out.println("Controller save02 is running");
  5.         ModelAndView modelAndView = new ModelAndView();
  6.         modelAndView.addObject("username","feitian");
  7.         modelAndView.setViewName("success");
  8.         return modelAndView;
  9.     }
  11.     //2.以ModelAndView参数的方式返回
  12.     @RequestMapping("/save03")
  13.     public ModelAndView save03(ModelAndView modelAndView){ 
  14.         System.out.println("Controller save03 is running");
  15.         modelAndView.addObject("username","xueshanfeitian");
  16.         modelAndView.setViewName("success");
  17.         return modelAndView;
  18.     }
  20.     //3.用拆分的方式返回ModelAndView
  21.     @RequestMapping("/save04")
  22.     public String save04(Model model){ 
  23.         System.out.println("Controller save04 is running");
  24.         model.addAttribute("username","xueshanfeitian");
  25.         return "success";
  26.     }
  28.   //4.以设置request参数的方式返回ModelAndView
  29.     @RequestMapping("/save05")
  30.     public String save05(HttpServletRequest request){ 
  31.         System.out.println("Controller save05 is running");
  32.         request.setAttribute("username","xueshanfeitian");
  33.         return "success";
  34.     }

回写数据

直接返回字符串

采用response注入对象回写数据

  1. //1.采用response回写数据
  2.     @RequestMapping("/save06")
  3.     public void save06(HttpServletResponse response)
  4.             throws IOException { 
  5.         System.out.println("Controller save06 is running");
  6.         response.getWriter().println("hello feitian");
  7.     }

此处需要说明的是ResponseBody注解，该注解是告诉springMVC框架，本返回数据不是去跳转页面，而是要以字符串的形式直接回写数据。
采用注解@ResponseBody注解，直接返回字符串。

  1. //2.采用responseBody注解的方式,不进行视图跳转
  2.     @RequestMapping("/save07")
  3.     @ResponseBody
  4.     public String save07() { 
  5.         System.out.println("Controller save07 is running");
  6.         return "{\"username\":\"我是张君的老祖！！！\",\"age\":\"3000\"}";
  7.     }

返回对象或数据

期望将对象或者集合转成jackson对象返回。
首先需要导入jackson依赖

  1. <dependency>
  2.        <groupId>com.fasterxml.jackson.core</groupId>
  3.        <artifactId>jackson-core</artifactId>
  4.        <version>2.9.0</version>
  5.    </dependency>
  6.    <dependency>
  7.        <groupId>com.fasterxml.jackson.core</groupId>
  8.        <artifactId>jackson-databind</artifactId>
  9.        <version>2.9.0</version>
  10.    </dependency>
  11.    <dependency>
  12.        <groupId>com.fasterxml.jackson.core</groupId>
  13.        <artifactId>jackson-annotations</artifactId>
  14.        <version>2.9.0</version>
  15.    </dependency>

手动转换成jackson对象返回，其本质是与返回字符串是一样的
采用jackson转换工具转换后，发挥jackson字符串。

  1. @RequestMapping("/save08")
  2.     @ResponseBody
  3.     public String save08() throws JsonProcessingException { 
  4.         System.out.println("Controller save08 is running");
  5.         User user = new User();
  6.         user.setRelation("我是张君的老祖");
  7.         user.setAge(3000);
  8.         ObjectMapper mapper = new ObjectMapper();
  9.         String json = mapper.writeValueAsString(user);
  10.         return  json;
  11.     }
采用修改springMVC配置文件的方式

这种方式本质上是将json转换器配置直接注入到RequestMappingHandlerAdapter即处理器适配器，换种思路就是将RequestMappingHandlerAdapter对象的成员变量messageConverters赋值为MappingJackson2HttpMessageConverter。
在springMVC中需要加入处理器映射器的配置如下:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  3.     <!--扫描controller-->
  4.     <!--<context:component-scan base-package="com.feitian.component.web.controller"/>-->
  5.     <context:component-scan base-package="com.feitian">
  6.         <!--表示扫描包含controller注解的服务-->
  7.         <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
  8.     </context:component-scan>
  9.     <!--配置资源解析器-->
  10.     <bean id="viewResolver" class=
  11.             "org.springframework.web.servlet.view.InternalResourceViewResolver">
  12.         <property name="prefix" value="/jsp/"/>
  13.         <property name="suffix" value=".jsp"/>
  14.     </bean>
  16.     <!--配置处理器映射器-->
  17.     <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
  18.         <property name="messageConverters">
  19.             <list>
  20.                 <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
  21.             </list>
  22.         </property>
  23.     </bean>
  24. </beans>

测试方法

  1. @RequestMapping("/save09")
  2.     @ResponseBody
  3.     //期望springMVC自动将User转换成json格式的字符串
  4.     public User save09() throws JsonProcessingException { 
  5.         System.out.println("Controller save09 is running");
  6.         User user = new User();
  7.         user.setRelation("我是张君的老祖");
  8.         user.setAge(3000);
  9.         return  user;
  10.     }

采用注册注解驱动方式

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
  3.     <!--扫描controller-->
  4.     <!--<context:component-scan base-package="com.feitian.component.web.controller"/>-->
  5.     <context:component-scan base-package="com.feitian">
  6.         <!--表示扫描包含controller注解的服务-->
  7.         <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
  8.     </context:component-scan>
  9.     <!--配置资源解析器-->
  10.     <bean id="viewResolver" class=
  11.             "org.springframework.web.servlet.view.InternalResourceViewResolver">
  12.         <property name="prefix" value="/jsp/"/>
  13.         <property name="suffix" value=".jsp"/>
  14.     </bean>
  16.     <!--配置处理器映射器-->
  17.     <!--<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>-->
  18.     <!--注册注解驱动-->
  19.     <mvc:annotation-driven/>
  20. </beans>

此处需要注意的是加入mvc命名空间。 采用注册注解驱动的这种配置方式，其本质上是将json转换器配置注入到处理器适配器的过程直接在底层实现，及<mvc:annotation-driven/>节省了我们以前繁琐的json转换器配置注入过程。
测试方法可以保持与上面一致save08保持一致

  1. @RequestMapping("/save09")
  2.     @ResponseBody
  3.     //期望springMVC自动将User转换成json格式的字符串
  4.     public User save09() throws JsonProcessingException { 
  5.         System.out.println("Controller save09 is running");
  6.         User user = new User();
  7.         user.setRelation("我是张君的老祖");
  8.         user.setAge(3000);
  9.         return  user;
  10.     }

测试方法可以与上面保持一致。

springMVC处理请求数据

当请求controller时, 则请求参数一般会自动映射
如本例中小猿的请求如下:
在这里插入图片描述
controller自动将请求参数映射

  1. @RequestMapping("/save10")
  2.     @ResponseBody
  3.     //期望springMVC自动将User转换成json格式的字符串
  4.     public void save10(String relation,int age) throws JsonProcessingException { 
  5.         System.out.println("Controller save10 is running");
  6.         System.out.println(relation+": 修炼年份"+age);
  7.     }

controller自动将请求参数映射并封装成实体类
请求地址;
在这里插入图片描述

请求方法如下所示:

  1. @RequestMapping("/save11")
  2.     @ResponseBody
  3.     //期望springMVC自动将User转换成json格式的字符串
  4.     public void save11(User user) throws JsonProcessingException { 
  5.         System.out.println("Controller save11 is running");
  6.         System.out.println(user.getRelation()+": 修炼年份"+user.getAge());
  7.     }

controller自动将请求参数映射并封装成数组
请求参数
在这里插入图片描述
请求方法如下所示:

  1. @RequestMapping("/save12")
  2.     @ResponseBody
  3.     public void save12(String  arr []) throws JsonProcessingException { 
  4.         System.out.println("Controller save12 is running");
  5.         System.out.println(Arrays.asList(arr));
  6.     }

采用将集合封装在一个对象的操作方式

请求数据采用表单提交的方式:

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3. <head>
  4.     <title>Title</title>
  5. </head>
  6. <body>
  7.     <form action="${pageContext.request.contextPath}/userController/save13" method="post">
  8.         <%--表明是第几个user对象的username--%>
  9.         <input type="text" name="userList[0].relation"/><br/>
  10.         <input type="text" name="userList[0].age"/><br/>
  11.         <input type="text" name="userList[1].relation"/><br/>
  12.         <input type="text" name="userList[1].age"/><br/>
  13.         <input type="text" name="userList[2].relation"/><br/>
  14.         <input type="text" name="userList[2].age"/><br/>
  15.         <input type="text" name="userList[3].relation"/><br/>
  16.         <input type="text" name="userList[3].age"/><br/>
  17.         <input type="submit" value="提交">
  18.     </form>
  20. </body>
  21. </html>

访问jsp页面:
在这里插入图片描述
挨个填写表单，然后提交即可在控制台看到请求后的数据封装。
测试类:

  1. @RequestMapping("/save13")
  2.     @ResponseBody
  3.     public void save13(Pojo pojo) throws JsonProcessingException { 
  4.         System.out.println("Controller save13 is running");
  5.         System.out.println(pojo);
  6.     }

其中pojo中有user对象

  1. public class Pojo { 
  2.     private List<User> userList;
  3.     ......
  4. }

在请求过程中我们会看到控制台答应乱码，我们需要对编码进行处理。
在这里插入图片描述
解决乱码问题需要在web.xml中需要配置filter。

filter的两种实现方法

web.xml配置方式

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0">
  4.     <!--配置springMVC的前端控制器-->
  5.     <servlet>
  6.         <servlet-name>DispatcherServlet</servlet-name>
  7.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  8.         <init-param>
  9.             <param-name>contextConfigLocation</param-name>
  10.             <param-value>classpath:springMVC.xml</param-value>
  11.         </init-param>
  12.         <load-on-startup>1</load-on-startup>
  13.     </servlet>
  14.     <servlet-mapping>
  15.         <servlet-name>DispatcherServlet</servlet-name>
  16.         <url-pattern>/</url-pattern>
  17.     </servlet-mapping>
  19.     <!--将applicationContext.xml放入ServletContext，方便自定义监听类初始化该文件。-->
  20.     <context-param>
  21.         <param-name>contextConfigLocation</param-name>
  22.         <param-value>classpath:applicationContext.xml</param-value>
  23.     </context-param>
  25.     <!--监听器启动时要加载定义监听类-->
  26.     <listener>
  27.         <listener-class>com.feitian.component.web.listener.ContextLoaderListener</listener-class>
  28.     </listener>
  30.     <!--将UserServlet加载到web容器中-->
  31.     <servlet>
  32.         <servlet-name>UserServlet</servlet-name>
  33.         <servlet-class>com.feitian.component.web.servlet.UserServlet</servlet-class>
  34.     </servlet>
  36.     <!--映射UserServlet为userServlet-->
  37.     <servlet-mapping>
  38.         <servlet-name>UserServlet</servlet-name>
  39.         <url-pattern>/userServlet</url-pattern>
  40.     </servlet-mapping>
  42.     <!--配置过滤器相关文件-->
  43.     <filter>
  44.         <filter-name>CharacterEncodingFilter</filter-name>
  45.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  46.         <init-param>
  47.             <param-name>encoding</param-name>
  48.             <param-value>UTF-8</param-value>
  49.         </init-param>
  50.     </filter>
  51.     <filter-mapping>
  52.         <filter-name>CharacterEncodingFilter</filter-name>
  53.         <url-pattern>/*</url-pattern>
  54.     </filter-mapping>
  55. </web-app>

filter接口实现

通过以上过滤器的配置就可以防止乱码，本质上web.xml配置方式与实现Filter接口的效用是一致的，filter实现结果如下:

  1. @WebFilter("/*")
  2. public class CharacterFilter implements Filter { 
  3.     public void destroy() { 
  4.     }
  5.     //采用过滤器实现utf-8编码过滤
  6.     public void doFilter(ServletRequest req, ServletResponse resp,
  7.                          FilterChain chain) throws ServletException, IOException { 
  8.         HttpServletRequest request = (HttpServletRequest)req;
  9.         HttpServletResponse response = (HttpServletResponse)resp;
  10.         String method = request.getMethod();
  11.         if(method.equalsIgnoreCase("post")){ 
  12.             request.setCharacterEncoding("utf-8");
  13.         }
  14.         response.setContentType("text/html;charset=utf-8");
  15.         chain.doFilter(request, response);
  16.     }
  17.     public void init(FilterConfig config) throws ServletException { 
  18.     }
  19. }

上述代码执行效果
在这里插入图片描述
另外一种请求参数封装方式，采用@RequestBody注解，xml配置方式大体内容与save14保持一致，需要添加关一些开发资源的配置。
两种方式都可以。

  1. <!--<mvc:resources mapping="/js/**" location="/js/"/>-->
  2.     <mvc:default-servlet-handler/>

上述注解是让各位大猿在开发时，让静态资源轻松躲过拦截的一种配置，相当于在服务器内部让静态资源有了自有行走的通信证。
注意查看下面图片，注意两种配置的区别:
在这里插入图片描述
请求方式

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3. <head>
  4.     <title>Title</title>
  5.     <script src="${pageContext.request.contextPath}/js/jquery-3.3.1.js"></script>
  6.     <script>
  7.         var userList = new Array();
  8.         userList.push({ relation:"tom是张君老祖",age:3000});
  9.         userList.push({ relation:"lucy是张君老祖",age:3000});
  10.         userList.push({ relation:"jack是张君老祖",age:3000});
  11.         userList.push({ relation:"hack是张君老祖",age:3000});
  12.         userList.push({ relation:"鹏爷是张君老祖",age:3000});
  13.         $.ajax({ 
  14.             type:"POST",
  15.             url:"${pageContext.request.contextPath}/userController/save14",
  16.             data:JSON.stringify(userList),
  17.             contentType:"application/json;charset=utf-8"
  18.         })
  19.     </script>
  20. </head>
  21. <body>
  22. <h4>ajax</h4>
  23. </body>
  24. </html>

测试案例

  1. @RequestMapping("/save14")
  2.     @ResponseBody
  3.     public void save14(@RequestBody List<User> userList) throws JsonProcessingException { 
  4.         System.out.println("Controller save13 is running");
  5.         System.out.println(userList);
  6.     }

当请求参数名与Controller方法接收参数名不一致的情况下，我们可以采用@RequestParam

  1. @RequestMapping("/save15")
  2.     @ResponseBody
  3.     public void save15(@RequestParam("name") String username) throws JsonProcessingException { 
  4.         System.out.println("Controller save15 is running");
  5.         System.out.println(username);
  6.     }

Restful风格

Restful是一种软件架构风格、设计风格，它不是标准，本质上只是一组设计原则和约束条件，他主要用于客户端和服务器交互的软件。

  1. @RequestMapping("/save16/{name}")
  2.     @ResponseBody
  3.     //建立restful分割
  4.     public void save16(@PathVariable(value = "name",required = false) String username) throws JsonProcessingException { 
  5.         System.out.println("Controller save16 is running");
  6.         System.out.println(username);
  7. }

访问：

自定义格式转换器

为了防止有些参数请求报错，需要自定义转换器，自定义转换器要实现以下几个要点:

实现Converter接口
  1. //访问方式:http://localhost:8080/springmvc/userController/save16/feitian
  2. public class DateConverter implements Converter<String,Date> { 
  3.     public Date convert(String dateStr) { 
  4.         Date date = null;
  5.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
  6.         try { 
  7.              date = simpleDateFormat.parse(dateStr);
  8.         } catch (ParseException e) { 
  9.             e.printStackTrace();
  10.         }
  11.         return date;
  12.     }
  13. }
在springMVC中声明转换器
  1. ......
  2. <!--声明转换器-->
  3.     <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
  4.         <property name="converters">
  5.             <list>
  6.                 <bean class="com.feitian.component.converter.DateConverter"/>
  7.             </list>
  8.         </property>
  9.     </bean>
  10. ......
在annotation-driven 中引用转换器
  1. ......
  2. <!--声明转换器-->
  3. <mvc:annotation-driven conversion-service="conversionService" />
  4. ......

访问

  1. http://localhost:8080/springmvc/userController/save17/2019-10-28

测试方法成功运行
在这里插入图片描述

获得请求头

有些情况下我们需要获取请求头信息：获取方法所如下

  1. @RequestMapping("/save18")
  2.     @ResponseBody
  3.     //建立restful分割
  4.     public void getContent18(@RequestHeader(value = "User-Agent",required = false)
  5.                                String contentHeader) throws JsonProcessingException { 
  6.         System.out.println("Controller save17 is running");
  7.         System.out.println(contentHeader);
  8.     }
  10.     @RequestMapping("/save19")
  11.     @ResponseBody
  12.     //获取jsessionID
  13.     public void getContent19(@CookieValue(value = "JSESSIONID",required = false)
  14.                                      String JSID) throws JsonProcessingException { 
  15.         System.out.println("Controller save17 is running");
  16.         System.out.println(JSID);
  17.     }

上面两种方法分别介绍了如何获取请求头的两种方式，其中获取cookie是比较常见，希望各位猿能记住这个方法。

发表评论

表情：
评论列表 （有 0 条评论，319人围观）

还没有评论，来说两句吧...

相关阅读

    相关 SpringMVC框架整理（二）

    SpringMVC框架整理第二发，数据绑定流程，数据校验（错误信息国际化），拦截器，异常处理。 数据绑定流程（数据转换，数据格式化，数据校验） 1. S

    悠悠悠悠/ 0 赞/ 407 阅读