SpringMVC

最新推荐文章于 2022-09-21 19:41:11 发布

weixin_46080949

最新推荐文章于 2022-09-21 19:41:11 发布

阅读量140

点赞数

分类专栏： SpringMVC 笔记文章标签： spring

本文链接：https://blog.csdn.net/weixin_46080949/article/details/108350430

版权

笔记同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

SpringMVC

1 篇文章 0 订阅

订阅专栏

一、Spring集成web环境

1.1ApplicationContext应用上下文获取方式

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

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

1.2Spring提供获取应用上下文的工具

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

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

在web.xml中配置监听器ContextLoaderListener监听器（导入Spring-web坐标）
使用WebApplicationContextUtils获取应用上下文对象ApplicationContext

1.3知识要点

配置ContextLoaderListener（导入Spring-web坐标）
使用WebApplicationContextUtils获取应用上下文对象

二、SpringMVC简介

2.1SpringMVC概述

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

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

2.2SpringMVC的开发步骤

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

开发步骤：

导入SpringMVC相关坐标
配置SpringMVC核心控制器DispathcerServlet
创建Controller类和视图页面
使用注解配置Controller类中业务方法的映射地址
配置SpringMVC的核心文件spring-mvc.xml（配置组件扫描）
客户端发起请求测试

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

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <!--配置SpringMVC的前端控制器-->
    <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>


    <!--全局初始化参数-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>



    <!--配置监听器-->
    <listener>
<!--        <listener-class>com.itheima.listener.ContextLoaderListenet</listener-class>-->
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>


    <welcome-file-list>
        <welcome-file>/index.jsp</welcome-file>
    </welcome-file-list>


    <servlet>
        <servlet-name>UserServlet</servlet-name>
        <servlet-class>com.itheima.web.UserServlet</servlet-class>
    </servlet>


    <servlet-mapping>
        <servlet-name>UserServlet</servlet-name>
        <url-pattern>/userServlet</url-pattern>
    </servlet-mapping>


</web-app>

@Controller
public class UserController {
    //http://localhost:8080/quick
    @RequestMapping("quick")
    public String save(){
        System.out.println("controller save runing...");
        return "success.jsp";
    }
}

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

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

</beans>

访问后控制台输出结果

controller save runing...

2.3SpringMVC控制流程图

在这里插入图片描述

2.4知识要点

SpringMVC的开发步骤

导入SpringMVC相关坐标
配置SpringMVC核心控制器DispatcherServlet
创建Controller类和视图页面
使用注解配置Controller类中业务方法的映射地址
配置SpringMVC的核心文件spring-mvc.xml（配置组件扫描）
客户端发起请求测试

三、SpringMVC组件解析

3.1SpringMVC的执行流程

在这里插入图片描述

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

3.2SpringMVC注解解析

@RequestMapping

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

位置：

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

属性：

value：用于指定请求的URL，它和path属性的作用是一样的
method ：用于指定请求的方式
params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一摸一样

例如：

params = {“accountName”},表示请求参数必须有accountName
params = {“money！100”},表示请求参数中的money不能是100

MVC命名空间引入

命名空间：

xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"

约束地址：

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

组件扫描

SpringMVC基于Spring容器所以进行SpringMVC操作时，需要Controller存储到Spring容器中，如果使用@Controller注解标注的话，就需要使用<context:component-scan base-package=“com.itheima.controller”/>进行扫描

3.3SpringMVC的XML配置解析

视图解析器

SpringMVC有默认的组件配置，默认都是DispatcherServlet配置文件中配置的，该配置文件地址org/springframework/web/servlet/DispatcherServlet.properties，该文件中配置了默认的视图解析器，如下：
```
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
```
翻看该解析源码，可以看到该解析器的默认设置，如下：
- REDIRECT_URL_PREFIX = “rediect:” --重定向前缀
- FORWARD_URL_PREFIX = “forward:” --转发前缀（默认值）
- prefix = “”; — 视图名称前缀
- suffix = “”; — 视图名称后缀

3.4知识要点

SpringMVC的相关组件

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

