SpringMVC
1.简介
SSM：mybatis + spring + springmvc
MVC三层架构：Model + View + Controller
SpringMVC中的重点：SpringMVC中的执行流程
SSM框架整合
SpringMVC 是 SpringFramework 的一部分，是基于 Java 实现MVC 的轻量级框架
学习SpringMVC的原因：
- 轻量级，简单易学
- 高效，基于请求响应的MVC框架
- 与Spring兼容性好，无缝结合
- 约定优于配置
- 功能强大，RESTful，数据验证，格式化，本地化，主题等
- 简洁灵活
2.MVC
MVC：模型（相当于 dao , service ），视图（相当于 jsp），控制器（相当于 servlet）
- MVC是模型(Model)，视图(View)，控制器(Controller)的简写，是一种软件设计规范
- 是将业务、数据、显示分离的方法来组织代码
- MVC主要作用是降低了视图与业务逻辑间的双向耦合
- MVC不是一种设计模式，是一种架构模式，不同的MVC是存在差异的
Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或者是JavaBean组件，不过现在一般分成 Value Object（数据 dao）和服务层（行为 service）。
View（视图）：负责进行模型的展示，一般就是我们所说的用户界面
Controller（控制器）：接收用户请求，委托给模型进行处理，把处理完毕后返回的模型数据返回给视图。
在实际开发中，可能存在 前端传输的东西不一定是实体类需要的。比如
在实体类User中，有20个字段，前端完成一个登录功能，只需要提供用户名和密码两个字段即可
那么我们就没必要把前端传入的数据封装成一个User对象，这样会浪费很多空间（很多字段为null）
于是我们可以把pojo进行细分，创建一个userVo对象，只有用户名和密码两个字段。这只是一种细分，vo实际上还是实体类。（dto 一般用来命名数据传输对象）
最典型的MVC就是：JSP + Servlet + JavaBean
2.1 Model1
在Web的早期开发中，通常采用的都是Model1
在Model1中，主要分为两层，视图层和模型层
JSP的本质就是一个Servlet，很多时候代码可以不用Servlet去做，直接写在JSP中
Model1的优点：架构简单，适合小型项目的开发
Model1的缺点：JSP需要负责的事情太多，不便于维护
2.2 Model2
Model2把项目分为三部分：视图、控制、模型
- 用户发请求
- Servler接收请求数据，并调用对应的业务逻辑方法
- 业务处理完毕，返回更新后的数据给Servlet
- Servlet转向到JSP，由JSP来渲染页面
- 响应给前端更新后的页面
Model2的优点：提高了代码的复用率和项目的扩展性，更方便维护，并且方便团队开发。
3.回顾Servlet
首先创建一个普通的maven项目，然后删除项目中的src目录，再添加需要使用的包的依赖
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.1</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</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>
在项目中新建一个子模块，也是普通的maven项目
创建好之后，右键该模块，然后选择添加框架支持，选择webapplication。这样创建web项目的话，可以节省自己配置web.xml的步骤，节省一些成本
在子项目中导入要使用的maven依赖，虽然父项目中已经导入了，但是也可以在子项目中导入，确保万一
编写一个servlet类，用来处理用户的请求
在编写前端页面时，如果为了保证页面安全，用户不可见，就放在WEB-INF下面，如果是公共可见的，就放在WEB下面
项目结构如下
// HelloServlet.java
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 1.获取前端参数
String method = req.getParameter("method");
if(method.equals("add")){
req.getSession().setAttribute("msg","执行了add方法");
}
if(method.equals("delete")){
req.getSession().setAttribute("msg","执行了delete方法");
}
// 2.调用业务层
// 3.视图转发或者重定向
req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
// 重定向：resp.sendRedirect();
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doGet(req, resp);
}
}
编写完servlet之后，马上去web.xml中配置servlet，这里不使用注解直接配置的原因，是为了配合Spring
<!-- 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>hello</servlet-name>
<servlet-class>com.muzimu.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
<!-- <!– 配置欢迎页 –>-->
<!-- <welcome-file-list>-->
<!-- <welcome-file>index.jsp</welcome-file>-->
<!-- </welcome-file-list>-->
<!-- <!– 配置 session-config 的过期时间 –>-->
<!-- <session-config>-->
<!-- <!– 15分钟过期 –>-->
<!-- <session-timeout>15</session-timeout>-->
<!-- </session-config>-->
</web-app>
编写一个表单来接收参数提交，再编写一个测试页面来进行测试
<%-- form.jsp --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="/hello" method="post">
<input type="text" name="method">
<input type="submit">
</form>
</body>
</html>
<%-- test.jsp --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
编写完代码后，配置tomcat
点击添加配置后，点击加号进行配置
选择的是本地的tomcat
启动tomcat，在浏览器地址栏输入
http://localhost:8080/hello?method=add
http://localhost:8080/hello?method=delete
进行测试
在程序中，MVC框架要做的事情：
- 将 url 映射到 java 类或者 java 类的方法
- 封装用户提交的数据
- 处理请求–调用相关的业务处理–封装响应数据
- 将响应数据进行渲染，jsp/html 等显示数据
扩展：
MVVM表示：M V VM（ViewModel）VM是双向绑定，是核心
4.HelloSpringMVC
Spring的web框架围绕 DispatcherServlet （调度servlet）设计
DispatcherServlet 的作用是将请求分发到不同的处理器。
可以这样理解：在以前的业务中，我们要写许多的servlet来响应各种请求，用户的请求会寻找对应的servlet，然后进行一系列操作之后再返回给用户，我们编写的所有servlet都要在 web.xml 中进行注册。 这样显然是很麻烦的。于是我们可以增加一个调度器，用来处理请求，适配URL，跳转页面。用户的操作会经过这个调度器，调度器会寻找对应的servlet，这样我们就只需要注册这个调度器就行了。这个调度器就可以简单的理解为 DispatcherServlet ，他完成的是请求调度分发的作用
SpringMVC和许多MVC框架一样，以请求为驱动，围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet实际上就是一个Servlet （ 它继承了 HttpServlet ）
搭建环境
首先创建项目以及编写对应的文件，项目运行成功后，再详细解读对应的文件信息
项目结构如下
先编写 web.xml 文件，再编写 springmvc-servlet.xml 文件。然后编写 HelloController 文件，最后编写 hello.jsp
<!-- 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">
<!-- 1.注册DispatcherServlet -->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 关联一个springmvc的配置文件：【servlet-name】- servlet.xml -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc-servlet.xml</param-value>
</init-param>
<!-- 启动级别-1 -->
<load-on-startup>1</load-on-startup>
</servlet>
<!-- / ：表示匹配所有的请求（不包括.jsp） -->
<!-- /* ：表示匹配所有的请求（包括.jsp） -->
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
<!-- 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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
<!-- 视图解析器：DispatcherServlet给他的ModlAndView -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 前缀 -->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!-- 后缀 -->
<property name="suffix" value=".jsp"/>
</bean>
<!-- Handler -->
<bean id="/hello" class="com.muzimu.controller.HelloController"/>
</beans>
// HelloController.java
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// 这里导入的Controller接口是 springframework 中的接口
public class HelloController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
// ModelAndView 模型和视图
ModelAndView mv = new ModelAndView();
// 封装对象Model，放在 ModelAndView 中
mv.addObject("msg","HelloSpringMVC");
// 封装要跳转的视图，放在 ModelAndView 中
mv.setViewName("hello");
// 由于在配置文件中设置了前缀后缀，该视图传输后会变成
// /WEB-INF/jsp/hello.jsp
return mv;
}
}
<%-- hello.jsp --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
在编写完之后，需要重新配置tomcat。由于这是另一个子项目，所以要切换 Deployment
注意下面的 Application context
当 Application context 为 / 时，表示路径为 localhost:8080/
修改完配置后，运行tomcat，去浏览器中输入 localhost:8080/hello
如果提示 404 错误，很可能是 jar 包没有导入的错误，即使你已经有依赖，但是还是会出现这种错误
解决方法：
右键当前项目，选择项目结构，切换到如下位置
一定要在 Artifacts 中选中当前项目，然后在 WEB-INF 下面创建 lib 文件夹，并在lib文件夹中加入jar包
重启 tomcat 服务器，运行成功。
4.1 SpringMVC执行原理
这张图表示了较为完整的SpringMVC执行流程，其中 实线表示 SpringMVC 框架提供的技术，不需要开发者去实现，虚线表示需要开发者去实现技术
分析执行流程：
- 用户发出请求，DispatcherServlet接收并拦截请求（DispatcherServlet 表示前置控制器，是整个SpringMVC的控制中心）
- 假设请求的url为：https://localhost:8080/SpringMVC/hello
- 可以将这个url拆分成为三部分
- https://localhost:8080 表示服务器域名
- SpringMVC 表示 部署在服务器上的web站点
- hello 表示控制器
- 通过分析，这个url表示 请求位于 localhost:8080 上的 SpringMVC 站点的 hello 控制器
- HandlerMapping 是处理器映射，DispatcherServlet 调用 HandlerMapping，HandlerMapping 根据请求 url 查找 Handler
- HandlerExecution 表示具体的 Handler，主要作用是根据url查找控制器，比如在第一点中的url，查找的就是名为hello的控制器
- HandlerExecution 将解析后的信息返回给 DispatcherServlet ，比如解析控制器映射等
- HandlerAdapter 表示处理器适配器，按照特定的规则去执行Handler
- Handler 让具体的 Controller 执行，Controller 调用业务层（我们例题中并没有写业务层）
- Controller 将具体的执行信息返回给 HandlerAdapter ，返回的就是 ModelAndView（可以理解为：指定的前端以及要携带给前端的数据）
- HandlerAdapter 将视图逻辑名或模型传递给 DispatcherServlet
- DispatcherServlet 调用视图解析器 ViewResolver 来解析 HandlerAdapter 传递的逻辑视图名
- 获取 ModelAndView 的数据
- 解析 ModelAndView 的视图名字
- 根据规定的前缀后缀拼接视图名字，找到对应的视图
- 将数据渲染到视图上
- 视图解析器将解析的逻辑视图名传给DispatcherServlet
- DispatcherServlet 根据视图解析器解析的视图结果，调用具体的视图
- 最终视图呈现给用户
以上操作可以细分为三步
- HandlerMapping 和 HandlerExecution 。来适配请求
- HandlerView 和 Controller 。执行请求的具体操作，返回 ModelAndView
- ViewResolver 和 View 。 进行视图解析并且展示给用户
这些操作都不需要我们去执行，我们只需要执行 controller 调用业务层执行操作，以及设置返回的视图名字即可
4.2 分析SpringHelloMVC 中的所有代码
<?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">
<!-- 1.注册DispatcherServlet，这个是SpringMVC的核心
它可以叫 请求分发器，或者 前端控制器 ，我们所有的请求都会经过它
-->
<servlet>
<servlet-name>springmvc</servlet-name>
<!-- 它对应的类是spring中已有的类，不是我们自己编写的类 -->
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- DispatcherServlet 要绑定 Spring 的配置文件 -->
<init-param>
<!-- 通过配置地址定位 -->
<param-name>contextConfigLocation</param-name>
<!-- classpath 表示当前 classes 下面（可以理解为当前项目的 src 目录下），对于多个同名的配置文件，只会加载找到的第一个文件；
classpath* 除了指定的class路径，还会到该class路径下的jar包中进行查找配置文件，对于多个同名的配置文件，都会被加载。
-->
<param-value>classpath:springmvc-servlet.xml</param-value>
</init-param>
<!-- 启动级别-1 -->
<!-- 由于系统一启动，可能有一些内置的请求就已经处理了
所以这里设置为1，让他与服务器一起启动
-->
<load-on-startup>1</load-on-startup>
</servlet>
<!--
在SpringMVC中
/ ：只匹配所有的请求，不会去匹配jsp页面
/* ：匹配所有的请求 ，包括jsp页面
在SpringMVC中，所有的请求都会通过DispatcherServlet，而jsp是已经完善的页面
如果使用 /* ，那么jsp页面也会再次经过上面编写的 DispatcherServlet
由于我们编写了前缀后缀适配，于是会出现 jsp 页面无限进行适配的情况
形成 /WEB-INF/jsp/XXX.jsp.jsp.jsp....... 这种情况
-->
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 由SpringMVC执行原理可以知道
我们需要一个 处理器映射器，以及一个 处理器适配器
即： HandlerMapping HandlerAdapter
这里使用的只是其中一种，根据前缀还有许多种
在实际开发中，可以使用注解直接配置，不用像这样进行配置
-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
<!-- 视图解析器：解析DispatcherServlet给他的ModlAndView
视图解析器也有许多种
-->
<!--
1.获取 ModelAndView 的数据
2.解析 ModelAndView 的视图名字
3.拼接视图名字，找到对应的视图 /WEB-INF/jsp/hello.jsp
4.将数据渲染到视图上
-->
<!-- 处理器映射器，处理器适配器，视图解析器 是SpringMVC 的核心三要素，不能省略 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
<!-- 前缀 -->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!-- 后缀 -->
<property name="suffix" value=".jsp"/>
</bean>
<!-- 由于处理器映射器使用的是 BeanNameUrlHandlerMapping
所以要配置请求的 bean，处理器会根据 id 来进行寻找处理
-->
<bean id="/hello" class="com.muzimu.controller.HelloController"/>
</beans>
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// 这里导入的Controller接口是 springframework 中的接口
// 这里为了说明原理，所以不能使用 @Controller
public class HelloController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
// ModelAndView 模型和视图
ModelAndView mv = new ModelAndView();
// 业务代码
// 由于本例没有编写业务，只用一个简单的返回值代替，比如返回一句简单的语句
String result = "HelloSpringMVC";
// addObject : 里面是一个 键值对
// addObject(String attributeName , @Nullable Object attributeValue)
// 封装对象Model，放在 ModelAndView 中
mv.addObject("msg",result);
// 封装要跳转的视图，放在 ModelAndView 中
mv.setViewName("hello");
// 由于在配置文件种的 视图解析器 设置了前缀后缀，所以该视图被解析后会变成
// /WEB-INF/jsp/hello.jsp
// Controller 返回一个 ModelAndView ，让视图解析器来处理
return mv;
}
}
详细执行流程：
- 用户发起请求
- 寻找DispatcherServlet
- DispatcherServlet 绑定了一个配置文件，寻找配置文件
- 执行处理器映射器
- 映射到 hello，把 hello 对应的类返回出去
- 处理器适配器寻找到对应的类来进行处理
- Controller 处理具体的业务
- 返回 ModelAndView
- 视图解析器解析返回的 ModelAndView
- 解析完之后返回给 DispatcherServlet
- 将视图展示给用户
这个项目只是为了说明原理，在真实开发中，并不会使用这种方法来进行开发，而是使用注解进行开发。
5.使用注解开发SpringMVC
搭建环境
-
新建子模块，添加Web框架支持，建立包结构 com.muzimu.controller
-
开启资源过滤
<build> <resources> <resource> <directory>src/main/resources</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> <resource> <directory>src/main/java</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> </resources> </build> -
在pom.xml文件中引入相关依赖
-
配置web.xml
- 注意 web.xml 要是最新版本的
- 在Atrifacts中添加lib目录和依赖
- 注册DispatcherServlet
- 关联SpringMVC配置文件
- 设置启动级别为1
- 响应请求设置为 /
-
添加SpringMVC配置文件（使用注解方式）
- 让IOC的注解生效
- 静态资源过滤：HTML , JS , CSS , 图片 , 视频…
- MVC的注解驱动
- 配置视图解析器
<?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 https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd"> <!-- 自动扫描包，让指定包下的注解生效，由IOC容器统一管理 --> <context:component-scan base-package="com.muzimu.controller"/> <!-- 让SpringMVC不处理静态资源 有的时候我们会引用一些资源 .css .html .mp3 .mp4....... 这些资源如果也被视图解析器过滤，就会出错 所以要让这些资源不被处理 --> <mvc:default-servlet-handler/> <!-- 支持mvc注解驱动 在Spring中一般采用@RequestMapping注解来完成映射关系 如果要使用 @RequestMapping 要在上下文中注册 DefaultAnnotationHandlerMapping和 一个AnnotationMethodHandlerAdapter实例 这两个实例分别在类级别和方法级别处理 而 annotation-driven 配置帮助我们自完成这两个实例的注入 --> <mvc:annotation-driven/> <!-- 视图解析器 --> <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/jsp/"/> <property name="suffix" value=".jsp"/> </bean> </beans>在这里面的代码中，除了第一句扫描包需要按照对应的项目修改，下面的代码都是固定的，在实际开发中也是这样的，不需要再去改动了
-
编写Controller（正常开发我们是不用去写接口的）
import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.RequestMapping; @Controller // 自动被扫描生效，不用再去配置bean // @RequestMapping("/HelloController") // 表示这个类的映射为： /HelloController public class HelloController { // 这个方法实际上就是一个请求，处理对应请求只要增加对应的方法即可 @RequestMapping("/hello") // 这是处理请求地址映射的注解 // 这里表示这个方法的映射为： /hello // 真实访问路径为： localhost:8080/projectName/hello public String hello(Model model){ // 通过Model封装数据，可以在jsp页面中直接取出并且渲染 model.addAttribute("msg","Hello,SpringMVC-Annotation"); return "hello"; // 这个 return 的结果，会被视图解析器处理 // /WEB-INF/jsp/hello.jsp } } -
创建视图层hello.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Title</title> </head> <body> ${msg} </body> </html> -
配置Tomcatÿ
最低0.47元/天 解锁文章
1294
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
