自己实现spring IOC

自己实现一个简易版的ioc容器，通过xml配置文件来加载bean

首先编写需要用到的bean，这里写三个简单的bean分别是A,B,C

package com.bean;

public class A {

private String name;
public A() {
System.out.println("创建A");
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

}

package com.bean;

public class B {

private A a;
public B() {
System.out.println("创建B");
}

public A getA() {
return a;
}
public void setA(A a) {
this.a = a;
}

}

package com.bean;

public class C {
private B b;
public C() {
System.out.println("创建C");
}
public B getB() {
return b;
}
public void setB(B b) {
this.b = b;
}

}

接下来编写配置文件 applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>

<bean name="a" class="com.bean.A" >
<property name="name" value="Tom">
</property>
</bean>

<bean name="b" class="com.bean.B" scope="prototype">
<property name="a" ref="a">
</property>
</bean>

<bean name="c" class="com.bean.C" scope="prototype">
<property name="b" ref="b">
</property>
</bean>

</beans>

然后是保存bean信息的类，bean信息包括：bean的name，class，scope，和property

这里的scope值只设定为singleton和prototype两种，spring中bean 的scope值默认为singleton，表示在同一个ioc容器中只有一个实例，而prototype则是每次getBean()都会得到一个新的实例。

property有可能是一个普通属性，也可能是引用另一个bean

package com.config;

import java.util.ArrayList;
import java.util.List;

public class Bean {

private String name;
private String className;
private String scope = "singleton";//scope默认为singleton

private List<Property> properties = new ArrayList<Property>();

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getClassName() {
return className;
}

public void setClassName(String className) {
this.className = className;
}

public List<Property> getProperties() {
return properties;
}

public void setProperties(List<Property> properties) {
this.properties = properties;
}
//重新toString 方法 为了测试的时候可能明确看到读取的bean信息
@Override
public String toString() {
// TODO Auto-generated method stub
return "Bean[name="+name+" class="+className+" scope="+scope+" property="+properties+"]";
}

public String getScope() {
return scope;
}

public void setScope(String scope) {
this.scope = scope;
}

}

package com.config;

public class Property {

private String name;
private String value; //value表示普通的属性值
private String ref;   //ref表示引用的其他bean的name
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public String getRef() {
return ref;
}
public void setRef(String ref) {
this.ref = ref;
}

}

读取和解析xml文件，得到bean的信息，将其封装为bean对象，返回一个Map<beanName,bean>

package com.config.parse;

import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import com.config.Bean;
import com.config.Property;

public class ConfigManager {

//读取配置文件，并返回读取结果
public static Map<String,Bean> getConfig(String path){
Map<String,Bean> map = new HashMap<String,Bean>();
//dom4j 实现
//1.创建解析器
SAXReader reader = new SAXReader();
//2，加载配置文件=> document对象
InputStream is = ConfigManager.class.getResourceAsStream(path);
Document doc = null;
try {
doc = reader.read(is);
} catch (DocumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//3.定义xpath表达式，取出所有Bean对象
String xpath = "//bean";
//4.对Bean元素进行遍历
List<Element> list = doc.selectNodes(xpath);
if(list != null){
for(Element beanEle : list){
//将bean元素的name/class 属性封装到Bean对象中
String name = beanEle.attributeValue("name");
String className = beanEle.attributeValue("class");
String scope = beanEle.attributeValue("scope");

Bean bean = new Bean();
bean.setName(name);
bean.setClassName(className);
if(null != scope){ //不设置scope值时，默认为singleton
bean.setScope(scope);
}
//获得Bean元素下的所有property子元素，将属性封装到Property对象
List<Element> children = beanEle.elements("property");

if(children != null){
for(Element child : children){
Property prop = new Property();
String pName = child.attributeValue("name");
String pValue = child.attributeValue("value");
String pRef = child.attributeValue("ref");

prop.setName(pName);
prop.setValue(pValue);
prop.setRef(pRef);
//将Property封装到Bean对象
bean.getProperties().add(prop);
}
}
//将Bean对象封装到Map中（用于返回）
map.put(name, bean);
}
}

//5.返回Map结果
return map;
}

}

利用反射创建bean实例并将属性注入，在容器初始化的时候，先将所有作用域为singleton的bean加载到容器中，而prototype类型的bean不会保存在容器中，每次调用getBean时都会创建一个实例。

首先创建一个beanFactory

package com.main;

public interface BeanFactory {

//根据Bean的name获得Bean对象的方法
Object getBean(String beanName);

}

实现了beanFactory，并创建容器和bean的类

package com.main;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

import com.config.Bean;
import com.config.Property;
import com.config.parse.ConfigManager;
import com.utils.BeanUtils;

public class ClassPathXmlApplicationContext implements BeanFactory {

//希望在ClassPathXmlApplicationContext类一创建
//就初始化spring容器（装载Bean实例）

private Map<String, Bean> config; //获取的配置文件
//使用一个map来作为容器
private Map<String, Object> context = new HashMap<String, Object>();

@Override
public Object getBean(String beanName) {
//根据bean的名称获得bean实例

Object bean = context.get(beanName);
//如果bean的scope属性为prototype，那么context中不会包含该bean，需要创建该bean并返回
if(null == bean){
bean= createBean(config.get(beanName));
}

return bean;
}
public ClassPathXmlApplicationContext(String path) {
//1.读取配置文件获得需要初始化的Bean信息
config = ConfigManager.getConfig(path);
//2.遍历配置，初始化Bean
if(config != null){
for(Entry<String, Bean> en : config.entrySet()){
//获取配置中的Bean信息
String beanName = en.getKey();
Bean bean = en.getValue();
Object existBean = context.get(beanName);
//先判断容器中是否已存在该bean,因为createBean方法在创建并将一个bean加载到容器时，也会创建并加载它引用的bean
if(existBean == null && bean.getScope().equals("singleton")){
//如果不存在，并且bean的scope属性为singleton时才将其放入容器中
//根据bean配置创建bean对象
Object beanObj = createBean(bean);
//                System.out.println(beanObj);
//3.将初始的Bean放入容器
context.put(beanName, beanObj);
}
}
}

}

private Object createBean(Bean bean){
//1.获得要创建的bean的Class
String className = bean.getClassName();
Class clazz = null;
try {
clazz = Class.forName(className);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//获得class后将class对应的对象创建出来
Object beanObj = null;
try {
beanObj = clazz.newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//2.获得Bean的属性，将其注入
if(bean.getProperties() != null){
for(Property prop : bean.getProperties()){

//获得要注入的元素名称（属性名或者bean名）
String name = prop.getName();
//根据属性名称获得对应属性的set方法
Method setMethod = BeanUtils.getWriteMethod(beanObj, name);

Object param = null;
//注入分两种情况
if(prop.getValue() != null){
//1.value属性注入
//获得要注入的属性值，为了简单起见，这里没有考虑属性类型转换的问题，通常，从配置文件中直接读取的属性值都为String类型，还需要转换成具体Bean中所定义的类型
param = prop.getValue();

}
if(prop.getRef() != null){
//2.其他bean的注入
//要注入其他bean到当前bean中，先从容器中查找，当前要注入的bean是否已经创建并放入容器中
Object existBean = context.get(prop.getRef());
if(existBean == null){
//容器中不存在要注入的bean，创建该bean
existBean = createBean(config.get(prop.getRef()));
//将创建好的单例bean放入容器中
if(config.get(prop.getRef()).getScope().equals("singleton"))
context.put(prop.getRef(), existBean);
}
param = existBean;
}

try {
//调用set方法注入该属性
setMethod.invoke(beanObj, param);
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
return beanObj;
}

}

上面用到了setXxx方法来注入属性，首先需要获得该类的setXxx方法，这里自己实现了一个简单的BeanUtils，也可以使用apache提供的BeanUtils

顺便提一下javaBean的一个命名规范，java的属性变量名都必须以小写字母开头，在特殊情况下也允许大写字母开头的属性变量名，不过必须满足“变量的前两个字母要么全部大写，要么全部小写”，例如iDcode这种命名是非法的，在sping中如果这样配置了属性名，将找不到setter方法。

package com.utils;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class BeanUtils {

//参数1.bean对象
//参数2.要获得bean对象的属性名
public static Method getWriteMethod(Object beanObj, String name) {
// TODO Auto-generated method stub

Class<?> className = beanObj.getClass();
Method writeMethod = null;
/*使用反射
Field field = null;
try {
field = className.getDeclaredField(name);
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

String firstLetter = name.substring(0, 1).toUpperCase();
String methodName = "set"+firstLetter+name.substring(1);

try {
writeMethod = className.getDeclaredMethod(methodName, field.getType());
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
*/

//使用内省introspector 内省(IntroSpector)是Java语言对JavaBean 类属性、事件的一种缺省处理方法

try {
//1.分析bean对象，得到BeanInfo
BeanInfo beanInfo = Introspector.getBeanInfo(className);
//2.根据BeanInfo获得所有属性的描述器
PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();

//3.遍历描述器

if(descriptors != null){
for(PropertyDescriptor descriptor : descriptors){
//判断当前遍历的描述器所描述的属性是否是我们要找的属性
if(name.equals(descriptor.getName())){
//4.如果找到了，返回该属性的set方法，如果没有找到抛出异常，提醒用户创建该属性的set方法
writeMethod = descriptor.getWriteMethod();
break;
}
}
}
if(writeMethod == null){
new Throwable("请创建创建该"+name+"属性的set方法");
}

} catch (IntrospectionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

return writeMethod;

}

}

接下来写一个测试类

package com.test;

import java.util.Map;

import com.bean.A;
import com.bean.B;
import com.bean.C;
import com.config.Bean;
import com.config.parse.ConfigManager;
import com.main.BeanFactory;
import com.main.ClassPathXmlApplicationContext;

public class Test {

@org.junit.Test
public void fun(){
BeanFactory bf = new ClassPathXmlApplicationContext("/applicationContext.xml");

//        A a = (A) bf.getBean("a");
//        A a2 = (A) bf.getBean("a");
//        A a3 = (A) bf.getBean("a");
//
//
//        System.out.println(a.getName());
//
//        B b = (B) bf.getBean("b");
//        B b2 = (B) bf.getBean("b");
//        B b3 = (B) bf.getBean("b");
//        System.out.println(b.getA().getName());
C c = (C) bf.getBean("c");
C c2 = (C) bf.getBean("c");
C c3 = (C) bf.getBean("c");
}

}

输出的结果如下：

创建A
创建C
创建B
创建C
创建B
创建C
创建B

结果分析，其中A为singleton类型，所以在初始化时只创建了一次，B和C都是prototype类型，每次调用getBean时都会创建一次，其中C，引用了B，B引用了A，所以创建C的时候需要先检查B和A，这时A已经在初始化时创建了，所以每次创建C时都会创建一次B。