Spring快速入门——Spring集成Web环境

最新推荐文章于 2024-08-26 14:18:37 发布
原创 最新推荐文章于 2024-08-26 14:18:37 发布 · 411 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #spring #intellij-idea

本文介绍了如何在Web环境中搭建Spring的三层架构，包括pom.xml配置、applicationContext.xml配置、各层代码实现以及web.xml配置。此外，讨论了通过ServletContextListener监听器和WebApplicationContextUtils工具类优化应用上下文的获取，避免重复加载配置文件。最后，提到了Spring提供的ContextLoaderListener监听器简化配置和获取应用上下文的过程。

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

基本三层架构环境搭建

  • pom.xml

    <?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>org.example</groupId>
    <artifactId>spring_mvc</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.16</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.16</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
        </dependency>
    </dependencies>
</project>

  • applicationContext.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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置Dao-->
    <bean id="userDao" class="com.study.dao.impl.UserDaoImpl"/>
    <!--配置Service-->
    <bean id="userService" class="com.study.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

  • dao层

    package com.study.dao;

public interface UserDao {
    public void save();
}

    package com.study.dao.impl;

import com.study.dao.UserDao;

/**
 * @title: UserDaoImpl
 * @Author Mj
 * @Date: 2022/3/2 14:09
 * @Version 1.0
 */

public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("userDao save running...");
    }
}

  • service层

    package com.study.service;

public interface UserService {
    public void save();
}

    package com.study.service.impl;

import com.study.dao.UserDao;
import com.study.service.UserService;

/**
 * @title: UserServiceImpl
 * @Author Mj
 * @Date: 2022/3/2 14:12
 * @Version 1.0
 */

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save() {
        userDao.save();
    }
}

  • web层

    package com.study.web;

import com.study.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

/**
 * @title: UserServlet
 * @Author Mj
 * @Date: 2022/3/2 22:08
 * @Version 1.0
 */
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //加载配置文件，创建Spring容器
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }
}

  • 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>UserServlet</servlet-name>
        <servlet-class>com.study.web.UserServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>UserServlet</servlet-name>
        <url-pattern>/userServlet</url-pattern>
    </servlet-mapping>
</web-app>

部署在Tomcat服务器运行，访问localhost:8080/userServlet

image-20220302232131068

ApplicationContext应用上下文获取方式

  • 应用上下文对象是new ClassPathXmlApplicationContext(spring配置文件)方式获取的，但是每次从容器中获得Bean时都要编写new ClassPathXMLApplicationContext(spring配置文件)，这样的弊端是配置文件加载多次，应用上下文对象创建多次。

  • 在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，再将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了

    • web.xml文件中添加以下配置

      <!--全局初始化参数-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>applicationContext.xml</param-value>
</context-param>
<!--配置监听器-->
<listener>
    <listener-class>com.study.listener.ContextLoaderListener</listener-class>
</listener>

    • 在ContextLoaderListener.java监听Web应用的启动

      package com.study.listener;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

/**
 * @title: ContextLoaderListener
 * @Author Mj
 * @Date: 2022/3/2 23:28
 * @Version 1.0
 */
public class ContextLoaderListener implements ServletContextListener {
    public void contextInitialized(ServletContextEvent sce) {
        //获取servletContext对象
        ServletContext servletContext = sce.getServletContext();

        //通过配置文件的方式创建容器
        // ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        //将配置文件放到web.xml中，从读取web.xml中的全局参数
        String contextConfigLocation = servletContext.getInitParameter("contextConfigLocation");
        ApplicationContext app = new ClassPathXmlApplicationContext(contextConfigLocation);

        //将Spring的应用上下文对象存储到ServletContext域中
        servletContext.setAttribute("app",app);

        System.err.println("spring容器创建完毕...");
        System.err.println("监听器执行完毕...");
    }

    public void contextDestroyed(ServletContextEvent sce) {

    }
}

    • 编写工具类WebApplicationContextUtils类，返回从servletContext域获取的应用上下文ApplicationContext对象

      package com.study.utils;

import org.springframework.context.ApplicationContext;

import javax.servlet.ServletContext;

/**
 * @title: WebApplicationContextUtils
 * @Author Mj
 * @Date: 2022/3/2 23:45
 * @Version 1.0
 */
public class WebApplicationContextUtils {
    public static ApplicationContext getApplicationContext(ServletContext servletContext){
         return (ApplicationContext) servletContext.getAttribute("app");
    }
}

    • 在UserServlet.java中通过WebApplicationContextUtils类的getApplicationContext()方法获取应用上下文ApplicationContext对象

      package com.study.web;

import com.study.service.UserService;
import com.study.utils.WebApplicationContextUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

/**
 * @title: UserServlet
 * @Author Mj
 * @Date: 2022/3/2 22:08
 * @Version 1.0
 */
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //加载配置文件，创建Spring容器
        // ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        ServletContext servletContext = req.getServletContext();

        // ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
        ApplicationContext app = WebApplicationContextUtils.getApplicationContext(servletContext);
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }
}
Spring提供获取应用上下文的工具

上面的分析不用手动实现，Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具WebApplicationContextUtils供使用者获得应用上下文对象

所以我们只需要做两件事：

  1. 在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）

    <!--pom.xml中先导入坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.3.16</version>
</dependency>

    <!--在web.xml中配置监听器-->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

  2. 使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

    WebApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
知识要点总结
Spring集成Web环境步骤
  1. 配置ContextLoaderListener监听器
  2. 使用WebApplicationContextUtils获得应用上下文
