# litespring

**Repository Path**: kenwar/litespring

## Basic Information

- **Project Name**: litespring
- **Description**: 从零开始造spring
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-04-03
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

## IOC 实现
### 读取xml配置文件，实例化bean
```
<?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
           http://www.springframework.org/schema/beans/spring-beans.xsd">
  
  <bean id="petStore"
        class="com.ken.litespring.service.v1.PetStoreService" >
  </bean> 
 <bean id="invalidBean"
        class="xxx.xxxxx" >   
  </bean> 
</beans>
```
### 单元测试
```
    @Test
    public void testGetBean() throws Exception {
        BeanFactory factory = new DefaultBeanFactory("petstore-v1.xml");
        BeanDefinition bd = factory.getBeanDefinition("petStore");
        // 获取配置中配置的bean的class名
        Assert.assertEquals("com.ken.litespring.service.v1.PetStoreService",bd.getBeanClassName());
        // 获取bean的实例
        PetStoreService petStore = (PetStoreService)factory.getBean("petStore");
        Assert.assertNotNull(petStore);
    }
```
### 定义一个BeanDefinition 接口，可以获取bean的定义
```
public interface BeanDefinition {
    String getBeanClassName();
}
```
#### BeanDefinition的默认实现类
```
public class GenericBeanDefinition implements BeanDefinition {
	private String id;
	private String beanClassName;
	public GenericBeanDefinition(String id, String beanClassName) {
		
		this.id = id;
		this.beanClassName = beanClassName;
	}
	public String getBeanClassName() {
		
		return this.beanClassName;
	}

}
```
### 定义一个BeanFactory接口
```
public interface BeanFactory {
    /**
     根据beanId获取bean的定义
    */
    BeanDefinition getBeanDefinition(String beanId);

    /**
        根据beanId获取bean的实例
    */
    Object getBean(String beanId);
}

```
#### BeanFactory的默认实现
```
public class DefaultBeanFactory implements BeanFactory {

    public static final String ID_ATTRIBUTE = "id";

    public static final String CLASS_ATTRIBUTE = "class";

    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();

    public DefaultBeanFactory(String configFile) {
        this.loadBeanDefinition(configFile);
    }

    /**
     * 加载bean的配置
     * @param configFile
     */
    private void loadBeanDefinition(String configFile){
        Document document = null;
        SAXReader saxReader = new SAXReader();
        try {
            document = saxReader.read(new File(configFile));
            Element rootElement = document.getRootElement(); // <beans>
            Iterator<Element> elementIterator = rootElement.elementIterator();
            while (elementIterator.hasNext()) {
                Element element = elementIterator.next();// <bean>
                String id = element.attributeValue(ID_ATTRIBUTE);
                String beanClassName = element.attributeValue(CLASS_ATTRIBUTE);
                BeanDefinition bd = new GenericBeanDefinition(id, beanClassName);
                beanDefinitionMap.put(id, bd);
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }

    public BeanDefinition getBeanDefinition(String beanId) {
        return this.beanDefinitionMap.get(beanId);
    }

    public Object getBean(String beanId) throws Exception {
        // 根据beanId获取bean的定义
        BeanDefinition beanDefinition = this.getBeanDefinition(beanId);
        if (beanDefinition == null) {
            return null;
        }
        String beanClassName = beanDefinition.getBeanClassName();
        // 获取classLoader
        ClassLoader cl = null;
        if (cl == null) {
            // getClassLoader() returning null indicates the bootstrap ClassLoader
            try {
                cl = ClassLoader.getSystemClassLoader();
            } catch (Throwable ex) {
                // Cannot access system ClassLoader - oh well, maybe the caller can live with null...
            }
        }
        // 根据类名实例化bean
        Class<?> clz = cl.loadClass(beanClassName);
        return clz.newInstance();
    }
}
```
### UML 类图
![image](http://pubimg.kenwar.cn/v1.0uml.png)
```

```