SpringMVC--框架学习

发表于 更新于 分类于 阅读次数：
本文字数： 27k 阅读时长 ≈ 25 分钟
记录学习SpringMVC框架的过程

前言

本篇记录学习SpringMVC框架的过程。

项目演示基于SpringMVC–快速开发 | 花猪のBlog (cnhuazhu.top)一文中的项目。

执行流程

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

组件解析

前端控制器（DispatcherServlet）

用户请求到达前端控制器，它就相当于MVC模式中的C，DispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet的存在降低了组件之间的耦合性。

处理器映射器（HandlerMapping）

HandlerMapping负责根据用户请求找到Handler即处理器，SpringMVC提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

处理器适配器（HandlerAdapter）

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

处理器（Handler）

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

视图解析器（View Resolver）

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

视图（View）

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

注解解析

@RequestMapping

@RequestMapping注解用于建立请求URL和处理请求方法之间的对应关系

他可以用于两个位置：

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

基本使用

编写UserController类：

1
2
3
4
5
6
7
8
9
10
@Controller
@RequestMapping("/user")  //一级访问目录
public class UserController {
    //请求地址：http://localhost:8080/user/quick
    @RequestMapping("/quick")
    public String save() {
        System.out.println("Controller save running....");
        return "/success.jsp";
    }
}

开启tomcat服务，浏览器访问http://localhost:8080/user/quick，结果如下：

说明：

需要注意，如果采用二级目录的方式，方法的返回值需要添加/，表示从当前web应用下寻找资源。（否则可能出现404报错）

参数

  • value：用于指定请求的URL。它和path属性的作用是一样的（如果只有一个value参数则可以省略写）

@RequestMapping(value = "/quick")

  • method：用于指定请求的方式（默认为GET请求）

    @RequestMapping(value = "/quick", method = RequestMethod.GET)

    @RequestMapping(value = "/quick", method = RequestMethod.POST)

  • params：用于指定限制请求参数的条件，支持简单的表达式，支持多个限制条件。（要求请求参数的key和value必须和配置的一模一样，否则不予资源请求）

    @RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"xxx","xxx"})

    例如：

    1
    @RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"username","age"})

    要求请求中必须携带参数username和age

    此外还支持简单的表达式，如 params = {"age!100"}，表示age的值不能为100

转发与重定向

查看org.springframework:spring-webmvc中的UrlBasedViewResolver源码可以看见两个前缀设定：

这就是转发（forward）与重定向（redirect）

说明：

  • 在方法的返回视图处添加
  • 如果不加以具体说明，默认为重定向

转发

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"username","age"})
    public String save() {
        System.out.println("Controller save running....");
        return "forward:/success.jsp";  //转发
    }
}

启动tomcat服务，浏览器访问http://localhost:8080/user/quick?username=%22HuaZhu%22&age=18，结果如下：

重定向

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"username","age"})
    public String save() {
        System.out.println("Controller save running....");
        return "redirect:/success.jsp";  //重定向
    }
}

启动tomcat服务，浏览器访问http://localhost:8080/user/quick?username=%22HuaZhu%22&age=18，结果如下：

可以看到被重定向到success.jsp文件。

数据响应

页面跳转

直接返回字符串

首先在/webapp目录下新建一个jsp文件夹，将success.jsp移至其中。

可以在spring-mvc.xml配置文件中配置内部资源视图解析器

1
2
3
4
5
6
<!--配置内部资源视图解析器-->
<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>

这样在UserController类中方法直接返回success就好

1
2
3
4
5
6
7
8
9
10
@Controller
@RequestMapping("/user")
public class UserController {
    //请求地址：http://localhost:8080/user/quick
    @RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"username","age"})
    public String save() {
        System.out.println("Controller save running....");
        return "success";
    }
}

这种直接返回字符串的形式：会将返回的字符串与视图解析器的前后缀拼接后跳转。

以上例视图解析器配置分析：

  • 转发：相当于forward:/jsp/success.jsp
  • 重定向：相当于redirect:/jsp/success.jsp

设置视图解析器后方法返回值的写法（以上述例字为例）：

  • 转发：return "success";（不可以加forward关键词）
  • 重定向：return "redirect:/jsp/success.jsp";（写法不变）

通过ModelAndView对象返回

在UserController类下新编写一个方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick2")
    public ModelAndView save2() {
        /*
            Model：模型 作用：封装数据
            View：视图 作用：展示数据
        */
        ModelAndView modelAndView = new ModelAndView();
        //设置模型数据
        modelAndView.addObject("username", "花猪");
        //设置视图
        modelAndView.setViewName("success");
        return modelAndView;
    }
}

