久趣下载站

当前位置: 首页 » 游戏攻略 » Spring MVC 获取三个域(request请求域,session 会话域,application 应用域)对象的方式

Spring MVC 获取三个域(request请求域,session 会话域,application 应用域)对象的方式

1. Spring MVC 获取三个域(request请求域,session 会话域,application 应用域)对象的方式

@


2. Servlet中的三个域对象

Servlet 中的三个域对象分别是:

请求域:request

会话域:session

应用域:application

三个域都有以下三个方法:

// 向域中存储数据
void setAttribute(String name, Object obj);

// 从域中读取数据
Object getAttribute(String name);

// 删除域中的数据
void removeAttribute(String name);

主要是通过:setAttribute + getAttribute 方法来完成在域中数据的传递和共享。


request:

接口名:HttpServletRequest

简称:request

request对象代表了一次请求。一次请求一个request。

使用请求域的业务场景:

在A资源中通过转发的方式跳转到B资源,因为是转发,因此从A到B是一次请求,如果想让A资源和B资源共享同一个数据,可以将数据存储到request域中。


session:

接口名:HttpSession

简称:session

session对象代表了一次会话。从打开浏览器开始访问,到最终浏览器关闭,这是一次完整的会话。每个会话session对象都对应一个JSESSIONID,而JSESSIONID生成后以cookie的方式存储在浏览器客户端。浏览器关闭,JSESSIONID失效,会话结束。

使用会话域的业务场景:

  1. 在 A 资源中通过重定向(重定向是一次新的请求)的方式转到 B 资源,因为是重定向,因此从 A到 B 是两次请求,如果想让 A 资源和 B 资源共享同一个数据,可以将数据存储到 session域中
  2. 登录成功后保存用户的登录状态


application

接口名:ServletContext

简称:application

application对象代表了整个 web 应用,服务器启动的创建,服务器关闭时销毁,对于一个 web 应用来说,application 对象只有一个。

使用应用域的业务场景:记录网站的在线人数。

3. 准备工作

3.1 创建模块,添加依赖

<?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.rainbowsea</groupId>
    <artifactId>springmvc-004-blog</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>

    <dependencies>
        <!--springmvc依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>6.1.4</version>
        </dependency>
        <!--logback依赖-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.5.3</version>
        </dependency>
        <!--servlet依赖-->
        <dependency>
            <groupId>jakarta.servlet</groupId>
            <artifactId>jakarta.servlet-api</artifactId>
            <version>6.0.0</version>
            <scope>provided</scope>
        </dependency>
        <!--thymeleaf和spring6整合的依赖-->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring6</artifactId>
            <version>3.1.2.RELEASE</version>
        </dependency>
    </dependencies>


</project>

3.2 添加 web 支持

先在 main 目录下,添加名为

webapp

的目录(文件夹),只能是这个 webapp 目录名,不可以是其他的。


3.3 编写 web.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">

    <!--前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数来指定springmvc配置文件的路径和名字。-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <!--在服务器启动的时候初始化DispatcherServlet,提高第一次访问的效率-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
<!--        除了 jsp 其他的路径都被获取到-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

3.4 创建 IndexController 类

创建 IndexController 类作为 首页来使用

package com.rainbowsea.springmvc.controller;

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


@Controller // 交给 Spring IOC 容器管理
public class IndexController {


    @RequestMapping("/")
    public String index() {
        return "index";
    }
}

3.5 编写 springmvc.xml

在 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.rainbowsea.springmvc.controller"></context:component-scan>

    <!--    视图解析器-->
    <bean id="thymeleafViewResolver" class="org.thymeleaf.spring6.view.ThymeleafViewResolver">
        <!--作用于视图渲染的过程中,可以设置视图渲染后输出时采用的编码字符集-->
        <property name="characterEncoding" value="UTF-8"/>
        <!--如果配置多个视图解析器,它来决定优先使用哪个视图解析器,它的值越小优先级越高-->
        <property name="order" value="1"/>
        <!--当 ThymeleafViewResolver 渲染模板时,会使用该模板引擎来解析、编译和渲染模板-->
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring6.SpringTemplateEngine">
                <!--用于指定 Thymeleaf 模板引擎使用的模板解析器。模板解析器负责根据模板位置、模板资源名称、文件编码等信息,加载模板并对其进行解析-->
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring6.templateresolver.SpringResourceTemplateResolver">
                        <!--设置模板文件的位置(前缀)-->
                        <property name="prefix" value="/WEB-INF/templates/"/>
                        <!--设置模板文件后缀(后缀),Thymeleaf文件扩展名不一定是html,也可以是其他,例如txt,大部分都是html-->
                        <property name="suffix" value=".html"/>
                        <!--设置模板类型,例如:HTML,TEXT,JAVASCRIPT,CSS等-->
                        <property name="templateMode" value="HTML"/>
                        <!--用于模板文件在读取和解析过程中采用的编码字符集-->
                        <property name="characterEncoding" value="UTF-8"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

