Spring学习(二)(Spring创建和使用)
经过前⾯的学习我们已经知道了，Spring 就是⼀个包含了众多⼯具⽅法的 IoC 容器。既然是容器那么 它就具备两个最基本的功能： 将对象(Bean)存储到容器（Spring）中； 从容器中将对象取出来。那么该怎么将Bean存储的Spring以及再将其拿出来使用呢？？别着急其实很简单，只需要跟着学习就可以掌握。
目录
1. 创建Spring项目
1.1 创建一个Maven项目
1.2 添加Spring依赖（Maven国内源）
1.3 添加 Spring 框架⽀持
1.4 添加启动类
2.存储Bean对象
2.1 创建Bean
2.2 将Bean注册到容器当中
3. 获取并使用Bean对象
3.1 创建Spring上下文
3.3 使用Bean
4.总结
1. 创建Spring项目
接下来使⽤ Maven ⽅式来创建⼀个 Spring 项⽬，创建 Spring 项⽬和 Servlet 类似，总共分为以下 3 步：
- 1. 创建⼀个普通 Maven 项⽬。
- 2. 添加 Spring 框架⽀持（spring-context、spring-beans）。
- 3. 添加启动类。
1.1 创建一个Maven项目
按照下面的截图操作即可。
1.2 添加Spring依赖（Maven国内源）
这两个都要设置。前者是当前文件，后者是以后新建文件配置。
然后找到settings.xml
我的在C:\Users\用户名\.m2\下面，打开settings.xml。在
alimaven
central
aliyun maven
http://maven.aliyun.com/nexus/content/repositories/central/
1.3 添加 Spring 框架⽀持
在项⽬的 pom.xml 中添加 Spring 框架的⽀持，xml 配置如下：
org.springframework
spring-context
5.2.24.RELEASE
org.springframework
spring-beans
5.2.3.RELEASE
从上述配置中可以看出，添加的框架有 spring-context：spring 上下⽂，还有 spring-beans：管理对 象的模块。
此时还需要重新加载我们的依赖：
然后下载完依赖后：
1.4 添加启动类
我们刚才创建好的项目此时应该已经成功创建，在java文件下创建一个启动类，包含main方法即可：
public class App {
public static void main(String[] args) {
}
}2.存储Bean对象
既然一直在说Spring是一个包含众多工具的IoC容器，现在我们的Spring项目也创建好的，那么怎么将Bean对象存进Spring呢？？听起来十分的高大上，其实也是很简单的套路。存储Bean可以分为两步：
- 1. 存储Bean之前，我们必须得现有Bean啊，因此先要创建一个Bean。
- 2. 将创建的Bean注册到Spring容器之中。
2.1 创建Bean
Bean，听起来很高级，其实就是Java中的一个普通的对象，我们可以简单实现一个：
public class Student {
public Student() {
System.out.println("Student无参构造");
}
public void play(){
System.out.println("我喜欢打篮球！");
}
}2.2 将Bean注册到容器当中
在创建好的项⽬中添加 Spring 配置⽂件 spring-config.xml，将此⽂件放到 resources 的根⽬录下， 如下图所示：（鼠标右键新建file，文件名称spring-config.xml）
这里Spring配置文件的格式是固定的，直接找一份复制就好了，不需要记忆，这些东西记忆下来也没有什么用处，就是格式问题。
然后就可以将刚才的Student类注册到Spring中了，怎么存呢？先介绍通过配置文件的方式来存储。具体的操作就是在刚才的配置文件中的
3. 获取并使用Bean对象
获取并使⽤ Bean 对象，分为以下 3 步：
- 1. 得到 Spring 上下⽂对象，因为对象都交给 Spring 管理了，所以获取对象要从 Spring 中获取，那 么就得先得到 Spring 的上下⽂。
- 2. 通过 Spring 上下⽂，获取某⼀个指定的 Bean 对象。
- 3. 使⽤ Bean 对象。
3.1 创建Spring上下文
这里介绍两种方式来创建Spring上下文。
第一种就是使用ApplicationContext，实现代码如下：（ApplicationContext是接口 ClassPathXmlApplicationContext是它的一个实现类。）
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");第二种就是使⽤ BeanFactory 来作为 Spring 的上下⽂，如下代码所示：
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));这里第二种方式其实并不推荐，这是早期的用法，现在官方已经不推荐使用了，IDEA使用时会看到已经被划线了。既然提到了两种方式必然要做出比较，这也是一道十分常见的面试题。
ApplicationContext VS BeanFactory（常⻅⾯试题）
- 继承关系和功能⽅⾯来说：Spring 容器有两个顶级的接⼝：BeanFactory 和 ApplicationContext。其中 BeanFactory 提供了基础的访问容器的能⼒，⽽ ApplicationContext 属于 BeanFactory 的⼦类，它除了继承了 BeanFactory 的所有功能之外，它还拥有独特的特性， 还添加了对国际化⽀持、资源访问⽀持、以及事件传播等⽅⾯的⽀持（这几个支持通过后面的学习应该会提到，目前不展开说明）。
- 从性能⽅⾯来说：ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象，⽽ BeanFactory 是需要那个才去加载那个，因此更加轻量。
第一点很好理解，BeanFactory 是很早之前使用的接口，现在使用的ApplicationContext 是继承自BeanFactory所以除了具有父类的特点之外还具有自己的独特的特性。那么第二点ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象，⽽ BeanFactory 是需要那个才去加载那个，因此更加轻量怎么来理解呢？？之后会从代码角度展示出来它们的区别。
3.2 获取指定的Bean对象
// 1.得到Spring ApplicationContext是接口 ClassPathXmlApplicationContext是它的一个实现类
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
// Student student1 = new Student(); 传统方式----缺点已经讲过
// 2. 从Spring中获取Bean对象
//Student student = (Student)context.getBean("student"); // 根据名称获取 十分不推荐 而且使用了强转
//Student student = context.getBean(Student.class); // 根据类型获取 只有当此种类型的Bean有且只有一个的时候才可以使用
Student student = context.getBean("student", Student.class); // 根据名称和类型来获取对象注意：
1. 通过context.getBean()来获取Bean的时候，Bean的ID要和配置文件里的ID一一对应：
2. 获取Bean的方法有很多这里提供了三种，他们是重载的关系，根据不同的场景来使用，当然更推荐第三种。第二种是通过类名来获取，当只存一个指定类的时候才可以使用，否则就会报错。第三种是通过名称+类型，这种方式是最靠谱最推荐的方式。如果一类类型的对象存入为两个不同的id使用Student student = context.getBean(Student.class)的时候就会报错。
3. 当一个类型被以不同的id注册进Spring时，两个Bean是同一个引用吗？？比如
答案是：不是同一个引用。他们分别存放，是不同的地址。
Student student = context.getBean("student", Student.class); Student stu = context.getBean("stu", Student.class); System.out.println("stu == student??:"+(stu==student))运行结果是false。
3.3 使用Bean
这里就是为了验证我们的Bean对象是否成功的被我们存进Spring中并且可以成功使用，因此不用设计太多的逻辑结构，直接利用我们获取到的Bean对象来调用它的共有方法，以此来验证是否成功。
student.play();运行我们的APP：
此时发现的确成功的进行了Bean的存储和获取使用，在这里我们没有通过new的方式来实例化对象，之前也讲过这样new的方式来实例化的花会有诸多弊端。详情可以移步前一节的博客了解。博客链接。
现在我们存储和获取使用一套流程可以完整的走下来了，但是之前提到的ApplicationContext VS BeanFactory的问题还没有用代码来展示，现在可以用代码展示。怎么来设计代码呢？先看我们要证明的东西：ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象，⽽ BeanFactory 是需要那个才去加载那个。这样我们可以再配置文件中再存储一个Teacher类，然后再通过两种方式获取Student类只使用Student看看他们的区别。代码如下：
配置文件：
Studeant类和Teacher类：
public class Student {
public Student() {
System.out.println("Student无参构造");
}
public void play(){
System.out.println("我喜欢打篮球！");
}
}
public class Teacher {
public Teacher() {
System.out.println("teacher 无参数构造");
}
public void play(){
System.out.println("我喜欢打高尔夫！");
}
}App:（Application方式获取）
public class App {
public static void main(String[] args) {
// 1. 得到Spring上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
// 2. 从spring容器中获取bean对象
Student student = context.getBean("student", Student.class); // 根据名称和类型来获取对象
//3. 使用bean
student.play();
}
}App2：（BeanFactory方式获取）
public class App2 {
public static void main(String[] args) {
// 1. 得到Spring上下文对象
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
// 2. 从spring容器中获取bean对象
Student student = (Student)beanFactory.getBean("student"); // 根据名称获取
//Student student = beanFactory.getBean(Student.class); // 根据类型获取
//3. 使用bean
student.play();
}
}分别运行发现：
并且Application方式在
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
这一行代码运行后就会直接初始化所有的Bean对象，可以自己实验一下，将后面的代码注释掉也会执行Student和Teacher的构造方法。
4.总结
1. 操作容器之前，先要有容器，所以先要得到容器。
2. 存对象
- a. 创建 Bean（普通类）。
- b. 将 Bean 注册（配置）到 spring-confing.xml 中。
3. 取对象
- a. 得到 Spring 上下⽂，并读取到 Spring 的配置⽂件。
- b. 获取某⼀个 Bean 对象。
- c. 使⽤ Bean 对象。