SpringMVC的注解和配置

请求映射注解：@RequestMapping
视图解析器配置：
- REDIRECT_URL_PREFIX = “rediect:” --重定向前缀
- FORWARD_URL_PREFIX = “forward:” --转发前缀（默认值）
- prefix = “”; — 视图名称前缀
- suffix = “”; — 视图名称后缀

四、SpringMVC的数据响应方式

4.1SpringMVC的数据响应方式

页面跳转
- 直接返回字符串
- 通过ModelAndView对象返回
回写数据
- 直接返回字符串
- 返回对象或集合

4.2页面跳转

返回字符串形式

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

在这里插入图片描述

返回带有前缀的字符串：

转发：forward：/WEB-INF/views/index.jsp

重定向：redirect:/index.jsp

@RequestMapping("quick")
public String save(){
    System.out.println("controller save runing...");
    return "success.jsp";
}

返回ModelAndView对象

@RequestMapping("quick2")
public ModelAndView save2(){
    System.out.println("controller save runing...");
    /*
    model:模型 作用封装数据
    view:视图 作用展示数据
     */
    ModelAndView modelAndView = new ModelAndView();
    //设置模型数据
    modelAndView.addObject("username","301");
    //设置视图
    modelAndView.setViewName("index.jsp");
    return modelAndView;
}

@RequestMapping("quick3")
public ModelAndView save3(ModelAndView modelAndView){
    modelAndView.addObject("username","第二种方式");
    modelAndView.setViewName("index");
    return modelAndView;
}

@RequestMapping("quick4")
public String save4(Model model){
    model.addAttribute("username","第三种方式");
    return "index";
}

4.3回写数据

直接返回字符串

Web基础阶段，客户访问服务器，如果想直接回写字符串作为响应体返回的话，只需要使用response.getWriter().print(“hello word”)即可，那么Controller中想直接回写字符串该怎样呢？

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