</beans>

3.6 编写 index.html 文件视图

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>测试三个对象</title>
</head>
<body>
<h1>测试三个域对象</h1>
<hr>
<h2>测试 request 域对象</h2>
</body>
</html>

3.7 部署测试


4. Spring MVC 获取 request 请求域对象的五种方式

在SpringMVC中,在request域中共享数据有以下五种方式:

  1. 使用原生Servlet API方式。
  2. 使用Model接口。
  3. 使用Map接口。
  4. 使用ModelMap类。
  5. 使用ModelAndView类。

4.1 第一种方式:使用原生Servlet API方式 获取到 request 请求域,同时获取到请求域当中对应的内容

第一种方式: 在Spring MVC 中使用原生的 Servlet API 可以完成 request 域数据共享

,在处理器方法上添加 HttpServletRequest 参数即可。

将 HttpServletRequest 作为参数,定义到方法上,Spring MVC 框架会自动从 Tomcat 服务器当中获取到这个 HttpServletRequest 对象的值,然后,传递给这个方法的 HttpServletRequest 参数值上,完成赋值。

创建一个 RequestScopeTestController 类,注意要交给 Spring IOC 容器管理起来

package com.rainbowsea.springmvc.controller;


import jakarta.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import java.util.Map;

@Controller // 交给Spring IOC 容器管理
public class RequestScopeTestController {


    // request 请求域
    @RequestMapping("/testServletAPI")
    public String testServletAPI(HttpServletRequest request) {

        // 将共享的数据存储到 request域当中
        // 跳转视图,在视图页面将request域中的数据取出,这样就完成了,Controller和View在同一个请求当中两个组件之间的数据共享

        // 将共享的数据存储到request域当中
        request.setAttribute("testRequestScope", "在SpringMVC当中使用原生Servlet API 完成 request域的数据共享");
        System.out.println(request);
        System.out.println(request.getClass().getName());

        // 跳转视图,在视图页面将 request 域中的数据取出来,这样就完成了,Controller 和 View 在同
        // 一个请求当中两个组件之间数据的共享

        // 注意:这个是跳转,默认情况下是,转发的方式,(转发 forward 是一次请求)
        // 这个返回的是一个逻辑视图名称,经过视图解析器解析,变成物理视图名称,/WEB-INF/templates/ok.html
        return "ok";
    }

}

index页面超链接的编写:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>测试三个对象</title>
</head>
<body>
<h1>测试三个域对象</h1>
<hr>
<h2>测试 request 域对象</h2>


<a th:href="@{/testServletAPI}">测试在SpringMVC当中使用原生 Servlet API 完成 request 域的数据共享</a>
<br>

</body>
</html>

ok 页面获取 request 请求域的展示

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>测试三个对象</title>
</head>
<body>
<h1>测试三个域对象</h1>
<hr>
<h2>测试 request 域对象</h2>


<a th:href="@{/testServletAPI}">测试在SpringMVC当中使用原生 Servlet API 完成 request 域的数据共享</a>
<br>

</body>
</html>

测试结果:

这种方式当然可以,用 SpringMVC 框架,不建议使用原生 Servlet API

4.2 第二种方式:使用 Model 接口 获取到 request 请求域,同时获取到请求域当中对应的内容


import jakarta.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import java.util.Map;

@Controller // 交给Spring IOC 容器管理
public class RequestScopeTestController {

    @RequestMapping(value = "/testModel")
    public String testModel(Model model) {
        // 向 request 域当中绑定数据
        model.addAttribute("testRequestScope", "在SpringMVC 当中使用 Model 接口完成 request 域数据共享");
        System.out.println(model);
        System.out.println(model.getClass().getName());
        // 转发
        return "ok";
    }
}

index 页面超链接的编写:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>测试三个对象</title>
</head>
<body>
<h1>测试三个域对象</h1>
<hr>
<h2>测试 request 域对象</h2>


<a th:href="@{/testServletAPI}">测试在SpringMVC当中使用原生 Servlet API 完成 request 域的数据共享</a>
<br>
<a th:href="@{/testModel}">测试在 Spring MVC 当中使用 Model 接口完成 request 域数据共享</a>
<br>
</body>
</html>

ok 页面获取 request 请求域的展示

