SpringMVC基础内容

最新推荐文章于 2023-08-03 08:00:00 发布
最新推荐文章于 2023-08-03 08:00:00 发布
阅读量177 收藏
点赞数
分类专栏： java 文章标签： java spring mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43517448/article/details/110330687
版权

SpringMVC

1.学习目标

在这里插入图片描述

2.MVC 思想 & SpringMVC 框架概念与特点

2.1. 什么叫MVC？

​ 模型-视图-控制器（MVC）是⼀个众所周知的以设计界⾯应⽤程序为基础的设计思想。它主要通过分离模型、视图及控制器在应⽤程序中的角色将业务逻辑从界⾯中解耦。通常，模型负责封装应⽤程序数据在视图层展示。视图仅仅只是展示这些数据，不包含任何业务逻辑。控制器负责接收来⾃⽤户的请求，并调⽤后台服务（service或者dao）来处理业务逻辑。处理后，后台业务层可能会返回了⼀些数据在视图层展示。控制器收集这些数据及准备模型在视图层展示。MVC模式的核心思想是将业务逻辑从界面中分离出来，允许它们单独改变⽽不会相互影响。

2.2. 常见MVC框架运行性能比较

Jsp+servlet > struts1 > spring mvc > struts2+freemarker > struts2,ognl,值栈。

​ 开发效率上,基本正好相反。值得强调的是，spring mvc开发效率和struts2不相上下，但从⽬前来看，spring mvc 的流⾏度已远远超过struts2。

2.3. Spring MVC是什么?

​ Spring MVC是Spring家族中的⼀个web成员，它是⼀种基于Java的实现了Web MVC设计思想的请求驱动类型的轻量级Web框架，即使⽤了MVC架构模式的思想，将web层进⾏职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的⽬的就是帮助我们简化开发，Spring MVC也是要简化我们⽇常Web开发的。

​ Spring MVC是服务到⼯作者思想的实现。前端控制器是DispatcherServlet；应⽤控制器拆为处理器映射器(Handler Mapping)进⾏处理器管理和视图解析器(View Resolver)进⾏视图管理；⽀持本地化/国际化（Locale）解析及⽂件上传等；提供了⾮常灵活的数据验证、格式化和数据绑定机制；提供了强⼤的约定⼤于配置（惯例优先原则）的契约式编程⽀持。

2.4. Spring MVC能帮我们做什么?

  1. 让我们能⾮常简单的设计出⼲净的Web层；

  2. 进⾏更简洁的Web层的开发；

  3. 天⽣与Spring框架集成（如IOC容器、AOP等）；

  4. 提供强大的约定⼤于配置的契约式编程支持；

  5. 能简单的进行Web层的单元测试；

  6. 支持灵活的URL到⻚⾯控制器的映射；

  7. ⾮常容易与其他视图技术集成，如jsp、Velocity、FreeMarker等等，因为模型数据不放在特定的API⾥，⽽是放在⼀个Model⾥（Map数据结构实现，因此很容易被其他框架使用）；

  8. 非常灵活的数据验证、格式化和数据绑定机制，能使⽤任何对象进⾏数据绑定，不必实现特定框架的API；

  9. ⽀持灵活的本地化等解析；

  10. 更加简单的异常处理；

  11. 对静态资源的⽀持；

  12. ⽀持Restful⻛格。

3. SpringMVC 请求流程

3.1. Spring MVC 请求处理流程分析

在这里插入图片描述

​ Spring MVC框架也是⼀个基于请求驱动的Web框架，并且使⽤了前端控制器模式（是⽤来提供⼀个集中的请求处理机制，所有的请求都将由⼀个单⼀的处理程序处理来进⾏设计，再根据请求映射规则分发给相应的⻚⾯控制器（动作/处理器）进⾏处理。⾸先让我们整体看⼀下Spring MVC处理请求的流程：

  1. ⾸先⽤户发送请求,请求被SpringMvc前端控制器（DispatherServlet）捕获；

  2. 前端控制器(DispatherServlet)对请求URL解析获取请求URI,根据URI, 调⽤HandlerMapping；

  3. 前端控制器(DispatherServlet)获得返回的HandlerExecutionChain（包括Handler对象以及Handler对象对应的拦截器）；

  4. DispatcherServlet 根据获得的HandlerExecutionChain，选择⼀个合适的HandlerAdapter。（附注：如果成功获得HandlerAdapter后，此时将开始执⾏拦截器的preHandler(…)⽅法）；

  5. HandlerAdapter根据请求的Handler适配并执⾏对应的Handler；HandlerAdapter(提取Request中的模型数据，填充Handler⼊参，开始执⾏Handler（Controller)。 在填充Handler的⼊参过程中，根据配置，Spring将做⼀些额外的⼯作：

    ​ HttpMessageConveter： 将请求消息（如Json、xml等数据）转换成⼀个对象，将对象转换为指定的响应信息。

    数据转换：对请求消息进⾏数据转换。如String转换成Integer、Double等数据格式化：

    数据格式化。 如将字符串转换成格式化数字或格式化⽇期等

    数据验证： 验证数据的有效性（⻓度、格式等），验证结果存储到BindingResult或Error中）

  6. Handler执⾏完毕，返回⼀个ModelAndView(即模型和视图)给HandlerAdaptor

  7. HandlerAdaptor适配器将执⾏结果ModelAndView返回给前端控制器。

  8. 前端控制器接收到ModelAndView后，请求对应的视图解析器。

  9. 视图解析器解析ModelAndView后返回对应View;

  10. 渲染视图并返回渲染后的视图给前端控制器。

11、最终前端控制器将渲染后的⻚⾯响应给⽤户或客户端

3.2. Spring MVC 优势

  1. 清晰的⻆⾊划分：前端控制器（DispatcherServlet）、请求到处理器映射（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）、处理器或页面控制器（Controller）、验证器（ Validator）、命令对象（Command 请求参数绑定到的对象就叫命令对象）、表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）。

  2. 分⼯明确，⽽且扩展点相当灵活，可以很容易扩展，虽然⼏乎不需要；

  3. 和Spring 其他框架⽆缝集成，是其它Web框架所不具备的；

  4. 可适配，通过HandlerAdapter可以⽀持任意的类作为处理器；

  5. 可定制性，HandlerMapping、ViewResolver等能够⾮常简单的定制；

  6. 功能强⼤的数据验证、格式化、绑定机制；

  7. 利⽤Spring提供的Mock对象能够⾮常简单的进⾏Web层单元测试；

  8. 本地化、主题的解析的⽀持，使我们更容易进⾏国际化和主题的切换。

  9. 强⼤的JSP标签库，使JSP编写更容易。

    还有比如RESTful（⼀种软件架构风格，设计风格而不是标准，只是提供了⼀组设计原则和约束条件。它主要⽤于客户端和服务器交互类的软件，目前了解即可）风格的支持、简单的文件上传、约定⼤于配置的契约式编程支持、基于注解的零配置⽀持等等。

