SpringMVC-基本使用

一、什么是MVC

• MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
• 是将业务逻辑、数据、显示分离的方法来组织代码。
• MVC主要作用是降低了视图与业务逻辑间的双向偶合。
• MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

**Model（模型）：**数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao） 和 服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

**View（视图）：**负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

**Controller（控制器）：**接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

职责分析：

Controller：控制器

1. 取得表单数据
2. 调用业务逻辑
3. 转向指定的页面

Model：模型

1. 业务逻辑
2. 保存数据的状态

View：视图

1. 显示页面

最典型的MVC就是JSP + servlet + javabean的模式。

二、什么是SpringMVC

2.1 概述

Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。

查看官方文档：https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/web.html#spring-web

我们为什么要学习SpringMVC呢?

Spring MVC的特点：

1. 轻量级，简单易学
2. 高效 , 基于请求响应的MVC框架
3. 与Spring兼容性好，无缝结合
4. 约定优于配置
5. 功能强大：RESTful、数据验证、格式化、本地化、主题等
6. 简洁灵活

Spring的web框架围绕DispatcherServlet [ 调度Servlet ] 设计。

2.2 架构图

架构流程

1、用户发送请求至前端控制器DispatcherServlet

2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有
则生成)一并返回给DispatcherServlet。
4、DispatcherServlet通过HandlerAdapter处理器适配器调用处理器

5、执行处理器(Controller，也叫后端控制器)。

6、Controller执行完成返回ModelAndView

7、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet

8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器

9、ViewReslover解析后返回具体View

10、DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中

11、DispatcherServlet响应用户

流程说明:

