SpringMVC框架入门(一)

最新推荐文章于 2023-09-09 18:57:22 发布

xxyneymar

最新推荐文章于 2023-09-09 18:57:22 发布

阅读量204

点赞数 1

分类专栏： java框架文章标签： springmvc

本文链接：https://blog.csdn.net/xxyneymar/article/details/121104038

版权

java框架专栏收录该内容

28 篇文章 3 订阅

订阅专栏

1.1.3 中央调度器DispatcherServlet

1.2 第一个SpringMVC例子

1.2.1 项目介绍及步骤

1.2.2 创建一个maven项目

1.2.3 在pom.xml文件中加入依赖

1.2.4 注册中央调度器

1.2.5 创建前端页面

1.2.6 创建Controller对象

1.2.7 创建SpringMVC配置文件

1.2.8 springmvc请求处理过程

1.2.9 SpringMVC执行过程的源代码简单分析

1.3 SpringMVC的MVC组件

1.4 SpringMVC的执行流程

第一章、SpringMVC概述

1.1 SpringMVC简介

1.1.1 介绍

SpringMVC也叫Spring web mvc，是Spring框架的一部分，是在Spring3.0后发布的，专门是做web开发的。web开发的底层是servlet，框架是在servlet基础上加一些功能，让开发人员做web开发更方便，因此也可以将SpringMVC理解成servlet的一个升级。

SpringMVC就是一个Spring，Spring是容器，ioc能够管理对象，使用<bean>、 @Component、 @Repository、 @Service、@Controller等来创建对象。SpringMVC也能够创建对象，放入到SpringMVC容器中，SpringMVC容器中放的是控制器对象。

我们要做的是使用@Contorller创建控制器对象，把对象放入到springmvc容器中，把创建的对象作为控制器使用，这个控制器对象能接收用户的请求，显示处理结果，就当做是一个servlet使用即可。但是注意使用@Controller注解创建的是一个普通类的对象，不是Servlet。springmvc赋予了控制器对象一些额外的功能。

web开发底层是servlet， springmvc中有一个对象是Servlet ： DispatcherServlet(中央调度器)

DispatcherServlet：负责接收用户的所有请求，用户把请求给了DispatcherServlet，之后

DispatherServlet把请求转发给我们的Controller对象，最后是Controller

对象处理请求。

1.1.2 SpringMVC优点

①基于MVC架构，功能分工明确，解耦合；

②容易理解，上手快，使用简单。也是轻量级的，jar包很小。不依赖特定的接口和类。

③作为Spring框架的一部分，能够使用Spring的IoC和AOP，方便整合Struts、MyBatis、Hibernate、JPA 等其他框架；

④SpringMVC强化注解的使用，在控制器、Service、Dao都可以使用注解，方便灵活。使用@Controller创建处理器对象，@Service创建业务对象，@Autowired或者@Resource在控制器类中注入 Service，Service 类中注入 Dao。

1.1.3 中央调度器DispatcherServlet

1.DispatcherServlet叫做中央调度器，是一个servlet，它的父类是继承HttpServlet；

2.DispatcherServlet也叫做前端控制器(front Controller)；

3.DispatcherServlet负责接收用户提交的请求，调用其他的控制器对象，并把请求的处理结果显示给用户。

1.2 第一个SpringMVC例子

1.2.1 项目介绍及步骤

需求：在用户页面发起一个请求，请求交给springmvc的控制器对象，并显示请求的处理结果(在结果页面显示一个欢迎语句)。

步骤：

①新建web maven工程；

②加入依赖：spring-webmvc依赖(这个依赖间接把spring的依赖都加入到项目)、jsp、

servlet依赖；

③在web.xml文件中注册springmvc框架的核心对象DispatcherServlet；

④创建一个发起请求的页面index.jsp；

⑤创建控制器类：在类的上面加入@Controller注解，创建对象，并放入到springmvc容器

中；在类中的方法上加入@RequestMapping注解；

⑥创建一个作为结果的jsp文件，显示请求的处理结果；

⑦创建springmvc的配置文件(和spring的配置文件一样)：声明组件扫描器，指定@Controller

注解所在的包名；声明视图解析器，帮助处理视图的。