3.3. Spring MVC 环境搭建

3.3.1. 开发环境

​ Idea + Maven + Jdk1.8 + Jetty

3.3.2. 新建 Maven webApp

​ Idea 下创建 springmvc01 ⼯程

3.3.3. pom.xml 坐标添加

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <!-- spring web -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- spring mvc -->
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- web servlet -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>20201124springmvc01</finalName>
  <plugins>
    <!-- 编译环境插件 -->
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>2.3.2</version>
      <configuration>
        <source>1.8</source>
        <target>1.8</target>
        <encoding>UTF-8</encoding>
      </configuration>
    </plugin>
    <!-- jetty插件 -->
    <plugin>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-maven-plugin</artifactId>
      <version>9.4.27.v20200227</version>
      <configuration>
        <scanIntervalSeconds>10</scanIntervalSeconds>
        <!-- 设置端⼝ -->
        <httpConnector>
          <port>8080</port>
        </httpConnector>
        <!-- 设置项⽬路径 -->
        <webAppConfig>
          <contextPath>/springmvc01</contextPath>
        </webAppConfig>
      </configuration>
    </plugin>
  </plugins>
  </build>

3.3.4. 配置 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="3.0"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
        http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

  <!-- 编码过滤 utf-8 -->
  <filter>
      <description>char encoding filter</description>
      <filter-name>encodingFilter</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>encodingFilter</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>
        <!-- servlet请求分发器 -->
    <servlet>
        <servlet-name>springMvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring.xml</param-value>
        </init-param>
<!-- 表示启动容器时初始化该Servlet -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMvc</servlet-name>
        <!-- 这是拦截请求， "/"代表拦截所有请求，"*.do"拦截所有.do请求 -->
        <!-- <url-pattern>/</url-pattern> -->
        <url-pattern>*.tty</url-pattern>
    </servlet-mapping>
 </web-app>

​ 要想启动我们的 SpringMVC 环境，⽬前对于 mvc 框架的配置还未进行。以上在 web.xml 中引⽤了spring.xml ⽂件。

3.3.5. spring.xml 配置
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
 http://www.springframework.org/schema/mvc
 http://www.springframework.org/schema/mvc/spring-mvc.xsd
 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">
    <!-- 开启扫描器 -->
    <context:component-scan base-package="com.shsxt.springmvc.controller"/>
    <!-- 使⽤默认的 Servlet 来响应静态⽂件 -->
    <mvc:default-servlet-handler/>
    <!-- 开启注解驱动-->
    <mvc:annotation-driven/>
    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前缀：在WEB-INF⽬录下的jsp⽬录下 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!-- 后缀：以.jsp结尾的资源 -->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>
3.3.6. 页面控制器的编写
@Controller
public class UserController {
    @RequestMapping("/hello")
    public ModelAndView hello(){
        ModelAndView mv=new ModelAndView();
        mv.addObject("hello","hello spring mvc");
        mv.setViewName("hello");
        return mv;
    }
}
3.3.7. 添加视图页面

在 WEB-INF 下新建 jsp ⽂件夹 ，并在⽂件夹下新建 hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>hello</title>
</head>
<body>
    <h2>${hello}</h2>
</body>
</html>
3.3.8. 启动 jetty 服务器

4. URL 地址映射配置 & 参数绑定

4.1. URL 地址映射配置之 @RequestMapping

​ 通过注解 @RequestMapping 将请求地址与⽅法进⾏绑定，可以在类级别和⽅法级别声明。类级别的注解负责将⼀个特定的请求路径映射到⼀个控制器上，将 url 和类绑定；通过⽅法级别的注解可以细化映射，能够将⼀个特定的请求路径映射到某个具体的⽅法上，将 url 和类的⽅法绑定。

4.1.1. 映射单个 URL

@RequestMapping("") 或 @RequestMapping(value="")

/**
 * @RequestMapping 声明在⽅法上⾯，映射单个 URL
 * 访问地址：（如果有类路径需要写在⽅法路径前⾯）
 * http://ip:port/springmvc01/test01
 * @return
 */
@RequestMapping("/test01")
// @RequestMapping(value = "/test01")
public ModelAndView test01(){
 	ModelAndView modelAndView = new ModelAndView();
 	modelAndView.addObject("hello","test01");
 	modelAndView.setViewName("hello");
    return modelAndView; }
/**
 * 路径开头是否加 斜杠"/" 均可
 * @RequestMapping("/请求路径") 与 @RequestMapping("请求路径")均可
 * 建议加上，如：@RequestMapping("/test02")
 * 访问地址：（如果有类路径需要写在⽅法路径前⾯）
 * http://ip:port/springmvc01/test02
 * @return
 */
@RequestMapping("test02")
public ModelAndView test02(){
 	ModelAndView modelAndView = new ModelAndView();
 	modelAndView.addObject("hello","test02");
 	modelAndView.setViewName("hello");
 	return modelAndView; 
}
4.1.2. 映射多个 URL

@RequestMapping({"",""}) 或 @RequestMapping(value={"",""})

/**
 * @RequestMapping 声明在⽅法上⾯，映射多个 URL
 * ⽀持⼀个⽅法绑定多个 url 的操作
 * 访问地址：（如果有类路径需要写在⽅法路径前⾯）
 * http://ip:port/springmvc01/test03_01
 * http://ip:port/springmvc01/test03_02
 * @return
 */
@RequestMapping({"/test03_01","/test03_02"})
// @RequestMapping(value = {"/test03_01","/test03_02"})
public ModelAndView test03(){
 	ModelAndView modelAndView = new ModelAndView();
 	modelAndView.addObject("hello","test03");
 	modelAndView.setViewName("hello");
 	return modelAndView; 
}
4.1.3. 映射 URL 在控制器上

​ 用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

@Controller
@RequestMapping("/url")
public class UrlController {
 	/**
 	* @RequestMapping 声明在类上⾯，类中的的⽅法都是以该地址作为⽗路径
 	* 声明级别：
 	* 类级别 + ⽅法级别 （/类路径/⽅法路径）
 	* 访问地址：
 	* http://ip:port/springmvc01/url/test04
 	* @return
 	*/
 	@RequestMapping("/test04")
 	public ModelAndView test04(){
 		ModelAndView modelAndView = new ModelAndView();
 		modelAndView.addObject("hello","test04");
 		modelAndView.setViewName("hello");
 		return modelAndView;
 	}
}
4.1.4. 设置 URL 映射的请求方式

​ 默认没有设置请求方式，在HTTP 请求中最常⽤的请求方法是 GET、POST，还有其他的⼀些方法，如：DELET、PUT、HEAD 等。

