简介

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范
MVC主要作用是降低了视图与业务逻辑间的双向耦合
Spring MVC框架围绕DispatcherServlet这个核心展开，DispatcherServlet的作用是截获请求并组织一系列组件共同完成请求的处理工作
运行流程：
- 用户通过浏览器向服务器发送请求，请求会被SpringMVC的前端控制器DispatcherServlet所拦截
- DispatcherServlet拦截到请求后，会调用HandlerMapping处理器映射器
- 处理器映射器根据请求的URL找到具体的处理器(Handler)，生成处理器对象及处理器拦截器一并返回给DispatcherServlet
- DispatcherServlet会通过返回信息选择合适的HandlerAdapter(处理器适配器)
- HandlerAdapter会调用并执行处理器(Handler)
- 处理器(Handler)执行完成后，会返回一个ModelAndView对象，该对象中包含视图名或包含模型与视图名
- HandlerAdapter将ModelAndView对象返回给DispatcherServlet
- DispatcherServlet会根据ModelAndView对象选择一个合适的ViewResolver(视图解析器)
- ViewResolver解析后，会像DispatcherServlet中返回一个具体的View(视图)
- DispatcherServlet对View进行渲染
- 视图渲染结果会返回给客户端浏览器显示

处理器映射器、处理器适配器、视图解析器称为 SpringMVC 的三大组件

快速入门

在web.xml文件中配置DispacherServlet

