Spring菜鸟教程该怎么学？-杰瑞科技汇

什么是 Spring？为什么需要它？（小白必看）

想象一下,你在盖房子。

没有 Spring 的时候：你像一个总工程师，需要亲自去采购每一块砖、每一袋水泥、每一根钢筋（这些就是你的 Java 对象，UserService, DataSource），你还要知道怎么把它们一块块地砌起来，让它们协同工作，如果房子很大（项目很复杂），你需要记住成千上万个零件的用途和连接方式，这非常痛苦，而且很容易出错，这就是传统的 Java 开发，我们称之为 “硬编码” 和 “紧耦合”。
有了 Spring 的时候：你变成了一个“包工头”，你不需要自己去采购材料，而是写一张采购清单（这个清单在 Spring 里叫做 配置文件 或 Java 配置类），清单上写着：“我需要一台红色的挖掘机”、“我需要 100 袋标号 425 的水泥”，Spring 这个“神奇的项目经理”会根据你的清单，自动去找到、创建并管理好这些“材料”（Java 对象），你只需要在需要的时候告诉它“给我一台挖掘机”,它就会给你一台已经准备好的。

Spring 是一个“框架”：它提供了一套完整的企业级应用开发解决方案。
Spring 的核心是“控制反转”和“依赖注入”：这是它最神奇的地方，简单说，就是你不用自己去创建和管理对象，而是交给 Spring 来做，你只需要声明你需要什么，Spring 就会“注入”给你。
Spring 的好处：
- 解耦：各个组件之间的依赖关系大大降低,修改一个组件不会轻易影响另一个。
- 简单：大大简化了开发,你不需要写大量的重复代码。
- 高效：Spring 内置了很多成熟的功能，比如事务管理、Web 开发、安全等,你直接拿过来用就行。

第一步：搭建你的第一个 Spring 项目 (Maven + IDEA)

我们将使用最经典的 Spring Framework 和 Maven 来构建一个“Hello World”项目。

创建 Maven 项目

在 IntelliJ IDEA 中，选择 File -> New -> Project，然后选择 Maven，不要勾选任何模板（因为我们想从零开始）。

添加 Spring 依赖

打开 pom.xml 文件，添加 Spring 的核心依赖，Spring 5.x 版本需要额外引入 spring-context。

<dependencies>
    <!-- Spring 核心容器 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.23</version> <!-- 你可以使用更新的版本 -->
    </dependency>
</dependencies>

点击 IDEA 右下角的 Import Changes 或让 Maven 自动下载依赖。

创建一个简单的 Java 类

这个类就是我们想交给 Spring 管理的“材料”，它非常普通，没有任何 Spring 的痕迹。

// src/main/java/com/example/HelloWorld.java
package com.example;
public class HelloWorld {
    private String message;
    // Spring 会通过这个方法来注入值
    public void setMessage(String message) {
        this.message = message;
    }
    public void sayHello() {
        System.out.println(message);
    }
}

创建 Spring 配置文件

这是你的“采购清单”，在 src/main/resources 目录下，创建一个名为 applicationContext.xml 的文件。

<!-- src/main/resources/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">
    <!--
        id: 这个 bean 在 Spring 容器中的唯一标识。
        class: 要创建的对象的全限定类名。
    -->
    <bean id="helloWorld" class="com.example.HelloWorld">
        <!--
            property: 用于给对象的属性赋值。
            name: 属性名（与你的 Java 类中的 setXxx 方法对应，去掉 set，首字母小写）。
            value: 赋的值。
        -->
        <property name="message" value="Hello, Spring World!"/>
    </bean>
</beans>

运行程序

创建一个主类来启动 Spring 容器并获取我们的对象。

// src/main/java/com/example/MainApp.java
package com.example;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
    public static void main(String[] args) {
        // 1. 创建 Spring 容器
        // ClassPathXmlApplicationContext 会从 classpath 下寻找配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 2. 从容器中获取 bean
        // "helloWorld" 是我们在配置文件中定义的 id
        HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
        // 3. 调用对象的方法
        helloWorld.sayHello();
    }
}

