目录

• SpringMVC
• • SpringMVC概述
  • • DispatcherServlet
    • SpringMVC请求处理过程
    • SpringMVC的MVC组件
  • SpringMVC注解式开发
  • • @RequestMapping
    • 处理器方法的参数
    • 处理器方法的返回值
    • 解读url-pattern
  • SSM整合

SpringMVC

前言：SSM框架快告一段落了，感觉SSM被誉为Java这种极度符合软件工程开发思想和OOP的入门框架果然有他的一套。“高内聚，低耦合”这六个字表现的淋漓尽致了真的是。

希望Java越来越好，希望大家越学越好。

SSM-Spring篇：SSM框架中项目核心层：Spring
SSM-MaBtis篇：SSM框架中项目持久层：MyBatis
Maven篇：Java项目管理神器：Maven

SpringMVC概述

Spring web MVC 框架提供了模型-视图-控制的体系结构和可以用来开发灵活、松散耦合的 web 应用程序的组件。MVC模式导致了应用程序的不同方面(输入逻辑、业务逻辑和 UI 逻辑)的分离，同时提供了在这些元素之间的松散耦合。

• 模型封装了应用程序数据，并且通常它们由 POJO组成。
• 视图主要用于呈现模型数据，并且通常它生成客户端的浏览器可以解释的 HTML 输出。
• 控制器主要用于处理用户请求，并且构建合适的模型并将其传递到视图呈现。

SpringMVC底层也是Servlet。以Servlet为核心， 接收请求,处理请求。显示处理结果给用户。

DispatcherServlet

DispatcherServlet是框架一个Servlet对象。负责接收请求，响应处理结果。

DispatcherServlet作用：

• 在init()中创建容器对象，WebApplicationContext，即Controller对象
• 是一个servlet，能够接收请求

默认servlet配置文件位置

自定义配置文件位置：放在resource路径下，名称直接写servlet-name内容即可

<!-- web.xml -->
<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <!-- 声明springmvc的核心对象 -->
  <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:springmvc.xml</param-value>
    </init-param>
  </servlet>
  
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
      <!-- 把一些请求交给指定的servlet处理
 		使用中央调用器(DispatcherServlet)
		1. 使用扩展名方式，格式*.xxx
		2. 使用斜杠 "/"
		-->
    <url-pattern>/mymvc</url-pattern>
  </servlet-mapping>
</web-app>

此处补充一个选项

<!--表示服务器tomcat创建对象的顺序，是 个整数值，大于等于0.
数值越小，创建对象的时间越早。-->
<servlet>
    <!--
	...
	-->
<load-on-startup>1</load-on-startup>
</servlet>

此处放一个模板，后续解释

package com.bjpowernode.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

/**
 * @Controller
 * 创建控制器对象，控制器：后端控制器，自定义类，处理请求
 * 位置：在类的上面，表示创建此类的对象，对象在springmvc的容器中
 */
@Controller
public class MyController {
    /**
     * 方法的形参，表示请求中的参数
     * 方法的返回值，表示本次请求的处理结果
     * @return
     */
    /**
     * @RequestMapping 请求映射
     * 属性：value 请求的url地址，唯一值，以"/"开头
     * 位置：1.在方法上面（必须） 2.在类定义的上面（可选）
     * 作用：把指定的请求交给指定的方法处理,等同于url-pattern
     */
    @RequestMapping(value = {"/some.do"， "/first.do"})
    public ModelAndView doSome() {
        // 使用这个方法处理请求，能处理请求的方法叫做控制器方法
        // 调用service对象处理请求
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "处理了请求"); // 此处的msg是jsp文件中的内容
        mv.addObject("fun", "执行了请求");

        // 指定视图，视图的完整路径
        mv.setViewName("/show.jsp");
        /**
         * 当框架调用完doSome()方法后，得到返回中ModelLAndview.
         * 框架会在后续的处理逻辑值， 处fmv对象里面的数据和视图。
         * 对数据执行request. setAttribute( "msg", ”处理I some . do请求"); 把数据放入到request作用域。
         * 对视图执i行forward转发操作。 等同于request. getReques tDispather( "/show. jsp"). forward(.. )
         */
        // 返回结果
        return mv;
    }
}

SpringMVC请求处理过程

简单处理过程：

• 用户发起请求
• Tomcat接收了请求。
• Tomcat根据<url-pattern/>标签把请求交给了其上的<servlet-name/>中央调度器
• DispatcherServlet根据请求进行分配
• 查看该中央调度器的.xml文件，寻找控制器，查找注解RequestMapping
• 返回ModelAndView对象

视图解析器

<!-- controller.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 声明组件扫描器 -->
    <context:component-scan base-package="com.bjpowernode.controller"/>
    <!-- 声明视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀：指定视图文件的路径 -->
        <property name="prefix" value="/xxx/"/>
        <!-- 后缀：视图文件的扩展名 -->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>>
	

