[手写 MiniSpring 框架教程] 第 01 讲：项目介绍与环境搭建

📖 本讲目标

• 了解 Spring 框架的核心概念
• 理解 MiniSpring 项目的目标和范围
• 搭建开发环境
• 创建项目基础结构

🌟 Spring 框架简介

Spring 框架是 Java 企业级应用开发的事实标准，它提供了全面的编程和配置模型。Spring 的核心特性包括：
 

1. IoC（控制反转）

传统方式：对象自己创建和管理依赖

public class UserService {
    private UserRepository userRepository;

    public UserService() {
        this.userRepository = new UserRepository(); // 自己创建依赖
    }
}

IoC 方式：依赖由容器注入

@Component
public class UserService {
    @Autowired
    private UserRepository userRepository; // 容器自动注入
}

2. DI（依赖注入）

依赖注入是 IoC 的一种实现方式，通过以下方式实现：

• 构造函数注入：通过构造函数参数注入依赖
• 字段注入：通过反射直接设置字段值
• 方法注入：通过 setter 方法注入依赖

3. AOP（面向切面编程）

AOP 允许将横切关注点（如日志、事务、安全）从业务逻辑中分离出来。

示例：在不修改业务代码的情况下添加日志

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore() {
        System.out.println("方法执行前...");
    }
}

🎯 MiniSpring 项目目标

项目定位

MiniSpring 是一个教学项目，旨在通过实现一个精简版的 Spring 框架，帮助开发者深入理解 Spring 的核心原理。

功能范围

✅ 将要实现的功能：

1. IoC 容器：ApplicationContext 作为容器核心
2. 依赖注入：支持构造函数注入和字段注入（@Autowired）
3. Bean 生命周期：支持 singleton 和 prototype 作用域，实现初始化和销毁回调
4. 组件扫描：基于注解 (@Component) 的自动扫描和注册
5. 简单 AOP：基于 JDK 动态代理，支持 @Before 和 @After 通知
6. 按类型和按名称注入：灵活的依赖查找机制

❌ 不包含的功能：

• 事务管理 (@Transactional)
• Spring MVC 和 Web 容器集成
• Spring Data 数据访问层
• Spring Security 安全框架
• XML 配置支持（仅支持注解配置）
• 复杂的 AOP 功能（环绕通知、异常通知、AspectJ 语法）
• 属性文件注入 (@Value)
• 事件机制和监听器
• 条件装配 (@Conditional)

代码量控制

• 核心代码控制在 1000-1500 行以内
• 去除复杂特性，专注于核心功能
• 代码结构清晰，易于理解

🛠️ 开发环境准备

1. JDK 版本

推荐版本：Java 17 (LTS)

选择理由：

• Java 17 是长期支持版本
• 提供了现代化的语言特性
• 保持良好的稳定性和广泛的社区支持

最低兼容版本：Java 8（如需兼容，可调整语法）

2. 构建工具

Maven 3.8+

Maven 是 Java 生态中最成熟的构建工具，依赖管理简单清晰，适合教学和小型项目。

3. IDE 选择

推荐使用：

• IntelliJ IDEA（推荐）
• Eclipse
• VS Code（需安装 Java 扩展）

4. 核心依赖

本项目主要使用 Java 标准库，无需第三方依赖：

• 反射 API：java.lang.reflect
• 注解处理：java.lang.annotation
• JDK 动态代理：java.lang.reflect.Proxy

可选依赖（用于测试和调试）：

• JUnit 5：单元测试
• SLF4J + Logback：日志记录

📁 项目结构设计

包结构规划

com.minispring/
├── beans/                    # Bean 相关
│   └── factory/             # BeanFactory 接口和实现
│       ├── annotation/      # Bean 相关注解
│       │   ├── Autowired.java
│       │   ├── Qualifier.java
│       │   ├── PostConstruct.java
│       │   └── PreDestroy.java
│       ├── config/          # Bean 配置
│       │   └── BeanDefinition.java
│       ├── BeanFactory.java # BeanFactory 接口
│       └── *Exception.java  # 异常类
├── context/                  # 应用上下文
│   ├── annotation/          # 上下文相关注解
│   │   ├── Scope.java
│   │   └── Lazy.java
│   ├── ApplicationContext.java  # 核心容器实现
│   └── ClassPathBeanScanner.java # 类路径扫描器
├── aop/                      # AOP 相关
│   ├── Aspect.java
│   ├── Before.java
│   ├── After.java
│   └── AopProxy.java
└── stereotype/              # 组件注解
    └── Component.java

设计原则

1. 分层清晰：beans、context、aop 各司其职
2. 接口抽象：BeanFactory 作为核心接口
3. 注解驱动：使用注解配置，简化使用
4. 扩展性：预留扩展点，便于后续增强

🚀 创建项目

1. 使用 Maven 创建项目

mvn archetype:generate 
  -DgroupId=com.minispring 
  -DartifactId=mini-spring 
  -DarchetypeArtifactId=maven-archetype-quickstart 
  -DinteractiveMode=false

2. 配置 pom.xml

创建 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>com.minispring</groupId>
  <artifactId>mini-spring</artifactId>
  <version>1.0.0</version>
  <packaging>jar</packaging>

  <name>Mini Spring Framework</name>
  <description>一个精简版的 Spring 框架实现，用于学习 IoC、DI 和 AOP 原理</description>

  <properties>
    <java.version>17</java.version>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <!-- 依赖版本 -->
    <junit.version>5.9.3</junit.version>
    <slf4j.version>2.0.7</slf4j.version>
    <logback.version>1.4.8</logback.version>
  </properties>

  <dependencies>
    <!-- JUnit 5 测试框架 -->
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-engine</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>

    <!-- 日志依赖（可选，用于调试） -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>${logback.version}</version>
      <optional>true</optional>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <!-- Maven 编译插件 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.11.0</version>
        <configuration>
          <source>${java.version}</source>
          <target>${java.version}</target>
          <encoding>${project.build.sourceEncoding}</encoding>
        </configuration>
      </plugin>

      <!-- Maven 测试插件 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>3.1.2</version>
      </plugin>
    </plugins>
  </build>
</project>

3. 创建目录结构

mkdir -p src/main/java/com/minispring/{beans/factory/{annotation,config},context/annotation,aop,stereotype}
mkdir -p src/test/java/com/minispring

4. 验证项目

# 编译项目
mvn clean compile

# 运行测试（如果有）
mvn test

📝 本讲总结

本讲我们完成了：

1. ✅ 了解了 Spring 框架的核心概念（IoC、DI、AOP）
2. ✅ 明确了 MiniSpring 项目的目标和功能范围
3. ✅ 搭建了开发环境（JDK 17、Maven）
4. ✅ 设计了项目包结构
5. ✅ 创建了 Maven 项目并配置了 pom.xml

🎯 下一讲预告

在下一讲中，我们将开始实现 IoC 容器基础，包括：

• BeanFactory 接口设计
• ApplicationContext 核心实现
• Bean 的存储与管理机制

准备好了吗？让我们继续 第 02 讲：IoC 容器基础！

思考题：

1. IoC 和 DI 有什么区别和联系？
2. 为什么 Spring 框架要使用 IoC 容器？
3. 你理解的”控制反转”是什么意思？