深入理解 Spring 容器框架

程序猿小young

已于 2023-11-30 22:15:19 修改

阅读量178

点赞数

分类专栏： Java语言核心前端技术文章标签： spring java 后端

于 2023-11-30 22:12:30 首次发布

本文链接：https://blog.csdn.net/weixin_43519474/article/details/134723040

版权

Java语言核心同时被 2 个专栏收录

51 篇文章 2 订阅

订阅专栏

前端技术

14 篇文章 0 订阅

订阅专栏

Spring 框架是一个综合性的 Java 开发框架，提供了广泛的功能，其中之一就是容器（Container）的概念。Spring 容器是 Spring 框架的核心部分，负责管理和组织应用中的各个组件。

一、Spring 容器的类型

Spring 容器有两种主要的类型：

BeanFactory： 这是 Spring 框架最基础的容器接口。它提供了一种配置机制，允许通过 XML 或注解配置创建和管理对象。BeanFactory 是延迟初始化的，即只有在第一次访问 Bean 时才进行初始化。
ApplicationContext： 这是 BeanFactory 的子接口，也是更强大、更常用的容器。ApplicationContext 在启动时就进行了对象的实例化，提供更多的功能，例如事件发布、国际化支持等。在实际开发中，更推荐使用 ApplicationContext。

二、Spring 容器的配置

Spring 容器的配置可以使用多种方式，其中最常见的包括 XML 配置、Java 注解和 Java 代码配置。下面简要介绍这些配置方式：

1. XML 配置

XML 配置是 Spring 容器最传统和经典的配置方式。通过在 XML 文件中定义 Bean 的配置信息，Spring 容器可以读取并管理这些 Bean。以下是一个简单的 XML 配置示例：

<!-- applicationContext.xml -->
<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">

    <!-- 定义一个名为 "myBean" 的 Bean -->
    <bean id="myBean" class="com.example.MyBean" />

</beans>

2. Java 注解

Java 注解是一种更加简洁和方便的配置方式，通过在 Java 类上使用注解标记，Spring 容器可以自动扫描并管理这些 Bean。以下是一个使用 @Component 注解的示例：

// MyBean.java
package com.example;

import org.springframework.stereotype.Component;

@Component
public class MyBean {
    // Bean 的实现
}

在配置类上使用 @ComponentScan 注解可以指定要扫描的包路径：

// AppConfig.java
package com.example;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // 配置类
}

3. Java 代码配置

除了注解，还可以通过 Java 代码进行配置。使用 @Configuration 注解标记配置类，并在方法上使用 @Bean 注解定义 Bean。以下是一个使用 Java 代码配置的示例：

// AppConfig.java
package com.example;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
}

4. 组合配置

在实际应用中，通常会使用多种配置方式的组合。例如，可以使用 XML 配置一些基础的 Bean，然后使用 Java 注解或 Java 代码配置一些特定的 Bean。Spring 容器会自动将这些配置组合在一起。

<!-- applicationContext.xml -->
<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">

    <!-- 定义一个名为 "myBean" 的 Bean -->
    <bean id="myBean" class="com.example.MyBean" />

</beans>

// AppConfig.java
package com.example;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public AnotherBean anotherBean() {
        return new AnotherBean();
    }
}

Spring 容器的配置是 Spring 框架中非常重要的一部分，通过不同的配置方式，开发者可以根据项目需求选择最合适的方式。无论是 XML 配置、Java 注解还是 Java 代码配置，都提供了灵活的配置选项，使得 Spring 容器适用于各种不同规模和类型的应用。

三、Spring 容器的生命周期

Spring 容器的生命周期包括启动、运行和关闭等阶段，其中主要涉及到 Bean 的实例化、初始化和销毁过程。以下是 Spring 容器的生命周期主要阶段：

1. 启动阶段

在启动阶段，Spring 容器会完成以下主要任务：

容器实例化： 创建 Spring 容器的实例，可以是 ClassPathXmlApplicationContext、AnnotationConfigApplicationContext 等。
Bean 实例化： Spring 容器根据配置或注解信息实例化所有在容器中定义的 Bean。这一阶段仅完成对象的创建，不涉及属性的注入和初始化。
属性注入： 容器将属性值注入到 Bean 中。这包括基本类型、引用类型和集合类型的属性。

2. 运行阶段

在运行阶段，Spring 容器会完成以下主要任务：

Bean 初始化： 如果 Bean 实现了 InitializingBean 接口，容器将调用其 afterPropertiesSet 方法进行初始化。也可以通过配置指定初始化方法。
Bean 使用： 此阶段中，应用程序可以使用容器中的 Bean 对象，执行相应的业务逻辑。