说明：

  • 可以直接new一个ModelAndView对象：

  • 通过.addObject()方法可以设置一个键值对，值可以是字符串，也可以是集合

    jsp页面通过EL表达式，获取值：

    1
    <h1>${username}</h1>

  • 通过.setViewName()方法可以设置跳转的视图

上述例子还可以简写，在UserController类下新编写一个方法：

1
2
3
4
5
6
7
8
9
10
11
12
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick3")
    public ModelAndView save3(ModelAndView modelAndView) {
        //设置模型数据
        modelAndView.addObject("username", "花猪");
        //设置视图
        modelAndView.setViewName("success");
        return modelAndView;
    }
}

说明：

  • 可以直接在方法的参数列表中添加ModelAndView对象，SpringMVC在解析该方法时可以对方法的参数自动进行注入

Model和View还可以拆开写：

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick4")
    public String save4(Model model) {
        model.addAttribute("username","花猪");
        return "success";
    }
}

说明：

  • 仅在方法的参数处添加Model，在方法体中添加键值对
  • 在return返回处返回指定视图

Model是SpringMVC已经封装好的对象，当然我们也可以调用原始的Javaweb中的request对象（并不建议这么使用）：

1
2
3
4
5
@RequestMapping("/quick5")
public String save5(HttpServletRequest request) {
    request.setAttribute("username","花猪");
    return "success";
}

回写数据

直接返回字符串

普通字符串

在以往编写原始Servlet时，如果要返回内容需要调用response对象，在SpringMVC中可以实现这种原始方法：

1
2
3
4
5
6
7
8
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick6")
    public void save6(HttpServletResponse response) throws IOException {
        response.getWriter().print("hello HuaZhu");
    }
}

说明：直接在方法参数中调用HttpServletResponse模块，然后SpringMVC会自动帮助创建一个response对象，在方法体中可以直接调用方法。

但是并不建议用原始的方法，既然使用了框架，会有更为简介的实现方法：

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick7")
    @ResponseBody  //告知SpringMVC框架，不进行视图跳转，直接进行数据响应
    public String save7() throws IOException {
        return "Hello HuaZhu";
    }
}

说明：

  • 观察这种方式很像返回视图的写法（一摸一样），但是SpringMVC框架无法判断该方法是要进行视图跳转还是数据响应
  • @ResponseBody：该注解添加至方法前，用于告知SpringMVC框架，不进行视图跳转，直接进行数据响应

JSON字符串

大多数使用的场景，是需要向前端返回json格式的字符串，这里就需要用到json转化的工具。

首先在pom.xml配置文件中添加依赖：

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

一般情况下是调用数据库返回的对象进行操作，这里简化方便演示。在/src/main/java/mvc目录下新建domain文件夹，在其中创建User类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class User {

    private String username;
    private int age;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick8")
    @ResponseBody
    public String save8() throws IOException {
        User user = new User();
        user.setUsername("HuaZhu");
        user.setAge(18);
        //使用json的转化工具，将对象转换为json格式字符串
        ObjectMapper objectMapper = new ObjectMapper();
        String user_json = objectMapper.writeValueAsString(user);
        return user_json;
    }
}

说明：构建ObjectMapper对象，调用其中的.writeValueAsString()方法直接将对象转化为json格式的字符串。最后返回。

返回对象或集合

手动配置处理器映射器

也可以直接返回对象或集合，但是前端并不能对后端传回的对象或集合进行直接操作。最方便的还是转化为JSON格式。但是反复调用json转换方法过于繁琐，因此SpringMVC可以帮助将返回的对象或集合直接转化为JSON格式的数据，这需要在spring-mvc.xml中配置处理器映射器：

1
2
3
4
5
6
7
8
<!--配置处理器映射器-->
<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>

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick9")
    @ResponseBody
    //自动将返回对象转化为JSON格式
    public User save9() throws IOException {
        User user = new User();
        user.setUsername("HuaZhu");
        user.setAge(18);
        return user;
    }
}

集合类型返回不再演示

注解驱动

上述配置处理器映射过于繁琐，可以使用mvc的注解驱动代替上述配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<?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.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">

    <!--Controller的组件扫描-->
    <context:component-scan base-package="mvc.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>

    <!--配置处理器映射器-->
    <!--<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>-->

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

</beans>

需要注意的是，这里需要引入mvc的命名空间和约束路径

获得请求数据

SpringMVC可以接收如下类型的参数：

  • 基本类型参数
  • POJO类型参数
  • 数组类型参数
  • 集合类型参数

基本类型参数

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

