第1章: Spring 简介

一句话理解 Spring

🍳 生活比喻：餐厅 vs 自己做饭

🏠 自己做饭（传统 Java）

自己买菜 → new 菜()
自己切菜 → new 刀()
自己炒菜 → new 锅()
自己洗碗 → 手动销毁
什么都要自己管！

→

🏨 去餐厅（用 Spring）

点菜 → getBean("鱼香肉丝")
厨房备好一切 → 容器自动创建
端上来直接吃 → 直接使用
餐厅负责收拾 → 容器管理生命周期
你只管"吃"（写业务逻辑）！

一句话总结：Spring 就是一个"万能管家"，帮你创建对象、管理对象、连接对象，你只需要专注写业务代码。

💡 Spring 的两大核心超能力：

IoC（控制反转）

对象不用自己 new，Spring 帮你创建和管理
类似：你不用自己做饭，餐厅帮你做

AOP（面向切面编程）

日志、安全检查等自动加上，不用每个方法都写
类似：门卫自动登记，不用每个人都手写签到

Spring 家族全景图

Spring 是模块化的，像乐高积木一样，需要哪块用哪块。点击卡片查看详情：

🧱

核心容器

spring-core / spring-beans / spring-context
Spring 的地基，管理所有对象

🌐

Web 模块

spring-web / spring-webmvc
做网站、写接口的工具

🗄️

数据访问

spring-jdbc / spring-orm / spring-tx
连接数据库、管理事务

✂️

AOP 切面

spring-aop / spring-aspects
日志、权限等横切功能

⚠️ 初学者只需关注：

本章和后续几章主要学核心容器（IoC 和 DI），这是 Spring 的根基。Web 和数据库部分后面章节会专门讲。

跟我做：第一个 Spring 程序（XML 方式）

⚠️ 先别急着看理论！

按照下面的步骤，一步一步来。复制粘贴就能运行！

1

打开 IntelliJ IDEA → New Project

选择 Maven，GroupId 填 com.example，ArtifactId 填 spring-hello，点 Create

2

修改 pom.xml — 添加 Spring 依赖

打开项目根目录的 pom.xml，在 <project> 标签内添加：

<!-- 📄 pom.xml — Maven 依赖配置 -->
<dependencies>
    <!-- Spring 核心容器: 包含 IoC 容器、Bean 管理、注解支持 -->
    <!-- 引入这一个就够了，会自动拉取 spring-core、spring-beans 等 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.30</version>
    </dependency>
</dependencies>

添加后点右上角的 Maven 刷新按钮（🔄），等待下载完成

3

按照这个目录结构创建文件

spring-hello/
  src/main/java/com/example/spring/
    HelloWorld.java ← Bean 类
    MainApp.java ← 启动入口
  src/main/resources/
    applicationContext.xml ← Spring 配置文件
  pom.xml ← 已修改

4

逐个复制粘贴以下代码到对应文件

HelloWorld.java applicationContext.xml MainApp.java

📁 文件位置: src/main/java/com/example/spring/HelloWorld.java

// 📄 HelloWorld.java — 一个普通的 Java 类（Bean）
package com.example.spring;

// 注意: 这里没有任何 Spring 注解！
// 它就是一个普通的 Java 类，由 XML 配置文件告诉 Spring 来管理它
public class HelloWorld {
    private String message;  // 属性，将由 Spring 通过 setter 赋值

    // ⚠️ 必须有 setter！Spring XML 配置的 <property> 标签会调用它
    public void setMessage(String message) {
        this.message = message;
    }

    public void showMessage() {
        System.out.println("Spring 说: " + message);
    }
}

📁 文件位置: src/main/resources/applicationContext.xml

⚠️ 右键 resources 文件夹 → New → File → 输入 applicationContext.xml

<!-- 📄 applicationContext.xml — Spring XML 配置文件 -->
<?xml version="1.0" encoding="UTF-8"?>
<!-- 这是 Spring 的“菜单”，告诉容器要创建哪些对象、怎么配置 -->
<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">

    <!-- 定义一个 Bean: -->
    <!-- id="helloWorld": Bean 的名字，后面用 getBean("helloWorld") 取它 -->
    <!-- class: 告诉 Spring 创建哪个类的实例 -->
    <bean id="helloWorld" class="com.example.spring.HelloWorld">
        <!-- property: 调用 setMessage() 方法，把值设置进去 -->
        <property name="message" value="Hello Spring!"/>
    </bean>

</beans>

📁 文件位置: src/main/java/com/example/spring/MainApp.java

// 📄 MainApp.java — 启动入口（XML 方式）
package com.example.spring;

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

public class MainApp {
    public static void main(String[] args) {
        // 第1步: 启动 Spring 容器
        // 读取 classpath 下的 XML 配置文件，创建并管理所有 Bean
        ApplicationContext context =
            new ClassPathXmlApplicationContext("applicationContext.xml");

        // 第2步: 从容器中获取对象
        // 注意: 我们没有写 new HelloWorld()！对象是容器创建的
        // "helloWorld" 对应 XML 中 <bean id="helloWorld">
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");

        // 第3步: 直接使用
        // message 已经被 Spring 通过 <property> 设置好了！
        obj.showMessage();  // 输出: Spring 说: Hello Spring!
    }
}

5

运行 MainApp.java 的 main 方法

右键 MainApp.java → Run 'MainApp.main()'，你会看到：

Spring 说: Hello Spring!

🎯 你刚刚做了什么？

整个过程你没有写 new HelloWorld()！
对象是 Spring 容器帮你创建的，属性值也是 Spring 帮你设置的。
这就是 IoC（控制反转）—— 对象的控制权从"你"转移到了"Spring 容器"。

