35-springmvc（ssm及微服务入门，临时）

感谢你的路过，希望学生的笔记能给你一点微不足道的参考（2/100）
Java基础思维导图，完整Java体系的链接

1、SpringMVC概述

1.1 SpringMVC概念

   SpringMVC 也叫 Spring web mvc。是 Spring内置的一个MVC框架，在 Spring3.0 后发布。SpringMVC框架解决了WEB开发中常见的问题(参数接收、文件上传、表单验证等等)，而且使用简单，与Spring无
缝集成。支持 RESTful风格的URL请求。采用了松散耦合可插拔组件结构，比其他 MVC 框架更具扩展性
和灵活性。

1.2 SpringMVC原理

   在没有使用SpringMVC之前我们都是使用Servlet在做Web开发。但是使用Servlet开发在接收请求参数，
数据共享，页面跳转等操作相对比较复杂。servlet是java进行web开发的标准，既然springMVC是对
servlet的封装，那么很显然SpringMVC底层就是Servlet，SpringMVC就是对Servlet进行深层次的封
装。

1.3 SpringMVC优势

   1、基于 MVC 架构，功能分工明确。解决页面代码和后台代码的分离。
   2、简单易用。SpringMVC 也是轻量级的，jar 很小。不依赖的特定的接口和类就可以开发一个注解的SpringMVC 项目。
   3、作 为 Spring 框 架 一 部 分 ， 能 够 使 用Spring的IoC和AOP 。 方 便 整 合MyBatis,Hiberate,JPA等其他框架。
   4、springMVC的注解强大易用。

2、MVC模式回顾

模型1：jsp+javabean模型—在jsp页面中嵌入大量的java代码
模型2：jsp+servlet+javabean模型—jsp页面将请求发送给servlet，由servlet调用javabean，再由servlet将制定jsp页面响应给用户。
模型2一般就是现在的MVC模式，也是我们一直使用的。

Model-View-Controller：模型–视图–控制器
   Model： 模型层 javaBean 负责数据访问和业务处理 dao service pojo
   View： 视图 JSP技术 负责收集和展示数据
   Controller： 控制器 servlet技术 中间调度

控制器的工作：
   1、接受客户端的请求（包括请求中携带的数据）
   2、处理请求：调用后台的模型层中的业务逻辑
   3、页面导航：处理完毕给出响应：JSP页面

3、入门程序

3.1 创建maven项目

创建项目并补齐目录结构

3.2 pom.xml文件添加依赖和插件

<!--web项目-->
<packaging>war</packaging>
<dependencies>
<!--spring-webmvc依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.13.RELEASE</version>
</dependency>
<!--springmvc底层还是servlet，所以必须添加serlvet依赖-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope><!--插件运行的时候没有范围插件启动会失败-->
</dependency>
</dependencies>
<build>
<plugins>
<!-- 编码和编译和JDK版本 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<!--tomcat插件-->
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<path>/</path>
<port>8080</port>
</configuration>
</plugin>
</plugins>
</build>

3.3 创建Spring和SpringMVC的配置文件

我们一般将除了 Controller 之外的所有 Bean 注册到 Spring 容器中，而将 Controller 注册到SpringMVC 容器中。所以我们在 resources 目录下添加 applicationContext.xml 作为 spring 的配置，添加springmvc.xml作为springmvc的配置文件。

3.3.1 创建Spring配置文件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"
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
">
<!--spring的配置文件:除了控制器之外的bean对象都在这里扫描-->
<context:component-scan base-package="com.kkb.dao,com.kkb.service"/>
</beans>

3.3.2 创建SpringMVC的配置文件springmvc.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
">
<!--springmvc的配置文件:控制器的bean对象都在这里扫描-->
<context:component-scan base-package="com.kkb.controller"/>
</beans>

3.4 在web.xml中进行Spring和SpringMVC配置