1
2
3
4
5
6
7
8
9
10
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick10")
    @ResponseBody
    public void save10(String username, int age) throws IOException {
        System.out.println(username);
        System.out.println(age);
    }
}

启动tomcat服务，在浏览器中携带username和age两个先参数进行请求：

http://localhost:8080/user/quick10?username=花猪&age=18

结果如下，可以看到获得前端传来的参数：

POJO类型参数

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

我先感慨一句：好强大

还有一种常见的情况就是，接收完前端传回的参数，要封装给对象，这一步SpringMVC也做好了封装：

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick11")
    @ResponseBody
    public void save11(User user) throws IOException {
        System.out.println(user);
    }
}

启动tomcat服务，在浏览器中携带username和age两个先参数进行请求：

http://localhost:8080/user/quick11?username=花猪&age=18

接收来的两个参数，会直接进行User类封装：

数组类型参数

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

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick12")
    @ResponseBody
    public void save12(String[] strs) throws IOException {
        System.out.println(Arrays.asList(strs));
    }
}

启动tomcat服务，在浏览器中携带三个参数：

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

接下来接收参数，会直接封装到数组中：

集合类型参数

手动封装

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

现在有一个需求，假设前端表单传回多个User对象的参数，这时后端就需要封装一个User类型的集合来进行接收。

首先在/src/main/webapp/jsp目录下编写一个post.jsp的文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="/user/quick13" method="post">
        第一个对象<br>
        <input type="text" name="userList[0].username"><br>
        <input type="text" name="userList[0].age"><br>
        第二个对象<br>
        <input type="text" name="userList[1].username"><br>
        <input type="text" name="userList[1].age"><br>
        <input type="submit" value="提交">
    </form>
</body>
</html>

也可以用Postman进行测试

在/src/main/java/mvc/domain目录下编写VO类，用于封装User对象：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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 +
                '}';
    }
}

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick13")
    @ResponseBody
    public void save13(VO vo) throws IOException {
        System.out.println(vo);
    }
}

启动tomcat服务，在浏览器表单中输入两个User对象的数据，并提交：

SpringMVC会自动将两个User对象封装到VO对象中：

@RequestBody

在方法参数位置使用@RequestBody可以直接接收集合数据而无需使用POJO进行包装。

首先在/src/main/webapp/jsp目录下编写一个ajax.jsp的文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.6.0/jquery.js"></script>
    <script>
        var userList = new Array();
        userList.push({username:"花猪",age:18});
        userList.push({username:"张三",age:20});

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

</body>
</html>

说明：

  • 这里用Ajax提交两个User类型的的数据
  • 指定contentType为json形式

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick14")
    @ResponseBody
    public void save14(@RequestBody List<User> userList) throws IOException {
        System.out.println(userList);
    }
}

说明：

  • @RequestBody添加至方法参数前，可直接用集合去接收前端传来的数据。而不必再手动封装集合数据

启动tomcat服务，在浏览器中访问ajax.jsp：

http://localhost:8080/jsp/ajax.jsp

结果如下：

静态资源访问

几乎所有情况下，前端不仅会获取“动态”的数据资源，还会请求存储在服务器上的静态资源（例如土图片），但是之前在前端控制器的配置中web.xml有可能设置了缺省，这就意味着，前端的静态资源请求也会通过前端控制器，进而去寻找相应的方法，显然这个方法是不存在的。这时就需要进行配置，告诉前端控制器，服务器中的一些静态资源是可以直接对外开放的。

配置spring-mvc.xml：

方案一：<mvc:resources>标签：

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

说明：

  • 假设在webapp目录下存在js以及img的文件夹，分别用于存储js脚本和图片
  • <mvc:resources>标签可以用于告诉前端控制器开放哪些资源：
    • mapping：地址映射，可以理解为访问的url
    • location：本地目录，指定url可以访问到的本地资源路径

方案二：<mvc:default-servlet-handler/>标签：

1
<mvc:default-servlet-handler></mvc:default-servlet-handler>

说明：

  • 该标签的作用：将前端控制器无法找到的请求资源（静态）交由原始的容器处理。这里就交由tomcat处理，其中的机制有能力处理静态资源请求。

请求数据的乱码问题

尤其在获取中文时，可能会遇到乱码的问题，这里需要在web.xml中配置一个全局的过滤器：

1
2
3
4
5
6
7
8
9
10
11
12
13
<!--配置全局过滤的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

在实际开发中，前端的请求参数名和后端接收的参数名有可能出现不一致的情况（或者是遇到冲突不可避免的出现类似情况），这时注解@RequestParam就可以起到一个参数映射的作用。

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick15")
    @ResponseBody
    public void save15(@RequestParam(value = "name") String username) throws IOException {
        System.out.println(username);
    }
}

