Spring IOC与工厂模式
PS：本文内容较为硬核，需要对java的面向对象、反射、类加载器、泛型、properties、XML等基础知识有较深理解。
（一）简单介绍
在讲Spring IOC之前，有必要先来聊一下工厂模式（Factory Pattern）。工厂模式可将Java对象的调用者从被调用者的实现逻辑中分离出来。工厂模式是Java中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
这么讲可能有点抽象，简单的说就是以后我们不用自己new对象了，对象的实例化都交给工厂来完成，我们需要对象的时候直接问工厂拿一个就行，一会我们会来看一个例子。在这里有一点要说明，spring IOC与工厂模式并不是完全相同的，最大的不同在于普通的工厂模式内部还是使用new来创建对象，但是spring IOC是用反射来创建对象，这么做有什么好处呢？
（二）“new” VS “反射”
下面我们来看一个工厂模式例子。为了演示方便，我将所有的类和接口都写在一起：
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
public class ShapeFactory {
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}
我们来看一下这段代码干了啥。我们看这个ShapeFactory，里面有个getShape方法，输入图形的名字我们就能获得相应图形的对象。这就是所谓的工厂，有了这个工厂之后，我们想用什么图形的对象，直接调用getShape方法就能获得了。这样使用这些对象的类就可以和这些图形类解耦。但是我们很容易发现，现在工厂能生产三个不同的对象，如果我们要加一个新的对象到工厂中，是非常麻烦的，我们要修改代码然后重新编译，就好比现实中的工厂突然想要加一条新生产线是很麻烦的一样。于是我们肯定要寻求改进，这就孕育了spring IOC。
spring IOC的思想与工厂模式基本是一样的，只是创建对象的方式从“new”变成了反射，这就带来了很大的灵活性。不过，现在阅读spring源码还为时过早，于是我自己写了一个简单的例子来模拟spring IOC的基本原理。
首先，如果我们要用反射创建对象，全类名是必不可少的（反射不太记得的朋友请好好复习一下反射），然后我们还需要一个类名，用来告诉工厂我们需要哪个对象（就像上面getShape方法传入的参数shapeType一样），这个名字可以随便取，但是不能重复。这样我们就有了创建对象的两个要素，然后我们需要一个key-value对把这两个关联起来。然后就形成了这样一个模式：我们传入类名，工厂去查询key-value对，找到对应的全类名，然后通过全类名利用反射创建对象，再返回给我们。是不是很简单呢？
话不多说，我们先来创建这个key-value对，也就是所谓的配置文件，spring中用的是XML，我这里为了简化就用properties吧，原理都是一样的：
//文件名：bean.properties
circle=com.demo.Circle
rectangle=com.demo.Rectangle
square=com.demo.Square
配置文件有了之后，我们来写我们的BeanFactory。
//文件名：BeanFactory.java
package com.demo; import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties; public class BeanFactory {
//配置对象（类比spring IOC容器中的Bean定义注册表）
private static final Properties props;
//保存创建好的对象的容器，与类名组成key-value对（类比spring IOC容器中的Bean缓存池）
private static Map<String, Object> beans;
static {
props = new Properties();
//通过类加载器读入配置文件
InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
try {
//加载配置文件到配置对象
props.load(in);
//初始化容器
beans = new HashMap<>();
Enumeration<Object> keys = props.keys();
//循环遍历配置对象中的所有的类名（key）
while (keys.hasMoreElements()){
String key = keys.nextElement().toString();
//通过类名拿到全类名（value）
String beanPath = props.getProperty(key);
//利用全类名反射创建对象
Object value = Class.forName(beanPath).getDeclaredConstructor().newInstance();
//将对象放入容器中
beans.put(key, value);
}
} catch (IOException e) {
throw new ExceptionInInitializerError("初始化properties失败！程序终止！");
} catch (Exception e){
e.printStackTrace();
}
}
public static Object getBean(String beanName){
//从容器中获取对象
return beans.get(beanName);
}
}
另外三个类和一个接口依旧沿用上面那个工厂模式的例子的，本案例所有java文件都位于com.demo包下。我们来仔细看看这个BeanFactory（我自己写的山寨版，模仿spring IOC基本功能），首先我们先抓住核心，核心就是里面的Map<String, Object> beans，这个东西直接对标了spring IOC容器中的Bean缓存池，用来存放创建好的对象，用Map是为了可以直接通过类名取到对应的对象。然后我们来看看这些对象是如何生产出来的：
Object value = Class.forName(beanPath).getDeclaredConstructor().newInstance();
很显然，反射就在这一句上，我们通过类的全类名来创建了对象，全类名来自于我们的Properties对象，也就是读取我们的配置文件产生的对象，对标spring IOC容器中的Bean定义注册表。现在你应该已经明白了这个配置文件的作用，他就像我们给工厂的一张生产单，上面写了我们需要生产的对象。而Bean缓存池相当于工厂的仓库，用来存储生产完的对象，等待被取出。而我们定义的Bean实现类（就是上面的那些Circle、Square之类的）相当于图纸，告诉工厂这些对象是什么样，应该如何去生产。我们来总结一下：
模块 功能
Bean实现类 说明如何生产
Bean定义注册表 说明需要生产哪些
Bean缓存池（HashMap实现） 存放生产完的对象
（三）真正的Spring IOC
看完了我写的“山寨”IOC，我们再来画个图看一看真正的spring IOC的结构执行过程，其实与我写的基本是一致的。
我们来看看执行过程：
1.读取Bean配置信息放入Bean定义注册表
2.根据Bean注册表实例化Bean
3.将实例化之后的bean实例放入Bean缓存池（HashMap实现）
4.应用程序通过类名从Bean缓存池中取出Bean实例
看了这么多，我们还是来看看具体如何使用spring IOC容器来创建对象吧。首先，就像上面我的那个山寨IOC一样，我们要先来编写XML文件，XML比properties要复杂，不过好在我们暂时还用不到那么复杂的部分。首先先去官网的文档里面找一段模板抄下来：
<?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"> </beans>
这就是spring配置文件的模板了，上面定义了一些XML文件的约束，也就是我们在那些XML标签里能写啥。我们以后的开发都会基于这个模板。然后，就是我们的类名和全类名组成的key-value对了，这些流程和上面都是完全一样的，只是写法有所不同，我们把该写的都写上（注意我的写法）。
<?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="circle" class="com.demo.Circle"/>
<bean id="square" class="com.demo.Square"/>
<bean id="rectangle" class="com.demo.Rectangle"/>
</beans>
很显然，这个id就相当于类名，这个class就相当于全类名，是不是和我的山寨版基本一样？
当然，既然我们是在使用框架，所以那些繁琐的工作都不需要我们去做了，也就是说我们不需要去关心对象是如何创建如何管理的，这些都由spring帮我们完成了。我们要做的就是直接问spring IOC容器取出对象即可。那么这个容器在哪？现在当然是只能我们手动创建这个容器，不然他也不会凭空产生对吧。
我们来看一眼这个接口继承图，我们只需要关注两个，一个是里面的一个*接口——BeanFactory，另一个是最底下的ApplicationContext接口。BeanFactory是简单容器，他实现了容器的基本功能，典型方法如 getBean、containsBean等。ApplicationContext是应用上下文，他在简单容器的基础上，增加上下文的特性。我们开发时一般都是使用ApplicationContext接口，因为他的功能比BeanFactory更强大。当然，“应用上下文”这个名字可能有点奇怪，不过我们只需要记得他就是那个spring IOC容器接口就行。接口有了，接下来就是要找实现类。
ApplicationContext有好多的实现类，我们就挑一个最常用的讲——ClassPathXmlApplicationContext。
我们先来看一眼他的名字：ClassPathXmlApplicationContext。翻译为：类路径XML应用上下文，嗯，这个名字更奇怪了。其实，他就是一个只能读取类路径下的XML文件作为配置文件的应用上下文实现类。那我再举一个例子：FileSystemXmlApplicationContext，他是干嘛的？嗯，他是文件系统应用上下文，也就是说他可以读取磁盘任意位置（需要有读权限）的XML作为配置文件。
这样我们就可以实例化我们的IOC容器了：
package com.demo; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; public class Test {
public static void main(String[] args) {
//构造函数参数为配置文件名称
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
Shape circle = (Shape) applicationContext.getBean("circle");
circle.draw();
}
}
这样我们就拿到了容器里面的对象，是不是和我的山寨版基本一样呢？读到这里，你应该已经理解了spring IOC的原理了，后面我会更新新的文章，分析spring IOC的细节和一些其他功能。最后放一张截图，不清楚项目结构的可以看一眼。