​ 可以通过 method 属性设置⽀持的请求方式，如 method=RequestMethod.POST；如设置多种请求方式，以大括号包围，逗号隔开即可。

/**
 * 设置请求⽅式
 * 通过 method 属性设置⽅法⽀持的请求⽅式，默认 GET请求和 POST等请求都⽀持。
 * 设置了请求⽅式，则只能按照指定的请求⽅式请求。
 * 访问地址：（只能使⽤POST请求访问）
 * http://ip:port/springmvc01/url/test05
 * @return
 */
@RequestMapping(value = "/test05",method = RequestMethod.POST)
public ModelAndView test05(){
 	ModelAndView modelAndView = new ModelAndView();
 	modelAndView.addObject("hello","test05");
 	modelAndView.setViewName("hello");
 	return modelAndView; 
}
4.1.5. 通过参数名称映射 URL
/**
 * 通过参数名称访问
 * 通过参数的形式访问
 * 访问地址：
 * http://ip:port/springmvc01/url?test06
 * @return
 */
@RequestMapping(params = "test06")
public ModelAndView test06(){
 	ModelAndView modelAndView = new ModelAndView();
 	modelAndView.addObject("hello","test06");
 	modelAndView.setViewName("hello");
 	return modelAndView; 
}

4.2. 参数绑定

​ 客户端请求的参数到控制器功能处理⽅法上的参数的绑定，对于参数绑定⾮常灵活。

4.2.1. 基本数据类型
/**
 * 基本类型数据绑定
 * 参数值必须存在。如果没有指定参数值，也没有设置参数默认值，则会报500异常。
 * @param age
 * @param money
 */
@RequestMapping("data01")
public void data01(int age, double money){
 	System.out.println("age:" + age + ", money:" + money);
}
/**
 * 基本类型数据绑定
 * 通过注解 @RequestParam 标记⼀个形参为请求参数。（注解声明在形参的前⾯）
 * 可以通过注解的属性设置相关内容
 * 设置参数的默认值 defaultValue
 * @param age
 * @param money
 */
@RequestMapping("data02")
public void data02(@RequestParam(defaultValue = "18") int age,@RequestParam(defaultValue = "10.0") double money){
 	System.out.println("age:" + age + ", money:" + money);
}
/**
 * 基本类型数据绑定
 * 通过注解 @RequestParam 标记⼀个形参为请求参数。（注解声明在形参的前⾯）
 * 可以通过注解的属性设置相关内容
 * 设置参数的参数名（别名） name
 * @param age
 * @param money
 */
@RequestMapping("data03")
public void data03(@RequestParam(defaultValue = "18", name = "userAge") int age,
 @RequestParam(defaultValue = "10.0", name = "userMoney") double money){
 	System.out.println("age:" + age + ", money:" + money);
}
4.2.2. 包装类型
/**
 * 包装类型数据绑定 （如果数据是基本类型，建议使⽤包装类型）
 * 客户端请求参数名与⽅法形参名保持⼀致，默认参数值为null
 * 可以通过 @RequestParam 的name属性设置参数的别名，defaultValue属性设置参数默认值
 * @param age
 * @param money
 */
@RequestMapping("data05")
public void data05(Integer age, Double money){
 	System.out.println("age:" + age + ", money:" + money);
}
4.2.3. 字符串类型
/**
 * 字符串数据绑定
 * 客户端请求参数名与⽅法形参名保持⼀致，默认参数值为null
 * 可以通过 @RequestParam 的name属性设置参数的别名，defaultValue属性设置参数默认值
 * @param userName
 * @param userPwd
 */
@RequestMapping("data04")
public void data04(String userName, String userPwd){
 	System.out.println("userName:" + userName + ", userPwd:" + userPwd);
}
4.2.4. 数组类型
/**
 * 数组类型数据绑定
 * 客户端传参形式：ids=1&ids=2&ids=3
 * @param ids
 */
@RequestMapping("/data06")
public void data06(String[] ids){
 	for(String id : ids){
 		System.out.println(id + "---");
 	}
}
4.2.5. JavaBean 类型
/**
 * JavaBean 数据绑定
 * 客户端请求的参数名与JavaBean对象的属性字段名保持⼀致
 * @param user
 */
@RequestMapping("/data07")
public void data07(User user) {
 	System.out.println(user);
}
4.2.6. List 类型

​ 此时 User 实体需要定义对应 list 属性。（对于集合的参数绑定，⼀般需要使⽤用JavaBean 对象进⾏包装）

Jsp ⻚⾯定义

<form action="data08" method="post">
 	 <input name="list[0]" value="123456" />
	 <input name="list[1]" value="4576" />
	 <button type="submit"> 提交</button>
</form>

Controller ⽅法

@RequestMapping("/data08")
public void data08(User user){
 	System.out.println(user);
}
4.2.7. Set 类型
Set 和 List 类似，也需要绑定在对象上，⽽不能直接写在 Controller ⽅法的参数中。但是，绑定Set数据时，必须先在Set对象中add相应的数量的模型对象。

public class User {
 private int id;
 private String userName;
 private String userPwd;
 
 private Set<Phone> phones = new HashSet<Phone>();
 
 
 	public User() {
 		phones.add(new Phone());
 		phones.add(new Phone());
 		phones.add(new Phone());
 	}
 	/*public List<Phone> getPhones() {
 		return phones;
 	}
 	public void setPhones(List<Phone> phones) {
 		this.phones = phones;
 	}*/
 	public int getId() {
 		return id;
 		}
 	public void setId(int id) {
 		this.id = id;
 	}
 	public String getUserName() {
 		return userName;
 	}
 	public void setUserName(String userName) {
 		this.userName = userName;
 	}
 	public String getUserPwd() {
 		return userPwd;
 	}
 	public void setUserPwd(String userPwd) {
 		this.userPwd = userPwd;
    }
 	public Set<Phone> getPhones() {
 		return phones;
 	}
 	public void setPhones(Set<Phone> phones) {
 		this.phones = phones;
 	}
}

Controller ⽅法:

@RequestMapping("/data09")
public void data09(User user){
 	System.out.println(user);
}

表单页面

<form action="data09" method="post">
 	<input name="phones[0].num" value="123456" />
 	<input name="phones[1].num" value="4576" />
 	<input name="phones[2].num" value="4576" />
 	<button type="submit"> 提交</button>
</form>
4.2.8. Map 类型

​ Map最为灵活，它也需要绑定在对象上，⽽不能直接写在Controller⽅法的参数中。

Controller ⽅法

@RequestMapping("/data10")
public void data10(User user){
 	Set<Entry<String, Phone>> set = user.getMap().entrySet();
 	for(Entry<String, Phone> entry:set){
 		System.out.println(entry.getKey()+"--"+entry.getValue().getNum()); 
 	} 
}

表单页面

