SSM(SpringMVC篇)-Toy模板网

这篇具有很好参考价值的文章主要介绍了SSM(SpringMVC篇)。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

SpringMVC

SpringMVC简介

概述

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

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

入门

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

开发步骤：

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

步骤

1、导入Servlet和Jsp的坐标

<!--Spring应用上下文-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.23</version>
    </dependency>
 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.23</version>
    </dependency>

 <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
    </dependency>

    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.3.1</version>
    </dependency>

2、web.xml配置SpringMVC的核心控制器

<!--配置SpringMVC的前端控制器-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

3、创建Controller和业务方法

public class UserController {

    public String save() {
        System.out.println("Controller save running ....");
        return "success";
    }
}

创建视图页面index.jsp

<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>success</h1>
</body>
</html>

4、配置注解

@Controller
@RequestMapping(value = "/ssm")
public class UserController {
    @RequestMapping(value = "/demo")
    public String save() {
        System.out.println("Controller save running ....");
        return "success";
    }
}

5、创建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.alibaba.com/schema/stat"
       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.alibaba.com/schema/stat http://www.alibaba.com/schema/stat.xsd">
    
    <context:component-scan base-package="com.dc">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

SSM(SpringMVC篇)

SpringMVC流程图示

SSM(SpringMVC篇)

组件分析

执行流程

SSM(SpringMVC篇)

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

组件解析

1、前端控制器：DispatcherServlet

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

2、处理器映射器：HandlerMapping

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

3、处理器适配器：HandlerAdapter

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

4、处理器：Handler

这是具体的业务控制器。由DispatcherServlet把用户请求转发到Handler。由Handler对具体的用户请求进行处理

5、视图解析器：View Resolver

View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名，即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户

6、视图：View

SpringMVC框架提供了很多的View视图类型的支持，包括：jstView、freemarkerView、pdfView等。最常用的视图就是jsp。一般情况下需要通过页面标签或页面模板技术将模型数据数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面

注解解析

1、`@RequestMapping`

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

位置：

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

属性：

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

例如：

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

2、命名空间引入

命名空间：：xmlns:context=“http://www.springframework.org/schema/context” xmlns:mvc=“http://www.springframework.org/schema/mvc”

约束地址：http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd

http://www.springframework.org/schema/mvc

http://www.springframework.org/schema/mvc/spring-mvc.xsd

3、组件扫描

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

4、视图解析器

SpringMVC有默认组件配置，默认组件都是DispatcherServlet.properties配置文件中配置的，该配置文件地址org/springframework/web/servlet/DispatcherServlet.properties，该文件中配置了默认的视图解析器，如下：

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.I
nternalResourceViewResolver

解析器源码中，解析器的默认配置为：

REDIRECT_URL_PREFIX = "redirect:" --重定向前缀
FORWARD_URL_PREFIX = "forward:" --转发前缀（默认值）
prefix = ""; --视图名称前缀
suffix = ""; --视图名称后缀

xml配置解析

1、视图解析器

通过属性注入的方式修改视图的前后缀

<!--配置内部资源视图解析器-->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"/>
    </bean>

数据响应

数据响应方式

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

页面跳转

1、返回字符串形式

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

SSM(SpringMVC篇)

返回带有前缀的字符串：
转发：forward：/WEB_INF/views/index.jsp

重定向：redirect:/index.jsp

2、返回ModelAndView对象

    @RequestMapping("/s1")
    public ModelAndView demo() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("redirect:success.jsp");
        return modelAndView;
    }

    @RequestMapping("/s2")
    public ModelAndView demo1() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("forward:/success.jsp");
        return modelAndView;
    }

3、向request域存储数据

在进行转发时，往往要向request域中存储数据，在jsp页面显示Controller中向request存储数据方法如下：

1、通过SpringMVC框架注入的request对象setAttribute()方法设置

    @RequestMapping("/se1")
    public String save3(HttpServletRequest request) {
        request.setAttribute("username", "刺激");
        return "success";
    }

2、通过ModelAndView的addObject()方法设置

 @RequestMapping("/s")
    public ModelAndView save1() {
        /**
         * Model：模型 作用封装数据
         * View： 视图 作用展示数据
         */
        ModelAndView modelAndView = new ModelAndView();
        // 设置视图名称
        modelAndView.setViewName("success");
        // 设置模型数据
        modelAndView.addObject("username", "demo");
        return modelAndView;
    }

回写数据

1、直接返回字符串