在Controller中，使用文件名作为视图名使用，叫做视图逻辑名称

mv.setViewName("show");

使用Controller处理不同的请求

@RequestMapping(value = {"/some.do"， "/first.do"})

SpringMVC的MVC组件

• M：后端控制器，返回数据model
• V：视图，view
• C：前端控制器（中央调度器），front controller

SpringMVC注解式开发

@RequestMapping

请求映射

• 属性：value 请求的url地址，唯一值，以"/"开头
• 位置：
  • 在方法上面（必须）
  • 在类定义的上面（可选，对于公用的字符串使用）
• 作用：把指定的请求交给指定的方法处理,等同于url-pattern

对请求提交方式的定义

对于@RequestMapping,其有一个属性 method,用于对被注解方法所处理请求的提交方式进行限制，即只有满足该method属性指定的提交方式的请求，才会执行该被注解方法。

Method属性的取值为RequestMethod枚举常量。常用的为RequestMethod.GET与RequestMethod.POST,分别表示提交方式的匹配规则为GET与POST提交。

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@RequestMapping(value = "/some.do", method = RequestMethod.POST)

以上处理器方法只能处理POST方式提交的请求。客户端浏览器常用的请求方式，及其提交方式有以下几种:

web开发中配置文件的说明

• web.xml部署描述符文件，给服务器(tomcat)。

  作用:服务器在启动的时候，读取web.xml，根据文件中的声明创建各种对象，根据文件中的声明知道请求和servlet等对象的关系。

• 框架的配置文件，springmvc的配置文件

  作用:声明框架创建的项目中的各种对象，主要是创建Controller对象的。

服务器开启流程

• tomcat服务器启动， 读取web.xml，根据web.xml文件中的说明，创建对象。
• springmvc框架，new ClassPathXmlApplicationContext()读取springmvc的配置文件。
• 用户发起请求……

处理器方法的参数

处理器方法可以包含以下四类参数，这些参数会在系统调用时由系统自动赋值，即程序员可在方法内直接使用。

• HttpServletRequest
• HtpServletResponse
• HttpSession
• 请求中所携带的请求参数

接收请求中的参数：逐个接收，对象接收

逐个接收

概念：请求中的参数名和控制器方法的形参名一样，按照名称对象接收参数

<form...>
	<input type="text" name="name"/>
    <input type="text" name="age"/>
</form...>

@RequestMapping(value = "/some.do", method = RequestMethod.POST)
public ModelAndView doSome(String name, Integer age) {
    //
}

参数接收

• 框架使用request对象，接收参数

  String name = request.getParameter("name");
  String age = request.getParameter("age");
  

• 在中央调度器的内部调用doProperParam方法时，按名称传递参数

  doProperParam(name, Integer.valueOf(age));
  

  框架可以实现请求参数String到Integer，Long，Float等类型的转化。

当请求中参数名和接收参数名不一致时，可以使用@RequestParam注解

作用：解决名称不一样的问题

属性

• value：请求中的参数名称
  required :boolean类型的，默认是true
  • true：请求中必须有此参数，没有报错。
  • false：请求中不必有此参数，没有报错。

位置:在形参定义的前面

public ModelAndView doSome(@RequestParam(value="name")String rname, 
                           @RequestParam(value="age")Integer rage) {
    // 
}

对象接收

对象接收：在控制器方法的形参是java对象，使用java对象的属性接收请求中参数值。

要求: java对象的属性名和请求中参数名一样。

public ModelAndView doSome(Student student) {
    ModelAndView mv = new ModelAndView();
    mv.addObject("myname", student.getName());
    mv.setViewName("show");
    return mv;
}

处理器方法的返回值

处理器方法也可以返回Object对象。这个Object可以是Integer，String，自定义对象，Map, List 等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出现的。返回对象，需要使用@ResponseBody 注解，将转换后的JSON数据放入到响应体中。

ModelAndView数据和视图

请求的结果有数据和视图，使用ModelAndView最方便

• 数据：存放request作用域。
• 视图：执行forward转发操作。

String视图

框架的返回值是String，执行的是forward操作。

逻辑名称（配合配置文件.xml，视图解析器）

/**原
public ModelAndView doSome(Student student) {
    ModelAndView mv = new ModelAndView();
    mv.addObject("myname", student.getName());
    mv.setViewName("show");
    return mv;
}
*/
public String doSome(Student student) {
    return "show";
}

完整视图路径，项目中不能配置视图解析器

public String doSome(Student student) {
    return "/WEB-INF/view/show.jsp";
}

void

没有数据和视图，可以使用HttpServletResponse对象输出数据响应AJAX请求处理

Maven中加入依赖

<!-- pom.xml -->
<dependency>
	<groudId>com.fasterxml.jackson.core</groudId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
	<groudId>com.fasterxml.jackson.core</groudId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>