说明

  • 这里接收的参数名为username
  • @RequestParam(value="name")表示可以将前端的name参数名映射为username
  • 这时如果前端再传username的参数就会报400的错误

前端发的请求，其参数名为name：

http://localhost:8080/user/quick15?name=花猪

@RequestParam的其他参数：

  • value：与请求参数名称
  • required：此在指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错
  • defaultValue：当没有指定请求参数时，则使用指定的默认值赋值

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick15")
    @ResponseBody
    public void save15(@RequestParam(value = "name", required = false, defaultValue = "张三") String username) throws IOException {
        System.out.println(username);
    }
}

说明：

  • 这里前端需要传入参数name
  • required设置为false，说明前端不传参数可以访问该方法
  • defaultValue设置前端没有传入参数时的默认值

启动tomcat服务，浏览器不携带任何参数做如下请求：

http://localhost:8080/user/quick15

后台会打印设定的默认值：

Restful风格参数获取

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

Restful风格的请求是使用“url+请求方式”表示一次请求目的的，HTTP协议里面四个表示操作方式的动词如下：

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

例如：

  • /user/1 GET ：得到 id = 1 的 user
  • /user POST：新增 user
  • /user/1 PUT： 更新 id = 1 的 user
  • /user/1 DELETE： 删除 id = 1 的 user

在SpringMVC中可以使用占位符进行参数绑定。

例如：地址/user/1可以写成/user/{id}，占位符{id}对应的就是1的值。

可以使用@PathVariable注解进行占位符的匹配获取工作。

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick16/{username}")
    @ResponseBody
    public void save16(@PathVariable(value = "username") String username) throws IOException {
        System.out.println(username);
    }
}

说明：如果配合请求格式，可以在@RequestMapping中配置请求方式，例如：

@RequestMapping(value = "/quick16/{username}", method = RequestMethod.POST)

启动tomcat服务，浏览器携带参数username做如下请求：

http://localhost:8080/user/quick16/花猪

自定义类型转换器

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

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

在UserController类中编写方法，这里接受一个日期类型（date）的数据：

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick17")
    @ResponseBody
    public void save17(Date date) throws IOException {
        System.out.println(date);
    }
}

启动tomcat服务，浏览器携带日期参数做如下请求：

日期格式为：Year/Month/Day

http://localhost:8080/user/quick17?date=2022/1/10

但如果前端改变日期格式，做如下请求：

http://localhost:8080/user/quick17?date=2022-1-10

则会报400错误：

SpringMVC可以自定义转换器，步骤如下：

  1. 定义转换器类实现Converter接口
  2. 在配置文件中声明转换器
  3. 在<annotation-driven>中引用转换器

在/src/main/java/mvn目录下创建converter文件夹，在其中编写转换类DateConverter：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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配置文件中声明转换器：

1
2
3
4
5
6
7
8
9
10
11
<!--声明转换器-->
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="mvc.converter.DateConverter"></bean>
        </list>
    </property>
</bean>

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

说明：需要把声明的转换器传递给注解驱动

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick17")
    @ResponseBody
    public void save17(Date date) throws IOException {
        System.out.println(date);
    }
}

启动tomcat服务，浏览器携带日期参数做如下请求：

日期格式为：Year-Month-Day

http://localhost:8080/user/quick17?date=2022-1-10

后台控制台打印信息，传参成功：

Servlet相关API获取

SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入，常用的对象如下：

  • HttpServletRequest
  • HttpServletResponse
  • HttpSession

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
10
11
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick18")
    @ResponseBody
    public void save18(HttpServletRequest request, HttpServletResponse response, HttpSession session) throws IOException {
        System.out.println(request);
        System.out.println(response);
        System.out.println(session);
    }
}

启动tomcat服务，浏览器做如下请求：

http://localhost:8080/user/quick18

可以看到控制台的打印输出，为apache.catalina包下的，是由tomcat原生产生的：

请求头获取

@RequestHeader

使用@RequestHeader可以获得请求头信息，该注解属性如下：

  • value：请求头的名称
  • required：是否必须携带此请求头

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick19")
    @ResponseBody
    public void save19(@RequestHeader(value = "User-Agent",required = false) String user_agent) throws IOException {
        System.out.println(user_agent);
    }
}

启动tomcat服务，浏览器做如下请求：

http://localhost:8080/user/quick19

在控制台打印出User-Agent的信息：

@CookieValue

使用@CookieValue可以获得指定Cookie的值，注解属性如下：

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

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick20")
    @ResponseBody
    public void save20(@CookieValue(value = "JSESSIONID",required = false) String jsessionId) throws IOException {
        System.out.println(jsessionId);
    }
}

