Spring学习笔记01(初识Spring+Spring的核心概念)

choice of

于 2025-05-17 16:06:14 发布

阅读量460

点赞数 19

CC 4.0 BY-SA版权

文章标签： spring 学习笔记

本文链接：https://blog.csdn.net/2401_84040384/article/details/148028869

一 Spring 框架概述

1 Spring定义

Spring是一款开源的轻量级的java开发框架，目的是通过控制反转(IoC)和面向切面编程(AOP)等核心特性解决企业级应用开发业务逻辑层和其他各层的耦合问题，提高代码的可维护性和可测试性。

2 核心优势

轻量级 基于 POJO（普通 Java 对象）编程，无需依赖特定容器。

解耦通过IoC管理对象依赖，通过AOP分离业务逻辑和横切关注点(如日志，事务)。

生态丰富 与第三方架构无缝缝合

二 Spring系统架构

1 核心容器层（Core Container）

Spring的Core Container是其他模块建立的基础，由Beans,Core,Context等模块组成

Spring Core : 提供了IoC容器的基础实现

Spring Beans：定义Bean的配置，创建和管理规则

2 核心功能层

实现面向切面编程，分离业务逻辑和横切关注点（如权限校验、性能监控）。

3 数据访问层

支持 JDBC、ORM（如 Hibernate、MyBatis）、事务管理等，简化数据库操作

4 Web开发层

Spring Web：提供基础的 Web 开发支持（如 HTTP 客户端、Servlet 集成）。
Spring Web MVC：基于 MVC 模式的 Web 框架，用于构建 RESTful 服务或 Web 应用。

5 工具与集成层

Test：集成 JUnit、TestNG，支持单元测试和集成测试。
Context：扩展 ApplicationContext，支持与第三方框架（如邮件、缓存）集成。

三核心概念

1 控制反转(IoC)

定义将对象创建和依赖关系的管理从程序代码转移到IoC(Spring容器)中，由容器负责对象的生命周期管理。

本质对象被动接受依赖对象，而并非主动创建或查找依赖对象，实现控制权的反转。

实现方式

依赖注入(DI) 通过构造器、setter 方法或注解（如 @Autowired）将依赖对象注入到目标对象中。

工厂模式 Spring 容器作为对象工厂，根据配置（XML 或注解）生成 Bean 实例。

2 DI(依赖注入)

定义

IoC的具体实现方式，指在对象创建时，由容器将其依赖的对象通过某种方式（构造器、方法、字段）注入到该对象中。

类型

构造器注入：通过类的构造方法传入依赖对

象。
** setter 注入 **：通过类的 setter 方法注入依赖对象。
注解注入：通过 @Autowired、@Resource 等注解自动装配依赖对象。

3 Bean

Spring 容器管理的对象称为 Bean，需在配置中声明（如 XML 的 <bean> 标签或注解 @Component）。

Bean 的作用域（scope）：
singleton（默认）：容器中仅存在一个实例。
prototype：每次请求都会创建新实例。
request/session：Web 环境下，分别对应一次请求或一次会话的生命周期。

四 Ioc/DI入门案例

案例场景：实现一个简单的 “用户服务” 模块，用户服务依赖于 “用户数据访问对象（UserDAO）”。

1. 创建接口和实现类

UserDAO 接口：

public interface UserDAO {
    void save();
}

UserDAO 实现类（MySQL 版本）：

public class MySQLUserDAO implements UserDAO {
    @Override
    public void save() {
        System.out.println("保存用户到 MySQL 数据库");
    }
}

UserService 类（依赖 UserDAO）：

public class UserService {
    private UserDAO userDAO;

    // 构造器注入（依赖注入方式）
    public UserService(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public void register() {
        System.out.println("用户注册逻辑");
        userDAO.save(); // 调用依赖对象的方法
    }
}

2. Spring 配置（XML 方式）

在 applicationContext.xml 中声明 Bean 及依赖关系：

<?xml version="1.0" encoding="UTF-8"?>
<!-- 根元素定义Spring的bean容器 -->
<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">

    <!-- 数据访问层配置 -->
    <!-- 定义UserDAO接口的MySQL实现类 
         id属性作为bean的唯一标识符
         class属性指定具体实现类的全限定名 -->
    <bean id="userDAO" class="com.example.dao.MySQLUserDAO"/>

    <!-- 服务层配置 -->
    <!-- UserService业务逻辑类配置
         通过构造器注入方式实现依赖关系 -->
    <bean id="userService" class="com.example.service.UserService">
        <!-- constructor-arg表示构造器参数
             ref属性指向已定义的userDAO bean
             等价于：new UserService(userDAO) -->
        <constructor-arg ref="userDAO"/>
    </bean>
</beans>

3. 使用 Spring 容器获取对象并调用方法

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

public class Main {
    public static void main(String[] args) {
        // 加载 Spring 配置文件，创建容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        // 从容器中获取 UserService Bean
        UserService userService = context.getBean("userService", UserService.class);
        
        // 调用业务方法
        userService.register(); // 输出：用户注册逻辑 -> 保存用户到 MySQL 数据库
    }
}