跟我做：注解方式（推荐，现代写法）

💡 为什么要学注解方式？

上面的 XML 方式太啰嗦了！现代开发中 99% 用注解方式，更简洁、更直观。下面同样是复制粘贴就能跑！

❌ XML：需要额外配置文件

<bean id="helloWorld" 
  class="com.example.HelloWorld">
  <property name="message" 
    value="Hello!"/>
</bean>

→

✅ 注解：一行搞定

@Component  // 告诉Spring：管理我！
public class HelloWorld {
    private String message 
        = "Hello Spring!";
}

1

新建项目（或沿用上面的项目）

如果新建：IDEA → New Project → Maven，GroupId: com.example，ArtifactId: spring-annotation。pom.xml 依赖与上面一样。

2

按照这个目录结构创建 3 个文件

spring-annotation/
  src/main/java/com/example/spring/
    AppConfig.java ← 配置类（替代 XML）
    HelloWorld.java ← Bean 类
    MainApp.java ← 启动入口
  pom.xml ← 同上

3

逐个复制粘贴以下代码

AppConfig.java HelloWorld.java MainApp.java

📁 文件位置: src/main/java/com/example/spring/AppConfig.java

// 📄 AppConfig.java — 配置类（替代 XML 配置文件）
package com.example.spring;

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

// @Configuration: 标记为配置类，等价于一个 XML 配置文件
// @ComponentScan: Spring 启动时会扫描这个包下所有带 @Component 的类
@Configuration
@ComponentScan(basePackages = "com.example.spring")
public class AppConfig {
    // 不需要写任何代码！
    // Spring 自动扫描包下所有 @Component 标记的类，创建并管理它们
}

📁 文件位置: src/main/java/com/example/spring/HelloWorld.java

// 📄 HelloWorld.java — 注解方式的 Bean
package com.example.spring;

import org.springframework.stereotype.Component;

// @Component: 告诉 Spring“请管理我”
// Spring 扫描时看到这个注解，就会自动创建这个类的实例放入容器
// 不需要写 XML，一个注解搞定！
@Component
public class HelloWorld {
    // 直接赋初始值（不再需要 XML 的 <property>）
    private String message = "Hello Spring with Annotations!";

    public void showMessage() {
        System.out.println("Spring 说: " + message);
    }
}

📁 文件位置: src/main/java/com/example/spring/MainApp.java

// 📄 MainApp.java — 启动入口（注解方式）
package com.example.spring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        // 用 AnnotationConfigApplicationContext 替代 ClassPathXmlApplicationContext
        // 传入配置类 → Spring 读取 @ComponentScan → 自动扫描并创建 Bean
        ApplicationContext context =
            new AnnotationConfigApplicationContext(AppConfig.class);

        // 从容器获取 Bean（按类型获取，不需要强转）
        // 没有 new！Spring 自动创建的
        HelloWorld obj = context.getBean(HelloWorld.class);

        obj.showMessage();  // 输出: Spring 说: Hello Spring with Annotations!
    }
}

4

运行 MainApp.java 的 main 方法

右键 MainApp.java → Run 'MainApp.main()'，你会看到：

Spring 说: Hello Spring with Annotations!

🎯 注解方式 vs XML 方式对比

✅ 不需要 applicationContext.xml 配置文件了
✅ 加 @Component 就能让 Spring 管理，不用写 <bean> 标签
✅ 用 @Configuration + @ComponentScan 替代整个 XML
结论：后面所有章节都用注解方式，XML 了解即可！

💡 常用注解速查表：

注解	含义	白话翻译
`@Component`	通用组件	"Spring 你来管我"
`@Service`	业务逻辑层	"我是干活的"
`@Repository`	数据访问层	"我负责存数据"
`@Controller`	控制器层	"我接收用户请求"
`@Configuration`	配置类	"我是菜单/说明书"

互动实验室：亲手操作 Spring 容器

🧪 Spring IoC 容器模拟器

点击按钮模拟 Spring 容器的工作过程，观察对象是如何被创建和管理的

📋 配置文件（Bean 定义）

🗄️ UserDao — 数据访问层

⚙️ UserService — 业务逻辑层

🌐 UserController — 控制器

📊 容器状态

容器未启动，点击下方按钮开始

// 控制台日志将显示在这里...

⚡ 传统方式 vs Spring 方式 — 实时对比

点击按钮，看两种方式写代码的区别

📝 闯关练习

做完这 3 道题，确认你理解了本章核心知识点！

第 1 关：Spring 的核心特性是什么？

A. IoC 和 MVC B. IoC 和 AOP C. AOP 和 JDBC D. MVC 和 ORM

第 2 关：以下代码用了 Spring 的什么特性？

ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
UserService service = ctx.getBean(UserService.class); // 没有 new！

A. AOP 面向切面编程 B. IoC 控制反转 — 对象由容器创建和管理 C. 事务管理 D. MVC 模式

第 3 关：连线配对 — 把注解和它的作用对应起来

先点左边的注解，再点右边对应的作用

@Component

@Service

@Repository

@Controller

→
→
→
→

接收用户请求

通用组件标记

业务逻辑层

数据访问层

本章小结

🧱 Spring 是什么

Java 世界的"万能管家"
帮你创建、管理、连接对象

🎯 两大核心

IoC = 容器帮你创建对象
AOP = 自动加上通用功能

⚙️ 两种配置方式

XML 配置（传统）
注解配置（推荐，更简洁）

🔑 核心套路

不用 new → 找容器 getBean
配置文件/注解 → 告诉容器管谁