SpringMVC详解(一)概述

2023-01-09 11:18:27

文章目录

第一章 SpringMVC概述

1.SpringMVC基本说明

SpringMVC是基于Spring的，是Spring中的一个模块，做web开发使用的。springmvc叫做**spring web mvc **说明它是spring的核心技术，做web开发，springmvc内部使用的是mvc架构模式。

mybatis 是数据访问层，Spring 是 业务逻辑层 用户界面层是视图和控制器。

SpringMVC是一个·容器，管理对象的，使用loC核心技术。springmvc管理界面层中的控制器对象。springmvc底层也是Servlet. 以servlet为核心，接收请求，处理请求。显示处理结果给用户。

处理用户的请求：

用户发起请求 ----SpringMVC ---->Spring ----MyBatis ---- mysql 数据库

2. SpringMVC中的核心Servlet --DispatcherServlet

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

DispatcherServlet 它的父类是HttpServlet。

DispatcherServlet 也叫做前端控制器（front controller）。

SpringMVC是管理控制器对象，原来是没有SpringMVC之前 使用 Servlet 作为控制器对象使用。现在通过SpringMVC容器创建一种叫做控制器的对象，代替Servlet行使控制器的角色。功能。

SpringMVC主要使用注解的方式创建。

idea2019自动生成的web.xml不支持el表达式 格式替换为

<?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">
  
</web-app>

请添加图片描述
请添加图片描述

3 springmvc请求的处理过程

简单的处理过程：

用户发起请求some.do—>Tomcat接收了请求 —> DispatcherServlet ----分配MyController(doSome()返回mv对象)—显示给用户了。

省略tomcat

用户some.do-----DispatcherServlet-------MyController

多了DispatcherServlet 才能在请求中增加功能。

如果使用servlet处理请求

用户发起请求-------没有其他对象------------Servlet

PS: WEB-INF 是受保护的目录，浏览器是无法访问的。在项目中受保护页面可能非常多，可以新建子包来存储受保护的页面文件 比如包名为“jsp”

http://localhost:8080/ch01_springmvc/WEB-INF/view/show.jsp 这个网址在浏览器中不能访问

http://localhost:8080/ch01_springmvc/index.jsp 点击超链接跳转到 http://localhost:8080/ch01_springmvc/some.do展示的页面就是/WEB-INF/view/show.jsp

实例

请添加图片描述

index.jsp 中包含index.jsp 中有 some.do other.do add.do 控制器

DispatherServlet中央调度器（收集请求） 他是一个Servlet对象 有doGet doPost service() init() 将请求分派给控制器。

MyConroller控制器 对应some.do other.do

StudentController控制器 add.do

1. index.jsp

请添加图片描述

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>第一个springmvc</title>
</head>
<body>
    <a href="some.do">发起some.do的请求</a>
    <br/>
    <a href="test/second.do">/test/second.do</a>
    <br/>
    <a href="add.do">add.do请求</a>
</body>
</html>

2. other.jsp

请添加图片描述

"show.jsp"对应了controller 中的ModelAndView（视图解析器）中的 mv.setViewName(“show”);也就是说当Controller收到请求后，进行处理，处理完成跳转 show.jsp。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>show</title>
</head>

    /WEB-INF/view/other.jsp,显示request作用域中的数据<br/>
    <H3>msg数据： ${msg}</H3>
    <h3>fun数据： ${fun}</h3>

</body>
</html>

3.MyController

package com.sunny.controller;

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


 * @Controller: 创建控制器（处理器）对象
 *      控制器：叫做后端控制器 （back controller）,自定义的类处理请求的。
 *      位置 ： 在类的上面，表示创建此类的对象，对象放在springmvc的容器中。
 * */