<!--spring的配置-->
<context-param>
<!--contextConfigLocation：表示用于加载 Bean的配置文件-->
<param-name>contextConfigLocation</param-name>
<!--指定spring配置文件的位置
这个配置文件也有一些默认规则，它的配置文件名默认就叫 applicationContext.xml ，
如果将这个配置文件放在 WEB-INF 目录下，那么这里就可以不用 指定配置文件位置，
只需要指定监听器就可以。
这段配置是 Spring 集成 Web 环境的通用配置；一般用于加载除控制器层的 Bean（如
dao、service 等），以便于与其他任何Web框架集成。
-->
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
<listenerclass>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--SpringMVC的配置-->
<!--
前端控制器：所有的请求都会经过此控制器，然后通过此控制器分发到各个分控制器.
前端控制器本质上还是一个Servlet，因为SpringMVC底层就是使用Servlet编写的
-->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servletclass>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 创建前端控制器的时候读取springmvc配置文件启动ioc容器 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- Tomcat启动就创建此对象 -->
<load-on-startup>1</load-on-startup>
</servlet>
<!-- 配置拦截路径url，所有以.do结尾的请求都会被前端控制器拦截处理 -->
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<!--
SpringMVC的配置解析：
1、servlet-class：前端控制器的完全限定名，在spring-webmvc-5.2.5.RELEASE.jar包中的
org.springframework.web.servlet下
2、load-on-startup：标记是否在Web服务器（这里是Tomcat）启动时会创建这个 Servlet 实
例，即是否在 Web 服务器启动时调用执行该 Servlet 的 init()方
法，而不是在真正访问时才创建。 要求取值是整数。
值大于0：表示容器在启动时就加载并初始化这个 servlet，数值越小，该 Servlet的优先级就
越高，其被创建的也就越早
值小于0或者省略：表示该 Servlet 在真正被使用时才会去创建。
值相同：容器会自己选择创建顺序
3、url-pattern：可以写为 / ，可以写为*.do 、*.action、*.mvc等形式，此处先写*.do,以后
介绍不同写法的区别。
4、init-param：表示了springmvc配置文件的名称和位置。如果没有配置，默认在项目的WEB-INF
目录下找名称为 Servlet 名称-servlet.xml 的配置文件。
如果没有配置，启用默认的规则：即如果配置文件放在 webapp/WEB-INF/ 目录下，并且配置文
件的名字等于 DispatcherServlet 的名字+ -servlet（即这里的配置文件路径是 webapp/WEBINF/dispatcherServlet-servlet.xml），如果是这样的话，可以不用添加 init-param 参数，即不
用手动配置 springmvc 的配置文件，框架会自动加载。
而一般情况下，配置文件是放在类路径下，即 resources 目录下。所以，在注册前端控制器时，
还需要设置查找 SpringMVC 配置文件路径。
其中contextConfigLocation属性：来自DispatcherServlet的父类FrameworkServlet，
该类中的contextConfigLocation属性用来配置springmvc的路径和名称。
-->

3.5 创建控制器

package com.kkb.controller;
import com.kkb.service.TeamService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
/**
* ClassName: TeamController
*
* @author wanglina
* @version 1.0
*/
@Controller
public class TeamController {
   
@Autowired
private TeamService teamService;
@RequestMapping("hello.do")
public ModelAndView add(){
   
System.out.println("TeamController----add---");
teamService.add();
ModelAndView mv=new ModelAndView();
mv.addObject("teamName","湖人");//相当于
request.setAttrubuite("teanName","湖人");
mv.setViewName("index");//未来经过springmvc的视图解析器处理，转换成物理资源路径,
相当于request.getRequestDispatcher("index.jsp").forward();
//经过InternalResourceViewResolver对象的处理之后加上前后缀就变为了
/jsp/index.jsp
return mv;
}
}
package com.kkb.service;
import org.springframework.stereotype.Service;
@Service
public class TeamService {
   
public void add(){
   
System.out.println("TeamService---- add-----");
}
}

3.6 配置视图解析器

在springmvc.xml配置文件中添加视图解析器的配置

