SpringMVC

最新推荐文章于 2023-02-18 12:21:06 发布

love the future

最新推荐文章于 2023-02-18 12:21:06 发布

阅读量257

点赞数

分类专栏： SSM-Spring、SpringMVC、mybatis

本文链接：https://blog.csdn.net/weixin_43328816/article/details/114777163

版权

SSM-Spring、SpringMVC、mybatis 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1.SpringMVC相关介绍

1.在Spring中，每次获取对象的时候需要通过

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");来加载Spring的配置文件。

但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件) ，这样的弊端是配置文件加载多次，应用上下文对象创建多次。

2.在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域 servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

3.Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具 WebApplicationContextUtils供使用者获得应用上下文对象。

4.所以我们需要做的只有两件事：

① 在 web.xml 中配置 ContextLoaderListener 监听器（使用监听器需要导入 spring-web 坐标）

② 使用 WebApplicationContextUtils 获得应用上下文对象 ApplicationContext

导入spring-web的坐标：

在pom.xml中添加依赖

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>

在web.xml文件中配置ContextLoaderListener

  <!--全局初始化参数-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <!--配置监听器-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

通过WebApplicationContextUtils获得应用上下文对象ApplicationContext

public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        ServletContext servletContext = this.getServletContext();
        //ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
        //ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }
}

2.SpringMVC的概述：

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

SpringMVC 已经成为目前最主流的MVC框架之一，并且随着Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC 框架。它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持 RESTful 编程风格的请求。

快速入门的一个小例子

需求：客户端发起请求，服务器端接收请求，执行逻辑并进行视图跳转。

开发步骤：

①导入SpringMVC相关坐标

②配置SpringMVC核心控制器DispathcerServlet

③创建Controller类和视图页面

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

⑤配置SpringMVC核心文件 spring-mvc.xml

⑥客户端发起请求测试

①导入SpringMVC相关坐标

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.2.1</version>
    </dependency>
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>

②配置SpringMVC核心控制器DispathcerServlet

<!--配置前端控制器-->
  <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>
    <!--表示在服务器启动时就去加载Servlet对象，如果没有，就是默认第一次访问的时候才创建对象-->
    <load-on-startup>1</load-on-startup>
  </servlet>


  <servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <!--斜杠代表缺省的Servlet，表示每次访问都会走这个Servlet-->
    <url-pattern>/</url-pattern>
  </servlet-mapping>

③创建Controller类和视图页面

public class UserController { 
    public String save(){
        System.out.println("Controller save running....");
        //斜杠表示当前的webapps目录。
        return "/success";
    }
}

<%--
  Created by IntelliJ IDEA.
  User: 
  Date: 2021/3/13
  Time: 22:52
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>success!</h1>

</body>
</html>

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

@Controller
public class UserController { 
@Requestmapping("/quick")
    public String save(){
        System.out.println("Controller save running....");
        //斜杠表示当前的webapps目录。
        return "/success";
    }
}

⑤配置SpringMVC核心文件 spring-mvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<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.alibaba.com/schema/stat"
       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.alibaba.com/schema/stat http://www.alibaba.com/schema/stat.xsd
">

    <!--Controller的组件扫描-->
    <context:component-scan base-package="com.lsy">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

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



</beans>

⑥客户端发起请求测试

访问地址：http://localhost:8080/Maven02/quick

就可以访问success.jsp页面。

3.SpringMVC流程图示：

4.SpringMVC的组件解析

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的组件解析：

1. 前端控制器：DispatcherServlet

用户请求到达前端控制器，它就相当于 MVC 模式中的 C，DispatcherServlet 是整个流程控制的中心，由

它调用其它组件处理用户的请求，DispatcherServlet 的存在降低了组件之间的耦合性。

2. 处理器映射器：HandlerMapping

HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的

映射方式，例如：配置文件方式，实现接口方式，注解方式等。

3. 处理器适配器：HandlerAdapter

通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理

器进行执行

4. 处理器：Handler

它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由

Handler 对具体的用户请求进行处理。

5. 视图解析器：View Resolver

View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名，即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。

6. 视图：View

SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView等。最常用的视图就是 jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面

SpringMVC的注解解析：

@RequestMapping

作用：用于建立请求 URL 和处理请求方法之间的对应关系

位置：

类上，请求URL 的第一级访问目录。此处不写的话，就相当于应用的根目录
方法上，请求 URL 的第二级访问目录，与类上的使用@ReqquestMapping标注的一级目录一起组成访问虚拟路径

属性：

value：用于指定请求的URL。它和path属性的作用是一样的
method：用于指定请求的方式
params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样
params = {"accountName"}，表示请求参数必须有accountName
params = {"moeny!100"}，表示请求参数中money不能是100

在Spring-mvc.xml中需要引入命名空间和约束地址

<?xml version="1.0" encoding="UTF-8"?>
<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"
     http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                          
">

组件扫描：

  <!--Controller的组件扫描-->
    <context:component-scan base-package="com.lsy">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

可以配置相应的视图解析器：