<!DOCTYPE html>
<html lang="en" xmlns:th="http//www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>OK</title>
</head>
<body>
<div th:text="${testRequestScope}"></div>
</body>
</html>

启动 Tomcat 服务器测试结果:

4.3 第三种方式:使用Map接口 获取到 request 请求域,同时获取到请求域当中对应的内容

import jakarta.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import java.util.Map;

@Controller // 交给Spring IOC 容器管理
public class RequestScopeTestController {
    @RequestMapping(value = "/testMap")
    public String testMap(Map<String, Object> map) {

        // 向 request 域当中的存储数据
        map.put("testRequestScope", "在Spring MVC 当中使用 Map接口完成 request 域数据共享");
        System.out.println(map);
        System.out.println(map.getClass().getName());
        // 转发
        return "ok";
    }
}

index 页面超链接的编写:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>测试三个对象</title>
</head>
<body>
<h1>测试三个域对象</h1>
<hr>
<h2>测试 request 域对象</h2>


<a th:href="@{/testServletAPI}">测试在SpringMVC当中使用原生 Servlet API 完成 request 域的数据共享</a>
<br>
<a th:href="@{/testModel}">测试在 Spring MVC 当中使用 Model 接口完成 request 域数据共享</a>
<br>
<a th:href="@{/testMap}">测试在Spring MVC 当中使用 Map 接口完成 request 域数据共享</a>
<br>
</body>
</html>

ok 页面获取 request 请求域的展示 保持不变

启动 Tomcat 服务器测试结果:

4.4 第四种方式:使用 ModelMap 类 获取到 request 请求域,同时获取到请求域当中对应的内容



import jakarta.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import java.util.Map;

@Controller // 交给Spring IOC 容器管理
public class RequestScopeTestController {

    @RequestMapping(value = "/testModelMap")
    public String testModelMap(ModelMap modelMap) {
        // 向 request 域当中存储数据
        modelMap.addAttribute("testRequestScope", "在Spring MVC 当中 ModelMap类完成request 域数据共享");
        System.out.println(modelMap);
        System.out.println(modelMap.getClass().getName());
        return "ok";
    }
}

index 页面超链接的编写:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>测试三个对象</title>
</head>
<body>
<h1>测试三个域对象</h1>
<hr>
<h2>测试 request 域对象</h2>


<a th:href="@{/testServletAPI}">测试在SpringMVC当中使用原生 Servlet API 完成 request 域的数据共享</a>
<br>
<a th:href="@{/testModel}">测试在 Spring MVC 当中使用 Model 接口完成 request 域数据共享</a>
<br>
<a th:href="@{/testMap}">测试在Spring MVC 当中使用 Map 接口完成 request 域数据共享</a>
<br>
<a th:href="@{/testModelMap}">测试在Spring MVC当中使用 ModelMap 类完成 request 域数据共享</a>
<br>
</body>
</html>

ok 页面获取 request 请求域的展示 保持不变

启动 Tomcat 服务器测试结果:

4.5 补充:Model、Map、ModelMap的关系

可以在以上Model、Map、ModelMap的测试程序中将其输出,看看输出什么:

看不出来什么区别,从输出结果上可以看到都是一样的。

可以将其运行时类名输出:

通过输出结果可以看出,无论是Model、Map还是ModelMap,底层实例化的对象都是:BindingAwareModelMap。

可以查看 BindingAwareModelMap的继承结构:

通过继承结构可以看出:BindingAwareModelMap继承了ModelMap,而ModelMap又实现了Map接口。

另外,请看以下源码:

可以看出ModelMap又实现了Model接口。因此表面上是采用了不同方式,底层本质上是相同的。

SpringMVC之所以提供了这些方式,目的就是方便程序员的使用,提供了多样化的方式,可见它的重要性。

4.6 第五种方式:使用 ModelAndView 类获取到 request 请求域,同时获取到请求域当中对应的内容

在 Spring MVC 框架中为了更好的体现 MVC 架构模式,提供了一个类:ModelAndView。

这个类的实例封装了 Model 和 View 。也就是说 这个类封装业务处理之后的数据,也体现了跳转到哪个视图。使用它也可以完成 request 域数据共享。

使用这种方式的注意事项:

  1. 方法的返回值类型不是 String 了,而是 ModelAndView 对象
  2. ModelAndView 不是出现在方法的参数位置上了,而是在方法体中 new 出来的
  3. 需要调用

    addObject()

    向域中存储数据
  4. 需要调用

    setViewName()

    设置视图的名字
  5. 最后需要将 ModelAndView 作为参数,返回。