Web基础阶段，客户端访问服务器端，如果想直接回写字符串作为响应体返回的话，只需要使用response.getWriter().print(“hello world”)即可。

Controller中直接写字符串的方法：

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

@RequestMapping("/s3")
    public void demo2(HttpServletResponse response) throws IOException {
        response.getWriter().print("hello world");
    }

2、直接将需要返回的字符串直接返回，但此时需要通过@ResponseBody注解告诉SpringMVC框架，方法返回的字符串不是跳转，而是直接在Http响应体中返回

    @RequestMapping("/s4")
    @ResponseBody // 告知SpringMVC框架，不进行视图跳转 直接进行数据响应
    public String demo3() {
        return "hello demo";
    }

3、返回json字符串

在异步项目中，客户端与服务器端往往需要进行json格式字符串交互，此时可以手动拼接字符串返回

    @RequestMapping("/s5")
    @ResponseBody
    public String demo4() {
        return "{\"username\":\"zhangsan,\"age\":\"18\"}";
    }

通过jackson工具进行json转换

    <dependency>
     <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.13.5</version>
    </dependency>

    <dependency>
     <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.13.5</version>
    </dependency>

    <dependency>
     <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.13.5</version>
    </dependency>

代码：

    @RequestMapping("/s7")
    @ResponseBody
    public String demo6() throws JsonProcessingException {
        User user = new User();
        user.setName("zhangsan");
        user.setAge("18");
        ObjectMapper objectMapper = new ObjectMapper();
        String s = objectMapper.writeValueAsString(user);
        return s;
    }

2、返回对象或集合

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

 <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
      <property name="messageConverters">
          <list>
              <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">

            </bean>
        </list>
    </property>
</bean>

    @RequestMapping("/s6")
    @ResponseBody
    public User demo5() {
        User user = new User();
        user.setAge("30");
        user.setName("lisi");
        return user;
    }

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

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

在SpringMVC的各个组件中，处理器映射器、处理器适配器、视图解析器称为SpringMVC的三大组件，使用<mvc:annotation-driven>自动加载RequestMappingHandlerMapping（处理映射器）和RequestMappingHandlerAdapter(处理适配器)，可用在Spring-xml.xml配置文件中使用<mvc:annotation-driven>默认底层就会集成jackon进行对象或集合的json格式字符串的转换

获取请求参数

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

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

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

基本类型参数

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

    @RequestMapping("/s8")
    @ResponseBody
    public void demo9(String username, int age) {
        System.out.println(username);
        System.out.println(age);

    }

POJO类型参数

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

    @RequestMapping("/s9")
    @ResponseBody
    public void demo9(User user) {
        System.out.println(user);

    }

获取数组类型参数

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

    @RequestMapping("/s10")
    @ResponseBody
    public void demo10(String[] strs) {
        System.out.println(Arrays.asList(strs));

    }

获取集合类型参数

方式一：

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

<form action="${pageContext.request.contextPath}/s11" method="post">
  <input type="text" name="ulist[0].name"/>
  <input type="text" name="ulist[0].age"/>
  <input type="text" name="ulist[1].name"/>
  <input type="text" name="ulist[1].age"/>
  <input type="text" name="ulist[2].name"/>
  <input type="text" name="ulist[2].age"/>
  <input type="submit">
</form>

// lombok插件
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Vo {
    private List<User> ulist;
}    

    @RequestMapping("/s11")
    @ResponseBody
    public void demo11(Vo vo) {
        System.out.println(vo);
    }

方式二：

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

<script>
    var ulist = new Array();
    ulist.push({name:"zhangsan", age:"18"});
    ulist.push({name:"lisi", age:"28"});


    $.ajax({
        type:"POST",
        url:"${pageContext.request.contextPath}/s12",
        data:JSON.stringify(ulist),
        contentType:"application/json;charset=utf-8"
    });

</script>

    @RequestMapping("/s12")
    @ResponseBody
    public void demo11(@RequestBody List<User> ulist) {
        System.out.println(ulist);

    }

注意：通过浏览器抓包发现，没有加载到jquery文件，原因是SpringMVC的前端控制器DispatcherServlet的url-pattern的配置的是/，代表对所有的资源都进行过滤操作，可以通过以下两种方式指定放行静态资源

在Spring-mvc.xml配置文件中指定放行的资源