<!--视图解析器-->
<bean id="internalResourceViewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<mvc:annotation-driven/>
<!--annotation-driven是一种简写形式，也可以手动配置替代这种简写形式，简写形式可以让初学者快速
应用默认配置方案。
该注解会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter
两个bean,是springMVC为@Controller分发用户请求所必须的，解决了@Controller注解使用的前提配
置。
同时它还提供了：数据绑定支持，@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支
持，读写XML的支持（JAXB，读写JSON的支持（Jackson）。我们处理响应ajax请求时，就使用到了对json
的支持（配置之后，在加入了jackson的core和mapper包之后，不写配置文件也能自动转换成json）。
-->

3.7 编写index.jsp页面

webapp文件夹下面创建文件夹jsp,然后jsp文件夹中添加index.jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>index</title>
</head>
<body>
<h1>index---------------${teamName}</h1>
</body>
</html>

3.8 测试

3.9 解析

当 Spring 和 SpringMVC 同时出现，我们的项目中将存在两个容器，一个是 Spring 容器，另一个是SpringMVC 容器，Spring 容器通过 ContextLoaderListener 来加载，SpringMVC 容器则通过DispatcherServlet 来加载，这两个容器不一样：

如图所示：
ContextLoaderListener 初始化的上下文加载的 Bean 是对于整个应用程序共享的，不管是使用什么表现层技术，一般如 dao层、service层 的bean；
DispatcherServlet 初始化的上下文加载的 bean 是只对 Spring Web MVC 有效的 bean，如Controller、HandlerMapping、HandlerAdapter 等等，该初始化上下文应该只加载 Web相关组件。
1.Spring容器中不能扫描所有Bean嘛？
不可以。当用户发送的请求达到服务端后，会寻找前端控制器DispatcherServlet去处理，只在SpringMVC容器中找，所以Controller必须在SpringMVC容器中扫描。
2.SpringMVC容器中可以扫描所有Bean嘛？
可以。可以在SpringMVC容器中扫描所有Bean。但是实际开发中一般不会这么做，原因如下：
（1）为了方便配置文件的管理
（2）未来在 Spring+SpringMVC+Mybatis组合中，要写的配置内容很多，一般都会根据功能分开编写

4、SpringMVC工作流程

4.1 工作流程分析

（1）用户通过浏览器发送请求到前端控制器DispatcherServlet。
（2）前端控制器直接将请求转给处理器映射器HandleMapping。
（3）处理器映射器HandleMapping会根据请求，找到负责处理该请求的处理器，并将其封装为处理器执行链HandlerExecutionChina后返回给前端控制器DispatcherServlet。
（4）前端控制器DispatcherServlet根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器HandlerAdaptor。
（5）处理器适配器HandlerAdaptor调用执行处理器Controller。
（6）处理器Controller将处理结果及要跳转的视图封装到一个对象 ModelAndView 中，并将其返回给处理器适配器HandlerAdaptor。
（7）处理器适配器直接将结果返回给前端控制器DispatcherServlet。
（8）前端控制器调用视图解析器，将 ModelAndView 中的视图名称封装为视图对象。
（9）视图解析器ViewResolver将封装了的视图View对象返回给前端控制器DispatcherServlet.
（10）前端控制器DispatcherServlet调用视图对象，让其自己进行渲染，即进行数据填充，形成响应对象。
（11）前端控制器响应浏览器。
4.2 SpringMVC组件
1.DispatcherServlet：
前端控制器,也称为中央控制器或者核心控制器。用户请求的入口控制器，它就相当于 mvc 模式中的c，DispatcherServlet 是整个流程控制的中心，相当于是 SpringMVC 的大脑，由它调用其它组件处理用户的请求，DispatcherServlet 的存在降低了组件之
间的耦合性。SpringMVC框架提供的该核心控制器需要我们在web.xml文件中配置。
2.HandlerMapping：
处理器映射器HandlerMapping也是控制器，派发请求的控制器。我们不需要自己控制该类，但是他是springmvc运转历程中的重要的一个控制器。 HandlerMapping负责根据用户请求找到 Handler 即处理器（也就是我们所说的 Controller），SpringMVC 提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等，在实际开发中，我们常用的方式是注解方式。
3.Handler：处理器
Handler 是继 DispatcherServlet 前端控制器的后端控制器，在DispatcherServlet 的控制下 Handler 对具体的用户请求进行处理。由于 Handler 涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发 Handler。（这里所说的 Handler 就是指我们的 Controller）
4.HandlAdapter：
处理器适配器通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展处理器适配器，支持更多类型的处理器,调用处理器传递参数等工作。
5.ViewResolver：
视图解析器ViewResolver 负责将处理结果生成 View 视图，ViewResolver 首先根据逻辑视图名解析成物理视图名称，即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。 SpringMVC 框架提供了很多的 View 视图类型，包括：jstlView、freemarkerView、pdfView 等。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

