【Spring 】项目创建和使用

ゝ一世哀愁。 2023-10-12 20:02 7阅读 0赞

![1252c628e6298c355aaa9e4fa30dc9cd.gif][]

>  **哈喽，哈喽，大家好~ 我是你们的老朋友：****保护小周ღ** ![1b8f8768c9cd4d7cabc7d51e10200ef5.jpeg][]
> 
> --------------------
> 
> 谈起Java 圈子里的框架，最年长最耀眼的莫过于 Spring 框架啦，如今已成为最流行、最广泛使用的Java开发框架之一。不知道大家有没有在使用 Spring 框架的时候思考过这些问题，**什么是框架？Spring 是什么？如何理解 Spring ? loC 和 DI 是什么，有什么区别？ Spring 最核心的功能是啥？** **本文将为大家讲解，一起来看看叭~**
> 
> --------------------
> 
> **本期收录于博主的专栏**：[JavaEE\_保护小周ღ的博客-CSDN博客][JavaEE_-CSDN]
> 
> 适用于编程初学者，感兴趣的朋友们可以订阅，查看其它 “JavaEE基础知识”。
> 
> **更多精彩敬请期待：保护小周ღ \*★,°\*:.☆(￣▽￣)/$:\*.°★\* ‘**

--------------------

## 一、Spring 的概念 ##

**书接上回，Spring : 包含众多工具方法的 IoC 容器。**

**Spring 的核心 ：IoC （控制反转）， DI (依赖注入)。**

**loC （Inversion of Control）**翻译成中文就是 “控制反转” 的意思，**控制反转一种编程设计思想**，将程序的控制流程从传统的主动调用方式转变为被动接收方式（一个类的内部不再实例另一个类，而是告诉程序这个类需要那个类作为参数采用运行），从而实现对象和对象之间的解耦和依赖管理。

**DI （Dependency Injection 的缩写——“依赖注入”）**“依赖注入” **指的就是由 IoC 容器在运行期间（程序运行期间），动态地将某种依赖关系注入到对象之中。**传统的做法是由程序主动去找他所依赖的对象然后进行实例化，而DI则是由容器主动地将依赖关系注入到对象中。这样做的好处是对象之间解耦。  
既然 Spring 是一个 loC 容器，那么它就具备两个最基本的功能：

*  将对象存储到容器（Spring）中
 *  从容器（Spring）中将对象取出来

**在 Java 中一个普通的实例化的对象也被称之为 Bean 对象，在框架这一块我们遇到的对象就是以 Bean 对象称呼。**

**想要了解更多 Spring 概念知识的朋友可以阅读博主的另一篇博客：**

[【Spring】核心与设计思想\_保护小周ღ的博客-CSDN博客][Spring_-CSDN]

--------------------

## 二、创建 Spring 项目 ##

我们在了解 Spring 是啥之后，接下来结合 IDEA (集成开发环境) 演示如何创建一个 Spring 项目。

### 2.1 创建一个 普通的 Maven 项目（无需使用模板） ###

![6481b8bf1a6447edabda223022acf0a4.png][]

![d5d4b3a4b49a47d08f6ab98399ec4211.png][]

**来到这个界面就说明创建成功了**![c1d102b0e8a641fd874223bb7f0919d7.png][]

###  ###

--------------------

### 2.2 添加 Spring 框架支持 ###

> Spring 是一个开源的 Java 框架，由 Rod Johnson 在 2002 年创建。Spring 提供了许多简化 Java 开发的功能，因此它在 Java 开发社区中得到了广泛的应用和认可。Spring 是第三方的资源（框架）是由大佬对已有的功能进行封装拓展，使得程序猿更容易地编写功能，并不属于 JDK 官方 , 所以我们要想使用 Spring 就需要下载第三方依赖。

**只需要在项目中地 pom.xml 文档中添加 Spring 框架地支持, xml 配置如**

<dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.3.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>5.2.3.RELEASE</version>
            </dependency>
    </dependencies>

