SpringMVC笔记

本文详细介绍了SpringMVC在SSM(Spring、SpringMVC、Mybatis)框架中的作用,以及Model1和Model2的演变过程。SpringMVC作为轻量级Web框架,其核心是DispatcherServlet,它负责请求分发。文章通过一个简单的Servlet实例解释了MVC模式,接着探讨了SpringMVC的执行原理和流程,强调了其与Spring的无缝集成。此外,还展示了如何配置SpringMVC,包括配置版和注解版的区别。最后,文章总结了使用SpringMVC所需配置的组件,并指出SpringMVC简化了传统MVC框架的配置和使用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

SpringMVC

ssm:Mybatis+Spring+SpringMVC

SpringMVC+Vue+SpringBoot+SpringCloud+Linux

SSM:JavaWeb做项目

Spring:IOC+AOP

SpringMVC:SpringMVC的执行流程(理论,面试要点)

SpringMVC:SSM框架整合(实践)

1 回顾MVC

1.1 回顾MVC

MVC:模型(dao,service) 视图(jsp)控制器(Servlet)

dao层:连接数据库

service层:调用dao层,执行一些具体的业务代码

servlet:接收前端数据,把数据和业务请求交给service层去处理,接收返回的数据并进行页面跳转(注意转发和重定向)

jsp/html

前端 数据传输 实体类(

【注意】前端传输的字段不一定包含pojo的所有属性,但是面向对象打交道是一般是使用一个pojo

实体类:用户名,密码,生日,爱好…约20个

前端:用户名, 密码

pojo:User

vo(视图层对象):UserVo 相当于为前端再封装了一个对象,还是实体类

  • MVC是模型(Model)、视图(View)、控制器(Controller)的简写,是一种软件设计规范
  • 是将业务逻辑、数据、显示分离的方法来组织代码。
  • MVC主要作用是降低了视图与业务逻辑间的双向耦合。
  • MVC不是一种设计模式,MVC是一种架构模式。当然不同的MVC存在差异。

Model(模型):数据模型,提供要在展示的数据,包含数据和行为,现在分为dao层数据库连接和sql操作,service层负责具体业务逻辑的处理。模型提供了“模型数据查询”和“模型数据的状态更新”,包括数据与业务。

**View(视图):**负责模型数据的展示,界面展示

**Controller(控制器):**接收用户请求,将请求委托给model层进行处理;处理完毕后把返回的模型数据飞View层进行渲染展示(即调整到view层)。也即是说controller做了一个调度员的工作。

最典型的MVC模型就是:JSP+Servlet+JavaBean模式

image-20210906140317676

JSP:本质就是一个Servlet

假设一个面试问题:你的项目的架构,是设计好的,还是演进的?

回答:演进的

Alibaba,刚开始PHP

用户量过高,开始用Java

王坚 去IOE MySQL

MySQL:MySQL==>ALiSQL、AliRedis

All in one==>微服务

1.2 Model1时代

在web早期的开发中,通常采用的都是Model1

Model1中,主要分为两层,视图层和模型层(将controller层和model层混在一起了)

image-20210906141522375

Model1优点:架构简单,比较适合小型项目开发

Model1缺点:JSP职责不单一,职责过重,不便于维护

1.3 Model2时代

Model2把项目分为三部分,包括view,controller、model

image-20210906141909751

  1. 用户发送请求
  2. servlet接收请求数据,并调用对应的业务逻辑方法
  3. 业务处理完毕,返回更新后的数据给Servlet
  4. Servlet转向JSP,由JSP来渲染页面
  5. 响应给前端更新后的页面

职责分析:

Controller:

  1. 取得表单数据
  2. 调用业务逻辑
  3. 转向指定的页面

Model:

  1. 业务逻辑
  2. 保存数据的状态

View:

  1. 显示页面

Model2这样不仅提高了代码的复用率与项目的扩展性,且大大降低了项目的维护成本。

Model1实现模式比较简单,适用于快速开发小规模项目,Model1中JSP页面身兼View和controller两种角色,将控制逻辑和表现逻辑混杂在一起,从而导致代码的重用性非常低,增加了应用的扩展性和维护的难度。

Model2消除了Model1的缺点。

1.4 回顾Servlet

结构:

image-20210906150901884

1.创建一个普通的maven项目,一个父工程可以完成所有的事情

删除src、提前导入公共pom依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.kuang</groupId>
    <artifactId>springMVC</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>springmvc-01-servlet</module>
    </modules>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>

        </dependency>


        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.5</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>

        </dependency>

        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/jsp-api -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>

        </dependency>


        <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

    </dependencies>

</project>

2.创建子模块Moudle:依旧创建普通项目springmvc-01-servlet,添加Web-app框架支持

3.子模块的pom文件中,导入servlet和jsp的jar依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springMVC</artifactId>
        <groupId>com.kuang</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springmvc-01-servlet</artifactId>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>

        </dependency>

        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/jsp-api -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>

    </dependencies>

</project>

4.编写一个Servlet类,用来处理用户的请求

package com.kuang.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

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);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       doGet(req, resp);
    }
}