5 @RequestMapping 注解

5.1@RequestMapping出现的位置

过@RequestMapping 注解定义了处理器对于请求的映射规则。该注解可以定义在类上，也可以定义在方法上，但是含义不同。

一个@Controller 所注解的类中，可以定义多个处理器方法。当然，不同的处理器方法所匹配的 URI 是不同的。这些不同的 URI 被指定在注解于方法之上的@RequestMapping 的value 属性中。但若这些请求具有相同的 URI 部分，则这些相同的 URI，可以被抽取到注解在类之上的RequestMapping 的 value属性中。此时的这个 URI 表示模块的名称。URI 的请求是相对于 Web 的根目录。在类的级别上的注解会将一个特定请求或者请求模式映射到一个控制器之上。之后你还可以另外添加方法级别的注解来进一步指定到处理方法的映射关系。
示例：修改TeamController.java 如下

package com.kkb.controller;
import com.kkb.service.TeamService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
/**
* ClassName: TeamController
*
* @author wanglina
* @version 1.0
*/
@Controller
@RequestMapping("team")
public class TeamController {
   
@Autowired
private TeamService teamService;
@RequestMapping(value = "add.do")
public ModelAndView addTeam(){
   
System.out.println("TeamController----addTeam---");
ModelAndView mv=new ModelAndView();
mv.setViewName("team/add");// 映射成为物理资源路径：/jsp/team/add.jsp
return mv;
}
@RequestMapping(value = "update.do")
public ModelAndView updateTeam(){
   
System.out.println("TeamController----updateTeam---");
ModelAndView mv=new ModelAndView();
mv.setViewName("team/update");//映射成为物理资源路径：/jsp/team/update.jsp
return mv;
}
@RequestMapping("hello.do")
public ModelAndView hello(){
   
System.out.println("TeamController----add---");
teamService.add();
ModelAndView mv=new ModelAndView();
mv.addObject("teamName","湖人");//相当于
request.setAttrubuite("teanName","湖人");
mv.setViewName("index");//未来经过springmvc的视图解析器处理，转换成物理资源路径,
相当于request.getRequestDispatcher("index.jsp").forward();
//经过InternalResourceViewResolver对象的处理之后加上前后缀就变为了
/jsp/index.jsp
return mv;
}
}

浏览器中访问：

5.2 指定请求提交方式

@RequestMapping的method属性，用来对被注解方法所处理请求的提交方式进行限制，即只有满足method 属性指定的提交方式的请求，才会执行该被注解方法。
Method 属性的取值为 RequestMethod 枚举常量。常用的为 RequestMethod.GET 与
RequestMethod.POST，分别表示提交方式的匹配规则为 GET 与 POST 提交。


以下表格列出了常用的提交方式：

5.3 补充url-pattern解析

5.3.1 url-pattern解析

在web.xml配置SpringMVC的前端控制器时有这个节点。这个节点中的值一般有两种写法：

案例：在index.jsp页面添加一张图片，如果节点中的值为*.do,图片可以正常访问，但是如果为/就不能
访问。
1、项目中添加图片，同时修改index.jsp页面

2、修改web.xml

3、此时访问图片无法显示

5.3.2 静态资源访问

如果的值配置为/后，静态资源可以通过以下两种方法解决。

5.3.2.1使用< mvc:default-servlet-handler/ >

在springmvc的配置文件中添加如下内容：