import jakarta.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import java.util.Map;

@Controller // 交给Spring IOC 容器管理
public class RequestScopeTestController {



    @RequestMapping(value = "/testModelAndView")
    public ModelAndView testModelAndView() {
        // 创建模型视图对象
        ModelAndView modelAndView = new ModelAndView();
        // 给模型视图对象绑定数据
        modelAndView.addObject("testRequestScope", "在SpringMVC当中使用 ModelAndView 类完成 request 域数据共享");

        // 给模型视图对象 绑定视图(绑定逻辑视图名称)
        modelAndView.setViewName("ok");

        // 返回模型视图对象
        return modelAndView;
    }
}

index页面超链接的编写:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>测试三个对象</title>
</head>
<body>
<h1>测试三个域对象</h1>
<hr>
<h2>测试 request 域对象</h2>


<a th:href="@{/testServletAPI}">测试在SpringMVC当中使用原生 Servlet API 完成 request 域的数据共享</a>
<br>
<a th:href="@{/testModel}">测试在 Spring MVC 当中使用 Model 接口完成 request 域数据共享</a>
<br>
<a th:href="@{/testMap}">测试在Spring MVC 当中使用 Map 接口完成 request 域数据共享</a>
<br>
<a th:href="@{/testModelMap}">测试在Spring MVC当中使用 ModelMap 类完成 request 域数据共享</a>
<br>
<a th:href="@{/testModelAndView}">测试在Spring MVC当中使用 ModelAndView 类完成 request 域数据共享</a>
<br>

</body>
</html>

ok 页面获取 request 请求域的展示的编写:

<!DOCTYPE html>
<html lang="en" xmlns:th="http//www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>OK</title>
</head>
<body>
<div th:text="${testRequestScope}"></div>
</body>
</html>

启动 Tomcat 服务器测试结果:

4.7 补充:ModelAndView 源码分析

以上我们通过了五种方式完成了request域数据共享,包括:原生 Servlet API,Model、Map、ModelMap、ModelAndView

其中后四种:Model、Map、ModelMap、ModelAndView。

这四种方式在底层DispatcherServlet调用我们的Controller之后,返回的对象都是ModelAndView,

这个可以通过源码进行分析。

在以上四种方式中,拿Model举例,添加断点进行调试:

启动服务器,发送请求,走到断点:

查看VM Stack信息:

查看 DispatcherServlet 的1089行,源码如下:

可以看到这里,无论你使用哪种方式,最终都要返回一个ModelAndView对象。

对于

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

处理器方法来说,不管你使用的参数是 Model接口,还是Map接口,还是ModelMap类,还是ModelAndView类,最终处理器方法执行结束之前

返回的都是 ModelAndView对象,这个返回的ModelAndView对象给DispatcherServlet类了

当请求路径不是JSP的时候,都会走前端控制器 DispatcherServlet

DispatcherServlet 中有一个核心方法 doDispatch(),这个方法用来通过请求路径找到对应的处理器方法

然后调用处理器方法,处理器方法返回一个逻辑视图名称(可能也会直接返回一个ModelAndView对象)

,返回给DispatcherServlet

提醒:大家可以通过以下断点调试方式,采用一级一级返回,最终可以看到都会返回ModelAndView对象。

5. Spring MVC 获取 session 会话域对象的二种方式

在SpringMVC中使用session域共享数据,实现方式有多种,其中比较常见的两种方式:

  1. 使用原生Servlet API
  2. 使用SessionAttributes注解

5.1 第一种方式:使用原生Servlet API 获取到 session 会话域,同时获取到 session 会话域当中的信息

使用原生Servlet API ,就是将 HttpSession 作为方法的参数形式,Spring MVC 会自动获取到 Tomcat 服务器当中的 HttpSession 对象,赋值到这个方法的对应的 HttpSession 参数上。

创建:SessionScopeTestController 类


import jakarta.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.SessionAttributes;



@Controller // 交给 Spring IOC 容器管理
public class SessionScopeTestController {


    @RequestMapping("/testSessionServletAPI")
    public String testServletAPI(HttpSession session) {
        // 处理核心业务...
        //将数据存储到 Session中
        session.setAttribute("testSessionScope","在Spring MVC 当中使用原生 Servlet API 完成 session 域数据共享");
        // 返回逻辑视图(这是一个转发的行为)
        return "ok";
    }
}

index 页面超链接的编写:

ok 页面获取 request 请求域的展示的编写

<!DOCTYPE html>
<html lang="en" xmlns:th="http//www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>OK</title>
</head>
<body>
<div th:text="${session.testSessionScope}"></div>
</body>
</html>