SpringMVC有默认组件配置，默认组件都是DispatcherServlet.properties配置文件中配置的，该配置文件地址org/springframework/web/servlet/DispatcherServlet.properties，该文件中配置了默认的视图解析器，如下：

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

源码内容：

REDIRECT_URL_PREFIX = "redirect:" --重定向前缀

FORWARD_URL_PREFIX = "forward:" --转发前缀（默认值）

prefix = ""; --视图名称前缀

suffix = ""; --视图名称后缀

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

当返回的是“success”的时候，默认访问的就是/jsp/success.jsp

5.SpringMVC数据的响应

1.SpringMVC的数据相应方式

1）页面跳转

直接返回字符串，跳转页面的路径和页面名称
通过ModelAndView对象返回

解析：

package com.lsy.controller;


import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;

/**
 * @Description:
 * @Author:lsy
 * @Date:
 */
@Controller
@RequestMapping("/user")
public class UserController {


    //之前的方式是通过Request对象设置参数进行存储，在SoringMVC框架中，已经的封装好了Resquest对象
    //传入相应的参数,Tomcat服务器就会创建相应的对象。
    @RequestMapping(value = "/quick5")//请求映射
    public String save5(HttpServletRequest request){
       request.setAttribute("username","lsy5");
       return "success";
    }

    //传入的是模型，返回视图
    @RequestMapping(value = "/quick4")//请求映射
    public String save4(Model model){
        //设置模型数据
        model.addAttribute("username","lsy4");
        //设置视图名

        return "success";
    }


    //也可以将ModelAndView作为参数传入，会自定创建一个空的ModelAndView
    @RequestMapping(value = "/quick3")//请求映射
    public ModelAndView save3(ModelAndView modelAndView){
        //设置模型数据
        modelAndView.addObject("username","lsy3");
        //设置视图名
        modelAndView.setViewName("success");
        return modelAndView;
    }


    //返回的ModelAndView
    @RequestMapping(value = "/quick2")//请求映射
    public ModelAndView save2(){
        /*
        model:封装数据
        view :展示数据。

         */
        ModelAndView modelAndView = new ModelAndView();
        //设置模型数据
        modelAndView.addObject("username","lsy");
        //设置视图名
        modelAndView.setViewName("success");
        return modelAndView;
    }




    @RequestMapping(value = "/quick",method = RequestMethod.GET)//请求映射
    public String save(){
        System.out.println("Controller save running....");
//跳转地址
        //斜杠表示当前的webapps目录。
        return "/success.jsp";
    }
}

2）回写数据

直接返回字符串

Web基础阶段，客户端访问服务器端，如果想直接回写字符串作为响应体返回的话，只需要使用

response.getWriter().print(“hello world”) 即可，那么在Controller中想直接回写字符串该怎样呢？

① 通过 SpringMVC 框架注入的 response 对象，使用 response.getWriter ().print(“hello world”) 回写数据，此时不需要视图跳转，业务方法返回值为 void 。

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

② 将需要回写的字符串直接返回，但此时需要通过 @ ResponseBody 注解告知 SpringMVC 框架，方法返回的字符串不是跳转是直接在 http 响应体中返回。

@RequestMapping(value="/quick7")
    @ResponseBody  //告知SpringMVC框架 不进行视图跳转 直接进行数据响应
    public String save7() throws IOException {
        return "hello mvc";
    }

③在异步项目中，客户端与服务器端往往要进行json格式字符串交互，此时我们可以手动拼接json字符串返回。

   @RequestMapping(value="/quick8")
    @ResponseBody
    public String save8() throws IOException {
        return "{\"username\":\"zhangsan\",\"age\":18}";
    }

可以直接使用json格式转换：

导入相应的依赖：

<dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.11.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.9.2</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.11.0</version>
    </dependency>


    @RequestMapping(value="/quick9")
    @ResponseBody
    public String save9() throws IOException {
        User user = new User();
        user.setUsername("lisi");
        user.setAge(30);
        //使用json的转换工具将对象转换成json格式字符串在返回
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(user);

        return json;
    }

返回对象或集合

通过SpringMVC帮助我们对对象或集合进行json字符串的转换并回写，为处理器适配器配置消息转换参数，指定使用jackson进行对象或集合的转换，因此需要在spring-mvc.xml中进行如下配置：

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

 @RequestMapping(value="/quick10")
    @ResponseBody
    //期望SpringMVC自动将User转换成json格式的字符串
    public User save10() throws IOException {
        User user = new User();
        user.setUsername("lisi2");
        user.setAge(32);

        return user;
    }

在方法上添加@ResponseBody就可以返回json格式的字符串，但是这样配置比较麻烦，配置的代码比较多，因此，我们可以使用mvc的注解驱动代替上述配置。

在 SpringMVC 的各个组件中，处理器映射器、处理器适配器、视图解析器称为 SpringMVC 的三大组件。

使用<mvc:annotation-driven>自动加载 RequestMappingHandlerMapping（处理映射器）和

RequestMappingHandlerAdapter（处理适配器），可用在Spring-xml.xml配置文件中使用

<mvc:annotation-driven>替代注解处理器和适配器的配置。

