Spring项目创建与Bean的存储与读取(DL)

女爷i 2024-04-26 10:56 56阅读 0赞

#### 文章目录 ####

*  一. Spring项目的创建
 *   *  1. 创建Maven项目
     *  2. 配置国内源
     *  3. 添加spring依赖
     *  4. 创建启动类
 *  二.储存或读取Bean对象
 *   *  1. 添加spring配置文件
     *  2. 创建Bean对象
     *  3. 读取Bean对象

## 一. Spring项目的创建 ##

### 1. 创建Maven项目 ###

**第一步，创建 Maven 项目**，Spring 也是基于 Maven 的。

![img][]

### 2. 配置国内源 ###

由于国外源不稳定，可能让下面第二步引入 Spring 依赖会失败，所以这里先介绍如何一下配置国内镜像源。

![img][img 1]

![img][img 2]

![img][img 3]  
现成的`settings.xml`文件链接：[gitee][]

如果你已经有了`settings.xml`文件，但没有配置`mirror`，配置内容如下：

<mirror>
        <id>alimaven</id>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <mirrorOf>central</mirrorOf>        
    </mirror>

如果你是在引入相关依赖失败后进行的国内源配置，就要去本地管理`jar`包的目录将`jar`包都进行删除，然后重新刷新下载依赖即可。

![img][img 4]

### 3. 添加spring依赖 ###

**第二步，在 Maven 项目中添加 Spring 的支持（spring-context, spring-beans）**

