Java-Spring入门指南（二）利用IDEA手把手教你如何创建第一个Spring系统

---

前言

• 在前一篇《Java-Spring 入门指南（一）》中，我们已经理清了 Spring 的核心逻辑：它是帮我们解决 “手动 new 对象”“模块耦合紧”“重复写工具代码” 的 Java 开发助手，也初步理解了 IOC（控制反转）——“让 Spring 接管对象创建和管理” 的核心思想
• 所以这一篇，我们直接进入实操环节—— 带你用 IDEA 从 0 到 1 搭建第一个能跑通的 Spring 系统。

我的个人主页，欢迎来阅读我的其他文章
https://blog.csdn.net/2402_83322742?spm=1011.2415.3001.5343
我的Java-Spring入门指南知识文章专栏
欢迎来阅读指出不足
https://blog.csdn.net/2402_83322742/category_13040333.html?spm=1001.2014.3001.5482

---

一、创建新项目

• 创建完之后删除右边的src文件
  

二、导入maven

我的maven如何下载并编辑为国内阿里云官方镜像的博客
https://blog.csdn.net/2402_83322742/article/details/145998804

编辑完之后在最右边找到maven设置

• 导入之后的样子
  

三、配置依赖包

首先我们需要在最外面的.xml安装俩个依赖包，分别是Spring的依赖包和junit的依赖包，以便于我们更好的测试和运行Spring

junit依赖包网站

https://mvnrepository.com/artifact/junit/junit
这里我选择了 4.13.2的版本

Spring依赖包网站

https://mvnrepository.com/artifact/org.springframework/spring-webmvc
这里我选择了 6.2.10 的版本

导入之后的样子

四、新建新模块

1. 在User中编写代码

• 之后在org.example的包下新建一个pojo的包，并在pojo的包下新建User和Test的俩个类
• 首先在User里面创建俩个私有变量name和age
• 并生成他们的Getter和Setter
• 接着生成他们的tostring

getter和setter是做什么的？

• 因为变量被private保护起来了，外面不能直接用 user.age 查看或修改年龄，所以需要专门的方法来 “获取” 和 “设置” 这些值：
• getter主要是获得对应的数据
• setter主要是可以修改对应的数据

tostring是做什么的？

• toString()是 Java 自带的一个方法，当你打印对象时（比如System.out.println(user)），Java 会默认调用这个方法。
  如果不重写，打印出来的会是一串看不懂的东西（比如org.example.pojo.User@123456），这是对象在内存中的地址，没啥用

2. 在resources目录下创建beans.xml编写代码

• 在 resources 目录下创建的 beans.xml，是 Spring 框架早期（XML 配置时代）的核心 IoC 容器配置文件，其核心作用是定义 Spring 容器管理的 Bean 对象、配置 Bean 之间的依赖关系、以及声明 Spring 相关的功能特性，是 Spring IoC（控制反转）容器实现 “对象创建权、依赖管理权” 的核心 “蓝图”

首先我们需要在resources目录下创建beans.xml

并在里面导入beans的模板

Spring官方网站
https://docs.spring.io/spring-framework/reference/index.html

• 我们可以在Spring官方网站下找到编写beans的模板

<?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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="..." class="..."><!-- collaborators and configuration for this bean go here --></bean><bean id="..." class="..."><!-- collaborators and configuration for this bean go here --></bean><!-- more bean definitions go here --></beans>

接下来我们详细讲一下这段代码与java中创建对象的关系

2.1 先看传统方式创建对象

在普通Java代码中，我们创建对象是这样的：

// 声明一个User类型的变量user，同时创建User对象
User user = new User();

• User：是要创建的对象的类名（完整类名应该包含包路径，比如org.example.pojo.User）
• user：是这个对象的引用变量名（我们通过这个变量名来使用对象）
• new User()：实际创建对象的动作

2.2 对应到Spring的配置

Spring的核心是"IoC容器"，它帮我们管理对象的创建。配置文件中的<bean>标签就是告诉容器：“请帮我创建一个对象，按这个规则来”。

以我们的例子为例：

<bean id="..." class="..."><!-- collaborators and configuration for this bean go here -->
</bean>