运行 MainApp 的 main 方法，你会在控制台看到：

Hello, Spring World!

恭喜你！你已经成功运行了你的第一个 Spring 程序！

你刚刚体验了 Spring 的核心：

定义 Bean：在 applicationContext.xml 中定义了 HelloWorld 这个对象。
依赖注入：Spring 自动创建了 HelloWorld 对象，并通过 setMessage 方法给它设置了 message 属性。
获取 Bean：通过 context.getBean() 方法,我们从容器中拿到了已经准备好的对象。

第二步：进阶 - 注解方式（现代开发方式）

上面的 XML 配置方式虽然直观，但在大型项目中会非常繁琐，主流开发都使用注解，它能让你的 Java 代码更干净。

开启注解支持

在 applicationContext.xml 中添加一行，告诉 Spring 去扫描带有特定注解的类。

<!-- src/main/resources/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"
       xmlns:context="http://www.springframework.org/schema/context" <!-- 添加这一行 -->
       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"> <!-- 添加这一行 -->
    <!-- 告诉 Spring 去哪里扫描带有 @Component 等注解的类 -->
    <context:component-scan base-package="com.example"/>
</beans>

使用注解改造你的代码

你可以把 applicationContext.xml 中的 <bean> 标签删掉了,改用注解。

标记组件

在 HelloWorld.java 类上添加 @Component 注解，告诉 Spring：“我是一个需要被你管理的组件！”

// src/main/java/com/example/HelloWorld.java
package com.example;
import org.springframework.stereotype.Component; // 导入 Component 注解
@Component // 告诉 Spring，这个类是一个 Bean
public class HelloWorld {
    private String message;
    // 使用 @Autowired 进行自动注入（稍后讲）
    // 或者用 setter 方法注入
    public void setMessage(String message) {
        this.message = message;
    }
    public void sayHello() {
        System.out.println(message);
    }
}

自动装配

Spring 可以自动帮你把依赖的“零件”组装起来，最常用的就是 @Autowired。

假设我们还有一个 MessageService：

// src/main/java/com/example/MessageService.java
package com.example;
import org.springframework.stereotype.Service;
@Service // 同样，这也是一个 Bean
public class MessageService {
    public String getMessage() {
        return "This is a message from MessageService!";
    }
}

现在修改 HelloWorld，让它使用 MessageService：

// src/main/java/com/example/HelloWorld.java
package com.example;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class HelloWorld {
    // Spring 会自动在容器中寻找类型为 MessageService 的 Bean，并注入到这里
    @Autowired
    private MessageService messageService;
    public void sayHello() {
        System.out.println(messageService.getMessage());
    }
}

你的 MainApp 代码可以完全不变，运行它,你会看到：

This is a message from MessageService!

你看，我们完全没有在 XML 里配置 HelloWorld 和 MessageService 之间的关系，Spring 就通过 @Autowired 自动帮我们完成了。

第三步：了解 Spring 的核心概念

IoC (Inversion of Control) - 控制反转

这是 Spring 的思想核心。“控制权”的转移。

没有 IoC：对象创建、依赖查找、生命周期管理等控制权都在开发者手中（在代码里 new 出来）。
有了 IoC：这些控制权都交给了 Spring 容器，你只需要告诉容器你需要什么,容器会为你准备好。

DI (Dependency Injection) - 依赖注入

这是 IoC 的一种具体实现方式。“依赖关系”的建立。

什么是依赖：类 A 中用到了类 B 的对象，A 就依赖于 B。
什么是注入：不是 A 自己去创建 B，而是由外部（Spring 容器）创建好 B，注入”到 A 中。
- Setter 注入：通过 setter 方法注入（我们第一个例子用的）。
- 构造器注入：通过类的构造方法注入（推荐，尤其在 Spring Boot 中）。
- 字段注入：直接在字段上使用 @Autowired（简单但不推荐，因为它隐藏了依赖）。