@RequestMapping("quick6")
public void save6(HttpServletResponse response){
    response.setCharacterEncoding("UTF-8");
    try {
        response.getWriter().println("回写数据直接返回字符串");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

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

@RequestMapping("quick7")
@ResponseBody//告知SpringMVC框架 不进行视图跳转 直接进行数据响应
public String save7(HttpServletResponse response){
    return  "回写数据直接返回字符串2";
}

返回json格式字符串

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

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

返回对象或集合

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

<!-- 配置处理器映射器   -->
<bean id="handlerAdapter" 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("quick10")
@ResponseBody
//期望SpringMVC自动将User转换成json格式的字符串
public User save10() throws IOException {
    User user = new User();
    user.setName("lisi");
    user.setAge(30);
    return user;
}

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

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

代替

<!-- 配置处理器映射器   -->
<bean id="handlerAdapter" 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>

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

使用mvc:annotation-driven/自动加载RequestMappingHandlerMapping（处理映射器）和RequestMappingHandlerAdapter（处理适配器)，可用在Spring-xml.xml配置文件中使用mvc:annotation-driven/代替注解处理器和适配器的配置。

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

4.4知识要点

SpringMVC的数据响应方式

页面跳转
- 直接返回字符串
- 通过ModelAndView对象返回
回写数据
- 直接返回字符串
- 返回对象或集合

五、SpringMVC获得请求数据

5.1获得请求参数

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

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

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

5.2获得基本数据类参数

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

http://localhost:8080/quick11?username=zs&age=18

@RequestMapping("quick11")
@ResponseBody
public void save11(String username,int age){
    System.out.println(username);
    System.out.println(age);
}

输出

zs
18

5.3获得POJO类型参数

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

public class User  {

    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

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

http://localhost:8080/quick12?name=zs&age=18

@RequestMapping("quick12")
@ResponseBody
public void save12(User user){
    System.out.println(user);
}

输出结果

User{name='zs', age=18}

5.4获得数组类型参数

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

http://localhost:8080/quick13?strs=aaa&strs=bbb&strs=CCC

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

输出结果

[aaa, bbb, CCC]

5.5获得集合类型参数

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

http://localhost:8080/from.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/quick14" method="post">
        <%--表明是第一个user对象的name age--%>
        第一个对象：<br>
        姓名：<input type="text" name="userList[0].name">
        年龄：<input type="text" name="userList[0].age">
            <br>
        第二个对象：<br>
        姓名：<input type="text" name="userList[1].name">
        年龄：<input type="text" name="userList[1].age">
        <br>
        第三个对象：<br>
        姓名：<input type="text" name="userList[2].name">
        年龄：<input type="text" name="userList[2].age">
        <br>
        <button type="submit">确认</button>
    </form>
</body>
</html>

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

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

输出结果

[User{name='zs', age=21}, User{name='ls', age=22}, User{name='ww', age=23}]

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

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}js/jquery-3.5.0.js"></script>
    <script>
    var userList = new Array();
    userList.push({name:"zhangsan",age:18});
    userList.push({name:"lisi",age:28});
    $.ajax({
    type:"POST",
    url:"${pageContext.request.contextPath}/quick15",
    data:JSON.stringify(userList),
    contentType:"application/json;charset=utf-8"
    })
    </script>
</head>
<body>

</body>
</html>

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

<mvc:default-servlet-handler/>

5.6请求数据乱码问题

当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>

5.7参数绑定注解@RequestParam

当请求的参数名称与Controller的业务方法参数名称不一致时，就需要通过@RequestParam注解显示的绑定。

http://localhost:8080/quick16?name=zhangsan

@RequestMapping(value = "/quick16")
@ResponseBody
public void save16(@RequestParam("name") String username){
    System.out.println(username);
}

注解@RequestParam还有如下参数可以使用：

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

@RequestMapping(value = "/quick16")
@ResponseBody
public void save16(@RequestParam(value = "name",required = false,defaultValue = "zzh") String username){
    System.out.println(username);
}

5.8自定义类型转换器

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

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

定义转换器类型实现Converter接口
在配置文件中声明转换器
在中引用转换器

public class DateConverter implements Converter<String,Date> {

    @Override
    public Date convert(String s) {
        //将日期字符串换成日期对象，返回
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = simpleDateFormat.parse(s);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

@RequestMapping(value = "/quick17")
@ResponseBody
public void save17(Date date){
    System.out.println(date);
}

<!-- 声明转换器   -->
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="com.itheima.converter.DateConverter"></bean>
        </list>
    </property>
</bean>

<mvc:annotation-driven conversion-service="conversionService" />

http://localhost:8080/quick17?date=2020-10-29

5.9获得Servlet相关API

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

HttpServletRequest
HttpServletResponse
HttpSession

@RequestMapping(value = "/quick18")
@ResponseBody
public void save18(HttpServletRequest request, HttpServletResponse response, HttpSession session){
    System.out.println(request);
    System.out.println(response);
    System.out.println(session);
}

5.10获得请求头

@RequestHeader

使用@RequestHeader可以获得请求头信息，相当于web阶段学习的request.getHeader（name）

@RequestHeader注解的属性如下
- value：请求头的名称
- require是否必须携带此请求头
```
@RequestMapping(value = "/quick19")
@ResponseBody
public void save19( @RequestHeader(value = "User-Agent",required = false) String str){
    System.out.println(str);
}
```

@CookieValue

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

@CookieValue注解的属性如下：

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

@RequestMapping(value = "/quick20")
@ResponseBody
public void save20( @CookieValue(value = "JSESSIONID",required = false) String str){
    System.out.println(str);
}

5.11获得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注解进行占位符的匹配获取工作。

http://localhost:8080/quick21/zhangsan

@RequestMapping(value = "/quick21/{name}")
@ResponseBody
public void save21( @PathVariable(value = "name",required = false) String name){
    System.out.println(name);
}

5.12文件上传

文件上传客户端三要素
- 表单项type =“file”
- 表单的提脚方式是post
- 表单的enctype属性是多部分表单形式，及enctype=“multipart/form-data”
文件上传原理
- 当form表单修改为多部分表单时，request.getparameter()将失败
- enctype="application/x-www-form-urlencoded"时，form表单的正文内容格式是：key=value&key=value&key=value… …
- 当form表单的enctype取值为multipart/form-data时，请求正文内容就变成多部分形式：

在这里插入图片描述

5.13单文件上传步骤

导入fileupload和io坐标
配置文件上传解析器
编写文件上传代码

<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.6</version>
</dependency>

<!--配置文件上传解析器    -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="defaultEncoding" value="UTF-8"/>
    <property name="maxUploadSize" value="500000"/>
</bean>

@RequestMapping(value = "/quick22")
    @ResponseBody
    public void save22(String username, MultipartFile uploadfile) throws IOException{
        System.out.println(username);
        System.out.println(uploadfile);
        String originalFilename = uploadfile.getOriginalFilename();
        uploadfile.transferTo(new File("C:\\Users\\枭毅\\Desktop\\作业\\"+originalFilename));
    }

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/quick22" method="post" enctype="multipart/form-data">
        名称：<input type="text" name="username"/><br>
        文件：<input type="file" name="uploadfile"/><br>
        <button type="submit">提交</button>
    </form>
</body>
</html>

5.14多文件上传

多文件上传，只需要将页面修改为多文件上传项，将方法参数MultiparFile类型修改为MultipartFile[]即可

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/quick23" 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>
        <button type="submit">提交</button>
    </form>
</body>
</html>

@RequestMapping(value = "/quick23")
@ResponseBody
public void save23(String username, MultipartFile[] uploadfile) throws IOException{
    System.out.println(username);
    for (int i = 0; i < uploadfile.length; i++) {
        MultipartFile multipartFile = uploadfile[i];
        String originalFilename = multipartFile.getOriginalFilename();
        multipartFile.transferTo(new File("C:\\Users\\枭毅\\Desktop\\作业\\"+originalFilename));
    }
}

5.15知识要点

MVC实现数据请求方式

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

MVC获取数据细节

中文乱码问题
@RequestParam和@PathVariable
自定义类型转换器
获得Servlet相关API
@RequestHeader和@CookieValue
文件上传

六、SpringMVC拦截器

6.1拦截器(interceptor)的作用

SpringMVC的拦截器的作用类似于Servlet 开发中的过滤器，用于对处理器进行预处理和后处理。

将拦截器按一定的顺序连接成一条链，这条链称为拦截器链(interceptor Chain)。在访问被拦截的方法或字段时，拦截链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体实现。

6.2拦截器(interceptor)和过滤器(filter)区别

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

6.3拦截器的快速入门

自定义拦截器很简单，只有如下三步：

创建拦截器实现HandlerInterceptor接口
配置拦截器
测试拦截器的拦截效果

创建实现HandlerInterceptor接口类

public class MyInterceptor1 implements HandlerInterceptor {
    //在目标方法执行之前执行的
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle....");
        String param = request.getParameter("param");
        if("yes".equals(param)){
            return true;
        }else {
            request.getRequestDispatcher("/error.jsp").forward(request,response);
            return false;
        }

    }
    //目标方法执行之后 视图对象返回之前
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        //会覆盖目标方法的Attribute
        request.setAttribute("naem","威哥");
        System.out.println("postHandle....");
    }
    //在整个流程都执行完毕后执行
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion....");
    }
}