<!--注册DispatcherServlet-->
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--绑定spring mvc配置文件-->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc-servlet.xml</param-value>
    </init-param>
    <!--启动级别-->
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!--/ 匹配所有的请求：(不包括jsp)-->
    <!--/* 匹配所有的请求：(包括jsp)-->
    <url-pattern>/</url-pattern>
</servlet-mapping>

创建springmvc-servlet.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--处理器映射器-->
    <!--根据请求的url与spring容器中定义的处理器bean的id属性进行匹配-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--处理器适配器-->
    <!--处理一个Handler给ModelAndView-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

    <!--视图解析器:DispatcherServlet给他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--Handler-->
    <bean id="/hello" class="com.demo.controller.HelloController"/>
</beans>

创建Controller类

public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv=new ModelAndView();

        //封装对象，放在ModelAndView中
        mv.addObject("msg","HelloSpringMVC");

        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello");//  /WEB-INF/jsp/hello.jsp

        return mv;
    }
}

注解开发

在web.xml文件中配置DispacherServlet

创建springmvc-servlet.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/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--自动扫描包，让指定包下的注解生效，由IOC统一管理-->
    <context:component-scan base-package="com"/>
    <!--让SpringMVC不处理静态资源-->
    <mvc:default-servlet-handler/>
    <!--自动装配处理器映射器和处理器适配器-->
    <mvc:annotation-driven/>
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

RequestMapping注解
- RequestMapping注解的作用是建立请求URL和处理方法之间的对应关系
- RequestMapping注解可以作用在方法和类上
  - 作用在类上：第一级的访问目录
  - 作用在方法上：第二级的访问目录
- RequestMapping的属性
  - path：指定请求路径的url
  - value：value属性和path属性是一样的
  - mthod ：指定该方法的请求方式
  - params：指定限制请求参数的条件
  - headers：发送的请求中必须包含的请求头

Restful风格

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

功能

资源：互联网所有的事物都可以被抽象为资源
资源操作：使用POST、GET、DELETE、PUT,使用不同方式对资源进行操作
分别对应：添加，查询，删除，修改

使用

在方法参数前加上**@PathVariable**注解，让方法参数的值对应绑定到一个URL模板变量上

@RequestMapping(value = "/add/{a}/{b}",method = RequestMethod.GET)
    public String test(@PathVariable int a,@PathVariable int b, Model model){
        int res=a+b;
        model.addAttribute("msg","结果为:"+res);
        return "hello";
    }
}

注解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
注解替代method = RequestMethod.GET

请求参数的绑定

绑定流程
- SpringMVC将ServletRequest对象传递给DataBinder
- 将处理方法的入参对象传递给DataBinder
- DataBinder调用ConversionService组件进行数据类型转换，数据格式化等工作，并将ServletRequest对象中的消息填充到参数对象中
- 调用Validator组件对已经绑定了请求消息数据的参数对象进行数据合法性校验
- 检验完成后会生成数据绑定结果BindingResult对象,SpringMVC会将BindingResult对象中的内容赋给处理方法的相应参数
绑定机制
- 表单提交的数据都是key=value格式的
- SpringMVC的参数绑定过程是把表单提交的请求参数，作为控制器中方法的参数进行绑定的
- 要求：提交表单的name和参数的名称是相同的
- @RequestParam注解用于定义请求中的参数
支持的数据类型
- 基本数据类型和字符串类型
- 实体类型（JavaBean）
- 集合数据类型（List、map集合等）
基本数据类型和字符串类型
- 提交表单的name和参数的名称是相同的
- 区分大小写
实体类型（JavaBean）
- 提交表单的name和JavaBean中的属性名称需要一致
- 如果一个JavaBean类中包含其他的引用类型，那么表单的name属性需要编写成：对象.属性例如： address.name

乱码问题

在web.xml中配置Spring提供的过滤器类

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

JSON乱码问题

<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8" />
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false" />
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

常用注解

RequestParam注解
- 把请求中的指定名称的参数传递给控制器中的形参赋值
- 属性
  - value：请求参数中的名称
  - required：请求参数中是否必须提供此参数，默认值是true，必须提供
RequestBody注解
- 作用：用于将请求体中的数据绑定到方法的形参中，该注解用在方法的形参上（注意：get方法不可以）
ResponseBody
- 作用：用于直接返回return对象，该注解用在方法上
PathVariable注解
- 作用：拥有绑定url中的占位符的
- 属性
  - value：指定url中的占位符名称
RequestHeader注解
- 作用：获取指定请求头的值
- 属性
  - value：请求头的名称
CookieValue注解
- 作用：用于获取指定cookie的名称的值
- 属性
  - value：cookie的名称
ModelAttribute注解
- 作用
  - 出现在方法上：表示当前方法会在控制器方法执行前线执行。
  - 出现在参数上：获取指定的数据给参数赋值。
- 应用场景
  - 当提交表单数据不是完整的实体数据时，保证没有提交的字段使用数据库原来的数据
SessionAttributes注解
- 作用：用于多次执行控制器方法间的参数共享
- 属性
  - value：指定存入属性的名称

结果视图

返回值分类

返回字符串
- Controller方法返回字符串可以指定逻辑视图的名称，根据视图解析器为物理视图的地址
返回值是void
- 如果控制器的方法返回值编写成void，执行程序报404的异常，默认查找JSP页面没有找到
- 可以使用请求转发或者重定向跳转到指定的页面
返回值是ModelAndView对象
- ModelAndView对象是Spring提供的一个对象，可以用来调整具体的JSP视图

转发和重定向

转发
```
 return "forward:/user/findAll";
```
重定向
```
 return "redirect:/add.jsp";
```

SSM

导入jar包依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.4.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.2</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.2</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.10</version>
    </dependency>
</dependencies>

web.xml配置

<?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">

    <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:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--配置乱码过滤-->
    <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>

    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>

</web-app>

applicationContext.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/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--关联数据库配置文件-->
    <context:property-placeholder location="classpath:database.properties"/>

    <!--c3p0 连接池-->
    <bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--获取数据源-->
        <property name="dataSource" ref="datasource"/>
        <!--绑定MyBatis映射文件-->
        <property name="mapperLocations" value="classpath:com/demo/dao/BooksMapper.xml"/>
        <!--别名-->
        <property name="typeAliasesPackage" value="com.demo.pojo"/>
        <!--日志-->
        <property name="configuration">
            <bean class="org.apache.ibatis.session.Configuration">
                <property name="logImpl" value="org.apache.ibatis.logging.stdout.StdOutImpl"/>
            </bean>
        </property>
    </bean>

    <!--配置dao接口扫描包，动态的实现了Dao接口可以注入到Spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <property name="basePackage" value="com.demo.dao"/>
    </bean>


    <!--扫描service下的包-->
    <context:component-scan base-package="com.demo.service"/>
    <!--将所有的业务类，注入到spring-->
    <bean id="booksServiceImpl" class="com.demo.service.BooksServiceImpl">
        <property name="booksMapper" ref="booksMapper"/>
    </bean>

    <!--声明式事务-->
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="datasource"/>
    </bean>


    <!--让SpringMVC不处理静态资源-->
    <mvc:default-servlet-handler/>
    <!--自动装配处理器映射器和处理器适配器-->
    <mvc:annotation-driven/>
    <!--自动扫描包，让指定包下的注解生效，由IOC统一管理-->
    <context:component-scan base-package="com.demo.controller"/>
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

database.properties 数据源配置

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///ssmbuild
jdbc.username=root
jdbc.password=root

json乱码解决

<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

拦截器

SpringMVC框架中的拦截器用于对处理器进行预处理和后处理的技术。
可以定义拦截器链，连接器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链中的拦截器会按着定义的顺序执行。
拦截器和过滤器的功能比较类似，有区别
- 过滤器是Servlet规范的一部分，任何框架都可以使用过滤器技术。
- 拦截器是SpringMVC框架独有的。
- 过滤器配置了/*，可以拦截任何资源。
- 拦截器只会对控制器中的方法进行拦截。
- 拦截器也是AOP思想的一种实现方式
- 想要自定义拦截器，需要实现HandlerInterceptor接口

步骤

创建类，实现HandlerInterceptor接口，重写需要的方法
- preHandle方法是controller方法执行前拦截的方法
  - 可以使用request或者response跳转到指定的页面
  - return true放行，执行下一个拦截器，如果没有拦截器，执行controller中的方法。
  - return false不放行，不会执行controller中的方法。
- postHandle是controller方法执行后执行的方法，在JSP视图执行前。
  - 可以使用request或者response跳转到指定的页面
  - 如果指定了跳转的页面，那么controller方法跳转的页面将不会显示。
- postHandle方法是在JSP执行后执行
  - request或者response不能再跳转页面了

在applicationContext.xml中配置拦截器

 <!-- 配置拦截器 -->    
<mvc:interceptors>        
    <mvc:interceptor>            
        <!-- 哪些方法进行拦截 -->  
        <!--/** 表示拦截这个请求下面的所有请求-->
        <mvc:mapping path="/**"/>            
        <!-- 哪些方法不进行拦截             
		<mvc:exclude-mapping path=""/>-->            
        <!-- 注册拦截器对象 -->            
        <bean class="com.demo.config.MyInterceptor"/>        
    </mvc:interceptor>    
</mvc:interceptors>

文件上下传

导入依赖jar包

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

在applicationContext.xml中配置文件上传

<!--文件上传配置-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!--请求的编码格式，必须和jsp的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1-->
    <property name="defaultEncoding" value="UTF-8"/>
    <!--上传文件大小上限，单位为字节(10485760=1M)-->
    <property name="maxUploadSize" value="10485760"/>
    <property name="maxInMemorySize" value="40960"/>
</bean>

编写jsp上传页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>文件上传</h3>
<form action="${pageContext.request.contextPath}/upload" method="post" enctype="multipart/form-data">
    选择文件：<input type="file" name="file"/><br/>
    <input type="submit" value="上传文件"/></form>
</body>
</html>

编写上传Java代码

@RestController
public class FileController {

    @RequestMapping("/upload")
    public String upload(@RequestParam("file")MultipartFile 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:/upload.jsp";
    }

    @RequestMapping("/download")
    public String downloads(HttpServletRequest request,HttpServletResponse response) throws IOException{
        //要下载的图片地址
        String path = request.getServletContext().getRealPath("/upload");
        String fileName="1.jpg";

        //设置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);
        //读取文件
        InputStream is=new FileInputStream(file);
        //写出文件
        OutputStream os=response.getOutputStream();

        byte[] buff=new byte[1024];
        int len=0;
        while ((len=is.read(buff))!=-1){
            os.write(buff,0,len);
            os.flush();
        }
        os.close();
        is.close();
        return "OK";
    }
}

SpringMVC笔记

简介