@Controller
public class MyController {
//    定义方法，处理请求。

    
     * springmvc框架，使用控制器类中的方法，处理请求。
     * 方法的特点：
     * 1.方法的形参，表示请求中的参数
     * 2.方法的返回值，表示本次请求的处理结果
     * */

  
     * @RequestMapping:请求映射
     *              属性：value 请求中的uri地址，唯一值，以“/”开头。
     *              位置：1.在方法的上面（必须的） 2.在类定义的上面（可选）
     *              作用：把指定的请求，交给指定的方法处理，等同于url-pattern
     *
     *返回值 ModelAndView ：表示本次请求的处理结果（数据和视图）
     *      Model:表示数据
     *      View：表示视图
     *
     * */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(){  //doGet()
        System.out.println("执行了MyController的doSome方法");
//        使用这个方法处理请求。能处理请求的方法叫做控制器方法
//        调用service对象，处理请求，返回数据
        ModelAndView mv = new ModelAndView();
//        添加数据
        mv.addObject("msg","处理了some.do请求");
        mv.addObject("fun","执行了doSome方法");

//        指定视图,setViewName("视图的完整路径")
//        mv.setViewName("/WEB-INF/view/show.jsp");
//        mv.setViewName("/WEB-INF/view/other.jsp");

//        当配置了视图解析器，使用文件名称作为视图名使用，叫做视图逻辑名称。
//        使用了逻辑名称，框架使用配置文件中视图解析器的前缀和后缀，拼接为完整视图路径
//        /WEB-INF/view/   +  show   +  .jsp
        mv.setViewName("show");

//        返回结果
        return mv;

    }
 
     * 当框架调用完doSome()方法后，得到返回中ModelAndView.
     * 框架会在后续的处理逻辑值  处理mv对象里面的数据和视图。
     * 对数据执行 mv.addObject("msg","处理了some.do请求"); 把数据放入到request作用域。
     * 对视图执行forward转发操作。等同于 request.getRequestDispather("/show.jsp").forward(..)
     * */
    @RequestMapping(value = {"/other.do","/test/second.do"})
    public ModelAndView doOther(){  //doGet()
        System.out.println("执行了MyController的doSome方法");
//        使用这个方法处理请求。能处理请求的方法叫做控制器方法
//        调用service对象，处理请求，返回数据
        ModelAndView mv = new ModelAndView();
//        添加数据
        mv.addObject("msg","处理了other.do请求");
        mv.addObject("fun","执行了doOther方法");


        mv.setViewName("other");

//        返回结果
        return mv;

    }
}

4.StudentConroller

package com.sunny.controller;

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

@Controller
public class StudentController {

    @RequestMapping(value = "/add.do")
    public ModelAndView addStudent(){
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","注册成功");
        mv.setViewName("show");
        return mv;
    }
}

4.复习

复习：使用springmvc做web项目 首先加依赖，加入springmvc的依赖就已经把spring其他的依赖加进来了，因为springmvc就是spring的一个模块，把servlet交给了springmvc容器进行管理。这里提到了中央调度器。

DispatcherServlet作用：

1.在init()中创建springmvc的容器对象 WebApplicationContext。创建springmvc配置文件种的所有java对象，java对象就是Controller对象。

2.DispatcherServlet是一个Servlet，能够接收请求。

用户发起some.do—DispatcherServlet(Servlet接收请求) —转给MyController

模拟中央调度器的代码。

public class DispatcherServlet extends HttpServlet{
    
    public void service(HttpServletRequest request,HttpServletResponse response){
        if("some.do".equals(request.getURI() ) ){
            //从容器中获取MyController
            MyController c = ctx.getBean("some");
            c.doSome();
        }else if("other.do".equals( request.getURI() ) ){
            OtherController c = ctx.getBean("some");
            c.doOther();
        }
    }
}

5.web开发中配置文件的说明

  1. web.xml 部署描述符文件，给服务器（tomcat）。

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

  2. 框架的配置文件，springmvc的配置文件

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

配置文件的加载顺序和功能

