简述
IoC是指控制反转，是指有容器来控制对象的生命周期和对象之间的关系。简单来说就是之前使用对象首先需要new一个对象，而现在直接从容器中取就可以了。这就像有小农经济转变到商品经济。
小农经济：自给自足，什么东西都需要自己动手也就类似于对象需要自己new。
商品经济：需要啥去商店买就行，这里的商店就相当于容器，商品就相当于对象，生成商品的工厂就相当于对象工厂等。
Spring IOC 的简单实现
分析
1、首先我们得有一个容器，这个容器负责保存和生成bean，这也就是对象工厂BeanFactory 。
2、其次，得有一个bean注册器，这负责bean的注册和真正生成。
3、然后，还得有一个资源加载器，用来加载bean的定义
4、最后，得有一个bean的定义模型和配置文件。
实现
分析为倒叙分析，实现就得看正序实现了，不然依赖就颠倒了。
1、配置文件和bean模型
先准备一个示例的bean
1
2
3
4
5
| public class BeanExample {
public void print(String string){
System.out.println("test out: " + string);
}
}
|
配置文件，偷懒使用一个<key,value>键值对代替
1
| beanExample:com.shopmall.springIoc.BeanExample
|
bean模型定义
1
2
3
4
5
6
7
8
| @Getter
@Setter
public class BeanDefinition {
private String beanName;
private Class beanClass;
}
|
2、资源加载器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| public class ResourceLoader {
public static Map<String, BeanDefinition> getResource() {
Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();
Properties properties = new Properties();
try {
InputStream inputStream = ResourceLoader.class.getResourceAsStream("/beans.properties");
properties.load(inputStream);
for (String key : properties.stringPropertyNames()) {
String className = properties.getProperty(key);
BeanDefinition beanDefinition = new BeanDefinition();
beanDefinition.setBeanName(key);
Class clazz = Class.forName(className);
beanDefinition.setBeanClass(clazz);
beanDefinitionMap.put(key, beanDefinition);
}
inputStream.close();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
return beanDefinitionMap;
}
}
|
3、对象注册器
简化过程，都用单例了
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| public class BeanRegister {
//单例Bean缓存
private final Map<String, Object> singletonBeanMap = new HashMap<>();
/**
* 获取单例Bean
*
* @param beanName bean名称
* @return Object 单例Bean
*/
public Object getSingletonBean(String beanName) {
return singletonBeanMap.get(beanName);
}
/**
* 注册单例bean
*
* @param beanName bean名称
* @param bean 单例bean
*/
public void registerSingletonBean(String beanName, Object bean) {
if (singletonBeanMap.containsKey(beanName)) {
return;
}
singletonBeanMap.put(beanName, bean);
}
}
|
4、容器bean工厂
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
| public class BeanFactory {
private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();
private BeanRegister beanRegister;
public BeanFactory() {
//创建bean注册器
beanRegister = new BeanRegister();
//加载资源
this.beanDefinitionMap = new ResourceLoader().getResource();
}
/**
* 获取bean
*
* @param beanName bean名称
* @return Object Bean
*/
public Object getBean(String beanName) {
//从bean缓存中取
Object bean = beanRegister.getSingletonBean(beanName);
if (bean != null) {
return bean;
}
//根据bean定义，创建bean
return createBean(beanDefinitionMap.get(beanName));
}
/**
* 创建Bean
*
* @param beanDefinition bean定义
* @return Object Bean
*/
private Object createBean(BeanDefinition beanDefinition) {
try {
Object bean = beanDefinition.getBeanClass().newInstance();
//缓存bean
beanRegister.registerSingletonBean(beanDefinition.getBeanName(), bean);
return bean;
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
}
|
5、测试运行