Bean

在 Spring 中，由 Spring 容器创建、管理和装配的对象，都称为 Bean，你可以把它理解为 Spring 管理的“组件”。

Spring 容器

Spring 容器是 Spring 框架的核心，它负责创建 Bean、配置 Bean，并且管理它们的生命周期,最常用的两个容器实现是：

ApplicationContext：功能更全面的容器,是开发中首选。
BeanFactory：是基础容器,功能较少。

下一步去哪里？

你已经掌握了 Spring 最基础的概念，这是一个巨大的进步！你可以探索更广阔的 Spring 生态：

Spring Boot (强烈推荐！)：这是现代 Spring 开发的事实标准，它极大地简化了 Spring 应用的创建和部署，通过“约定优于配置”的理念，让你能快速启动一个项目。学完 Spring Framework 基础后，下一步就是学习 Spring Boot。
Spring MVC：如果你想做 Web 开发（比如网站、API），Spring MVC 是你必学的，它是一个用于构建 Web 应用程序的强大框架。
Spring Data JPA / MyBatis：用于操作数据库，让你可以不用写繁琐的 SQL 语句。
Spring Security：用于为你的应用添加安全认证和授权功能。

学习资源推荐

官方文档：永远是最好的资料,虽然有时比较晦涩。
菜鸟教程网站：有关于 Spring Boot 的中文教程,可以继续在上面学习。
Bilibili：搜索“Spring Boot 入门”,有大量优秀的免费视频教程。
书籍：《Spring 实战》（Spring in Action）是一本非常经典的入门书籍。

希望这份菜鸟教程能帮助你顺利开启 Spring 学习之旅！多动手实践，从最简单的例子开始，慢慢你就会发现 Spring 的强大之处,祝你学习愉快！

Spring菜鸟教程该怎么学？

什么是 Spring？为什么需要它？（小白必看）

第一步：搭建你的第一个 Spring 项目 (Maven + IDEA)

创建 Maven 项目

添加 Spring 依赖

创建一个简单的 Java 类

创建 Spring 配置文件

运行程序

第二步：进阶 - 注解方式（现代开发方式）

开启注解支持

使用注解改造你的代码

第三步：了解 Spring 的核心概念

IoC (Inversion of Control) - 控制反转

DI (Dependency Injection) - 依赖注入

Bean

Spring 容器

下一步去哪里？

学习资源推荐

99ANYc3cd6

Jade XRD教程怎么学？入门步骤有哪些？

Python ringbuffer如何实现高效循环队列？

CentOS教程PDF哪里找？

Java类间继承关系是怎样的？

Java如何调用Python代码？

Java Socket编程实例具体怎么实现？

Java数组与ArrayList，何时用哪个更合适？

Java如何开发RESTful WebService？

Java如何将String转为Double？

Java异常捕获时，父类异常能否先于子类被catch？

Java表单提交如何正确使用from标签？

Python array flatten有哪些方法？

Puppet如何自动化部署Python Django项目？

string转datetime java，如何正确转换？

Java日期如何转为整数？

ArrayList与List有何区别？

Spring菜鸟教程该怎么学？

什么是 Spring？为什么需要它？（小白必看）

第一步：搭建你的第一个 Spring 项目 (Maven + IDEA)

创建 Maven 项目

添加 Spring 依赖

创建一个简单的 Java 类

创建 Spring 配置文件

运行程序

第二步：进阶 - 注解方式（现代开发方式）

开启注解支持

使用注解改造你的代码

第三步：了解 Spring 的核心概念

IoC (Inversion of Control) - 控制反转

DI (Dependency Injection) - 依赖注入

Bean

Spring 容器

下一步去哪里？

学习资源推荐

相关推荐

Java Socket编程实例具体怎么实现？