一、写在前面：
做这个Demo主要是为了能够更好的理解Spring的原理，看再多的文章，听再多的讲解最终都最好自己去实现一遍，可以将Spring的功能分块实现，最终自然比较容易将各个功能组合起来。
这个Demo里主要实现的是Spring的IOC功能，即原本需要通过写硬代码来实现初始化复杂类，现在通过配置就能动态的构建复杂类，复杂类的属性值也由配置动态指定，这种实现方式称之为控制反转IOC或叫依赖注入DI；在本例中主要是实现了Spring早期的IOC功能，即通过xml文件配置beans，然后通过XmlBeanFactory来getBean，这里不涉及太多设计模式、异常处理和性能优化，主要还是为了打通过程。对于Spring的注解形式的IOC功能以及AOP功能等还未实践，有时间了也需要归纳知识去实现一遍方能完全理解和记忆。
二、实现功能：
实现了Spring的通过配置文件动态的配置bean，并提供scope、lazy-init、constructor-arg、property的属性或子结点的配置；最终通过factory.getBean("id")来获取从配置文件里构建的bean对象。
三、代码及配置：
1.beans.xml的配置：
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="stud1" class="me.silentdoer.simulatespring.pojo.Student"/>
<bean id="str1" class="java.lang.String" scope="singleton" lazy-init="true">
<constructor-arg value="UUUUUUUU" type="java.lang.String"/>
</bean>
<bean id="stud2" class="me.silentdoer.simulatespring.pojo.Student">
<constructor-arg name="uid" value="500" type="java.lang.Long"/>
<constructor-arg name="gender" ref="str1" type="java.lang.String"/>
<property name="name" value="Hello" type="java.lang.String"/>
</bean>
</beans>
2.pojo类：Student
package me.silentdoer.simulatespring.pojo;
import java.io.Serializable;
public class Student implements Serializable {
private Long uid;
private String name;
private String gender;
public Student(){
this.name = "silentdoer";
}
public Student(Long uid){
this.uid = uid;
}
public Student(Long uid, String gender){
this.uid = uid;
this.gender = gender;
}
@Override
public String toString(){
return String.format("Student-[uid=%s, name=%s, gender=%s]", this.uid, this.name, this.gender);
}
public Long getUid() {
return uid;
}
public void setUid(Long uid) {
this.uid = uid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
3.基础类型和其包装类的转换类，如value="500"将500转换为Long型
package me.silentdoer.simulatespring.util; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; /**
* @Author Silentdoer
* @Since 1.0
* @Version 1.0
* @Date 2018-2-23 16:39
*/
public class PrimitiveParser {
public static <T> T parse(String type, Object origin){
Logger logger = LoggerFactory.getLogger("myLogger");
if(logger.isDebugEnabled()){
logger.debug(String.format("%s, %s", type, origin));
}
Object result = null;
switch(type){
case "long":
case "java.lang.Long":
result = Long.parseLong(origin.toString());
break;
// etc.
default:
throw new UnsupportedOperationException("暂不支持");
}
return (T) result;
}
}
4.配置文件bean的包装类
package me.silentdoer.simulatespring.beans.factory.config; import java.io.Serializable;
import java.util.List; /**
* 这个不是VO，也不是涉及RPC的POJO，故可以用基础类型以及有默认值
* @Author Silentdoer
* @Since 1.0
* @Version 1.0
* @Date 2018-2-19 21:37
*/
public class BeanInfo implements Serializable {
public static final int SCOPE_PROTOTYPE = 1, SCOPE_SINGLETON = 2;
private String id;
private String clazz;
private Object instance;
private int scope = SCOPE_SINGLETON;
private boolean lazyInit = false;
private List<KeyValueTypePair> constructorArgs;
private List<KeyValueTypePair> properties; public String getId() {
return id;
} public void setId(String id) {
this.id = id;
} public String getClazz() {
return clazz;
} public void setClazz(String clazz) {
this.clazz = clazz;
} public Object getInstance() {
return instance;
} public void setInstance(Object instance) {
this.instance = instance;
} public int getScope() {
return scope;
} public void setScope(int scope) {
this.scope = scope;
} public boolean isLazyInit() {
return lazyInit;
} public void setLazyInit(boolean lazyInit) {
this.lazyInit = lazyInit;
} public List<KeyValueTypePair> getConstructorArgs() {
return constructorArgs;
} public void setConstructorArgs(List<KeyValueTypePair> constructorArgs) {
this.constructorArgs = constructorArgs;
} public List<KeyValueTypePair> getProperties() {
return properties;
} public void setProperties(List<KeyValueTypePair> properties) {
this.properties = properties;
} public static class KeyValueTypePair {
private String key;
private Object value;
private String type; public String getKey() {
return key;
} public void setKey(String key) {
this.key = key;
} public Object getValue() {
return value;
} public void setValue(Object value) {
this.value = value;
} public String getType() {
return type;
} public void setType(String type) {
this.type = type;
}
}
}
5.XmlBeanFactory类，用于提供bean
package me.silentdoer.simulatespring.beans.factory; import me.silentdoer.simulatespring.beans.factory.config.BeanInfo;
import me.silentdoer.simulatespring.util.PrimitiveParser;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*; import static me.silentdoer.simulatespring.beans.factory.config.BeanInfo.KeyValueTypePair; /**
* @Author Silentdoer
* @Since 1.0
* @Version 1.0
* @Date 2018-2-19 21:01
*/
public class XmlBeanFactory {
private InputStream resource = null;
private boolean inited = false;
private Map<String, BeanInfo> beansInfo;
private Map<String, Class<?>> primitiveAndWrapperTable; public XmlBeanFactory(InputStream inputStream){
this.resource = inputStream;
primitiveAndWrapperTable = new HashMap<>(16);
primitiveAndWrapperTable.put("long", long.class);
primitiveAndWrapperTable.put("java.lang.Long", Long.class);
primitiveAndWrapperTable.put("int", int.class);
primitiveAndWrapperTable.put("java.lang.Integer", Integer.class);
// etc.
} protected final void init() throws DocumentException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
if (inited) {
return;
}
Logger logger = LoggerFactory.getLogger("myLogger");
final InputStream config = this.resource;
if (null == config) {
throw new IllegalStateException("初始化失败");
} SAXReader reader = new SAXReader();
Document document = reader.read(config);
Element root = document.getRootElement();
List<Element> beans = root.elements("bean");
final Map<String, BeanInfo> beanInfoMap = this.beansInfo = new LinkedHashMap<String, BeanInfo>(beans.size());
/** 先构建标签的属性 */
for (Element bean : beans) {
Attribute id = bean.attribute("id");
Attribute clazz = bean.attribute("class");
Attribute scope = bean.attribute("scope");
Attribute lazyInit = bean.attribute("lazy-init");
if (id == null || clazz == null) {
throw new RuntimeException("配置不合法");
}
BeanInfo beanInfo = new BeanInfo();
beanInfo.setId(id.getValue());
beanInfo.setClazz(clazz.getValue());
if (scope != null && scope.getValue().equals("prototype")) {
beanInfo.setScope(BeanInfo.SCOPE_PROTOTYPE);
}
if (lazyInit != null && lazyInit.getValue().equals("true")) {
beanInfo.setLazyInit(true);
}
beanInfoMap.put(id.getValue(), beanInfo);
} /** 构建标签的子结点 */
for (Element bean : beans) {
List<Element> constructorParams = bean.elements("constructor-arg");
List<Element> properties = bean.elements("property");
String id = bean.attributeValue("id");
BeanInfo beanInfo = beanInfoMap.get(id);
List<KeyValueTypePair> conArgs = new ArrayList<KeyValueTypePair>(constructorParams.size());
beanInfo.setConstructorArgs(conArgs);
initKeyValueTypePair(conArgs, constructorParams.iterator(), beanInfoMap); List<KeyValueTypePair> pros = new ArrayList<KeyValueTypePair>(properties.size());
beanInfo.setProperties(pros);
initKeyValueTypePair(pros, properties.iterator(), beanInfoMap);
} /** 根据上面构建出的配置和参数构建bean */
for(BeanInfo bean : beanInfoMap.values()){
//boolean prototype = bean.getScope() == BeanInfo.SCOPE_PROTOTYPE;
boolean lazyInit = bean.isLazyInit();
// 只要是非lazyInit则初始化后BeanInfo内的instance一定不为null，这个主要是为了先初始化ref的bean后防止重复初始化该bean
if(!lazyInit && bean.getInstance() == null){
Object instance = instantiateBean(bean);
bean.setInstance(instance);
}
}
inited = true;
} /**
* 通过构建好的BeanInfo初始化具体的实例
* @param beanInfo
* @return 实例对象
* @throws ClassNotFoundException
* @throws NoSuchMethodException
*/
protected Object instantiateBean(BeanInfo beanInfo) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Logger logger = LoggerFactory.getLogger("myLogger");
Object result = beanInfo.getInstance();
if(result != null)
return result;
Class<?> instanceClazz = Class.forName(beanInfo.getClazz());
/** ----------------------constructor-arg---------------------- */
List<KeyValueTypePair> constructorArgs = beanInfo.getConstructorArgs();
List<Class> conArgTypes = new ArrayList<Class>(16);
List<Object> conArgs = new ArrayList<Object>(16);
for(KeyValueTypePair pair : constructorArgs){
//logger.debug(pair.getType());
conArgTypes.add(Class.forName(pair.getType()));
Object value = pair.getValue();
// ref的情况则先初始化ref对应的bean
if(BeanInfo.class.isInstance(value)){
// 递归优先初始化所有的依赖bean
value = instantiateBean((BeanInfo)value);
}
conArgs.add(value);
}
/*if(logger.isDebugEnabled()) {
logger.debug(conArgTypes.toString());
}*/
Constructor constructor = instanceClazz.getConstructor(conArgTypes.toArray(new Class[conArgTypes.size()]));
Object[] initargs = conArgs.toArray(new Object[conArgs.size()]);
if(logger.isDebugEnabled()){
for(int i=0;i<initargs.length;i++){
logger.debug("Tag:" + initargs[i].getClass());
}
}
result = constructor.newInstance(initargs);
/** ----------------------property---------------------- */
List<KeyValueTypePair> propertyArgs = beanInfo.getProperties();
for(KeyValueTypePair pair : propertyArgs){
String type = pair.getType();
String name = pair.getKey();
String setter = String.format("set%s%s", name.substring(0, 1).toUpperCase(), name.substring(1));
Method setterM = instanceClazz.getMethod(setter, Class.forName(type));
Object value = pair.getValue();
if(BeanInfo.class.isInstance(value)){
value = instantiateBean((BeanInfo) value);
}
setterM.invoke(result, value);
}
return result;
} /**
* 通过bean的constructor-arg或property配置填充keyValueTypePairs
* @param keyValueTypePairs
* @param iterator
* @param beansContainer
*/
protected final void initKeyValueTypePair(final List<KeyValueTypePair> keyValueTypePairs, final Iterator<Element> iterator, final Map<String, BeanInfo> beansContainer){
Logger logger = LoggerFactory.getLogger("myLogger");
while(iterator.hasNext()){
Element next = iterator.next();
String name = next.attributeValue("name");
Object value = next.attributeValue("value");
String ref = next.attributeValue("ref");
String type = next.attributeValue("type");
if(value == null && ref == null || value != null && ref != null){
throw new RuntimeException("配置不合法");
}
KeyValueTypePair e = new KeyValueTypePair();
e.setKey(name);
e.setType(type);
if(value != null){
// 需要转换
if(primitiveAndWrapperTable.get(type) != null){
value = PrimitiveParser.parse(type, value);
}
e.setValue(value);
}else{ // ref
// NOTE 目前只是初始化BeanInfo，还没到初始化具体的Bean对象
BeanInfo refBean = beansContainer.get(ref); // name=gender ref=str1
// 暂且规定ref的bean要先配置
if(refBean == null){ // 也可以改成从配置里查找name，有则先初始化该BeanInfo，然后赋值
throw new RuntimeException("配置不合法");
}
e.setValue(refBean);
}
keyValueTypePairs.add(e);
}
} public <T> T getBean(String id){
try {
init();
}catch (Throwable ex){
throw new IllegalStateException(ex);
}
Object result = null;
final Map<String, BeanInfo> beans = this.beansInfo;
BeanInfo beanInfo = beans.get(id);
result = beanInfo.getInstance();
if(result == null){
try {
result = instantiateBean(beanInfo);
}catch (Exception ex){
ex.printStackTrace();
}
}
if(beanInfo.getScope() == BeanInfo.SCOPE_PROTOTYPE){
try {
Method clone = Object.class.getMethod("clone");
clone.setAccessible(true);
result = clone.invoke(beanInfo.getInstance());
}catch (Exception ex){
ex.printStackTrace();
}
}
return (T) result;
}
}
6.main方法类
import me.silentdoer.simulatespring.beans.factory.XmlBeanFactory;
import me.silentdoer.simulatespring.pojo.Student; import java.io.InputStream; /**
* @Author Silentdoer
* @Since 1.0
* @Version 1.0
* @Date 2018-2-19 20:01
*/
public class Entrance {
public static void main(String[] args){
InputStream resource = Thread.currentThread().getContextClassLoader().getResourceAsStream("beans.xml");
System.out.println(resource == null);
XmlBeanFactory factory = new XmlBeanFactory(resource);
String str1 = factory.getBean("str1");
System.out.println(str1);
Student student = factory.getBean("stud1");
System.out.println(student);
Student student2 = factory.getBean("stud2");
System.out.println(student2);
}
}
最终main方法输出为：
UUUUUUUU
Student-[uid=null, name=silentdoer, gender=null]
Student-[uid=500, name=Hello, gender=UUUUUUUU]
Spring的基础的IOC功能实现完毕，源码放在我的GitHub上：https://github.com/Silentdoer/demos/tree/master/模拟Spring的IOC功能/Demo.SimulateSpringIOC