<form action="data10" method="post">
 	<input name="map['1'].num" value="123456" />
 	<input name="map['2'].num" value="4576" />
 	<input name="map['3'].num" value="4576" />
 	<button type="submit"> 提交</button>
</form>

5.请求转发与重定向的问题

​ SpringMVC 默认采⽤服务器内部转发的形式展示⻚⾯信息。同样也⽀持重定向⻚⾯。

5.1. 重定向

​ 重定向是发⼀个302的状态码给浏览器，浏览器⾃⼰去请求跳转的⽹⻚。地址栏会发⽣改变

重定向以 redirect: 开头

/**
 * 重定向到JSP⻚⾯
 * @return
 */
@RequestMapping(value="/view01")
public String view01(){
 	return "redirect:view.jsp"; 
}
/**
 * 重定向到JSP⻚⾯
 * 传递参数
 * @return
 */
@RequestMapping(value="/view02")
public String view02(){
 	return "redirect:view.jsp?uname=zhangsan&upwd=123456"; 
}
/**
 * 重定向到JSP⻚⾯
 * 传递参数 （传递中⽂参数会出现乱码）
 * @return
 */
@RequestMapping(value="/view03")
public String view03(){
 return "redirect:view.jsp?uname=张三&upwd=123456"; }
/**
 * 重定向到JSP⻚⾯
 * 传递参数 （通过 RedirectAttributes 对象设置重定向参数，避免中⽂乱码问题）
 * @param redirectAttributes
 * @return
 */
@RequestMapping(value="/view04")
public String view04(RedirectAttributes redirectAttributes){
 	redirectAttributes.addAttribute("uname","张三");
 	redirectAttributes.addAttribute("upwd","123456");
 	return "redirect:view.jsp"; 
}
/**
 * 重定向到JSP⻚⾯
 * 返回 ModelAndView 对象
 * @param modelAndView
 * @return
 */
@RequestMapping(value="/view06")
public ModelAndView view06(ModelAndView modelAndView){
 	modelAndView.addObject("uname","李四");
 	modelAndView.addObject("upwd","123321");
 	modelAndView.setViewName("redirect:view.jsp");
 	return modelAndView; 
}
/**
 * 重定向到Controller
 * 返回 ModelAndView 对象
 * @param modelAndView
 * @return
 */
@RequestMapping(value="/view07")
public ModelAndView view07(ModelAndView modelAndView){
 	modelAndView.addObject("uname","admin");
 	modelAndView.setViewName("redirect:test01");
    return modelAndView; 
}

页面中获取参数值

${param.参数名}

5.2. 请求转发

​ 请求转发，直接调⽤跳转的⻚⾯，让它返回。对于浏览器来说，它⽆法感觉服务器有没有forward。地址栏不发⽣改变。可以获取请求域中的数据。

请求转发以 forward: 开头

/**
 * 请求转发到JSP⻚⾯
 */
@RequestMapping("/view08")
public String view08(){
 	return "forward:view.jsp"; 
}
/**
 * 请求转发到JSP⻚⾯
 * 设置参数
 */
@RequestMapping("/view09")
public String view09(){
 	return "forward:view.jsp?uname=张三&upwd=123456"; 
}
/**
 * 请求转发到JSP⻚⾯
 * 设置请求域
 */
@RequestMapping("/view10")
public String view10(Model model){
 	model.addAttribute("uname","张三");
 	return "forward:view.jsp"; 
}
/**
 * 请求转发到JSP⻚⾯ （默认）
 * 默认会去指定⽬录下找JSP⻚⾯ （配置⽂件中设置的）
 */
@RequestMapping("/view11")
public String view11(){
	return "/../../view"; 
}
/**
 * 请求转发到 Controller
 * @return
 */
@RequestMapping("/view12")
public ModelAndView view12(ModelAndView modelAndView){
 	modelAndView.setViewName("forward:test01");
 	return modelAndView; 
}
/**
 * 请求转发到 Controller
 * 传递参数
 * @return
 */
@RequestMapping("/view13")
public ModelAndView view13(ModelAndView modelAndView){
 	modelAndView.setViewName("forward:test01?uname=admin");
 	return modelAndView; 
}

⻚⾯中获取数据

获取传递的参数：${param.参数名}
获取请求域的数据：${请求域中设置的名称}

总结：

​ 在有行为时，不管是redirect还是forward，都不会经过视图解析器，如果是.jsp,或html之类的就会走webapp下面的页面，如果没有后缀，则是走controller。

​ 在没有行为时，会走视图解析器，添加配置好的路径和后缀。

6. SpringMVC之 JSON 数据开发

6.1. 基本概念

​ Json 在企业开发中已经作为通用的接口参数类型，在页面（客户端）解析很方便。SpringMVC 对于json 提供了良好的⽀持，这里需要修改相关配置，添加 json 数据支持功能

6.1.1. @ResponseBody

​ 该注解用于将 Controller 的⽅法返回的对象，通过适当的 HttpMessageConverter 转换为指定格式后，写入到 Response 对象的 body 数据区。

​ 返回的数据不是 html 标签的页⾯，而是其他某种格式的数据时（如 json、xml 等）使用（通常用于ajax 请求）。

6.1.2. @RequestBody

​ 该注解⽤于读取 Request 请求的 body 部分数据，使⽤系统默认配置的 HttpMessageConverter 进⾏解析，然后把相应的数据绑定到要返回的对象上 ，再把 HttpMessageConverter 返回的对象数据绑定到 controller 中⽅法的参数上。

6.2. 使用配置

6.2.1. pom.xml 添加 json相关坐标
	<dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.10.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.10.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.10.0</version>
    </dependency>
6.2.2. 修改spring.xml
<mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>
6.2.3. 注解使用
6.2.3.1. @ResponseBody

​ 可以放在类上，

​ 可以放在方法上

​ 可以放在方法的修饰符和返回类型之间

@Controller
@RequestMapping("/user")
public class UserController {
     /**
 	* @ResponseBody 返回的是JOSN格式的数据，返回JavaBean对象
 	* 注解设置在⽅法体上
 	* @return
 	*/
 	@RequestMapping("queryUser01")
 	@ResponseBody
 	public User queryUser01(){
 		User user = new User();
 		user.setId(1);
 		user.setUserName("zhangsan");
 		user.setUserPwd("123456");
 		// 返回的是user对象
 		return user;
 	}
 	/**
 	* @ResponseBody 返回的是JOSN格式的数据，返回JavaBean对象
 	* 注解设置在⽅法返回对象前，修饰符之后
 	* @return
 	*/
 	@RequestMapping("queryUser02")
 	public @ResponseBody User queryUser02(){
 		User user = new User();
 		user.setId(2);
 		user.setUserName("lisi");
 		user.setUserPwd("123321");
 		// 返回的是user对象
		return user;
 	}
 
