前言

上一篇文章中我们讲了 Spring 的相关简介，那么这一节我们就来看看，如何使用 Spring 来创建一个最简单的 HelloWorld 入门实例。等到我们上手之后，再去研究一下 Spring 的一些核心原理及配置。

创建 Spring 实例的各种方式

创建 Spring 项目的方式有很多种，最原始可以通过导包来创建，但在这里我们就直接用 Maven 来进行依赖管理，省去各种导包过程。如果你对 Maven 还不够熟悉，那么推荐你先去看看 Maven 的相关内容，我这里之前也写了 Maven 的相关文章，详情可戳 👉 Maven 系列文章。

Maven 创建

  1. 新建 Maven 项目；

创建 Spring 项目的 3 种方式 - 图1

  1. 填写项目名及 Maven 坐标相关配置；

创建 Spring 项目的 3 种方式 - 图2

  1. 点击 Finish 后完成项目构建，构建后的项目目录结构如下；

创建 Spring 项目的 3 种方式 - 图3

  1. 接下来我们就是在 pom.xml 中添加 Spring 的相关依赖，这里主要导入 Spring 的四个核心依赖包 Beans、Context、Core、Expression。
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.cunyu1943</groupId>
  8.     <artifactId>springdemo1</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <properties>
  12.         <maven.compiler.source>11</maven.compiler.source>
  13.         <maven.compiler.target>11</maven.compiler.target>
  14.     </properties>
  15.     <dependencies>
  16.         <dependency>
  17.             <groupId>org.springframework</groupId>
  18.             <artifactId>spring-core</artifactId>
  19.             <version>5.3.9</version>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>org.springframework</groupId>
  23.             <artifactId>spring-context</artifactId>
  24.             <version>5.3.9</version>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>org.springframework</groupId>
  28.             <artifactId>spring-beans</artifactId>
  29.             <version>5.3.9</version>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>org.springframework</groupId>
  33.             <artifactId>spring-expression</artifactId>
  34.             <version>5.3.9</version>
  35.         </dependency>
  36.     </dependencies>
  37. </project>
  1. 创建一个普通类，然后类中创建一个普通方法；
  1. package com.cunyu;
  3. /**
  4.  * Created with IntelliJ IDEA.
  5.  *
  6.  * @author : zhangliang
  7.  * @version : 1.0
  8.  * @project : JavaLearning
  9.  * @package : com.cunyu
  10.  * @className : Hero
  11.  * @createTime : 2021/8/14 10:48
  12.  * @description : 英雄实体类
  13.  */
  14. public class Hero {
  15.     private String name;
  16.     private Integer sex;
  18.     public void attack() {
  19.         System.out.println("开始攻击 ~");
  20.     }
  21. }
  1. 创建 Spring 配置文件，用于配置创建的对象；

Spring 配置文件一般是一个 xml 文件，其名字可以有我们自定义。但是要注意它的存放位置，一般是位于 resources 目录下，如果放在其他位置，有可能出现报错。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  5.     <bean id="hero" class="com.cunyu.Hero"></bean>
  6. </beans>
  1. 建立测试类进行测试；
  1. package com.cunyu;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. /**
  8.  * Created with IntelliJ IDEA.
  9.  *
  10.  * @author : zhangliang
  11.  * @version : 1.0
  12.  * @project : JavaLearning
  13.  * @package : com.cunyu
  14.  * @className : HeroTest
  15.  * @createTime : 2021/8/14 10:55
  16.  * @description : 英雄测试类
  17.  */
  18. public class HeroTest {
  19.     @Test
  20.     public void testAttack() {
  21.         //    加载 Spring 配置文件
  22.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("ApplicationContent.xml");
  24.         //    获取配置创建的对象
  25.         Hero hero = applicationContext.getBean("hero", Hero.class);
  26.         System.out.println(hero);
  28.         hero.attack();
  29.     }
  30. }

创建 Spring 项目的 3 种方式 - 图4

Spring Initializer 创建

  1. 新建项目时选择 Spring Initializer ，并填下 Maven 坐标相关信息；