5.编写text.jsp,在WEB-INF目录下新建一个jsp的文件夹,新建text.jsp

<%--
  Created by IntelliJ IDEA.
  User: liujie
  Date: 2021/9/6
  Time: 14:55
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>处理结果</title>
</head>
<body>
${msg}
</body>
</html>

6.在web.xml中注册Servlet

<?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.kuang.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

<!--    <session-config>-->
<!--        <session-timeout>15</session-timeout>-->
<!--    </session-config>-->
<!--    -->
<!--    <welcome-file-list>-->
<!--        <welcome-file>index.jsp</welcome-file>-->
<!--    </welcome-file-list>-->
</web-app>

7.配置Tomcat,并启动测试

localhost:8080/user?method=add
localhost:8080/user?method=delete

image-20210906150400998

MVC框架要做的事情

  1. 将url映射到java类或者java类的方法
  2. 封装用户提交的数据
  3. 处理请求-调用相关的业务逻辑-封装响应数据
  4. 将响应的数据进行渲染,jsp/html等表示层数据

说明:

  • 常见的服务器端MVC框架有:Struts、SpringMVC、ASP.NET MVC、Zend framework、JSP;
  • 常见前端MVC框架:vue、angularjs、react、backbone
  • 由MVC演化出的另外一些模式如:MVP、MVVM等等(MVVM:M V VM==>ViewModel双向绑定)

2 什么是SpringMVC

2.1 概述

SpringMVC是Spring Framework的一部分,是基于Java实现的MVC轻量级Web框架。

底层还是Servlet

SpringMVC官网地址:

https://docs.spring.io/spring-framework/docs/current/reference/html/web.html

Spring MVC的特点

  1. 轻量级,简单易学

  2. 高效,基于请求响应的MVC框架

  3. 与Spring的兼容性好,无缝结合

    Spring:大杂烩,我们可以将SpringMVC中所有要用到的bean,注册到Spring中;

  4. 约定大于配置

  5. 功能强大:RESTful(就是网址中没有用问号传,用的是斜线)、数据验证、格式化、本地化、主题等

  6. 简洁灵活

Spring的web框架围绕DispatcherServlet(调度Servlet)设计

DispatcherServlet的作用是将请求分发到不同的处理器。从Spring2.5开始,使用java5或者以上版本的用户可以采用基于注解形式进行开发,十分简洁;

正因为SpringMVC好,简单,便捷,医学,天生和Spring无缝集成(使用其IOC和AOP),使用约定大于配置,能够进行简单的junit测试,支持Restful风格,异常处理,本地化,国际化,数据验证,类型转换,拦截器等等……所以我们要学习

最重要的是用的人多,使用的公司多

2.2 中心控制器

  • Spring的web框架围绕DispatcherServlet【调度Servlet】设计。

    DispatcherServlet的作用是将请求分发到不同的的处理器(Servlet类及其方法)。

    从Spring2.5开始,使用Java5或者以上版本的用户可以采用基于注解的controller声明方式。

  • SpringMVC框架向许多其他MVC框架一样,以请求为驱动,围绕一个中心Servlet分派请求及提供其他功能,DispatcherServlet实际上也是一个Servlet(它继承自HttpServlet父类)

image-20210906155527314

image-20210906200551980

SpringMVC的原理如下图所示:

  • 当发起请求时被前置控制器拦截到请求,根据请求参数生成代理请求,找到请求对应的实际控制器;

  • 控制器处理请求,创建ModelAndView(访问数据库,选择视图),将ModelAndView返回给中心控制器;

  • 中心控制器使用视图解析器,选择视图+渲染数据,将结果返回给中心控制器

  • 中心控制器将结果返回给请求者

    image-20210906201314240

2.3 SpringMVC执行原理

image-20210906202124143

图为SpringMVC的一个较为完整的流程图,实线表示SpringMVC框架提供的技术,不需要开发者实现;

虚线表示需要开发者实现:

  • Controller业务逻辑+数据库访问+返回ModelAndView
  • 具体前端页面书写