 	/**
 	* @ResponseBody 返回的是JOSN格式的数据，返回集合
 	* @return
 	*/
 	@RequestMapping("/queryUser03")
 	@ResponseBody
 	public List<User> queryUser03(){
 		List<User> list = new ArrayList<>();
 		User user01 = new User();
 		user01.setId(1);
 		user01.setUserName("zhangsan");
 		user01.setUserPwd("123456");
 		User user02 = new User();
 		user02.setId(2);
        user02.setUserName("lisi");
 		user02.setUserPwd("123321");
 		list.add(user01);
 		list.add(user02);
 		// 返回的是user集合
 		return list;
 	}
}
6.2.3.2. @RequestBody

​ @RequestBody 注解常⽤来处理 content-type 不是默认的 application/x-www-form-urlcoded 类型的内容，⽐如说：application/json 或者是application/xml 等。⼀般情况下来说常⽤其来处理application/json 类型。@RequestBody接受的是⼀个 json 格式的字符串，⼀定是⼀个字符串。

​ 通过 @RequestBody 可以将请求体中的 JSON 字符串绑定到相应的 bean 上，当然，也可以将其分别绑定到对应的字符串上。

/**
 * @RequestBody 规定请求的参数是JOSN格式的字符串
 * 注解设置在形参前⾯
 * @param user
 * @return
 */
@RequestMapping("/getUser")
@ResponseBody
public User getUser(@RequestBody User user){
 	System.out.println(user);
 	return user; 
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html> 
    <head>
 	<title>JSON处理</title>
 	<%-- 引⼊Jquery的核⼼JS⽂件 --%>
 	<script type="text/javascript" src="js/jquery-3.4.1.js"></script>
	</head> 
    <body>
 
        <input type="button" value="JSON数据测试" οnclick="test()"/>
 	<script type="text/javascript">
	 /**
 	* 请求传递JSON格式的数据
	* 返回JSON格式的数据
	*/
 	function test(){
 		$.ajax({
 			// 请求⽅式 Get|Post
 			type: "post",
			// 请求路径
 			url: "user/getUser",
 			// 预期服务器返回的额数据类型
 			dataType: "json",
 			// 设置服务器请求类型的数据类型为JSON格式
 			contentType: "application/json;charset=utf-8",
 			// 传递给服务器的参数
 			data:'{"userName":"admin","userPwd":"123456"}',
 			// 回调函数，接收服务器返回的响应的结果 （函数中的形参⽤来接收服务器返回的数据）
 			success:function(data){
 				console.log(data);
 			}
 		})
 	}
 </script>
</body>
</html>

7.课程总结

​ 本节课程主要给⼤家讲解 SpringMVC 第⼀天相关知识点内容，这⾥需要⼤家重点理解 MVC 核⼼思想，SpringMVC 请求执⾏原理，能够借助 Idea + Maven 环境完成 SpringMVC 基本环境的搭建与测试操作，重点掌握SpringMVC 请求到 Handler ⽅法映射对应的 URL 地址的配置、SpringMVC 环境下⻚⾯转发与重定向实现配置，在SpringMVC 环境下能够实现 Json 形式的参数绑定操作以及 Json 结果到客户端响应的处理。

1. 学习目标

在这里插入图片描述

2. 拦截器

2.1. 基本概念

​ SpringMVC 中的 Interceptor 拦截器也是相当重要和相当有⽤的，它的主要作⽤是拦截⽤户的请求并进⾏相应的处理。⽐如通过它来进⾏权限验证，或者是来判断⽤户是否登陆等操作。对于 SpringMVC拦截器的定义⽅式有两种：

​ 实现接⼝：org.springframework.web.servlet.HandlerInterceptor

​ 继承适配器：org.springframework.web.servlet.handler.HandlerInterceptorAdapter

2.2. 拦截器实现

2.2.1. 实现 HandlerInterceptor 接⼝

接⼝实现类

/**
* 拦截器实现
* 实现 HandlerInterceptor 接⼝
*/
public class MyInterceptor01 implements HandlerInterceptor {
	 /**
	 * 在 ⽬标Handler(⽅法)执⾏前 执⾏
	 * 返回 true：执⾏handler⽅法
	 * 返回 false：阻⽌⽬标handler⽅法执⾏
	 * @param request
	 * @param response
	 * @param handler
	 * @return
	 * @throws Exception
	 */
 	@Override
 	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
 		System.out.println("⽬标Handler执⾏前执⾏MyInterceptor01 --> preHandle⽅ 法...");
 		/**
 		* 返回 true：执⾏handler⽅法
 		* 返回 false：阻⽌⽬标handler⽅法执⾏
 		*/
 		return true;
 	}
 	/**
 	* 在 ⽬标Handler(⽅法)执⾏后，视图⽣成前 执⾏
 	* @param request
 	* @param response
 	* @param handler
 	* @param modelAndView
 	* @throws Exception
 	*/
 	@Override
 	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
 		System.out.println("⽬标Handler执⾏后，视图⽣成前执⾏MyInterceptor01 -->postHandle⽅法...");
     }
 	/**
 	* 在 ⽬标Handler(⽅法)执⾏后，视图⽣成后 执⾏
 	* @param request
 	* @param response
 	* @param handler
 	* @param ex
 	* @throws Exception
 	*/
 	@Override
	public void afterCompletion(HttpServletRequest request,HttpServletResponse response, Object handler, Exception ex) throws Exception {
 		System.out.println("⽬标Handler执⾏后，视图⽣成后执⾏MyInterceptor01 -->afterCompletion⽅法...");
 	}
}

拦截器xml配置

<!-- 拦截器配置：⽅式⼀ -->
<mvc:interceptors>
 	<!--
 	使⽤bean定义⼀个Interceptor
 	直接定义在mvc:interceptors根下⾯的Interceptor将拦截所有的请求
 	-->
 	<bean class="com.xxxx.springmvc.interceptor.MyInterceptor01"/>
</mvc:interceptors>

<!-- 拦截器配置：⽅式⼆ (推荐使⽤) -->
<mvc:interceptors>
 	<!--
 	定义在 mvc:interceptor 下⾯，可以⾃定义需要拦截的请求
 	如果有多个拦截器满⾜拦截处理的要求，则依据配置的先后顺序来执⾏
 	-->
 	<mvc:interceptor>
 		<!-- 通过 mvc:mapping 配置需要拦截的资源。⽀持通配符。可配置多个。 -->
 		<mvc:mapping path="/**"/> <!-- "/**"表示拦截所有的请求。 -->
 		<!-- 通过 mvc:mapping 配置不需要被拦截的资源。⽀持通配符。可配置多个。 -->
 		<mvc:exclude-mapping path="/url/*"/> <!-- "/url/*"表示放⾏url路径下的请求。 -->
 			<bean class="com.xxxx.springmvc.interceptor.MyInterceptor01"/>
 		</mvc:interceptor>