1. 浏览器发送请求，请求具体发到谁呢?先发到前端控制器，也就是说所有的请求都给发到前端控制器，前端控制器是所有请求的入口，但前端控制器不能处理业务请求，它只是一个请求的转发。
2. 谁来处理业务请求呢? Handler处理器来真正处理业务请求，那么问题来了，前端控制器如何来找到这个Handler处理器呢?处理器映射器记录的就是请求的url和处理的方法之间的映射关系，过个咖时关系就相当于一个Map (key-valte人碁求之后，要找到个注解来建立起来的，这个映射关系就相当于一个Map(key-value这种形式)，key就是请求的url，value就是处理的Handler。现在，前端控制器拿到这个请求之后，要找到对应的Handler，怎么找呢?就要找处理器映射器，问它请求谁来处理?
3. 处理器映射器会根据你请求的url来找对应的处理器,找不到就会报错,如果找到之后，这时，它就会返回一个处理器执行链，这个处理器执行链里面除了有Handler之外，还有拦截器(这儿我们可以开发自己的拦截器)，然后返回给前端控制器。
4. 前端控制器依然不能处理这个业务请求，它这时做的还有另外一件事情，因为返回Handler，它也不知道这个Handler是什么类型，因为在spring mvc中Handler除了可以是注解形式的之外，其实还可以是非注解形式的(非注解形式我们一般不用)，前端控制器并不知道这个Handler到底是什么类型的,那就没办法执行它,那总得找个东西执行，这时它就会把这个事交给另外一个组件来处理，这个组件就叫处理器适配器，这个处理器适配器就是来适配不同类型的Handler。它就会根据你不同类型的Handler来选择不同类型的适配器来执行它。
5. 假如当前Handler是注解形式的，那么它就会选择注解形式的处理器适配器来执行这个Handler。Handler就执行了，也就是说我们Controller类中的那个方法就执行了，方法执行之后，里面的业务就处理了。
6. 业务处理之后，最后返回一个ModelAndView。处理器适配器拿到这个结果是没有用的，它的作用就是执行这个Handler，把这个Handler执行完之后，它的事就做完了。
7. 做完之后，拿到这个返回结果，那么它会原封不动地把这个返回结果扔给前端控制器，这时处理器适配器的事就做完了。
8. 前端控制器拿到这个ModelAndView，它还是没有办法处理，它还是不能返回html，这时它要找到相应的jsp，因为ModelAndView即包含模型又包含视图，这个视图指定我们要用谁来渲染这个数据。我们要渲染数据,这时它就要找一个视图解析器来解析这个视图，由于这个视图也有很多种(我们最常见的视图是jsp，除了jsp，其实还有其他的，比如说还可以是报表，还可以是pdf，还可以是freemaker等)，它会找不同的视图解析器来处理。因为现在我们最常用的视图是jsp，所以它就找到jsp对应的视图解析器。
9. 找到这个视图解析器，它来把这个视图解析，解析完了之后它会返回一个View对象。
10. 最后我们再调用这个视图解析器的渲染视图这个过程,渲染视图这个过程其实就是对于我们的jsp来说，就是把这个数据渲染成html。
11. 最终渲染成html之后，就响应给用户。

2.3 组件说明

DispatcherServlet:前端控制器

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

HandlerMapping:处理器映射器

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

Handler:处理器

Handler是继DispatcherServlet前端控制器的后端控制器,在DispatcherServlet的控制下Handler对具体的用户请求进行处理。
由于Handler涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。

HandlAdapter:处理器适配器

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

View Resolver:视图解析器

View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。springmvc框架提供了很多的View视图类型，包括: jstlView.
freemarkerView、pdfView等。

一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户,需要由程序员根据业务需求开发具体的页面。

三、SpringMVC开发环境配置

1、创建一个maven项目

2、引用依赖包（省略spring的依赖）

<!-- springmvc相关的依赖 -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>
 <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
  <!-- 文件上传组件 -->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.3</version>
    </dependency>
<!-- json依赖 -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.6</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.9.6</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.6</version>
    </dependency>

    <!-- jstl依赖 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>1.1.2</version>
    </dependency>

3、配置spring-mvc.xml配置文件

注：里面配置文件需要自己改包

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:mvc="http://www.springframework.org/schema/mvc"
   xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.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-4.3.xsd">
   <!-- 扫描包 -->
   <context:component-scan base-package="com.zsn.mvc"></context:component-scan>
   <!-- 开启springmvc的注解支持 -->
   <mvc:annotation-driven></mvc:annotation-driven>
   <!-- 过滤静态资源 -->
   <mvc:default-servlet-handler/>
   
   <!-- 配置多媒体文件解析器 -->
   <!-- 文件上传 -->
   <bean id="multipartResolver"
       class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
       <!-- 设置上传文件的最大尺寸为10MB 1024*1024*10 -->
       <property name="maxUploadSize">
           <value>10485760</value>
       </property>
   </bean>
   
   <!-- 定义视图解析器 -->
   <bean
      class="org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name="viewClass"
         value="org.springframework.web.servlet.view.JstlView"></property>
      <property name="prefix" value="/WEB-INF/jsp/"></property>
      <property name="suffix" value=".jsp"></property>
   </bean>
</beans>

编写web.xml

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <!-- 编码方式过滤器 -->
  <filter>
    <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>
  <!-- dispatcherservelt -->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <!-- spring-*.xml:表示所有以spirng-开头，以.xml结束的所有文件 classpath:表示类路径下 -->
      <param-value>classpath:spring-*.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

四、第一个SpringMVC程序

1、首先新建一个welcome.jsp

2、编写Java程序

@Controller
@RequestMapping("/test")
public class TestController {

    @RequestMapping("/welcome")
    public String welcome(){
        return "welcome";	//返回的是一个视图
    }
}
//访问路径:项目根路径/test/welcome
//返回值: welcome--->访问WEB-INF/jsp/welcome.jsp(视图)

3、启动Tomcat服务器，在URL地址栏中输入地址

五、SpringMVC访问路径和返回值

5.1 @RequestMapping

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

即通过@RequestMapping设置访问路径。

5.2 映射路径

@RequestMapping(" / demo")或者@RequestMapping(value=" / demo"):注解，可以放在类上面，也可以放在方法上面。

@Controller
@RequestMapping("/test")
public class TestController {

    @RequestMapping("/welcome")
    public String welcome(){
        return "welcome";	//返回的是一个视图
    }
}

5.3 对请求方法的限制（Get/Post）

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

现在访问/ test路径的时候，只能是get的请求方式

5.4 返回值

返回 ModelAndView

@Controller
@RequestMapping("/test")
public class TestController {

    @RequestMapping("/welcome")
    public ModelAndView welcome(){
        ModelAndView mav = new ModelAndView();
        //设置页面显示的内容（ Model)
        mav.addobject( "message","hello world");
        //设置视图
        mav.setViewName("welcome")
        return mav;	
    }
}

返回 String（常用）

返回指定的视图

@Controller
@RequestMapping("/test")
public class TestController {

    @RequestMapping("/welcome")
    public String welcome(){
        return "welcome";	//返回的是一个视图
    }
}

如果返回 return “redirect:welcome”; 重定向

如果返回 return “forward:welcome”; 请求转发

注意:在springMVC中使用return "redirect:/index.jsp"进行重定向，“/”指向的是项目的根路径（不是服务器的跟路径，这里与 servlet中是有区别的)