<mvc:default-servlet-handler/>
<!--声 明 了 <mvc:default-servlet-handler /> 后 ，springmvc框架会在容器中创建
DefaultServletHttpRequestHandler处理器对象。该对象会对所有进入 DispatcherServlet的URL
进行检查。如果发现是静态资源的请求，就将该请求转由Web应用服务器默认的Servlet 处理。
一般的服务器都有默认的 Servlet。例如咱们使用的Tomcat服务器中，有一个专门用于处理静态资源
访问的 Servlet 名叫 DefaultServlet。其<servlet-name/>为default。可以处理各种静态资源访问请求。该Servlet注册在 Tomcat 服务器的 web.xml 中。在 Tomcat安装目录/conf/web.xml。-->

5.3.2.2 使用 < mvc:resources/ >

在springmvc的配置文件中添加如下内容：

<mvc:resources location="/images/" mapping="/images/**" />
<!--
location: 表示静态资源所在目录。当然，目录不要使用/WEB-INF/及其子目录。
mapping: 表示对该资源的请求。注意，后面是两个星号**。-->

在 Spring3.0 版本后，Spring 定义了专门用于处理静态资源访问请求的处理器
ResourceHttpRequestHandler。并且添加了< mvc:resources/ >标签，专门用于解决静态资源无法访问问题。

6、处理器方法的参数

处理器方法可以包含以下四类参数，这些参数会在系统调用时由系统自动赋值.所以我们可以在方法内直
接使用。以下是这四类参数:
   HttpServletRequest
   HttpServletResponse
   HttpSession
   请求中所携带的请求参数
准备工作：创建新的控制器ParamController.java和前端页面hello.jsp页面

package com.kkb.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
@RequestMapping("param")
public class ParamController {
   
@RequestMapping("hello")
public ModelAndView hello(){
   
return new ModelAndView("hello);
}
}

6.1 直接使用方法的参数逐个接收

6.2 使用对象接收多个参数

6.3 请求参数和方法名称的参数不一致

6.4 使用HttpServletRequest 对象获取参数

6.5 直接使用URL地址传参

6.6 获取日期类型的参数

6.7 获取数组类型的参数

6.8 获取集合类型的参数

SpringMVC不支持直接从参数中获取对象集合类型，需要将对象集合封装到实体类中。
案例源码：
修改实体类Team.java

package com.kkb.pojo;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
public class Team {
   
private Integer teamId;
private String teamName;
private String location;
@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date createTime;
@Override
public String toString() {
   
return "Team{" +
"teamId=" + teamId +
", teamName='" + teamName + '\'' +
", location='" + location + '\'' +
", createTime=" + createTime +
'}';
}
//省略set get方法
}

创建实体类QueryVO.java

package com.kkb.vo;
import com.kkb.pojo.Team;
import java.util.List;
public class QueryVO {
   
private List<Team> teamList;
public List<Team> getTeamList() {
   
return teamList;
}
public void setTeamList(List<Team> teamList) {
   
this.teamList = teamList;
}
}

前端页面hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>hello</title>
</head>
<body>
<h3>8、获取集合类型的参数</h3>
<form action="/param/test08" method="post">
球队名称1：<input type="text" name="teamName"/><br/>
球队名称2：<input type="text" name="teamName"/><br/>
球队名称3：<input type="text" name="teamName"/><br/>
<button type="submit">提交</button>
</form>
<form action="/param/test09" method="post">
球队id1：<input type="text" name="teamList[0].teamId"/><br/>
球队id2：<input type="text" name="teamList[1].teamId"/><br/>
球队id3：<input type="text" name="teamList[2].teamId"/><br/>
球队名称1：<input type="text" name="teamList[0].teamName"/><br/>
球队名称2：<input type="text" name="teamList[1].teamName"/><br/>
球队名称3：<input type="text" name="teamList[2].teamName"/><br/>
<button type="submit">提交</button>
</form>
<h3>7、获取数组类型的参数</h3>
<form action="/param/test07" method="post">
球队名称1：<input type="text" name="teamName"/><br/>
球队名称2：<input type="text" name="teamName"/><br/>
球队名称3：<input type="text" name="teamName"/><br/>
<button type="submit">提交</button>
</form>
<h3>6、获取日期类型的参数</h3>
<form action=