</mvc:interceptors>
2.2.2. 继承 HandlerInterceptorAdapter

实际上最终还是 HandlerInterceptor 接⼝实现。

​ ⼦类实现类

/**
* 拦截器实现
* 继承 HandlerInterceptorAdapter 适配器
*/
public class MyInterceptor02 extends HandlerInterceptorAdapter {
 /**
 * 在 ⽬标Handler(⽅法)执⾏前 执⾏
 * 返回 true：执⾏handler⽅法
 * 返回 false：阻⽌⽬标handler⽅法执⾏
 * @param request
 * @param response
 * @param handler
 * @return
 * @throws Exception
 */
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
 	System.out.println("⽬标Handler执⾏前执⾏MyInterceptor02 --> preHandle⽅ 法...");
 	/**
 	* 返回 true：执⾏handler⽅法
 	* 返回 false：阻⽌⽬标handler⽅法执⾏
 	*/
 	return true;
 	}
}

拦截器xml配置:与上面一样

<mvc:interceptors>
 	<mvc:interceptor>
 	<!-- 拦截的资源 -->
 	<mvc:mapping path="/**"/>
 	<!-- 放⾏的资源 -->
 	<mvc:exclude-mapping path="/url/test01"/>
 	<mvc:exclude-mapping path="/url/test02"/>
		<bean class="com.xxxx.springmvc.interceptor.MyInterceptor02"/>
 	</mvc:interceptor>
</mvc:interceptors>
2.2.3. 多个拦截器实现

​ SpringMVC 框架⽀持多个拦截器配置，从⽽构成拦截器链，对客户端请求进⾏多次拦截操作。

​ 拦截器代码实现

​ 这⾥参考MyInterceptor01、MyInterceptor02代码

​ 拦截器xml配置

<mvc:interceptors>
 	<!--
 	拦截器链（多个拦截器）
 	如果有多个拦截器满⾜拦截处理的要求，则依据配置的先后顺序来执⾏
 	先配置的拦截器的 preHandle ⽅法先执⾏
 	先配置的拦截器的 postHandle、afterCompletion ⽅法后执⾏
 	-->
 	<mvc:interceptor>
 		<!-- 拦截所有请求 -->
 		<mvc:mapping path="/**" />
 		<bean class="com.xxxx.springmvc.interceptor.MyInterceptor01" />
 	</mvc:interceptor>
 	<mvc:interceptor>
 	<!-- 拦截所有请求 -->
 	<mvc:mapping path="/**" />
 	<bean class="com.xxxx.springmvc.interceptor.MyInterceptor02" />
 	</mvc:interceptor>
</mvc:interceptors>

2.3. 拦截器应用 - 非法请求拦截

​ 使⽤拦截器完成⽤户是否登录请求验证功能

2.3.1. 用户控制器

​ UserInfoController 定义

/**
* ⽤户操作模拟实现
* ⽤户登录（⽆需登录）
* ⽤户添加（需要登录）
* ⽤户修改（需要登录）
* ⽤户删除（需要登录）
*/
@Controller
@RequestMapping("/userInfo")
public class UserInfoController {
 	/**
 	* ⽤户登录
 	* @return
 	*/
 	@RequestMapping("/login")
 	public ModelAndView userLogin(HttpSession session){
 		System.out.println("⽤户登录...");
 		ModelAndView mv = new ModelAndView();
 		// 设置视图
 		mv.setViewName("success");
  		// ⽤户登录后，设置对应的session域对象
 		User user = new User();
 		user.setId(1);
 		user.setUserName("admin");
 		user.setUserPwd("123456");
 		session.setAttribute("user",user);
 		return mv;
 	}
 	/**
 	* ⽤户添加
 	* @return
 	*/
 	@RequestMapping("/add")
 	public ModelAndView userAdd(){
 		System.out.println("⽤户添加...");
 		ModelAndView mv = new ModelAndView();
 		// 设置视图
 		mv.setViewName("success");
 		return mv;
 	}
 	/**
 	* ⽤户修改
 	* @return
 	*/
 	@RequestMapping("/update")
 	public ModelAndView userUpdate(){
 		System.out.println("⽤户更新...");
 		ModelAndView mv = new ModelAndView();
 		// 设置视图
 		mv.setViewName("success");
 		return mv;
 	}
 	/**
 	* ⽤户删除
 	* @return
 	*/
 	@RequestMapping("/delete")
 	public ModelAndView userDelete(){
 		System.out.println("⽤户删除...");
 		ModelAndView mv = new ModelAndView();
 		// 设置视图
 		mv.setViewName("success");  
     	return mv;
 	}
}
2.3.2. 页面定义

success.jsp 定义

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html> <head>
 <title>Title</title>
</head> 
    <body>
 		<h3>欢迎登录！</h3>
	</body>
</html>
2.3.3. 非法请求拦截器定义

LoginInterceptor 定义

/**
* ⾮法访问拦截
*/
public class LoginInterceptor extends HandlerInterceptorAdapter {
 /**
 * 在 ⽬标⽅法执⾏前 执⾏
 * @param request
 * @param response
 * @param handler
 * @return
 * @throws Exception
 */
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws
Exception {
 	// 获取 session 域对象中的user对象
 	User user= (User) request.getSession().getAttribute("user");
 	// 判断session域对象中的 user 是否为空
 	if(null == user){ // 如果为空，表示⽤户未登录
 		// 拦截⽤户跳转到登录⻚⾯
 		response.sendRedirect(request.getContextPath() + "/login.jsp");
 		// 不执⾏⽬标⽅法
 		return false;
     }
 	// ⽤户已登录，执⾏⽬标⽅法
 	return true;
 	}
}
2.3.4. 拦截器xml配置

servlet-context.xml 配置

<!-- 拦截所有请求 -->
<mvc:interceptors>
 	<mvc:interceptor>
 		<!-- 拦截所有请求 -->
 		<mvc:mapping path="/**" />
 		<!-- 放⾏⽤户登录请求 -->
	 	<mvc:exclude-mapping path="/userInfo/login"/>
 		<bean class="com.xxxx.springmvc.interceptor.LoginInterceptor" />
 	</mvc:interceptor>
</mvc:interceptors>

3.文件上传

3.1. 环境配置

3.1.1. pom.xml⽂件修改
<!-- 添加 commons-fileupload 依赖 -->
<dependency>
 	<groupId>commons-fileupload</groupId>
 	<artifactId>commons-fileupload</artifactId>
 	<version>1.3.2</version>
</dependency>
3.1.2. spring.xml修改
<!-- ⽂件上传 -->
<bean id="multipartResolver"
 
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
 <!-- 允许⽂件上传的最⼤尺⼨ -->
 <property name="maxUploadSize">
 <value>104857600</value>
 </property>
 <!--