EMQX 入门教程⑫——Spring Boot 集成 ExHook gRPC 服务
12-13 810
EMQX 入门教程⑫——Spring Boot 集成 ExHook gRPC 服务
spring WEB入门级项目搭建
08-09
spring WEB入门级项目搭建，实现简单登录，使用springMVC，springJDBC
Spring Web应用入门
keepeye的专栏
06-28 2641
Spring的Web应用框架也是一个基于web容器的一个框架,因此作为一个Servlet应用运行在容器中,实际上也就是一个普通的web应用,本文已Tomcat5.59版本容器为例来看Spring(V1.21)的配置和应用.在Spring Web框架中一般我们要提供三样东西:一个是自己的表示层页面,可以是velocity,xslt,freemarker,jasperreports等资源,一个是值对象
Spring与Web环境集成
qq_45566079的博客
11-21 218
1 ApplicationContext应用上下文获取方式 应用上下文对象是通过new ClasspathXmlApplicationContext(spring配置文件) 方式获取的，但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件) ，这样的弊端是配置文件加载多次，应用上下文对象创建多次。 在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring
SpringWeb入门（一）
Heavy_Dream的博客
04-15 473
项目结构：核心配置文件applicationContext.xml&lt;?xml version="1.0" encoding="UTF-8"?&gt;&lt;beans xmlns="http://www.springframework.org/schema/beans"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    x...
Springweb详解
qq_45576281的博客
07-05 2968
RestController //表示此类由spring创建管理@RequestMapping(path = "/loginCtl") //为类定义一个映射地址@Autowired//方便的注入其他对象//为方法定义映射地址，设置该方法允许哪些请求方式访问，可以方便接收请求中的参数//可以直接将返回的对象，自动转为json字符串。
Spring06 ——Spring集成web环境
春和的博客
04-03 870
目标：spring集成web环境，将ApplicationContext的创建交由Spring容器。 往期文章 Spring01 —— Spring概念及快速入门 Spring02 —— Spring配置文件详解和依赖注入 Spring03 —— SpringAPI和在Spring中配置数据源 Spring04 —— Spring的注解开发 Spring05 —— Spring集成Junit 文章目录往期文章Spring集成Web环境1、开发环境完善2、手动创建监听器3、Spring框架提供得到3.
SpringCloud入门——注册中心-Eureka server集成
wayne_lee_lwc的博客
03-02 286
简介 Spring Cloud 首先，对于Spring cloud，是基于Spring Boot实现的服务治理工具包，是一整套管理微服务的框架。主要用于管理和协调服务。 更官方书面的介绍： 它是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署——这段话摘自百度百科 微服务 上面提到了微服务，对于这个词语近年来也是经常被广泛使用，它是指
Spring快速入门教程
09-20
同时，下载Struts和Spring的最新版本，以及一个预配置的开发框架——Equinox，它简化了Struts-Spring集成的项目初始化工作。 在开始开发之前，创建项目目录和Ant构建文件至关重要。你可以将下载的Equinox解压缩到一...
学会Spring与Web环境集成以及SpringMVC快速入门这一篇就够了
LIUHAO的博客
04-14 529
学会Spring与Web环境集成以及SpringMVC快速入门这一篇就够了 Spring集成web环境 1.1 ApplicationContext应用上下文获取方式 1.2 Spring提供获取应用上下文的工具 1.3 导入Spring集成web的坐标 1.4 配置ContextLoaderListener监听器 1.5 通过工具获得应用上下文对象 SpringMVC SpringMVC概述 SpringMVC快速入门 SpringMVC流程图示 SpringMVC 组件解析 SpringMVC的执行流程
spring集成web
weixin_44235759的博客
03-25 593
<dependencies> <!--#################### spring start ####################--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <versi..
Spring集成Web
逐梦苍穹的博客
08-04 1068
Spring集成web
Spring基础学习——web
gua_Piter的博客
11-12 308
原始Javaweb开发中，Servlet充当Controller的角色，Jsp充当View角色，JavaBean充当模型角色，后期Ajax异步流行后，在加上现在前后端分离开发模式成熟后，View就被原始Html+Vue替代。在进行Java开发的时候要遵循三层架构+MVC，Spring操作最核心的就是Spring容器，web层需要注入Service，service层选哟注入Mapper（dao层），web层使用Servlet技术充当的话，需要在Servlet当中获取Spring容器。
Spring Web MVC入门
hlizoo的博客
10-28 1520
spring-web
cooper的专栏
05-24 272
spring-web web配置 在servlet 3.1以后，可以通过代码的方式来配置DispatcherServlet，而不用配置在web.xml中。在Servlet 3.0环境中，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类，如果发现就会用他来配置Servlet容器。Spring提供了这个接口的实现SpringServletContainerInitializer，这个类又会查找实现了webAppInitializerClasses
Spring Web
最新发布
qq_74623042的博客
08-26 1274
SpringWeb 是spring 框架中的一个模块。基于原生的 Servlet，提供了一个前端控制器 DispatcherServlet ，开发者无须额外开发控制器对象springWeb 是 Spring 框架中的一部分，是对 web 层进行封装。目前是企业开发首选。由框架提供，在web.xml 中配置。作用：统一处理请求和响应，整个流程控制的中心，由它调用其它组件处理用户的请求.由框架提供。作用：根据请求的 url 查找 Handler(处理器/Controller)
SpringWeb
qq_55674489的博客
02-17 881
springWeb 是 spring 框架的一个模块，springWeb 和 spring 无需通过中间整 合层进行整合。 springWeb 是一个基于 mvc 的 web 框架,方便前后端数据的传输. SpringWeb 拥有控制器，接收外部请求，解析参数传给服务层.
Spring Boot服务注册中心Web控制台快速入门
在这一节中，我们将会详细介绍一个与Spring Boot结合紧密的Starter模块——spring-boot-api-regcovery-dashboard-starter。这个模块主要用于创建服务注册中心的Web控制台，允许用户通过浏览器查看服务注册中心的服务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值