1.2.2 创建一个maven项目

选择maven-archetype-webapp。

1.2.3 在pom.xml文件中加入依赖

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>
    <!--servlet依赖-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>
    <!--springmvc依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.5.RELEASE</version>
    </dependency>
</dependencies>

1.2.4 注册中央调度器

<?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的核心对象DispatcherServlet
        需要在tomcat服务器启动后，创建DispatcherServlet对象的实例。
        为什么要创建DispatcherServlet对象的实例呢？
           因为DispatcherServlet在他的创建过程中，会同时创建springmvc容器对象，
           读取springmvc的配置文件，把这个配置文件中的对象都创建好，当用户发起
           请求时就可以直接使用对象了。

        servlet的初始化会执行init()方法。DispatcherServlet在init()中{
            //创建容器，读取配置文件
            WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
            //把容器对象放入到ServletContext全局作用域对象中
            getServletContext().setAttribute(key,ctx);
        }

        启动tomcat报错，需要读取这个文件：/WEB-INF/springmvc-servlet.xml(/WEB-INF/myWeb-servlet.xml)
        springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml
    -->
    <servlet>
        <servlet-name>myWeb</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--自定义springmvc读取的配置文件的位置-->
        <init-param>
            <!--springmvc的配置文件的位置的属性-->
            <param-name>contextConfigLocation</param-name>
            <!--指定自定义文件的位置-->
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>

        <!--在tomcat启动后，创建Servlet对象
            load-on-startup：表示tomcat启动后创建对象的顺序。它的值是整数，数值越小，
                             tomcat创建对象的时间越早。是大于等于0的整数。
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>myWeb</servlet-name>
        <!--
            使用框架的时候，url-pattern可以使用两种值
            1.使用扩展名方式，语法*.xxxx，xxxx是自定义的扩展名。常用的方式 *.do, *.action, *.mvc等等
              http://localhost:8080/myWeb/some.do
              http://localhost:8080/myWeb/other.do

            2.使用斜杠"/"
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>


</web-app>

1.2.5 创建前端页面

文件夹存储结构：WEB-INF下的文件对用户是不开放的，用户无法访问。

index.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <p>第一个springmvc项目</p>
    <p><a href="some.do">发起some.do的请求</a></p>
    <p><a href="other.do">发起other.do的请求</a></p>
</body>
</html>

show.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>/WEB-INF/view/show.jsp从request作用域获取数据</h3>
    <h3>msg数据：${msg}</h3>
    <h3>fun数据：${fun}</h3>
</body>
</html>

other.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>WEB-INF/view/other.jsp从request作用域获取数据</h3>
    <h3>msg数据：${msg}</h3>
    <h3>fun数据：${fun}</h3>
</body>
</html>

1.2.6 创建Controller对象

package com.bjpowernode.controller;

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


/**
 * @Controller：创建处理器对象，对象放在springmvc容器中
 * 位置：在类的上面
 * 和spring中讲的@Service，@Component一样
 *
 * 能处理请求的都是控制器(处理器)：MyController能处理请求，叫做后端控制器(back controller)
 */
@Controller
public class MyController {
    /*
        处理用户提交的请求，springmvc中是使用方法来处理的。
        方法是自定义的，可以有多种返回值，多种参数，方法名称自定义
     */