5.5 controller的默认（支持的）参数

1、HttpServletRequest
通过request对象获取请求信息

2、HttpServletResponse
通过response 处理响应信息

3、HttpSession
通过session对象得到session中存放的对象

4、Model/ModelMap
5、基本类型( int,String…)

6、pojo对象
可以使用以上这些参数来获取页面数据，和向页面显示数据。

数据处理

处理提交数据

1、提交的域名称和处理方法的参数名一致

提交数据 : http://localhost:8080/hello?name=zhanglingyu

处理方法 :

@RequestMapping("/hello")
public String hello(String name){
    System.out.println(name);
    return "hello";
}

后台输出 : zhanglingyu

2、提交的域名称和处理方法的参数名不一致

提交数据 : http://localhost:8080/hello?username=zhanglingyu

处理方法 :

//@RequestParam("username") : username提交的域的名称 .
@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
   System.out.println(name);
    return "hello";
}

后台输出 : zhanglingyu

3、提交的是一个对象

要求提交的表单域和对象的属性名一致 , 参数使用对象即可

1、实体类

public class User {
    private int id;
    private String name;
    private int age;
    //构造
    //get/set
    //tostring()
}

2、提交数据 : http://localhost:8080/mvc04/user?name=zhanglingyu&id=1&age=15

3、处理方法 :

@RequestMapping("/user")
public String user(User user){
    System.out.println(user);
    return "hello";
}

后台输出 : User { id=1, name=‘kuangshen’, age=15 }

说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

六、文件的上传下载

1、引用两个包

Commons-io.jar
Commons-fileupload.jar

<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.3.3</version>
</dependency>

2、spring-mvc.xml配置文件中配置

<!-- 文件上传 -->
<bean id="multipartResolver"
    class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 设置上传文件的最大尺寸为10MB 1024*1024*10 -->
    <property name="maxUploadSize">
        <value>10485760</value>
    </property>
</bean>

3、编写controller

CommonsMultipartFile 的 常用方法：

• String getOriginalFilename()：获取上传文件的原名
• InputStream getInputStream()：获取文件流
• void transferTo(File dest)：将上传文件保存到一个目录文件中

照片的上传

//上传文件
if(file!=null && file.getSize()>0){
    //获取源文件的名称
    String filename = file.getOriginalFilename();
    //获取后缀名 截取
    String extname = filename.substring(filename.lastIndexOf("."));
    //生成新的文件名
    String newfilename = UUID.randomUUID().toString()+extname;
    //创建文件的相对路径(保存到数据库中)
    String filepath = "/files/"+newfilename;
    //根据相对路径来获取绝对路径，创建file对象
    String path = request.getServletContext().getRealPath(filepath);
    File f = new File(path);
    //保存文件
    try {
        file.transferTo(f);
        //保存相对路径到数据库
        art.setArtimg(filepath);

    } catch (IOException e) {
        e.printStackTrace();
    }
}

文件的上传

1、前端页面：

<form action="/upload" enctype="multipart/form-data" method="post">
  <input type="file" name="file"/>
  <input type="submit" value="upload">
</form>

对表单中的 enctype 属性做个详细的说明：

• application/x-www=form-urlencoded：默认方式，只处理表单域中的 value 属性值，采用这种编码方式的表单会将表单域中的值处理成 URL 编码方式。
• multipart/form-data：这种编码方式会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求参数中，不会对字符编码。
• text/plain：除了把空格转换为 “+” 号外，其他字符都不做编码处理，这种方式适用直接通过表单发送邮件。