启动 Tomcat 服务器测试结果:

5.2 第二种方式:使用 @SessionAttributes 注解 获取到 session 会话域,同时获取到 session 会话域当中的信息

使用 @SessionAttributes 注解标注 Controller:

@SessionAttributes(value = {"x","y","testSessionScope"}) // 标注 x 和 y 都是存放到 session 域中,而不是 request域

**注意:@SessionAttributes 注解使用在Controller类上。标注了当 key是 x 或者 y 时,该(x 或 y)的数据将被存储到会话 session域当中中。而如果没有 SessionAttributes注解,默认存储到 request域中。 **


import jakarta.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.SessionAttributes;


@SessionAttributes(value = {"x","y","testSessionScope"}) // 标注 x 和 y 都是存放到 session 域中,而不是 request域
@Controller // 交给 Spring IOC 容器管理
public class SessionScopeTestController {



    @RequestMapping(value = "/testSessionAttributes")
    public String testSessionAttributes(ModelMap modelMap) {
        // 处理业务
        // 将数据存储到 Session域当中
        modelMap.addAttribute("testSessionScope","在Spring MVC 当中使用@SessionAttributes 注解完成 session 域数据共享");
        modelMap.addAttribute("x","李华");
        modelMap.addAttribute("y","小红");
        return "ok";
    }
}

index 页面超链接的编写:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>测试三个对象</title>
</head>
<body>
<h1>测试三个域对象</h1>
<hr>



<h2>测试Session域对象</h2>
<a th:href="@{/testSessionAttributes}">测试在Spring MVC 当中使用 @SessionAttributes 注解完成 session域数据共享</a>
<br>

</body>
</html>

ok 页面获取 request 请求域的展示的编写:

<!DOCTYPE html>
<html lang="en" xmlns:th="http//www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>OK</title>
</head>
<body>
<div th:text="${session.testSessionScope}"></div>
<div th:text="${session.x}"></div>
<div th:text="${session.y}"></div>
</body>
</html>

启动 Tomcat 服务器测试结果:

6. Spring MVC 获取 application 应用域对象的方式

在SpringMVC实现application域数据共享,最常见的方案就是直接使用Servlet API了:

这个 application 域使用较少,如果使用的话,一般是采用 ServletAPI的方式使用

创建:ApplicationScopeTestController 类

将 HttpServletRequest 作为参数,定义到方法上,Spring MVC 框架会自动从 Tomcat 服务器当中获取到这个 HttpServletRequest 对象的值,然后,传递给这个方法的 HttpServletRequest 参数值上,完成赋值。

package com.rainbowsea.springmvc.controller;

import jakarta.servlet.ServletContext;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;


@Controller // 交给 Spring IOC 容器管理
public class ApplicationScopeTestController {


    @RequestMapping("/testApplicationScope")
    public String testApplicationScope(HttpServletRequest request) {
        // 将数据存储到application域当中
        // 获取application对象,其实就是获取 ServletContext对象
        // 怎么获取 ServletContext对象/通过 request,通过 session都可以用
        ServletContext application = request.getServletContext();
        application.setAttribute("testApplicationScope", "在Spring MVC 中使用 Servlet API中实现application域共享");
        return "ok";
    }
}

index 页面超链接的编写:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>测试三个对象</title>
</head>
<body>
<h1>测试三个域对象</h1>
<hr>



<h2>测试Application应用域对象</h2>
<a th:href="@{/testApplicationScope}">测试在Spring MVC 当中使用 Servlet API 实现application域数据共享</a>
<br>

</body>
</html>

ok 页面获取 request 请求域的展示的编写

启动 Tomcat 服务器测试结果:

7. 总结:

  1. 三个域:request 请求域,session 会话域,application 应用域

  2. 三者域的使用,从最小范围的域,来判断使用,可以用范围更小的域,就用范围更小的域来解决问题,传数据资源。如果域的范围不够,就一点的扩大。

  3. 在SpringMVC中,在request域中共享数据有以下五种方式:

    1. 使用原生Servlet API方式。
    2. 使用Model接口。
    3. 使用Map接口。
    4. 使用ModelMap类。
    5. 使用ModelAndView类。
  4. 在SpringMVC中使用session域共享数据,实现方式有多种,其中比较常见的两种方式:

    1. 使用原生Servlet API
    2. 使用SessionAttributes注解
  5. Spring MVC 获取 application 应用域对象的方式

8. 最后:

“在这个最后的篇章中,我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉,我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底,继续在其他的领域奋斗。感谢你们,我们总会在某个时刻再次相遇。”

猜你喜欢
本类排行