• id=" "：对应传统方式中的变量名
  这是这个对象在Spring容器中的"唯一标识"，后续我们可以通过这个id从容器中获取这个对象（类似通过变量名使用对象）。

• class=" "：对应传统方式中的类名
  这里需要写全限定类名（包名+类名），告诉Spring容器：“你要创建的是那里包下的什么类的对象”，相当于传统方式中new后面的类名。

  • 因此他的完整写法是这样的

<bean id="user" class="org.example.pojo.User"><!-- 这里可以配置对象的属性、依赖等 -->
</bean>

2.3 核心区别

• 传统方式：我们自己用new手动创建对象（“我来控制对象创建”）。
• Spring方式：我们在配置文件中告诉容器"要创建什么对象"，由容器自动创建（“容器控制对象创建”），这就是"IoC（控制反转）"的核心思想。

总结来说，<bean>标签就是Spring容器创建对象的"说明书"：id是对象的"名字"，class是对象的"类型"，容器根据这个说明书帮我们创建并管理对象。

3. 如何利用Spring进行赋值

3.1 先看传统方式给对象设置属性

创建对象后，我们通常会通过setter方法给对象的属性赋值：

// 1. 创建User对象
User user = new User();
// 2. 给对象的name和age属性赋值
user.setName("Bob");  // 设置name属性为"Bob"
user.setAge(18);      // 设置age属性为18

3.2 对应到Spring的配置

Spring容器在创建User对象（通过<bean>标签）后，会自动执行属性赋值操作，<property>标签就是告诉容器：“给这个对象的XX属性设置XX值”。

<property name="name" value="Bob"></property>
<property name="age" value="18"></property>

• name="name"：表示要给对象的name属性赋值（对应User类中的name属性）。

  注意：这里的name实际对应User类中的setName()方法（Spring通过setter方法赋值），所以User类必须有public void setName(String name)方法，否则会报错。

• value="Bob"：表示给name属性设置的值是"Bob"（字符串类型）。

• 同理，name="age" value="18"表示：给对象的age属性设置值18，对应User类中必须有public void setAge(int age)方法。

3.2 核心逻辑

Spring容器的执行流程相当于：

1. 先通过<bean class="org.example.pojo.User">创建对象：User user = new User();
2. 再通过<property>标签调用setter方法赋值：user.setName("Bob"); user.setAge(18);

这样配置后，从Spring容器中获取的user对象，已经是一个name="Bob"、age=18的完整对象了。

五、在test文件下的java文件下创建UserTest

最后我们需要在test文件下的java文件下创建UserTest以此来调用beans.xml里面已经创建好的对象。前面我们在beans.xml中定义了User类的Bean（对象），但“定义”不等于“使用”——UserTest的核心作用，就是通过Spring容器获取到这些预先配置好的Bean，验证Spring IoC（控制反转）的实际效果。

先看完整代码，接下来我们逐行拆解核心逻辑：