2、controller

package com.kuang.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.commons.CommonsMultipartFile;
 
import javax.servlet.http.HttpServletRequest;
import java.io.*;
 
@Controller
public class FileController {
    //@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
    //批量上传CommonsMultipartFile则为数组即可
    @RequestMapping("/upload")
    public String fileUpload(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {
 
        //获取文件名 : file.getOriginalFilename();
        String uploadFileName = file.getOriginalFilename();
 
        //如果文件名为空，直接回到首页！
        if ("".equals(uploadFileName)){
            return "redirect:/index.jsp";
        }
        System.out.println("上传文件名 : "+uploadFileName);
 
        //上传路径保存设置
        String path = request.getServletContext().getRealPath("/upload");
        //如果路径不存在，创建一个
        File realPath = new File(path);
        if (!realPath.exists()){
            realPath.mkdir();
        }
        System.out.println("上传文件保存地址："+realPath);
 
        InputStream is = file.getInputStream(); //文件输入流
        OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //文件输出流
 
        //读取写出
        int len=0;
        byte[] buffer = new byte[1024];
        while ((len=is.read(buffer))!=-1){
            os.write(buffer,0,len);
            os.flush();
        }
        os.close();
        is.close();
        return "redirect:/index.jsp";
    }
}

采用file.Transto 来保存上传的文件

1、编写Controller

/*
 * 采用file.Transto 来保存上传的文件
 */
@RequestMapping("/upload2")
public String  fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {
 
    //上传路径保存设置
    String path = request.getServletContext().getRealPath("/upload");
    File realPath = new File(path);
    if (!realPath.exists()){
        realPath.mkdir();
    }
    //上传文件地址
    System.out.println("上传文件保存地址："+realPath);
 
    //通过CommonsMultipartFile的方法直接写文件（注意这个时候）
    file.transferTo(new File(realPath +"/"+ file.getOriginalFilename()));
 
    return "redirect:/index.jsp";
}

2、前端表单提交地址修改

文件的下载

1、设置 response 响应头

2、读取文件 – InputStream

3、写出文件 – OutputStream

4、执行操作

5、关闭流 （先开后关）

代码实现：

@RequestMapping(value="/download")
public String downloads(HttpServletResponse response ,HttpServletRequest request) throws Exception{
    //要下载的图片地址
    String  path = request.getServletContext().getRealPath("/upload");
    String  fileName = "基础语法.jpg";
 
    //1、设置response 响应头
    response.reset(); //设置页面不缓存,清空buffer
    response.setCharacterEncoding("UTF-8"); //字符编码
    response.setContentType("multipart/form-data"); //二进制传输数据
    //设置响应头
    response.setHeader("Content-Disposition",
            "attachment;fileName="+URLEncoder.encode(fileName, "UTF-8"));
 
    File file = new File(path,fileName);
    //2、 读取文件--输入流
    InputStream input=new FileInputStream(file);
    //3、 写出文件--输出流
    OutputStream out = response.getOutputStream();
 
    byte[] buff =new byte[1024];
    int index=0;
    //4、执行 写出操作
    while((index= input.read(buff))!= -1){
        out.write(buff, 0, index);
        out.flush();
    }
    out.close();
    input.close();
    return null;
}

前端

<a href="/download">点击下载</a>

七、RestFul 风格

概念

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

功能

资源：互联网所有的事物都可以被抽象为资源

资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。

分别对应 添加、 删除、修改、查询。

示例

1、controller编写

当我们需要对一个用户进行编辑时，就需要获取这个用户的id

例如：admin/user/toedit/8285f794-0eba-4c08-b6e0-68da99f213ba

toedit后边就是用户id

这种风格非常常见

/**
 * 初始化修改界面
 * @param model
 * @return
 */
@RequestMapping("/toedit/{userid}")
public String toedit(@PathVariable("userid") String userid, Model model){
    List<SysRole> roleList = service.selectRoleList();
    model.addAttribute("roleList", roleList);

    SysUser user = service.selectUser(userid);
    model.addAttribute("user",user);
    return "admin/user/edit";
}

在Spring MVC中可以使用 @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。