配置拦截器

<!--配置拦截器    -->
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean id="interceptor" class="com.itheima.interceptor.MyInterceptor1"/>
    </mvc:interceptor>
</mvc:interceptors>

测试

@Controller
public class TargetController {
    @RequestMapping("/target")
    public ModelAndView show(ModelAndView modelAndView){
        System.out.println("target running.....");
        modelAndView.addObject("name","渣渣辉");
        modelAndView.setViewName("target");
        return modelAndView;
    }
}

target.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>${naem}</h1>
</body>
</html>

error.jsp

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

访问路径

http://localhost:8080/target?param=yes

输出结果

preHandle....
preHandle....
target running.....
postHandle....
afterCompletion....
preHandle....

6.4SpringMVC拦截器

方法名	说明
preHandle()	方法将在请求处理之前调用，该方法的返回值是布尔值Boolean累着的，当它返回为false时，表示请求结束，后读的Interceptor和Controller都不会在执行；返回值为true时会继续调用下一个Interceptor的preHandler方法
postHandle()	该方法是在当前请求进行处理之后被调用，前提是preHandler方法的返回值为true时才被调用，而且它会在DispatcherServlet进行视图返回值渲染之前被调用，所有我们在这个方法中对Controller处理之后的ModelAndView对象进行操作
afterCompletion()	该方法将在整个请求结束之后，也就是在DispatcherServlet渲染了对应的视图之后执行，前提是preHandler方法的返回值为true时才能被调用