设置⽂件放⼊临时⽂件夹的最⼤⼤⼩限制。
 此值是阈值，低于此值，则保存在内存中，如⾼于此值，则⽣成硬盘上的临时⽂件。
 -->
 <property name="maxInMemorySize">
 <value>4096</value>
 </property>
</bean>

3.2. 代码实现

3.2.1. 单⽂件上传
3.2.1.1. 页面表单

​ input 的type设置为file

​ form 表单的method设为post,

​ form 表单的enctype设置为multipart/form-data，以⼆进制的形式传输数据

<form action="uploadFile" method="post" enctype="multipart/form-data">
 	<input type="file" name="file" />
 	<button type="submit"> 提交</button>
</form>
3.2.1.2. 代码实现
/**
* ⽂件上传
*/
@Controller
public class FileController {
    /**
 	* 单⽂件上传
 	* 使⽤MultipartFile对象作为参数，接收前端发送过来的⽂件
 	* @param file
 	* @param request
 	* @return
 	*/
 	@RequestMapping("/uploadFile")
 	public String uploadFile(@RequestParam("file") MultipartFile file, HttpServletRequest request){
 	// 判断⽂件是否为空，如果不为空进⾏对应的⽂件上传操作
 	if (!file.isEmpty()) {
 	try {
 		// 获取项⽬的所在的路径 （绝对路径）
 		String path = request.getServletContext().getRealPath("/");
    	// 设置上传的⽂件存放的⽬录
 		File uploadFile = new File(path + "/upload");
 		// 判断⽂件⽬录是否存在，不存在则新建⽬录
 		if (!uploadFile.exists()) {
 			// 新建⽬录
 			uploadFile.mkdir();
 		}
 		// 获取上传⽂件的原⽂件名
 		String originalName = file.getOriginalFilename();
 		// 获取上传的⽂件的后缀
 		String suffix =originalName.substring(originalName.lastIndexOf("."));
 		// 通过系统当前时间的毫秒数，⽣成随机⽂件名 （避免上传的⽂件名重复）
 		String fileName = System.currentTimeMillis() + suffix;
 		// 上传⽂件 (转存⽂件到指定⽬录)
 		file.transferTo(new File(uploadFile, fileName));
    	// 设置成功的域对象
    	request.setAttribute("msg","⽂件上传成功！");
 		} catch (IOException e) {
 			e.printStackTrace();
 			// 如果报错，设置的域对象
 			request.setAttribute("msg","⽂件上传失败！");
 		}
 	} else {
 		// 上传⽂件不存在，设置的域对象
 		request.setAttribute("msg","⽂件不存在，上传失败！");
 		}
 	return "result";
 	}
}
3.2.2. 多文件上传
3.2.2.1. 页面表单
<form action="uploadFiles" method="post" enctype="multipart/form-data">
 	<input type="file" name="files" />
 	<input type="file" name="files" />
 	<input type="file" name="files" />
 	<button type="submit"> 提交</button>
</form>
3.2.2.2. 代码实现
/**
* 上传⽂件
 * @param file
 * @param request
 */
public void saveFile(MultipartFile file, HttpServletRequest request) {
 	// 判断⽂件是否为空，如果不为空进⾏对应的⽂件上传操作
 	if (!file.isEmpty()) {
 		try {
		// 获取项⽬的所在的路径 （绝对路径）
 		String path = request.getServletContext().getRealPath("/");
 		// 设置上传的⽂件存放的⽬录
 		File uploadFile = new File(path + "/upload");
 		// 判断⽂件⽬录是否存在，不存在则新建⽬录
 		if (!uploadFile.exists()) {
 			// 新建⽬录
 			uploadFile.mkdir();
 		}
 		// 获取上传⽂件的原⽂件名
 		String originalName = file.getOriginalFilename();
 		// 获取上传的⽂件的后缀
 		String suffix = originalName.substring(originalName.lastIndexOf("."));
 		// 通过系统当前时间的毫秒数，⽣成随机⽂件名 （避免上传的⽂件名重复）
 		String fileName = System.currentTimeMillis() + suffix;
 		// 上传⽂件 (转存⽂件到指定⽬录)
 		file.transferTo(new File(uploadFile, fileName));
 		// 设置成功的域对象
 		request.setAttribute("msg","⽂件上传成功！");
 		} catch (IOException e) {
 			e.printStackTrace();
 			// 如果报错，设置的域对象
 			request.setAttribute("msg","⽂件上传失败！");
 		}
 	} else {
 		// 上传⽂件不存在，设置的域对象
 		request.setAttribute("msg","⽂件不存在，上传失败！");
 	}
}
/**
 * 多⽂件上传
 * @param files
 * @param request
 * @return
 */
@RequestMapping("/uploadFiles")
public String uploadFiles(@RequestParam("files") List<MultipartFile> files,HttpServletRequest request) {
 	// 判断⽂件集合是否为空
 	if (files != null && files.size() > 0) {
 		// 循环上传
 		for (MultipartFile file:files) {
 		// 上传⽂件
 		saveFile(file, request);
 	}
 }
 return "result"; }

utton>