<mvc:resources mappiing=“/js/**” location=“/js/”/>

location：指定静态资源的位置

mapping：用**表示映射到相应目录下的具体资源
使用<mvc:default-servlet-handler/>标签

将静态文件资源的请求转由web应用服务器默认的servlet处理，如果不是静态资源的请求，才由DispatcherServlet继续处理，通过用default-servlet-name=“所使用的web服务器默认使用的Servlet名称”

请求数据乱码问题

dangpost请求时，数据会出现乱码，此时可以设置一个过滤器进行编码的过滤

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

参数绑定注解@RequestParam

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

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

    }

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

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

    @RequestMapping("/s13")
    @ResponseBody
    public void demo12(@RequestParam(value = "username", required = false, defaultValue = "demo") String name) {
        System.out.println(name);

    }

获得Restful风格的参数

Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。主要用于客户端和服务器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制等。

Restful风格的请求是使用url+请求方式表示一次请求目的的，http协议中四个表示操作方式的动词如下：

GET：用于获取资源
POST：用于新建资源
PUT：用于更新资源
DELETE：用于删除资源

如：

/user/1 GET：得到id=1的user
/user/1 DELETE：删除id=1的user
/user/1 PUT：更新id=1的user
/user POST：新增user

http://localhost:8080/s14/1

    @RequestMapping("/s14/{name}")
    @ResponseBody
    public void demo13(@PathVariable(value = "name", required = true) String name) {
        System.out.println(name);
    }

自定义类型转换器

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

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

定义转换器类实现Converter接口
在配置文件中声明转换器
在<annotation-driven>中引用转换器

代码展示：

1、定义转换器类实现Converter接口

public class DateConverts implements Converter<String, Date> {

    @Override
    public Date convert(String dateStr) {
        // 将日期字符串转换成日期对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        Date date = null;
        try {
            date = sdf.parse(dateStr);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
        return date;
    }
}

2、在配置文件中声明转换器

<!--配置自定义类型转换器-->
    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <list>
                <bean class="com.dc.utils.DateConverts"/>
            </list>
        </property>
    </bean>
<!--mvc的注解驱动-->
    <mvc:annotation-driven conversion-service="conversionService"/>

获得Servlet相关API

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

HttpServletRequest
HttpServletResponse
HttpSession

    @RequestMapping("/s16")
    @ResponseBody
    public void demo15(HttpServletResponse response, HttpServletRequest request, HttpSession session) {
        System.out.println(request);
        System.out.println(response);
        System.out.println(session);
    }

获得请求头

@RequestHeader

使用@RequestHeader可以获得请求信息，相当于web阶段学习的requet.getHeader(name)

@RequestHeader注解的属性如下：

value：请求头的名称
required：是否必须携带此请求头

    @RequestMapping("/s17")
    @ResponseBody
    public void demo16(@RequestHeader(value = "User-Agent", required = false) String user_agent) {
        System.out.println(user_agent);
    }

@CookieValue

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

@CookieValue注解的属性如下：

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

    @RequestMapping("/s18")
    @ResponseBody
    public void demo17(@CookieValue(value = "JSESSIONID") String jessionId){
        System.out.println(jessionId);
    }

文件上传

文件上传客户端三要素

表单项type=“file”
表单的提交方式是post
表单的enctype属性是多部份表单形式，及enctype=“multipat/form-data”

代码：

1、导入fileupload和io坐标

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

    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.11.0</version>
    </dependency>

2、配置文件上传解析器

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

3、编写文件上传代码

    @RequestMapping("/s19")
    @ResponseBody
    public void demo18(String name, MultipartFile uploadFile) {
        System.out.println(name);
        System.out.println(uploadFile);
    }

    @RequestMapping("/s19")
    @ResponseBody
    public void demo18(String name, MultipartFile uploadFile) throws IOException {
        // 获得文件名称
        String originalFilename = uploadFile.getOriginalFilename();
        // 保存文件
        uploadFile.transferTo(new File("D:\\Desk\\" + originalFilename));
    }

多文件上传实现

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

<h1>多文件上传测试</h1>
<form action="${pageContext.request.contextPath}/s20" method="post" enctype="multipart/form-data">
    名称：<input type="text" name="name"/><br>
    文件1：<input type="file" name="uploadFiles"><br>
    文件2：<input type="file" name="uploadFiles"><br>
    文件3：<input type="file" name="uploadFiles"><br>
    <input type="submit" value="提交">
</form>

    @RequestMapping("/s20")
    @ResponseBody
    public void demo19(String name, MultipartFile[] uploadFiles) throws IOException {
        for (MultipartFile file : uploadFiles) {
            String originalFilename = file.getOriginalFilename();
            file.transferTo(new File("D:\\Desk\\" + originalFilename));
        }
    }