6.5知识要点

自定义拦截器步骤：

创建拦截器实现HandlerInterceptor接口
配置拦截器
测试拦截器的拦截效果

七、SpringMVC异常处理

7.1异常处理的思路

系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试等手段减少运行时异常的发生。

系统的Dao、Service、Controller出现都通过throwsException向上抛出，最后由SpringMVC前端控制器交由异常处理器进行异常处理，如下图：

在这里插入图片描述

7.2异常处理两种方式

使用SpringMVC提供的简单异常处理器SimpleMappingExceptionResolve
实现Spring的异常处理器接口HandlerExceptionResolve自定义自己的处理器

7.3简单异常处理器SimpleMappingExceptionResolve

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

<!--配置简单的异常处理器    -->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <!--value -默认的错误视图        -->
    <property name="defaultErrorView" value="error"/>
    <property name="exceptionMappings">
        <map>
                <!-- key - 异常的类型 ，value - 错误视图  -->
            <entry key="java.lang.ClassCastException" value="error1"/>
            <entry key="com.itheima.exception.MyException" value="error2"/>
        </map>
    </property>
</bean>

7.4自定义异常处理器

创建异常处理器类实现HandlerExceptionResolve
配置异常处理器
编写异常页面
测试异常跳转

7.5知识要点

异常处理方式

配置简单异常处理器SimpleMappingExceptionResolve
自定义异常处理器

自定义异常处理器步骤

创建异常处理器类实现HandlerExceptionResolve
配置异常处理器
编写异常页面
时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试等手段减少运行时异常的发生。

系统的Dao、Service、Controller出现都通过throwsException向上抛出，最后由SpringMVC前端控制器交由异常处理器进行异常处理，如下图：

[外链图片转存中…(img-bes2sSPA-1598964354041)]

7.2异常处理两种方式

使用SpringMVC提供的简单异常处理器SimpleMappingExceptionResolve
实现Spring的异常处理器接口HandlerExceptionResolve自定义自己的处理器

7.3简单异常处理器SimpleMappingExceptionResolve

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

<!--配置简单的异常处理器    -->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <!--value -默认的错误视图        -->
    <property name="defaultErrorView" value="error"/>
    <property name="exceptionMappings">
        <map>
                <!-- key - 异常的类型 ，value - 错误视图  -->
            <entry key="java.lang.ClassCastException" value="error1"/>
            <entry key="com.itheima.exception.MyException" value="error2"/>
        </map>
    </property>
</bean>

7.4自定义异常处理器

创建异常处理器类实现HandlerExceptionResolve
配置异常处理器
编写异常页面
测试异常跳转

7.5知识要点

异常处理方式

配置简单异常处理器SimpleMappingExceptionResolve
自定义异常处理器

自定义异常处理器步骤

创建异常处理器类实现HandlerExceptionResolve
配置异常处理器
编写异常页面
测试异常跳转

weixin_46080949

关注

0
点赞
踩
1

收藏

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

一、Spring集成web环境1.1ApplicationContext应用上下文获取方式应用上下文对象是通过new ClassPathXmlApplicationContext(Spring配置文件)方式获取的，但是每次从容器中获取Bean时都要编写new ClassPathXmlApplicationContext(Spring配置文件)，这样的弊端是配置文件加载多次，应用上下文对象创建多次。在web项目中，可以被ServletContextListener监听web应用的启动，我们可以在web
复制链接

扫一扫