```
3.2.2.2. 代码实现
/**
* 上传⽂件
 * @param file
 * @param request
 */
public void saveFile(MultipartFile file, HttpServletRequest request) {
 	// 判断⽂件是否为空，如果不为空进⾏对应的⽂件上传操作
 	if (!file.isEmpty()) {
 		try {
		// 获取项⽬的所在的路径 （绝对路径）
 		String path = request.getServletContext().getRealPath("/");
 		// 设置上传的⽂件存放的⽬录
 		File uploadFile = new File(path + "/upload");
 		// 判断⽂件⽬录是否存在，不存在则新建⽬录
 		if (!uploadFile.exists()) {
 			// 新建⽬录
 			uploadFile.mkdir();
 		}
 		// 获取上传⽂件的原⽂件名
 		String originalName = file.getOriginalFilename();
 		// 获取上传的⽂件的后缀
 		String suffix = originalName.substring(originalName.lastIndexOf("."));
 		// 通过系统当前时间的毫秒数，⽣成随机⽂件名 （避免上传的⽂件名重复）
 		String fileName = System.currentTimeMillis() + suffix;
 		// 上传⽂件 (转存⽂件到指定⽬录)
 		file.transferTo(new File(uploadFile, fileName));
 		// 设置成功的域对象
 		request.setAttribute("msg","⽂件上传成功！");
 		} catch (IOException e) {
 			e.printStackTrace();
 			// 如果报错，设置的域对象
 			request.setAttribute("msg","⽂件上传失败！");
 		}
 	} else {
 		// 上传⽂件不存在，设置的域对象
 		request.setAttribute("msg","⽂件不存在，上传失败！");
 	}
}
/**
 * 多⽂件上传
 * @param files
 * @param request
 * @return
 */
@RequestMapping("/uploadFiles")
public String uploadFiles(@RequestParam("files") List<MultipartFile> files,HttpServletRequest request) {
 	// 判断⽂件集合是否为空
 	if (files != null && files.size() > 0) {
 		// 循环上传
 		for (MultipartFile file:files) {
 		// 上传⽂件
 		saveFile(file, request);
 	}
 }
 return "result"; }
夜不过如此
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自己构建微服务(springmvc+内嵌jetty+maven 环境配置）
08-13
NULL 博文链接：https://fuaotech.iteye.com/blog/2292707
Spring MVC详解（转）
朱塔山的博客
06-26 1万+
1.1介绍Spring MVC是Spring Framework提供的Web组件，全称是Spring Web MVC,是目前主流的实现MVC设计模式的框架，提供前端路由映射、视图解析等功能Java Web开发者必须要掌握的技术框架1.2MVC是什么MVC是一种软件架构思想，把软件按照模型，视图，控制器来划分Model:模型层，指工程中的JavaBean，用来处理数据JavaBean分成两类：一类称为实体类Bean:专门用来存储业务数据，比如Student,User。
三大框架-- SpringMVC
qq_55624813的博客
07-21 8390
一.概念 Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的SpringMVC框架或集成其他MVC开发框架 二.MVC模型 M代表: Model模型 V代表: View视图 C代表: Control控制层 用来进行分层的结构，这样代码分离结构清晰，各层代码，
超详细讲解SpringMVC三层架构
热门推荐
m0_59234718的博客
12-06 1万+
SpringMVC三层架构 Java SpringMVC的工程结构一般来说分为三层，自下而上是Modle层（模型，数据访问层）、Cotroller层（控制，逻辑控制层）、View层（视图，页面显示层），其中Modle层分为两层：dao层、service层，MVC架构分层的主要作用是解耦。采用分层架构的好处，普遍接受的是系统分层有利于系统的维护，系统的扩展。就是增强系统的可维护性和可扩展性。 对于Spring这样的框架，（View\Web）表示层调用控制层（Controller），控制层调用业务层（Ser
【框架篇】Spring MVC 介绍及使用（详细教程）
最新发布
小杨的博客
08-03 1万+
Spring MVC是Spring框架提供的基于MVC架构并继承了Servlet API的Web开发框架。它遵循MVC模式的原则，提供了一套完整的开发流程和特性。通过Spring框架的支持，它能够实现灵活性、可配置性和可扩展性，帮助开发者构建高性能的Web应用程序。
SpringMVC项目基础练习资源（不包含SSM整合）
10-16
SpringMVC项目基础练习资源（不包含SSM整合），只有代码，具体描述内容见写的博客笔记 SpringMVC笔记练习。资源代码中包含了相关的lib依赖 。IDE 为STS3.0 版本。JDK8.0 主要参考的是 B站 颜群老师的教程。
SpringMVC详细文档，内容通俗易懂，适合学习springMVC的初学者
07-22
从基础到高级部分，讲解的很通俗易懂，案例包括spingMVC和myBatis的整合
springmvc-showcase
06-06
Spring MVC 展示通过小... 在此展示中，您将看到以下内容： 最简单的@Controller 映射请求获取请求数据生成响应消息转换器渲染视图类型转换验证形式上传文件异常处理获取代码： 克隆存储库： $ git clone git://github....
一个maven构建的springMvc+mybatis项目基础架构
03-11
一个maven构建的springMvc+mybatis项目基础架构，实现了lo4j日志，欢迎大家下载。使用mysql数据库。使用之前，请查看jdbc.properties内容，进行配置即可。
看透springMvc源代码分析与实践
05-04
第一篇（第1～7章）介绍网站相关的基础知识，涉及网站架构、网络通信的底层协议以及实现方法，并详细分析Tomcat的实现过程，旨在帮助大家整体掌握网站的结构并理解SpringMVC所处的位置。第二篇（第8～10章）对...
SpringMVC详解
互联网底层民工的博客
07-14 6342
SpringMVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级web框架，通过把Model，View，Controller分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分。简化开发，减少出错，方便组内开发人员之间的配合。 他通过一套注解，让一个简单的Java类成为处理请求的控制器，而无需实现任何接口。同时它还支持Restful编程风格的请求。
SpringMVC基础(2)：SpringMVC基础
mingyuli的博客
12-21 6600
·
SpringMVC全套详解
Original0的博客
06-25 6729
表示应用程序中的数据和业务逻辑。在Spring MVC中，通常使用POJO（Plain Old Java Object）作为模型对象。通常模型对象负责在数据库中存取数据。负责展示用户界面，通常是HTML页面、JSON响应或其他类型的视觉呈现。视图负责将模型数据渲染，并向用户呈现。接收并处理HTTP请求，并根据请求的内容选择相应的处理方法。控制器负责调度适当的业务逻辑，操作模型数据，并通过相应的视图返回响应结果。
springMVC
qq_45687780的博客
04-21 8549
基于狂神说的笔记+个人理解和总结
SpringMVC(全)
m0_47711130的博客
05-30 8895
全网最全总结，有不足之处欢迎补充 [email protected] 可以通过图片连接自行查看结果截图
springmvc详细讲解
m0_49102053的博客
04-30 3835
springmvc讲解
SpringMVC框架详解（学习总结）
swy2560666141的博客
03-20 1万+
MVC 设计模式一般指 MVC 框架，M（Model）指数据模型层，业务模型层，V（View）指视图层，C（Controller）指控制层。使用 MVC 的目的是将 M 和 V 的实现代码分离，使同一个程序可以有不同的表现形式。MVC 属于架构模式的一种，所谓架构就是如何设计一个程序的结构。MVC 将程序结构划分为三层，每一层都对外提供了可供上层调用的接口，既能维系三层之间的联系，也能保持相对的独立性。这种将业务逻辑、数据和界面分离的代码组织形式，降低了模块间的耦合度，有利于日后的维护与扩展。
SpringMVC框架（详解）
passerby的博客
07-03 4373
Spring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把（M）Model，（V）View，（C）Controller分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。MVC 优点： 多视图共享一个模型，大大提高代码的可重用性 MVC三个模块相互独立，松耦合架构 控制器提高了应用程序的灵活性和可配置性 有利于软件工程化管理完美的系统架构 = 松耦合+高重用性+高扩展性MVC 缺点： 原理复杂 增加了
Mybatis 基础、Mybatis高级查询 &Spring 基础、SpringMVC基础、 SpringMVC进阶&JSON、SSM三大框架 集成、Maven&IDEA&UML、MyBatis增 强、SpringA0P、SpringBoot、
05-17
SpringMVC基础包括SpringMVC的介绍、请求处理流程、控制器、视图解析器、数据绑定等内容。 SpringMVC进阶包括拦截器、文件上传、异常处理、RESTful风格等内容。 JSON包括JSON的介绍、JSON格式、JSON解析、JSON数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值