创建 Spring 项目的 3 种方式 - 图5

  1. 这里其实严格上说是一个 SpringBoot 项目，而不是 Spring 项目，但用于 Spring 项目也可以，直接 Finish；

创建 Spring 项目的 3 种方式 - 图6

  1. 同样的，我们创建实体类 Hero
  1. package com.cunyu.springdemo2;
  3. /**
  4.  * Created with IntelliJ IDEA.
  5.  *
  6.  * @author : zhangliang
  7.  * @version : 1.0
  8.  * @project : JavaLearning
  9.  * @package : com.cunyu.springdemo2
  10.  * @className : Hero
  11.  * @createTime : 2021/8/14 11:18
  12.  * @description :
  13.  */
  14. public class Hero {
  15.     private String name;
  16.     private Integer sex;
  18.     public void attack() {
  19.         System.out.println("开始攻击 ~");
  20.     }
  21. }
  1. 然后同样在 resources 目录下新建 Spring 配置文件 ApplicationContent.xml；
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  5.     <bean id="hero" class="com.cunyu.springdemo2.Hero"></bean>
  6. </beans>
  1. 编写测试类进行测试；
  1. package com.cunyu.springdemo2;
  3. import org.junit.jupiter.api.Test;
  4. import org.springframework.boot.test.context.SpringBootTest;
  5. import org.springframework.context.ApplicationContext;
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;
  8. @SpringBootTest
  9. class SpringDemo2ApplicationTests {
  11.     @Test
  12.     void testAttack() {
  13.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("ApplicationContent.xml");
  14.         Hero hero = applicationContext.getBean("hero", Hero.class);
  15.         System.out.println(hero);
  16.         hero.attack();
  17.     }
  19. }

创建 Spring 项目的 3 种方式 - 图7

  1. 注意

通过这种方式创建的 pom.xml 文件如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.5.3</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.cunyu</groupId>
  12.     <artifactId>springdemo2</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>SpringDemo2</name>
  15.     <description>SpringDemo2</description>
  16.     <properties>
  17.         <java.version>11</java.version>
  18.     </properties>
  19.     <dependencies>
  20.         <dependency>
  21.             <groupId>org.springframework.boot</groupId>
  22.             <artifactId>spring-boot-starter</artifactId>
  23.         </dependency>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-test</artifactId>
  28.             <scope>test</scope>
  29.         </dependency>
  31.     </dependencies>
  33.     <build>
  34.         <plugins>
  35.             <plugin>
  36.                 <groupId>org.springframework.boot</groupId>
  37.                 <artifactId>spring-boot-maven-plugin</artifactId>
  38.             </plugin>
  39.         </plugins>
  40.     </build>
  42. </project>

对比通过 Maven 创建的方式，这里所添加的依赖有所不同。这是因为这种方式实际上创建的是 SpringBoot 项目，而 SpringBoot 的依赖和 Spring 有所不同，但 SpringBoot 能够实现 Spring 所具有的功能，所以这里不用再去重复添加 Spring 的相关依赖。

在线创建

这种方式其实和 Spring Initializer 创建的方式一样，只不过它是以网页在线的方式，然后再导入导出 IDEA 中进行后续操作。

  1. 打开 https://start.spring.io/ 来生成项目；

创建 Spring 项目的 3 种方式 - 图8

  1. 然后点击左下角生成按钮或使用快捷键 Ctrl + Enter 生成；
  2. 将压缩包下载后，解压缩后用自己喜欢的 IDE 开发即可；

创建 Spring 项目的 3 种方式 - 图9

假如我们导入到 IDEA，那么接下来的步骤就是同上一种方式相同，接着就是创建实体类、配置 Spring 相关配置，最后测试类测试即可。

总结

好了，以上就是今天的所有内容了，主要介绍了 3 种创建 Spring 实例的方式。当然，你也可以去把 Spring 相关的依赖包进行下载后，然后导入包的方式进行项目创建，但这里更加推荐使用 Maven 的方式，方便快捷。

最后，原创不易，如果你觉得文章的内容对你有所帮助，那就点赞关注吧！