1.tomcat服务器启动，读取web.xml。根据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">
<!--    声明springmvc的核心对象
        访问mymvc地址后，报错 文件没有找到，找的文件/WEB-INF/springmvc-servlet.xml
                                                /WEB-INF/myweb-servlet.xml
        错误原因：
            在Servlet的init()方法中，创建springmvc使用的容器对象WebApplicationContext.
            WebApplicationContext ctx = new ClassPathXmlApplicationContext("配置文件");

            1.配置文件的默认路径： /WEB-INF/<servlet-name>-servlet.xml-->
    <servlet>
      <servlet-name>myweb</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--        2.自定义配置文件的位置-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
<!--
         表示服务器tomcat创建对象的顺序，是个整数值，大于等于0.
         数值越小，创建对象的时间越早。
-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
      <servlet-name>myweb</servlet-name>
<!--
        url-pattern 作用：把一些请求交给指定的servlet处理
        使用中央调度器（DispatcherServlet）
        1.使用拓展名方式，格式 *.xxx，xxx是自定义的拓展名。
          例如 *.do , *.action, *.mvc 等等。 不能使用*.jsp
            <url-pattern>*.do</url-pattern>
            http://localhost:8080/myweb/some.do
            http://localhost:8080/myweb/user/list/queryUser.do

        2.使用斜杠 “/”
            <url-pattern>/mymvc</url-pattern>
-->
      <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

创建DispatcherServlet他的对象，会执行init()方法。在init()方法中会执行springmvc容器对象创建，WebApplicationContext ctx = new ClassPathXmlApplicationContext(“classpath:springmvc.xml”);

  1. springmvc框架，new ClassPathXmlApplicationContext() 读取springmvc的配置文件。
<!--    springmvc的配置文件-->
<!--    声明组件扫描器-->
    <context:component-scan base-package="com.bjpowernode.controller"/>
<!--    声明视图解析器：帮助处理视图-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--        前缀：指定视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/"/>
<!--        后缀：视图文件的拓展名-->
        <property name="suffix" value=".jsp"/>
    </bean>

使用组件扫描器 base-package=“com.bjpowernode.controller” ，遍历controller包中的所有类，MyController类，找到这个类中的@Controller , @RequestMapping注解，就能创建MyController对象。直到some.do的请求执行doSome()方法。

以上 1,2都是项目启动的过程，没有执行任何的用户请求。

3.用户发起请求some.do------>DispatcherServlet

DispatcherServlet 里面有WebApplicationContext。WebApplicationContext里面有MyController对象。

请求some.do，DispatcherServlet 就知道 MyController处理的。

6.SpringMVC内部的执行流程

这个流程对于从事开发工作或者长期使用框架的人比较好理解。对于刚学习框架的人比较难理解，但是执行流程在面试的时候可能会问。不过很少会问。

有一到两年的框架使用经验后，对这个流程可能会有比较深入的理解。

6.1.springmvc内部请求的处理过程

  1. 用户发起请求给DispatcherServlet

  2. DispatcherServlet把请求（request）交给了处理器的映射器。

    处理器映射器：springmvc框架中的对象，需要实现HandleMapping接口。

    映射器的作用：从springmvc容器中，获取控制器对象（MyController）,把找到的控制器和拦截器对象都放到处理器 执行链对象中，保存，并返回给中央调度器。（MyController controller = ApplicationContext.getBean() ）

  3. DispatcherServlet把回去到的处理器执行链中的控制器对象，交给了处理器适配器。

    处理器适配器：是springmvc框架中的对象，实现HandlerAdapter接口。

    适配器的作用 ：执行控制器的方法，也就是执行MyController.doSome()方法。得到结果ModelAndView。

  4. DispatcherServlet把控制器执行结果mv交给了视图解析器。

    视图解析器：springmvc中的对象，需要实现ViewResolver接口。

    视图解析器的作用：处理视图的，组成视图的完整路径。能创建View类型的对象。

  5. DispatcherServlet调用View类的方法，把Model中的数据放入到request作用域。执行request.setAttribute()，对视图执行forward()转发行为，request.getRequestDispather("/show.jsp").forward(request,response)

  • 作者：小高写BUG
  • 原文链接：https://blog.csdn.net/gao1213977085/article/details/121056468
    更新时间：2023-01-09 11:18:27