同时使用<mvc:annotation-driven>默认底层就会集成jackson进行对象或集合的json格式字符串的转换。

所以跟不用再进行上面的配置了，使用<mvc:annotation-driven>

先引入MVC的命名空间

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

6.SpringMVC的请求

1.获取请求参数：

客户端请求参数的格式是：name=value&name=value… …

服务器端要获得请求的参数，有时还需要进行数据的封装，SpringMVC可以接收如下类型的参数：

①基本类型参数
②POJO类型参数
③数组类型参数
④集合类型参数

①基本类型参数

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

 @RequestMapping(value="/quick11")
    @ResponseBody
    //不进行页面的跳转，并且返回的类型是void，表示response对象是一个空的
    public void save11(String username,int age) throws IOException {
        //该方法的参数，是用来接收请求参数的
        //http://localhost:8080/Maven02/user/quick11?username=lsy&age=22

        System.out.println(username);//lsy
        System.out.println(age);//22
    }

②POJO类型参数（参数的name与实体的属性名相同即可）

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

  @RequestMapping(value="/quick12")
    @ResponseBody
    public void save12(User user) throws IOException {
        System.out.println(user);
    }

http://localhost:8080/Maven02/user/quick12?username=li&age=12

③数组类型参数

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

http://localhost:8080/Maven02/user/quick13?strs=111&strs=222&strs=333


    @RequestMapping(value="/quick13")
    @ResponseBody
    public void save13(String[] strs) throws IOException {
        System.out.println(Arrays.asList(strs));
    }

④集合类型参数

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

package com.lsy.domain;

import java.util.List;

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 +
                '}';
    }
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page isELIgnored="false"%>
<html>
<head>
    <title>Title</title>
</head>
<body>

    <form action="${pageContext.request.contextPath}/user/quick14" method="post">
        <%--表明是第一个User对象的username age--%>
        <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>
</html>

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

当使用ajax提交时，可以指定contentType为json形式，那么在方法参数位置使用@RequestBody可以直接接收集合数据而无需使用POJO进行包装。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page isELIgnored="false"%>
<html>
<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}/js/jquery-3.3.1.js"></script>
    <script>
        var userList = new Array();
        userList.push({username:"zhangsan",age:18});
        userList.push({username:"lisi",age:28});

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

    </script>
</head>
<body>

</body>
</html>

注意：通过谷歌开发者工具抓包发现，没有加载到jquery文件，原因是SpringMVC的前端控制器DispatcherServlet的url-pattern配置的是/,代表对所有的资源都进行过滤操作，我们可以通过以下两种方式指定放行静态资源：

• 在 spring-mvc.xml 配置文件中指定放行的资源

<mvc:resources mapping="/js/**" location="/js/"/>

• 使用 < mvc:default-servlet-handler /> 标签

在spring-mvc文件中配置

POST请求出现乱码问题

我们需要在web.xml文件中配置一个过滤器


  <!--配置全局过滤的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：当没有指定请求参数时，则使用指定的默认值赋值

   @RequestMapping(value="/quick16")
    @ResponseBody
    public void save16(@RequestParam(value="name",required = false,defaultValue = "lsy") String username) throws IOException {
        //@RequestParam表示的是将浏览器的参数名name映射为username
        //(@RequestParam(value="name") 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

上述url地址/user/1中的1就是要获得的请求参数，在SpringMVC中可以使用占位符进行参数绑定。地址/user/1可以写成/user/{id}，占位符{id}对应的就是1的值。在业务方法中我们可以使用@PathVariable注解进行占位符的匹配获取工作。

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

自定义类型转换器

• SpringMVC 默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成 int 型进行参数设置。

• 但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自定义转换器。

例如在日期的参数，单输入为2021/3/14出现的是格林时间，sppringMVC框架有该类型转换器，但是输入2021-3-14就会报错

自定义类型转换器的开发步骤：

①定义转换器类实现Converter接口
②在spring-mvc.xml配置文件中声明转换器
③在<annotation-driven>中引用转换器

因此需要自定义一个类进行转换

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

package com.lsy.converter;

import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

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

②在spring-mvc.xml配置文件中声明转换器

    <!--转换器的声明-->
    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <list>
                <!--将转换器的实现类设为其参数-->
                <bean class="com.lsy.converter.DateConverter"></bean>
            </list>
        </property>
    </bean>

③在<annotation-driven>中引用转换器

获得请求头

1. @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) throws IOException {
        System.out.println(user_agent);
    }

http://localhost:8080/Maven02/user/quick20

2. @ CookieValue

使用@CookieValue可以获得指定Cookie的值

@CookieValue注解的属性如下：

value：指定cookie的名称
required：是否必须携带此cookie

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

@RequestHeader:获得的是Cookie后面的全部值

@ CookieValue：获得的是JSESSIONID后面的值

love the future

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC

1.SpringMVC相关介绍1.在Spring中，每次获取对象的时候需要通过 ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");来加载Spring的配置文件。但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件) ，这样的弊端是配置文件加载多次，应用上下文对象创建多次。2.在Web项...
复制链接

扫一扫