在`pom.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>

刷新等待加载完成。  
![img][img 5]

### 4. 创建启动类 ###

**第三步，创建启动类与**`main`**方法，用来做简单的测试**

在 `java` 目录创建类，写代码即可，因为这里只演示怎么创建 Spring 项目和介绍 Spring 的简单使用，不会就上线发布，就不按照 Maven 的模板目录结构来搞了。

![img][img 6]

## 二.储存或读取Bean对象 ##

### 1. 添加spring配置文件 ###

右键`resources`目录，新建一个`spring-config.xml`配置文件。  
![img][img 7]  
配置内容如下：

<?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>

### 2. 创建Bean对象 ###

第一步，创建`Bean`对象。  
比如我们要注入一个`Student`对象，就先的创建一个`Student`类。

package com.tr.demo;
    
    public class Student {
        
        public void sayHi(String name) {
        
            System.out.println("Hello！" + name );
        }
    }

然后将`Bean`通过配置文件，注入到`spring`中，即在`spring`配置文件中通过以下语句注入。

spring中对象的储存是通过键值对来存储的，其中`key`为`id`，`value`为`bean`，`id`一般使用小驼峰命名。

![img][img 8]

### 3. 读取Bean对象 ###

想要从 Spring 中将`Bean`对象读取出来，先要得到 Spring 上下文对象，相当于得到了 Spring 容器。

再通过 spring 上下文对象提供的方法获取到需要使用的`Bean`对象，最后就能使用`Bean`对象了。

`ApplicationContext`，也称为控制反转（IoC）容器，是 Spring 框架的核心。

<table> 
 <thead> 
  <tr> 
   <th>实现类</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ClassPathXmlApplicationContext（常用）</td> 
   <td>加载类路径下的配置文件，要求配置文件必须在类路径下</td> 
  </tr> 
  <tr> 
   <td>FileSystemXmlApplicationContext</td> 
   <td>可以加载磁盘任意路径下的配置文件（必须要有访问权限）</td> 
  </tr> 
  <tr> 
   <td>AnnotationContigApplicationContext</td> 
   <td>用于读取注解创建容器</td> 
  </tr> 
 </tbody> 
</table>

import com.tr.demo.Student;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class APP {
        
        public static void main(String[] args) {
        
            // 1. 得到上下文对象
            ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
            // 2. 获取 bean 对象，这里根据 id 获取
            Student student = (Student) context.getBean("student");
            // 3. 使用 bean 
            student.sayHi("张三");
        }
    }

运行结果：

![img][img 9]

还可以使用 Bean 工厂（旧）来获取 Bean。

import com.tr.demo.Student;
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.beans.factory.xml.XmlBeanFactory;
    import org.springframework.core.io.ClassPathResource;
    
    public class APP2 {
        
        public static void main(String[] args) {
        
            // 1. 得到 bean 工厂
            BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
            // 2. 获取 bean 对象
            Student student = (Student) factory.getBean("student");
            // 3. 使用 bean
            student.sayHi("李四");
        }
    }

但实际上并不推荐使用这种方式，算是过时代的方式了，因为旧时期需要考虑内存占用的问题，而现在内存资源没有这样的问题了。

运行结果：

![img][img 10]

此时我们可以发现，`ApplicationContext`与`BeanFactory`都可以从容器中获取`Bean`，都提供了`getBean`方法，最终的效果是一样的。

**?那么，**`ApplicationContext`**与**`BeanFactory`**有什么区别？**  
?相同点：

*  都是容器管理对象，都可以从容器中获取`Bean`，都提供了`getBean`方法。

?不同点：

*  `ApplicationContext`是`BeanFactory`的子类， `BeanFactory`只提供了基础访问`Bean`对象的功能，而`ApplicationContext`除了拥有`BeanFactory`的全部功能，还有其他额外功能的实现，如国际化，资源访问以及事务传播方面等功能的支持。
 *  它们两加载`Bean`的机制也是不同的，`BeanFactory`按需加载`Bean`，属于懒汉方式，使用它程序启动快，在后期获取对象时会慢一些；而`ApplicationContext`是饿汉方式，在创建时会将一次性将所有的`Bean`都加载，这种方式启动慢，启动之后获取对象就非常快了。

**这里验证一下他们两的加载机制：**  
我们在 com.tr.demo 目录下再添加一个`Teacher`类，并完善`Teacher`与`Student`类的构造方法，这样当类被构造时会给出一些提示信息，在获取上下文或工厂时根据这些信息我们就可以知道`Bean`是否会被构造。

package com.tr.demo;
    
    public class Teacher {
        
        public Teacher() {
        
            System.out.println("Teacher 已加载！");
        }
        public void sayHi(String name) {
        
            System.out.println("Hello！" + name );
        }
    }
    
    package com.tr.demo;
    
    public class Student {
        
        public Student() {
        
            System.out.println("Student 已加载！");
        }
        public void sayHi(String name) {
        
            System.out.println("Hello！" + name );
        }
    }

![img][img 11]

import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class APP3 {
        
        public static void main(String[] args) {
        
            // 1. 得到上下文对象
            ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        }
    }

运行结果：

程序启动，`ApplicationContext`创建时，会将所有的`Bean`对象都构造，类似于饿汉的方式。  
![img][img 12]

import org.springframework.beans.factory.BeanFactory;
    import org.springframework.beans.factory.xml.XmlBeanFactory;
    import org.springframework.core.io.ClassPathResource;
    
    public class APP4 {
        
        public static void main(String[] args) {
        
            // 1. 得到 bean 工厂
            BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
        }
    }

运行结果：

程序启动，在`BeanFactory`创建时，结果中没有如何输出，只要不去获取使用`Bean`就不会去加载，类似于懒汉的方式。

![img][img 13]`getBean`方法，其实是有三种使用方式的，具体如下：  
1️⃣方式1：根据`Bean`的名字来获取

Student student = (Student) context.getBean("student");

这种方式返回的是一个`Object`对象，需要我们去进行强制类型转换。

2️⃣方式2：根据`Bean`类型获取

Student student = context.getBean(Student.class);

这种方式当`beans`中只有一个类的实例没有问题，但是个有多个同类的实例，会有问题，即在 Spring 中注入多个同一个类的对象，就会报错。

我们来试一下，首先在 Spring 配置文件，注入多个`Student`对象：  
![img][img 14]  
然后我们再通过这种方式来获取对象，运行结果如下：

抛出了一个`NoUniqueBeanDefinitionException`异常，这表示注入的对象不是唯一的。

![img][img 15]

3️⃣方式3：根据名称 + 类型获取

Student student = context.getBean("student",Student.class);

相比方式1，更加健壮和优雅，也没有方式 2 中的问题

![img][img 16]

**总结**：

通篇下来涉及以下流程：

①创建 Spring 项目

②存储 Bean

1.  先创建 Bean 对象
2.  将 Bean 在 pring-config.xml 中进行配置

③取对象

1.  得到 Spring 上下文，读取 Spring 配置文件
2.  获取 Bean 对象
3.  使用 Bean 对象(可选项)  
    ![img][img 17]

[img]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8ff44a11feb544e589c6f587fb8fd1d0.png
[img 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/84a8a9fd76dd43ac91de4fe3860679e0.png
[img 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/810d50edff5e4a72bb0b4acd0ac4fc67.png
[img 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7d780736a35546c380d92c517ee775bd.png
[gitee]: https://gitee.com/xin-xiangrong/java-ee-advanced/blob/master/configuration_files/settings.xml
[img 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/3beb8c9e96fc46c482001c8e59f7c053.png
[img 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/166b7e2673ce4a20aeefbbac9fcd7794.png
[img 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/6b5348f6b469464c89d488d55a6ca1a3.png
[img 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c72ed8e2fff74d649f31012211684458.png
[img 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/445d46b0c0004c0b83fd02f1921662b3.png
[img 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/e7b8df6e6424487b80604703676b142e.png
[img 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7f6bc8a33f05453ba3ff2c7541a0fa2d.png
[img 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/563813e7fa924b08a9a786e0398c7ed1.png
[img 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/2816f06e6f5b43d1a6db91f003e54c7d.png
[img 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8e28c41b4d5e43bf86a78e1a467c0906.png
[img 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/e9a9efa5007340b6b78ddeaf3dce7a32.png
[img 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/a991a8c6e279495d8caaedd1afb6b34c.png
[img 16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/000a172d0d8e404f9fb2a5d8c896687e.png
[img 17]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/ac5e9471280d4517a2b9e7b2120f20f3.png