把对象转为AJAX

public String doSome(HttpServletResponse res, String name, Integer age) {
    ObjectMapper on = new ObjectMapper();
	String json = on.writeValueAsString(student);

	// 输出json，响应Ajax
    res.setContentType("application/json;charset=utf-8");
    PrintWriter pw = res.getWriter();
    pw.println(json);
    pw.flush();
    pw.close();
}

Object

返回对象Object是数据，而ajax请求需要的都是数据。在ajax请求中，一般返回的是json格式数据。

框架提供了处理java对象到json转换，还是数据输出工作。

HttpMessageConverter消息转换器：是一个接口

• 作用：
  • 实现请求的数据转为Java对象；
  • 把控制器方法返回的对象转为json、text、xml、二进制等不同格式的数据；

public interface HttpMessageConverter<T> {
    /* 检查var1，如果能转化成MediaType返回真 */
    boolean canRead(Class<?> var1, @Nullable MediaType var2);
	/* 检查var1，如果能转化成MediaType返回真 */
    boolean canWrite(Class<?> var1, @Nullable MediaType var2);

    List<MediaType> getSupportedMediaTypes();

    /* 接收请求中的对象，把数据转化成var1 */
    T read(Class<? extends T> var1, HttpInputMessage var2) throws IOException, HttpMessageNotReadableException;
	
    /* 把数据转化成var3，发送数据 */
    void write(T var1, @Nullable MediaType var2, HttpOutputMessage var3) throws IOException, HttpMessageNotWritableException;
}

框架根据控制器方法的返回类型，自动查找使用的实现类。

默认情况下: springmvc使用了HttpMessageConveter接口的4个实现类。包括了StringHttpMessageConverter。

需要在springmvc的配置文件，加入注解驱动的标签mvc:annotation-driven加入这个标签后，springmvc项目
启动后，会创建HttpMessageConveter接口的7个实现类对象， 包括StringHttpMessageConverter 和
Mappinglackson2HttpMessageConverter。

<mvc:annotation-driven />

public Student doSome(HttpServletResponse res, String name, Integer age) {
    //
    return student;
}

@ResponseBody：注解的作用，就是把student转换后的json通过HttpServletResponse对象输出给浏览器。

相当于

res.setContentType("application/json;charset=utf-8");
PrintWriter pw = res.getWriter();
pw.println(json);
pw.flush();
pw.close();

控制器方法返回对象转为json的步骤

• pom.xml加入jackson依赖， springmvc框架， 默认处理json就是使用jackson
• 在springmvc的配置文件中，加入注解驱动的标签mvc:annotation-dirven
• 在控制器方法的上面加入@ResponseBody注解，表示返回值数据，输出到浏览器。

List

与Object同理

解读url-pattern

静态资源的处理

主要是由Tomcat进行处理的

• 提供静态资源的处理
• 处理所有未映射到其他请求的请求处理

    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

如果在中央调度器使用

  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

如果在项目中，中央调度器使用了\，动态资源能访问，静态资源不能访问，因此需要处理静态资源的访问工作

第一种处理静态资源的方法：使用<mvc:default-servlet-handler/>

在springmvc的配置文件中加入mvc:default-servlet-handler标签，springmvc框架会在项目运行时，加入DefaultServletHttpRequestHandler对象，让这个对象处理静态资源的访问。

原理：DefaultServletHttpRequestHandler把接收的静态资源的地址，转发给了tomcat的default

优点：解决方法简单

缺点：依赖于Tomcat服务器

<mvc:annotation-driven /> <!-- 一般与其下配置防止冲突 -->

<mvc:default-servlet-handler/>

第二种处理静态资源的方法：使用<mvc:resources/>

在springmvc配置文件中加入一个mvc:resources标签，框架会创建ResourceHttpRequestHandler控制器对象，使用这个对象处理静态资源的访问。（不依赖tomcat服务器，推荐使用）

<mvc:annotation-driven /> <!-- 一般与其下配置防止冲突 -->

<!--
	mapping:访问静态资源的url地址，可以使用通配符(**)
	location:静态在项目中的位置 不要使用/WEB-INF目录
-->
<mvc:resources mapping="/images/**" location=""/>
<mvc:resources mapping="/js/**" location=""/>
<mvc:resources mapping="/css/**" location=""/>

<!-- 一句话设置静态资源 -->
<mvc:resources mapping="/static/**" location=""/>

SSM整合

SSM编程,即SpringMVC + Spring + MyBatis整合,是当前最为流行的JavaEE开发技术架构。其实SSM整合的实质，仅仅就是将MyBatis整合入Spring。因为SpringMVC原本就是Spring的- -部分, 不用专门整台。SSM整合的实现方式可分为两种:基于XML配置方式，基于注解方式。