import org.example.pojo.User;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;public class UserTest {@Testpublic void test() {//方式一：从类路径加载Spring配置文件（推荐）ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");//从容器中获取配置好的User对象User user = applicationContext.getBean("user", User.class);//打印对象（验证是否获取成功）System.out.println(user);}@Testpublic void test1() {//方式二：从文件系统绝对路径加载配置文件（了解为主）FileSystemXmlApplicationContext applicationContext = new FileSystemXmlApplicationContext("E:\\IDEA代码\\课堂代码\\Java_Spring\\HelloSpring\\src\\main\\resources\\beans.xml");//从容器中获取配置好的User对象User user = applicationContext.getBean("user", User.class);//打印对象（验证是否获取成功）System.out.println(user);}
}

2. 方式一：ClassPathXmlApplicationContext（推荐使用）

这是实际开发中最常用的方式，因为它基于“类路径”加载配置文件，项目移植时不用修改路径（比如从自己电脑传到别人电脑，路径不会失效）。我们分3步拆解test()方法：

2.1 第一步：创建Spring容器（加载配置文件）

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");

这句话的核心是初始化Spring IoC容器，关键要理解两个点：

• 什么是“类路径（classpath）”？
  Maven项目中，src/main/resources目录下的所有文件（比如beans.xml），会在项目编译后自动放入“类路径”中。简单说，Spring会自动去resources目录下找beans.xml，所以我们不用写复杂路径，直接传文件名"beans.xml"就行。

• 容器初始化时做了什么？
  这里有个关键特性：当你创建ClassPathXmlApplicationContext对象时，Spring会立刻加载beans.xml，并创建所有配置好的Bean（对象）。
  比如我们在beans.xml中定义了<bean id="user" class="org.example.pojo.User">，此时user对象已经被Spring创建好了，存放在容器里——这和传统Java“用的时候才new”完全不同，是IoC的核心体现。

2.2 第二步：从容器中获取User对象

User user = applicationContext.getBean("user", User.class);

这行代码是“从容器拿对象”的核心，两个参数必须和beans.xml对应：

• 第一个参数"user"：对应beans.xml中<bean>标签的id属性（<bean id="user" ...>），是Bean在容器中的“唯一身份证”，通过它找到我们要的对象；
• 第二个参数User.class：指定要获取的对象类型，避免强制类型转换（如果只传"user"，返回的是Object类型，需要手动写(User)applicationContext.getBean("user")，容易出错）。

举个通俗的例子：容器就像一个“储物架”，每个Bean是架上的“物品”，id是物品的“标签”。getBean("user", User.class)就是说：“从储物架上，找标签为‘user’的物品，并且这个物品必须是User类型”。

2.3 第三步：打印对象（验证结果）

System.out.println(user);

这行代码看似简单，实则和我们之前的操作呼应：
因为我们在User类中重写了toString()方法（前面“在User中编写代码”步骤提到的），所以这里打印的不是晦涩的内存地址（比如org.example.pojo.User@123456），而是清晰的属性值，比如：

User{name='Bob', age=18}

如果能看到这个结果，说明：

1. Spring容器成功加载了beans.xml；
2. 容器成功创建了User对象并赋值；
3. 我们成功从容器中获取到了对象。

3. 方式二：FileSystemXmlApplicationContext（了解为主）

test1()方法用的是另一种加载配置文件的方式，核心是“通过电脑的绝对路径找beans.xml”，实际开发中很少用，原因是移植性差。

3.1 核心代码拆解

FileSystemXmlApplicationContext applicationContext = new FileSystemXmlApplicationContext("E:\\IDEA代码\\课堂代码\\Java_Spring\\HelloSpring\\src\\main\\resources\\beans.xml");

• 区别于方式一：它需要写完整的绝对路径（比如Windows下的E:\xxx\beans.xml，注意路径中的\要写成\\，因为\在Java中是“转义字符”，需要转义）；
• 缺点：如果把项目复制到其他电脑，或者修改了项目存放路径，这个绝对路径就会失效（比如别人电脑上没有E:\IDEA代码\...这个路径），导致代码报错。

3.2 和方式一的对比

为了更清晰，我们用表格总结两种方式的区别：

对比维度	方式一：ClassPathXmlApplicationContext	方式二：FileSystemXmlApplicationContext
加载路径	类路径（src/main/resources目录）	电脑文件系统绝对路径（如E:\xxx\beans.xml）
路径写法	直接写文件名（如"beans.xml"）	完整路径（如"E:\\xxx\\beans.xml"）
移植性	好（换电脑/路径不用改）	差（路径变了就报错）
实际开发使用频率	极高（推荐）	极低（仅了解）

到这里，我们的第一个Spring系统就完整跑通了：从创建项目、导入依赖，到配置Bean、获取Bean，每一步都围绕“Spring帮我们管理对象”这个核心。下一篇我们会在此基础上，探索Spring更多的配置方！

我的个人主页，欢迎来阅读我的其他文章
https://blog.csdn.net/2402_83322742?spm=1011.2415.3001.5343
我的Java-Spring入门指南知识文章专栏
欢迎来阅读指出不足
https://blog.csdn.net/2402_83322742/category_13040333.html?spm=1001.2014.3001.5482

非常感谢您的阅读，喜欢的话记得三连哦