    /**
     * 准备使用doSome方法处理some.do请求。
     * @RequestMapping： 请求映射，作用是把一个请求地址和一个方法绑定在一起。
     *                   一个请求指定一个方法处理。
     * 属性：1.value 是一个String数组，表示请求的uri地址的。（some.do）
     *              value的值必须是唯一的，不能重复。在使用时推荐地址以"/"开头【唯一指请求中只有一个some.do地址】
     * 位置：1.在方法的上面，常用的。
     *      2.在类的上面
     * 说明：使用RequestMapping修饰的方法叫做处理器方法或者控制器方法。
     * 使用@RequestMapping修饰的方法可以处理请求的，类似Servlet中的doGet，doPost
     *
     * 返回值：ModelAndView 表示本次请求的处理结果
     *   Model：数据，请求处理完成后，要显示给用户的数据
     *    View：视图，比如jsp等
     */
    @RequestMapping(value = {"/some.do","/first.do"})
    public ModelAndView doSome(){//doGet()---调用service请求处理
        //处理some.do请求了。相当于service调用处理完成了
        ModelAndView mv = new ModelAndView();
        //添加数据，框架在请求的最后把数据放入到request作用域
        //相当于request.setAttribute("msg","欢迎使用springmvc做web开发");
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");

        //指定视图，指定视图的完整路径
        //框架对视图执行的forward操作，相当于request.getRequestDispacher("/show.jsp").forward(request,response);
        //mv.setViewName("/show.jsp");
        //mv.setViewName("/WEB-INF/view/show.jsp");

        //当配置了视图解析器后，可以使用逻辑名称(文件名)，指定视图
        //框架会使用视图解析器的 前缀 + 逻辑名称 + 后缀 组成完整路径，这就是字符串连接操作
        ///WEB-INF/view/ + show + .jsp
        mv.setViewName("show");

        //返回mv
        return mv;
    }

    @RequestMapping(value = {"/other.do","/second.do"})
    public ModelAndView doOther(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doOther方法");
        mv.setViewName("other");
        return mv;
    }
}

1.2.7 创建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"
       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"/>

    <!--声明springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀：视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/"/>
        <!--后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

1.2.8 springmvc请求处理过程

请求处理过程：

①发起some.do；

②tomcat根据web.xml--url-pattern知道 *.do的请求要交给DispatcherServlet

③DispatcherServlet根据springmvc.xml配置知道 some.do---doSome()方法

④DispatcherServlet把some.do转发给MyController.doSome()方法

⑤框架执行doSome()把得到的ModelAndView进行处理，转发到show.jsp

1.2.9 SpringMVC执行过程的源代码简单分析

1.Tomcat服务器启动，创建容器的过程。

通过load-on-start标签指定的1，创建DispatcherServlet对象，DisaptcherServlet它的父类是

继承HttpServlet的，它是一个serlvet，在被创建时，会执行init()方法。

在init()方法中：

//创建容器，读取配置文件

WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");

//把容器对象放入到ServletContext中

getServletContext().setAttribute(key, ctx);

上面创建容器作用：创建@Controller注解所在的类的对象，创建MyController对象，这个对

象放入到springmvc的容器中，容器是map，类似map.put("myController",MyController对象);

2.请求的处理过程。

执行servlet的service()方法：

protected void service(HttpServletRequest request, HttpServletResponse response)

protected void doService(HttpServletRequest request, HttpServletResponse response)

DispatcherServlet.doDispatch(request, response){

调用MyController的.doSome()方法

}

doDispatch：springmvc中DispatcherServlet的核心方法，所有的请求都在这个方法中完成

的。

1.3 SpringMVC的MVC组件

1.4 SpringMVC的执行流程

执行流程简单分析：

1.浏览器提交请求到中央调度器；

2.中央调度器直接将请求转给处理器映射器；

3.处理器映射器会根据请求，找到处理该请求的处理器，并将其封装为处理器执行链后返回给

中央调度器；

4.中央调度器根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器；

5.处理器适配器调用执行处理器；

6.处理器将处理结果及要跳转的视图封装到一个对象ModelAndView中，并将其返回给处理器

适配器；

7.处理器适配器直接将结果返回给中央调度器；

8.中央调度器调用视图解析器，将ModelAndView中的视图名称封装为视图对象；

9.视图解析器将封装了的视图对象返回给中央调度器；

10.中央调度器调用视图对象，让其自己进行渲染，即进行数据填充，形成响应对象；

11.中央调度器响应浏览器。

PS：根据动力节点课程整理，如有侵权，联系删除。

xxyneymar

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC框架入门(一)

第一章、SpringMVC概述1.1 SpringMVC简介1.1.1 介绍 SpringMVC也叫Spring web mvc，是Spring框架的一部分，是在Spring3.0后发布的，专门是做web开发的。web开发的底层是servlet，框架是在servlet基础上加一些功能，让开发人员做web开发更方便，因此也可以将SpringMVC理解成servlet的一个升级。 SpringMVC就是一个Spring，Spring是容器，ioc能够管理对象，使用<bean>...
复制链接

扫一扫