启动tomcat服务，浏览器做如下请求：

http://localhost:8080/user/quick20

在控制台打印获取到的cookie值：

文件上传

步骤：

  • 导入fileupload和io坐标
  • 配置文件上传解析器
  • 配置文件上传解析器

首先在/src/main/webapp/jsp目录下编写upload.jsp文件：

1
2
3
4
5
6
7
8
9
10
11
12
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="/user/quick21" method="post" enctype="multipart/form-data">
        用户<input type="text" name="username"><br>
        文件<input type="file" name="uploadFile"><br>
        <input type="submit" value="提交"><br>
    </form>
</body>
</html>

在pom.xml配置文件中添加依赖：

1
2
3
4
5
6
7
8
9
10
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.3</version>
</dependency>

在spring-mvc.xml配置文件中配置文件上传解析器：

1
2
3
4
5
6
7
8
9
<!--配置文件上传解析器-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!--上传文件的编码类型-->
    <property name="defaultEncoding" value="UTF-8"></property>
    <!--上传文件的总大小-->
    <property name="maxUploadSize" value="800000"></property>
    <!--上传单个文件的大小-->
    <property name="maxUploadSizePerFile" value="800000"></property>
</bean>

单文件上传

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick21")
    @ResponseBody
    public void save21(String username, MultipartFile uploadFile) throws IOException {
        System.out.println(username);
        System.out.println(uploadFile);
        //获得上传文件的名称
        String originalFilename = uploadFile.getOriginalFilename();
        uploadFile.transferTo(new File("G:\\代码\\Java\\spring-project\\spring_mvc\\src\\main\\resources\\static\\img\\" + originalFilename));
    }
}

启动tomcat服务，在浏览器表单中输入用户名以及上传文件，并提交：

可以看到文件已接收，并保存到指定目录下：

多文件上传

修改upload.jsp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="/user/quick21" method="post" enctype="multipart/form-data">
        用户<input type="text" name="username"><br>
        文件一<input type="file" name="uploadFile1"><br>
        文件二<input type="file" name="uploadFile2"><br>
        <input type="submit" value="提交"><br>
    </form>
</body>
</html>

修改UserController类中的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick21")
    @ResponseBody
    public void save21(String username, MultipartFile uploadFile1, MultipartFile uploadFile2) throws IOException {
        System.out.println(username);
        System.out.println(uploadFile1);
        System.out.println(uploadFile2);
        //获得上传文件的名称
        String originalFilename1 = uploadFile1.getOriginalFilename();
        uploadFile1.transferTo(new File("G:\\代码\\Java\\spring-project\\spring_mvc\\src\\main\\resources\\static\\img\\" + originalFilename1));
        String originalFilename2 = uploadFile2.getOriginalFilename();
        uploadFile2.transferTo(new File("G:\\代码\\Java\\spring-project\\spring_mvc\\src\\main\\resources\\static\\img\\" + originalFilename2));
    }
}

说明：

  • 在单文件上传的基础上多增加一个MultipartFile类型参数，如果文件少的话可以这么操作
  • 前端表单中的文件上传name值不同，且必须和后台参数名一一对应

启动tomcat服务，在浏览器表单中输入用户名以及上传文件，并提交：

可以看到文件已接收，并保存到指定目录下：

如果上传文件数量多的话，建议使用数组接收。

修改upload.jsp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="/user/quick22" method="post" enctype="multipart/form-data">
        用户<input type="text" name="username"><br>
        文件一<input type="file" name="uploadFile"><br>
        文件二<input type="file" name="uploadFile"><br>
        文件三<input type="file" name="uploadFile"><br>
        <input type="submit" value="提交"><br>
    </form>
</body>
</html>

在UserController类中编写方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/quick22")
    @ResponseBody
    public void save22(String username, MultipartFile[] uploadFile) throws IOException {
        System.out.println(username);
        for (MultipartFile multipartFile : uploadFile) {
            String originalFilename = multipartFile.getOriginalFilename();
            //获得上传文件的名称
            System.out.println(originalFilename);
            multipartFile.transferTo(new File("G:\\代码\\Java\\spring-project\\spring_mvc\\src\\main\\resources\\static\\img\\" + originalFilename));
        }
    }
}

说明：

  • 前端表单中的文件上传name值相同，且必须和后台接收参数名一致

启动tomcat服务，在浏览器表单中输入用户名以及上传文件，并提交：

可以看到文件已接收，并保存到指定目录下：

这里originalFilename接收到的值就是完整的文件名

后记

重拾记忆，之后遇到再补充。

相关文章