简单分析执行流程:

  1. DispatcherServlet表示前置控制器,中心控制器,是整个SpringMVC的控制中心。用户发出请求,DispatcherServlet接收请求并拦截请求。

    我们假设请求的url为:http://localhost:8080/SpringMVC/hello

    如上url拆分为三部分:

    http://localhost:8080 :服务器域名

    SpringMVC:部署在服务器上的web站点,可以Tomcat中配置

    hello:表示控制器

    通过分析,如上url表示为:请求 位于服务器localhost:8080上的,SpringMVC站点上的,hello控制器。

  2. HandlerMapping为处理器映射。

    DispatcherServlet调用HandlerMapping;HanderMapping根据请求的url查找HanderExecution;HanderExecution根据url寻找controller;如上url查找到的controller为:hello;

    将解析到的controller信息返回给DispatcherServlet

  3. HandlerAdapter表示处理器适配器,将按照特定的规则去执行Handler。

    Handler让具体的controller执行。

    controller执行业务逻辑+访问数据库,返回ModelAndView给HandlerAdapter,再返回给中心控制器;

  4. 中心控制器将ModelAndView给视图解析器ViewResolver,选择视图+渲染数据;将最终视图返回给中心控制器,中期控制器再返回给请求者。

3 HelloSpring

3.1 配置版

项目结构:

image-20210906195832029

  1. 新建一个Moudle,springmvc-02-hello,添加web支持

  2. 确定导入一个SpringMVC的依赖!

  3. 配置veb.xml,注册Dispatcherservlet

    <?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">
        <!--配置DispatcherServlet:这个类是SpringMVC的核心;请求分发器,前端控制器-->
        <servlet>
            <servlet-name>springmvc</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <!--DispatcherServlet必须要绑定Spring的配置文件,关联一个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>
    
    
  4. 在Resources目录下,编写SpringMVC配置文件,springmvc-servlet.xml:【servletname】-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">
        <!--1.处理器映射器:DispatcherController根据请求url找Controller名称-->
        <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
        <!--2.处理器适配器:适配连接具体的Controller,进行业务处理-->
        <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    
        <!--3.视图解析器:DispatcherServlet返回的ModelAndView都需要经过视图解析器
        1.获取了ModelAndView的数据
        2.解析了ModelAndView的视图名字
        3.拼接视图名字,找到了对应的视图 /WEB-INF/jsp/hello.jsp
        4.将数据渲染到这个视图上
        后面可以用模板引擎:ThymeLeaf Freemarker...-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
            <!--前缀-->
            <property name="prefix" value="/WEB-INF/jsp/"/>
            <!--前缀-->
            <property name="suffix" value=".jsp"/>
        </bean>
    
    
        <!--BeanNameUrlHandlerMapping处理器映射器,需要配置Controller的bean-->
        <bean id="/hello" class="com.kuang.controller.HelloController"/>
    
    </beans>
    
    
  5. 在java目录下新建com.kuang.controller包,新建HelloController类;

    编写我们要操作业务的Controller,要么实现Controller接口,要么增加注解;

    需要返回一个ModelAndView,装数据,封视图

    package com.kuang.controller;
    
    import org.springframework.web.servlet.ModelAndView;
    import org.springframework.web.servlet.mvc.Controller;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    //Controller:专心写业务
    //注意:这里我们先导入Controller接口
    //Controll
    public class HelloController implements Controller {
    
        public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
            //ModelAndView 模型和视图
            ModelAndView mv = new ModelAndView();
    
            //1.业务代码
            //封装对象,放在ModelAndView中。Model
            mv.addObject("msg","HelloSpringMVC!");
    
            //2.跳转视图,设置视图的名字就可以了
            //封装要跳转的视图,放在ModelAndView中
            mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
    
            return mv;
        }
    }
    
    
  6. 写要跳转的jsp页面,显示ModelAndView存放的数据,以及我们的正常页面

    hello.jsp

    --%>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    ${msg}
    </body>
    </html>
    
  7. 配置Tomcat,启动测试

    image-20210906184732259

可能遇到的问题,访问出现404,排查步骤:

  1. 查看控制台输出,看一下是不是缺少什么jar包

  2. 如果jar包存在,显示无法输出,就在idea的项目发布中,添加lib依赖

    image-20210906184928689

  3. 重启Tomcat即可解决

3.2 注解版

结构:

image-20210906215326855

  1. 新建一个Moudle,springmvc-03-annotation,添加web支持

  2. 由于maven可能存在资源过滤的问题,我们将配置完善

    <build>
            <resources>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.properties</include>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>false</filtering>
                </resource>
                <resource>
                    <directory>src/main/resources</directory>
                    <includes>
                        <include>**/*.properties</include>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>false</filtering>
                </resource>
            </resources>
        </build>
    
    
  3. 在pom.xml文件中引入相关的依赖:主要有Spring框架核心库、Spring MVC、servlet、jstl等,我们在父依赖中已经引入了!

  4. 配置web.xml——注册DispatcherServlet,一次配置无需改变

    注意点:

    • 注意web.xml版本问题,要最新版
    • 注意DispatcherServlet
    • 关联SpringMVC的配置文件
    • 启动级别为1
    • 映射路径为/【不要用/*,会404】
    <?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">
        <!--配置DispatcherServlet:这个类是SpringMVC的核心;请求分发器,前端控制器-->
        <servlet>
            <servlet-name>springmvc</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <!--DispatcherServlet必须要绑定Spring的配置文件,关联一个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>
    
  5. 在resources目录下添加SpringMVC的配置文件:springmvc-servlet.xml,一次配置,无需改变

    • 让IOC的注解生效
    • 静态资源过滤:HTML,JS,CSS,图片,视频
    • MVC的注解驱动,自动装配
    • 配置视图解析器

    在resources目录下添加springmvc-servlet.xml配置文件,配置的形式与Spring容器配置基本相似,为了支持基于注解的IOC,设置了自动扫描包的功能。

    <?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">
    
        <!--1.自动扫描包,让指定包下的注解生效,由IOC容器统一管理,实现了自动装配,无需再手动注册具体controller-->
        <context:component-scan base-package="com.kuang.controller"/>
    
        <!--让Spring MVC不处理静态资源-->
        <mvc:default-servlet-handler/>
    
        <!--支持mvc注解驱动,取代HandlerMapping和HandlerAdapter
           在spring中一般采用@RequestMapping注解来完成映射关系
           要想使@RequestMapping注解生效
           必须向上下文中注册DefaultAnnotationHandlerMapping
           和AnnotationMethodHandlerAdapter实例
           这两个实例分别在类级别和方法级别处理
           而annotation-driven配置帮助我们自动完成上述两个实例的注入-->
        <mvc:annotation-driven/>
    
    
        <!--视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
            <!--前缀-->
            <property name="prefix" value="/WEB-INF/jsp/"/>
            <!--后缀-->
            <property name="suffix" value=".jsp"/>
        </bean>
    </beans>
    

    不适用注解的情况下,需要配置:

    • HandlerMapping
    • HanderAdapter
    • 视图解析器
    • 具体的controller需要显示注册

    使用注解情况下:

    • 采用了“自动扫描包”,无需在手动注册 具体controller

    • 采用“注解驱动”,取代了HandlerMapping和HandlerAdapter

    • (注意静态资源的处理)

    • 同样“视图解析器”不可或缺

    在视图解析器中我们把所有的视图都存放在/WEB-INF/jsp目录下,这样可以保证视图安全,因为这个目录下的文件,客户端不能直接访问。

  6. 创建具体controller,使用注解

    编写一个java控制类,com.kuang.controller.HelloController,注意编码规范

    package com.kuang.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    @Controller
    @RequestMapping("/HelloController")  //外层可以添加一层路径,一般不加
    public class HelloController {
    
        //真实访问地址:项目名/helloController/hello
        @RequestMapping("/hello")
        public String hello(Model model){
            //向模型中添加属性msg和值,可以在jsp页面取出并渲染
            model.addAttribute("msg","Hello,SpringMVCAnnotation");
            
            return "hello"; //会被视图解析器处理 /WEB-INF/jsp/hello.jsp
        }
    }
    
    
    • @Controller是为了让SpringIOC容器初始化自动扫描到

    • @RequestMapping是为了映射请求路径,这里因为类与方法上都有映射,所以访问时应该是/HelloController/hello

    • 方法中声明Model类型的参数是为了把Action中的数据带到视图中

    • 方法返回的结果是视图的名称hello,加上配置文件中的前后缀变成/WEB-INF/jsp/hello.jsp

  7. 创建视图层

    在WEB-INF/jsp目录中创建hello.jsp,视图可以直接取出并展示从Controller带回的信息;

    可以通过EL表达式去除Model中存放的值或者对象;

    <%--
      Created by IntelliJ IDEA.
      User: liujie
      Date: 2021/9/6
      Time: 21:12
      To change this template use File | Settings | File Templates.
    --%>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    ${msg}
    </body>
    </html>
    
  8. 配置Tomcat运行

    image-20210906214319560

3.3 小结

无论是配置版还是注解版,实现步骤都差不多:

新建一个web项目

导入相关的jar包

1.编写web.xml,注册DispatcherServlet

2.编写springmvc配置文件:springmvc-servlet.xml

3.接下来就是去创建对应的控制类,controller

4.最后就是完善前端视图和controller之间的对应

测试运行调试

使用SpringMVC必须配置三大件:

配置版:处理器映射器HandlerMapping、处理器适配器HandlerAdapter、视图解析器ViewResolver

注解版:自动扫描+注解驱动,视图解析器

通常,我们只需要手动配置视图解析器,而HandlerMapping和HandlerAdapter只需要开启注解驱动即可,可以省去大段的xml配置

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值