3. 关闭阶段

在关闭阶段，Spring 容器会完成以下主要任务：

Bean 销毁： 如果 Bean 实现了 DisposableBean 接口，容器将在关闭时调用其 destroy 方法进行销毁。也可以通过配置指定销毁方法。
容器关闭： 调用容器的关闭方法，例如 close()。关闭容器会导致所有的 Bean 被销毁。

4. 容器生命周期的代码示例

以下是一个简单的示例，展示了 Spring 容器的生命周期：

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ContainerLifecycleExample {

    public static void main(String[] args) {
        // 创建 Spring 容器实例
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 获取 Bean 实例
        MyBean myBean = context.getBean(MyBean.class);

        // 使用 Bean
        myBean.doSomething();

        // 关闭容器，触发销毁阶段
        context.close();
    }
}

在上述示例中，MyBean 类可以实现 InitializingBean 和 DisposableBean 接口，或者使用 @PostConstruct 和 @PreDestroy 注解指定初始化和销毁方法。

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class MyBean implements InitializingBean, DisposableBean {

    @PostConstruct
    public void customInit() {
        // 自定义初始化方法
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // InitializingBean 接口的初始化方法
    }

    public void doSomething() {
        // Bean 的业务逻辑
    }

    @PreDestroy
    public void customDestroy() {
        // 自定义销毁方法
    }

    @Override
    public void destroy() throws Exception {
        // DisposableBean 接口的销毁方法
    }
}

通过以上配置，Spring 容器在启动时会调用初始化方法，运行时执行业务逻辑，而在关闭时会调用销毁方法。这是典型的 Spring 容器生命周期的体现。

四、使用 Spring 容器

一个常见的 Spring 实际使用的例子是创建一个基于 Spring 框架的 Web 应用程序。以下是一个简单的示例，演示了如何使用 Spring MVC 构建一个 Web 控制器：

创建 Maven 项目： 使用 Maven 创建一个新的 Java 项目。
添加依赖： 在 Maven 项目的 pom.xml 文件中添加 Spring MVC 的依赖：

<dependencies>
    <!-- Spring MVC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>5.3.10.RELEASE</version>
    </dependency>
</dependencies>

创建 Spring 配置文件： 在 src/main/resources 目录下创建一个名为 spring-config.xml 的 Spring 配置文件：

<!-- spring-config.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 启用注解驱动 -->
    <mvc:annotation-driven/>

    <!-- 开启组件扫描 -->
    <context:component-scan base-package="com.example.controller"/>

    <!-- 视图解析器配置 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

创建控制器类： 在 src/main/java 目录下创建一个包 com.example.controller，并在该包中创建一个名为 HelloController 的类：

package com.example.controller;

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

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("message", "Hello, Spring MVC!");
        return "hello"; // 视图名，对应 /WEB-INF/views/hello.jsp
    }
}

创建 JSP 视图： 在 src/main/webapp/WEB-INF/views 目录下创建一个名为 hello.jsp 的 JSP 文件：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <title>Spring MVC Example</title>
</head>
<body>

<h2>${message}</h2>

</body>
</html>

配置 Web.xml： 在 src/main/webapp/WEB-INF 目录下创建 web.xml 文件：

<!-- web.xml -->
<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">

    <!-- Spring MVC 配置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-config.xml</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- Spring MVC 前端控制器配置 -->
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-config.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

运行项目： 使用 Tomcat 或其他 Servlet 容器运行项目，并访问 http://localhost:8080/your-project-name/hello。应该能够看到显示 “Hello, Spring MVC!” 的页面。

这个简单的例子演示了如何使用 Spring MVC 构建一个 Web 应用程序。它包括了 Spring 容器的配置、控制器的创建、JSP 视图的使用等关键步骤。实际应用中，可以根据需求扩展并添加更多功能。

五、总结

Spring 容器是 Spring 框架的核心，它负责管理和组织应用中的各个组件。通过适当的配置，容器可以实例化、初始化、使用和销毁这些组件。Spring 容器的灵活性和可扩展性使得它成为 Java 开发中常用的容器框架之一。

程序猿小young

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
深入理解 Spring 容器框架

Spring 容器是 Spring 框架的核心，它负责管理和组织应用中的各个组件。通过适当的配置，容器可以实例化、初始化、使用和销毁这些组件。Spring 容器的灵活性和可扩展性使得它成为 Java 开发中常用的容器框架之一。
复制链接

扫一扫