![f6cbf7147c9143d3bcda025c26f178a0.png][]

从上述配置中可以看出，添加的框架有 spring-context: spring 上下文， 还有 spring-beans : 管理对象的模块。具体有啥作用下文讲述。

--------------------

### 1.3 添加一个启动类 ###

最后在创建好的项目 Java 文件夹下创建一个启动类，包含 main 方法即可：

public class App {
        public static void main(String[] args) {
    
        }
    }

在这个启动类中我们就可以对 Bean 对象进行一系列的操作。

--------------------

## 三、将对象存储到 Spring ##

要想存储 Bean 对象（类实例化后的对象）需要有 2 步操作：

*  创建一个 bean 对象 —— 需要一个类
 *  将 bean 对象 注册到 Spring 中 【使用 Spring 配置文件进行注册】

### 3.1 创建 Bean 对象 ###

所谓 Bean 对象就是 Java 中的一个普通的对象。

public class Dog {
        // 狗的属性
        private String name;
        private int age;
        private String sex;
        private String color;
    
    
        // 狗的行为
        public void cry() {
            System.out.println(this.name + "汪汪~");
        }
    
        /**
         * 小狗的做我介绍
         * @return
         */
        @Override
        public String toString() {
            return "Dog{" +
                    "我叫做：'" + name + '\'' +
                    ", 我今年：" + age +
                    "岁, 我的性别是：" + sex +
                    ", 我是'" + color + '\'' + "的" +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public String getColor() {
            return color;
        }
    
        public void setColor(String color) {
            this.color = color;
        }
    }

**常规的做法：**

public class App {
        public static void main(String[] args) {
            Dog dog = new Dog();
            dog.setName("哈巴狗");
            dog.setAge(3);
            dog.setSex("公");
            dog.setColor("白色");
            dog.cry();
            System.out.println(dog.toString());
        }
    }

![3e68f12aea3f4554a959328e96781b0f.png][]

--------------------

### 3.2 将 Bean 对象注册到 Spring ###

这里介绍一种古老的注册方法——【使用 Spring 配置文件进行注册】

在创建好的项目中添加 Spring 的配置文件 **spring-test.xml** , 将该文件放到 **resources 的根目录**下：

![7f65d1927a424b2aacc13ff4916cbc6c.png][]

这个配置文件 **spring-test.xml** 文件名**可以任意的名称但是必须保证文件后缀为（ .xml ）**，这里的文件名在后续的取 Bean 对象中会使用到。

该文件为 Spring 的配置文件，格式也是固定的（不需要记忆，找个文档保存一下即可）：

<?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">
    </beans>

接下来，实现如何将 我们自定义的对象（Dog）注册到 Spring 中就可以了，具体的操作在 <beans> 标签中添加的。

![2d8905d20ed54ac2b50fc9ff92853fe4.png][]

如果需要将多个 bean 对象注册到 Spring 中，重复以上操作即可。**注意：需要给每个 bean 对象取别名（标识）。**

--------------------

## 四、从 Spring 获取并使用 Bean 对象 ##

> **获取并使用 Bean 对象分为三个步骤：**
> 
>  *  获取 Spring 上下文对象（该对象维护了所有的 bean 对象），因为对象都交给了 Spring 管理，所以要从 Spring 中获取对象，就需要先得到 Spring 的上下文。
>  *  通过 Spring 的上下文，获取某一个指定（通过存储bean 对象的时候设置的标识）的 Bean 对象
>  *  返回值是 Bean 对象的实例，所以我们可以直接使用。
> 
> **如果需要取出 多个 Bean 对象重复以上第 2，3 步骤即可**

### 4.1 创建 Spring 上下文对象 ###

Spring的上下文是指Spring容器中存储Bean对象的**数据结构**，也可以理解为Spring容器中的环境。

**目前 Spring 上下文对象可以使用 ApplicationContext 接口来获取：**

> Spring框架中的ApplicationContext是一个IoC容器，负责管理应用程序中的Bean对象，它是一个配置文件，提供了Bean对象所需的配置信息，同时也是Bean对象的容器。通过ApplicationContext，开发人员可以将Bean对象存储在容器中，并在其他组件中使用这些Bean对象。

//1. 获取 Spring 上下文对象，创建的时候需要配置 Spring 的配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-test.xml");

![70062d9795604d54a1722503a69e7148.png][]

--------------------

除了使用 ApplicationContext 之外，**我们还可以使用 BeanFactory 接口**来获取 Spring 的上下文。

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-test.xml"));

> BeanFactory的主要作用是管理Bean的生命周期，包括Bean的创建、销毁和依赖注入等操作。BeanFactory是Spring框架中IoC容器的基础接口，它提供了对Bean对象的注册和获取。

不管是使用 ApplicationContext 还是使用 BeanFactory 获取 Spring 的上下文，二者的效果是一样的。但是他们在方式是有所区别的。

> **ApplicationContext VS BeanFactory**  
> **相同点：**
> 
> 1.  都可以得到 Spring 的上下文对象
> 2.  都是 Spring 容器的顶级接口 （都可以管理 bean 对象）
> 
> **不同点：**
> 
> 1.  在继承关系和功能上来说：ApplicationContext 属于 BeanFactory 的子类，BeanFactory 只具备最基础的管理 bean 对象的能力，而ApplicationContext 继承了 BeanFactory 自然就拥有了它的基本功能，除此以外，还拓展了更多的功能，如：国际化的支持、资源访问支持、以及事件传播等方面的支持。
> 2.  从性能的角度上来说：ApplicationContext 获取的Spring 上下文对象加载的方式是启动后一次性将 Spring 容器中的所有的 bean 对象全部实例化在内存中，所以在后面获取 Bean 对象的时候非常的快；BeanFactory 获取的Spring 上下文对象加载的方式是在需要某个 Bean 对象的时候，再去加载（实例化）Bean对象，所以在获取 Bean 对象的时候会比较慢。
> 
> 在Spring框架的历史版本中，从Spring 2.x版本的时候就有了ApplicationContext的接口，但是BeanFactory仍然是一个核心接口，没有被淘汰。
> 
> 一直到Spring 3.1版本，官方已经开始推荐使用ApplicationContext接口来代替BeanFactory进行Bean的管理和实例化。原因是ApplicationContext在BeanFactory的基础上增加了更多的功能，比如国际化、事件发布、AOP引入、web环境支持等，能够更好地满足开发的需求。

ClassPathXmlApplicationContext 属于 ApplicationContext 的子类，拥有 ApplicationContext 的所有功能，是通过 xml 文件（存储 Bean 对象的文件）的配置来获取所有的 Bean 对象的容器。

--------------------

### 4.2 获取指定的 Bean 对象 ###

上一步我们获取了 Spring 的上下文对象，context 这个对象就是用来管理 Bean 对象的，如果我们需要获取某个具体的 Bean 对象，需要在上下文对象的基础上调用 **getBean() 方法**

**getBean()方法是从Spring容器中获取Bean实例的核心方法。**

**当前给大家介绍的功能是读取Bean 对象：**

**通过Bean ID或Bean名称从 Spring 容器中获取指定的Bean定义，如果没有找到，则抛出异常。**

//1. 获取 Spring 上下文对象，创建的时候需要配置 Spring 的配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-test.xml");
            
