SpringMVC基础内容

2023-11-11 18:18:28

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能帮我们做什么?

让我们能⾮常简单的设计出⼲净的Web层；
进⾏更简洁的Web层的开发；
天⽣与Spring框架集成（如IOC容器、AOP等）；
提供强大的约定⼤于配置的契约式编程支持；
能简单的进行Web层的单元测试；
支持灵活的URL到⻚⾯控制器的映射；
⾮常容易与其他视图技术集成，如jsp、Velocity、FreeMarker等等，因为模型数据不放在特定的API⾥，⽽是放在⼀个Model⾥（Map数据结构实现，因此很容易被其他框架使用）；
非常灵活的数据验证、格式化和数据绑定机制，能使⽤任何对象进⾏数据绑定，不必实现特定框架的API；
⽀持灵活的本地化等解析；
更加简单的异常处理；
对静态资源的⽀持；
⽀持Restful⻛格。

3. SpringMVC 请求流程

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

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

⾸先⽤户发送请求,请求被SpringMvc前端控制器（DispatherServlet）捕获；
前端控制器(DispatherServlet)对请求URL解析获取请求URI,根据URI, 调⽤HandlerMapping；
前端控制器(DispatherServlet)获得返回的HandlerExecutionChain（包括Handler对象以及Handler对象对应的拦截器）；
DispatcherServlet 根据获得的HandlerExecutionChain，选择⼀个合适的HandlerAdapter。（附注：如果成功获得HandlerAdapter后，此时将开始执⾏拦截器的preHandler(…)⽅法）；
HandlerAdapter根据请求的Handler适配并执⾏对应的Handler；HandlerAdapter(提取Request中的模型数据，填充Handler⼊参，开始执⾏Handler（Controller)。在填充Handler的⼊参过程中，根据配置，Spring将做⼀些额外的⼯作：

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

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

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

数据验证：验证数据的有效性（⻓度、格式等），验证结果存储到BindingResult或Error中）
Handler执⾏完毕，返回⼀个ModelAndView(即模型和视图)给HandlerAdaptor
HandlerAdaptor适配器将执⾏结果ModelAndView返回给前端控制器。
前端控制器接收到ModelAndView后，请求对应的视图解析器。
视图解析器解析ModelAndView后返回对应View;
渲染视图并返回渲染后的视图给前端控制器。

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

3.2. Spring MVC 优势

清晰的⻆⾊划分：前端控制器（DispatcherServlet）、请求到处理器映射（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）、处理器或页面控制器（Controller）、验证器（ Validator）、命令对象（Command 请求参数绑定到的对象就叫命令对象）、表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）。
分⼯明确，⽽且扩展点相当灵活，可以很容易扩展，虽然⼏乎不需要；
和Spring 其他框架⽆缝集成，是其它Web框架所不具备的；
可适配，通过HandlerAdapter可以⽀持任意的类作为处理器；
可定制性，HandlerMapping、ViewResolver等能够⾮常简单的定制；
功能强⼤的数据验证、格式化、绑定机制；
利⽤Spring提供的Mock对象能够⾮常简单的进⾏Web层单元测试；
本地化、主题的解析的⽀持，使我们更容易进⾏国际化和主题的切换。
强⼤的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"; }

码农公寓

SpringMVC

1.学习目标

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

2.1. 什么叫MVC？

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

2.3. Spring MVC是什么?

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

3. SpringMVC 请求流程

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

3.2. Spring MVC 优势

3.3. Spring MVC 环境搭建

3.3.1. 开发环境

3.3.2. 新建 Maven webApp

3.3.3. pom.xml 坐标添加

3.3.4. 配置 web.xml

3.3.5. spring.xml 配置

3.3.6. 页面控制器的编写

3.3.7. 添加视图页面

3.3.8. 启动 jetty 服务器

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

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

4.1.1. 映射单个 URL

4.1.2. 映射多个 URL

4.1.3. 映射 URL 在控制器上

4.1.4. 设置 URL 映射的请求方式

4.1.5. 通过参数名称映射 URL

4.2. 参数绑定

4.2.1. 基本数据类型

4.2.2. 包装类型

4.2.3. 字符串类型

4.2.4. 数组类型

4.2.5. JavaBean 类型

4.2.6. List 类型

4.2.7. Set 类型

4.2.8. Map 类型

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

5.1. 重定向

5.2. 请求转发

6. SpringMVC之 JSON 数据开发

6.1. 基本概念

6.1.1. @ResponseBody

6.1.2. @RequestBody

6.2. 使用配置

6.2.1. pom.xml 添加 json相关坐标

6.2.2. 修改spring.xml

6.2.3. 注解使用

6.2.3.1. @ResponseBody

6.2.3.2. @RequestBody

7.课程总结

1. 学习目标

2. 拦截器

2.1. 基本概念

2.2. 拦截器实现

2.2.1. 实现 HandlerInterceptor 接⼝

2.2.2. 继承 HandlerInterceptorAdapter

2.2.3. 多个拦截器实现

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

2.3.1. 用户控制器

2.3.2. 页面定义

2.3.3. 非法请求拦截器定义

2.3.4. 拦截器xml配置

3.文件上传

3.1. 环境配置

3.1.1. pom.xml⽂件修改

3.1.2. spring.xml修改

3.2. 代码实现

3.2.1. 单⽂件上传

3.2.1.1. 页面表单

3.2.1.2. 代码实现

3.2.2. 多文件上传

3.2.2.1. 页面表单

3.2.2.2. 代码实现

3.2.2.2. 代码实现

相关文章