Java-Spring入门指南(二)利用IDEA手把手教你如何创建第一个Spring系统
- 前言
- 一、创建新项目
- 二、导入maven
- 三、配置依赖包
- 四、新建新模块
-
- [1. 在User中编写代码](#1. 在User中编写代码)
- [2. 在resources目录下创建beans.xml编写代码](#2. 在resources目录下创建beans.xml编写代码)
-
- [2.1 先看传统方式创建对象](#2.1 先看传统方式创建对象)
- [2.2 对应到Spring的<bean>配置](#2.2 对应到Spring的<bean>配置)
- [2.3 核心区别](#2.3 核心区别)
- [3. 如何利用Spring进行赋值](#3. 如何利用Spring进行赋值)
-
- [3.1 先看传统方式给对象设置属性](#3.1 先看传统方式给对象设置属性)
- [3.2 对应到Spring的<property>配置](#3.2 对应到Spring的<property>配置)
- [3.2 核心逻辑](#3.2 核心逻辑)
- 五、在test文件下的java文件下创建UserTest
-
- [2. 方式一:ClassPathXmlApplicationContext(推荐使用)](#2. 方式一:ClassPathXmlApplicationContext(推荐使用))
-
- [2.1 第一步:创建Spring容器(加载配置文件)](#2.1 第一步:创建Spring容器(加载配置文件))
- [2.2 第二步:从容器中获取User对象](#2.2 第二步:从容器中获取User对象)
- [2.3 第三步:打印对象(验证结果)](#2.3 第三步:打印对象(验证结果))
- [3. 方式二:FileSystemXmlApplicationContext(了解为主)](#3. 方式二:FileSystemXmlApplicationContext(了解为主))
-
- [3.1 核心代码拆解](#3.1 核心代码拆解)
- [3.2 和方式一的对比](#3.2 和方式一的对比)
前言
- 在前一篇《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的模板
java
<?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
https://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代码中,我们创建对象是这样的:
java
// 声明一个User类型的变量user,同时创建User对象
User user = new User();
User
:是要创建的对象的类名 (完整类名应该包含包路径,比如org.example.pojo.User
)user
:是这个对象的引用变量名(我们通过这个变量名来使用对象)new User()
:实际创建对象的动作
2.2 对应到Spring的配置
Spring的核心是"IoC容器",它帮我们管理对象的创建。配置文件中的<bean>
标签就是告诉容器:"请帮我创建一个对象,按这个规则来"。
以我们的例子为例:
xml
<bean id="..." class="...">
<!-- collaborators and configuration for this bean go here -->
</bean>
-
id=" "
:对应传统方式中的变量名这是这个对象在Spring容器中的"唯一标识",后续我们可以通过这个
id
从容器中获取这个对象(类似通过变量名使用对象)。 -
class=" "
:对应传统方式中的类名这里需要写全限定类名 (包名+类名),告诉Spring容器:"你要创建的是
那里
包下的什么
类的对象",相当于传统方式中new
后面的类名。- 因此他的完整写法是这样的
java
<bean id="user" class="org.example.pojo.User">
<!-- 这里可以配置对象的属性、依赖等 -->
</bean>

2.3 核心区别
- 传统方式:我们自己用
new
手动创建对象("我来控制对象创建")。 - Spring方式:我们在配置文件中告诉容器"要创建什么对象",由容器自动创建("容器控制对象创建"),这就是"IoC(控制反转)"的核心思想。
总结来说,<bean>
标签就是Spring容器创建对象的"说明书":id
是对象的"名字",class
是对象的"类型",容器根据这个说明书帮我们创建并管理对象。
3. 如何利用Spring进行赋值
3.1 先看传统方式给对象设置属性
创建对象后,我们通常会通过setter方法给对象的属性赋值:
java
// 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值"。

xml
<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容器的执行流程相当于:
- 先通过
<bean class="org.example.pojo.User">
创建对象:User user = new User();
- 再通过
<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(控制反转)的实际效果。
先看完整代码,接下来我们逐行拆解核心逻辑:
java
import org.example.pojo.User;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class UserTest {
@Test
public void test() {
//方式一:从类路径加载Spring配置文件(推荐)
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
//从容器中获取配置好的User对象
User user = applicationContext.getBean("user", User.class);
//打印对象(验证是否获取成功)
System.out.println(user);
}
@Test
public 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容器(加载配置文件)
java
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对象
java
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 第三步:打印对象(验证结果)
java
System.out.println(user);
这行代码看似简单,实则和我们之前的操作呼应:
因为我们在User类中重写了toString()方法 (前面"在User中编写代码"步骤提到的),所以这里打印的不是晦涩的内存地址(比如org.example.pojo.User@123456
),而是清晰的属性值,比如:

User{name='Bob', age=18}
如果能看到这个结果,说明:
- Spring容器成功加载了beans.xml;
- 容器成功创建了User对象并赋值;
- 我们成功从容器中获取到了对象。
3. 方式二:FileSystemXmlApplicationContext(了解为主)
test1()
方法用的是另一种加载配置文件的方式,核心是"通过电脑的绝对路径找beans.xml",实际开发中很少用,原因是移植性差。
3.1 核心代码拆解
java
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
|--------------------|
| 非常感谢您的阅读,喜欢的话记得三连哦 |