    //2. 从 Spring 上下文中取出某个 bean 对象
    Dog dog = (Dog)context.getBean("dog");// dog是我们给 Dog 类的实例取得的标志（名字）

**注意事项：**

![cc6376b82396459ea2bb07c3652dff3e.png][]

**否则会抛出：NoSuchBeanDefinitionException 异常**

![dbdd6e2486424e3cbf50d37878aef3f6.png][]

--------------------

#### 4.2.1 getBean() 方法的使用 ####

getBean() 方法有很多种重载的方法，我们也可以使用其他的方法来获取 Bean 对象。

**1. 根据 bean 对象的 id （标志）来获取 【上文已经讲过】**

// dog是我们给 Dog 类的实例取得的标志（名字）
    Dog dog = (Dog)context.getBean("dog");

使用 bean对象的 id 来获取，Spring 上下文对象—— context 的返回值是 Object, 所以需要进行强制类型转换。

**2. 根据类型来获取 Bean**

Dog dog = context.getBean(Dog.class);

因为我们直接使用 bean 对象的类型来获取，所以我们无需手动强制类型转换，在获取的时候会自动强转。

**3. 根据** **bean 对象的 id （标志）+ 类型 获取 bean**

Dog dog = context.getBean("dog",Dog.class);

**第一种方法的第二种方法的区别在于：**

当一个类被重复的注册到 spring-test.xml 的配置文件中时，只能使用根据 ID (名称) 来获取。

![680425537b8c432daef58bd4ac097fe9.png][]

此时 Spring 容器中存储了 两个 Dog 类的实例（bean 对象）。

**我们使用类型来获取 bean 对象并使用时的表现：**

![b591525c9761446888490653f0b93785.png][]

所以我们当同类型的对象被注册到 Spring 中多次时就会导致程序报错，此时我们应当使用 bean 对象的 ID (名称) 来获取。但是这种方式的缺陷在于 我们需要手动的进行强制类型转换（返回类型是 Object）

所以我们推荐的写法是使用第三种方法 ：**根据** **bean 对象的 id （标志）+ 类型 获取 bean 对象。**

--------------------

**4.3 使用 Bean 对象**

上文也说到其实 Bean 对像就是普通的实例化的对象，Bean 对象只是一个名字罢了。所以Bean 对象的使用跟我们传统对象的使用并无差异：

public class App {
        public static void main(String[] args) {
            //1. 获取 Spring 上下文对象，创建的时候需要配置 Spring 的配置文件
            ApplicationContext context =
                    new ClassPathXmlApplicationContext("spring-test.xml");
    
            //2. 使用类型从 Spring 容器中获取 bean 对象
            Dog dog = context.getBean("dog",Dog.class);
    
            //3. bean 对象的使用
            dog.setName("哈巴狗");
            dog.setAge(3);
            dog.setSex("公");
            dog.setColor("白色");
            dog.cry();
            System.out.println(dog.toString());  
        }
    }

![d9edbe7b1e58475c9981d1362e680ff3.png][]

--------------------

## 五、总结 ##

1. Spring 是一个包含众多工具方法的 loC （控制反转）容器，属于第三方库，所以我们在使用 Spring 的时候需要为项目注入相关依赖，既然是容器就有两个最基本的功能，存储和取出。

2. 存储 Bean 对象

*  创建 Bean 对象 （就是普通类的实例化对象）
 *  将Bean 对象注册（配置）到：Spring 的配置文件 【.xml 文件】

![49500ec94f4246a5ad25db294d917df6.png][]

文件名是自定义的，但是尽量保持规范，在从 Spring 中取出 Bean 对象的时需要用到配置文件名。如何注入请看上文解析……

3. 获取 Bean 对象

*  获取 Spring 上下文对象（管理着 Bean对象）获得的方式有两种：ApplicationContext 接口（官方推荐），Beanfactory (老版本)
 *  从上下文对象中获取某一个对象调用getBean() 方法，该方法有三种获取方式，**根据bean 对象的 ID （标识）获取**，**根据 Bean 对象类型获取，缺点：第一个需要强制类型转换，第二个在出现同类型的 Bean 对象的时候程序会报错。****所以推荐使用第三种做法： 根据 Bean 对象 ID 和 对象类型获取**
 *  获取到 Bean 对象后就可以正常的使用,与我们常规的用法一样

**操作流程如下图所示:**

![504f592536744e7e9dd1dd5c1f630970.png][]

--------------------

好了，到这里，**【Spring 】项目创建和使用** 博主已经分享完了，希望对大家有所帮助，如有不妥之处欢迎批评指正。

![a1aaec118f6f3215d0acbb1f7bf817ac.jpeg][]

**下期预告：使用注解更简单的使用 Spring**

**将 Bean 对象更简单的存储到 Spring ：使用注解【类注解 / 方法注解】**

感谢每一位观看本篇文章的朋友，**更多精彩敬请期待：保护小周ღ \*★,°\*:.☆(￣▽￣)/$:\*.°★\***

遇见你，所有的星星都落在我的头上……![318e26ac533a4801b9b73101a410677d.jpeg][]

[1252c628e6298c355aaa9e4fa30dc9cd.gif]: https://img-blog.csdnimg.cn/img_convert/1252c628e6298c355aaa9e4fa30dc9cd.gif
[1b8f8768c9cd4d7cabc7d51e10200ef5.jpeg]: https://img-blog.csdnimg.cn/1b8f8768c9cd4d7cabc7d51e10200ef5.jpeg
[JavaEE_-CSDN]: https://blog.csdn.net/weixin_67603503/category_12246101.html?spm=1001.2014.3001.5482
[Spring_-CSDN]: https://blog.csdn.net/weixin_67603503/article/details/131113710
[6481b8bf1a6447edabda223022acf0a4.png]: https://img-blog.csdnimg.cn/6481b8bf1a6447edabda223022acf0a4.png
[d5d4b3a4b49a47d08f6ab98399ec4211.png]: https://img-blog.csdnimg.cn/d5d4b3a4b49a47d08f6ab98399ec4211.png
[c1d102b0e8a641fd874223bb7f0919d7.png]: https://img-blog.csdnimg.cn/c1d102b0e8a641fd874223bb7f0919d7.png
[f6cbf7147c9143d3bcda025c26f178a0.png]: https://img-blog.csdnimg.cn/f6cbf7147c9143d3bcda025c26f178a0.png
[3e68f12aea3f4554a959328e96781b0f.png]: https://img-blog.csdnimg.cn/3e68f12aea3f4554a959328e96781b0f.png
[7f65d1927a424b2aacc13ff4916cbc6c.png]: https://img-blog.csdnimg.cn/7f65d1927a424b2aacc13ff4916cbc6c.png
[2d8905d20ed54ac2b50fc9ff92853fe4.png]: https://img-blog.csdnimg.cn/2d8905d20ed54ac2b50fc9ff92853fe4.png
[70062d9795604d54a1722503a69e7148.png]: https://img-blog.csdnimg.cn/70062d9795604d54a1722503a69e7148.png
[cc6376b82396459ea2bb07c3652dff3e.png]: https://img-blog.csdnimg.cn/cc6376b82396459ea2bb07c3652dff3e.png
[dbdd6e2486424e3cbf50d37878aef3f6.png]: https://img-blog.csdnimg.cn/dbdd6e2486424e3cbf50d37878aef3f6.png
[680425537b8c432daef58bd4ac097fe9.png]: https://img-blog.csdnimg.cn/680425537b8c432daef58bd4ac097fe9.png
[b591525c9761446888490653f0b93785.png]: https://img-blog.csdnimg.cn/b591525c9761446888490653f0b93785.png
[d9edbe7b1e58475c9981d1362e680ff3.png]: https://img-blog.csdnimg.cn/d9edbe7b1e58475c9981d1362e680ff3.png
[49500ec94f4246a5ad25db294d917df6.png]: https://img-blog.csdnimg.cn/49500ec94f4246a5ad25db294d917df6.png
[504f592536744e7e9dd1dd5c1f630970.png]: https://img-blog.csdnimg.cn/504f592536744e7e9dd1dd5c1f630970.png
[a1aaec118f6f3215d0acbb1f7bf817ac.jpeg]: https://img-blog.csdnimg.cn/img_convert/a1aaec118f6f3215d0acbb1f7bf817ac.jpeg
[318e26ac533a4801b9b73101a410677d.jpeg]: https://img-blog.csdnimg.cn/318e26ac533a4801b9b73101a410677d.jpeg