mini-spring(简易版spring)学习记录（1）

DefaultListableBeanFactory作为beanFactory中最顶级的类 它继承了AbstructAutowireCapableBeanFactory 并实现了ConfigurableListableBeanFactory 我们在这里实现了一个简易的spring框架。先从简单的测试代码开始讲起：

DefaultListableBeanFactory beanFactory=new DefaultListableBeanFactory();  
BeanDefinition beanDefinition=new BeanDefinition(HelloService.class); 

beanFactory.registerBeanDefinition("helloService",beanDefinition);  
HelloService helloService=(HelloService) beanFactory.getBean("helloService");  

helloService.sayHello();

我们首先看一下自定义的BeanDefinition类 这是Bean的定义类 里面有bean的Class文件，是否单例，是否懒惰加载，它的初始化策略与销毁策略，PropertyValues等。
在这里我们通过构造函数来构造了一个BeanDefinition，并beanFactory.registerBeanDefinition("helloService",beanDefinition);
接下来我们转向registerBeanDefinition,这是在DefaultListableBeanFactory中实现的，在这个类里，

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory  
implements ConfigurableListableBeanFactory,BeanDefinitionRegistry {  
  
private Map<String ,Object>beanDefinitionMap=new HashMap<>();  
  
@Override  
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {  
beanDefinitionMap.put(beanName,beanDefinition);  
}  
  
@Override  
public BeanDefinition getBeanDefinition(String beanName) throws BeansException {  
BeanDefinition beanDefinition= (BeanDefinition) beanDefinitionMap.get(beanName);  
if (beanDefinition ==null){  
throw new BeansException("No bean named '" + beanName + "' is defined");  
}  
return beanDefinition;  
}

我们可以看到有一个map专门用于保存beanDefinition,这样我们也就可以保存bean了
然后是Bean的获取

public Object getBean(String name) throws BeansException {  
Object sharedInstance = getSingleton(name);  
if (sharedInstance != null) {  
//如果是FactoryBean，从FactoryBean#getObject中创建bean  
return getObjectForBeanInstance(sharedInstance, name);  
}  
  
BeanDefinition beanDefinition = getBeanDefinition(name);  
Object bean = createBean(name, beanDefinition);  
return getObjectForBeanInstance(bean, name);  
}

在这里我们首先看到getSingleton，如果是单例的，那么看能不能从三级缓存里面拿到这个Bean这是个定义在DefaultSingletonBeanRegister里的方法

public Object getSingleton(String beanName) {  
    Object singletonObject=singletonObjects.get(beanName);  
    if(singletonObject==null){  
        singletonObject=earlySingletonObject.get(beanName);  
        if(singletonObject==null){  
            ObjectFactory<?>singletonFactory=singletonFactories.get(beanName);  if(singletonFactory!=null){  
    singletonObject= singletonFactory.getObject();  
    earlySingletonObject.put(beanName,singletonObject);  
    singletonFactories.remove(beanName);  
      }  
   }  
  }  
return singletonObject;  
}

而这也正是三级缓存的实现，接下来我们看到getBeanDefinition这一方法，在DefaultSingletonBeanRegister里，这是一个抽象函数，也即是一个模板方法，这是在DefaultListableBeanFactory中实现的。
然后就是创建Bean的操作，这也是一个模板方法，是在AbstractAutowiredBeanFacuory中实现的

    private InstantiationStrategy instantiationStrategy=new SimpleInstantiationStrategy();  
  
  
  
protected Object createBean(String beanName, BeanDefinition beanDefinition) {  
    Object bean = resolveBeforeInstantiation(beanName, beanDefinition);  
    if (bean != null) {  
    return bean;  
    }  
    return doCreateBean(beanName,beanDefinition);  
}  
  
private Object doCreateBean(String beanName, BeanDefinition beanDefinition) {  
    Object bean;  
  
    bean=createBeanInstance(beanDefinition);  
    if(beanDefinition.isSingleton()){  
    Object finalBean=bean;  
    addSingletonFactory(beanName, new ObjectFactory<Object>() {  
        @Override  
    public Object getObject() throws BeansException {  
        return getEarlyBeanReference(beanName,beanDefinition,finalBean);  
}  
});  
}  
 
    Object exposedObject= bean;  
// if(beanDefinition.isSingleton()){  
// exposedObject=getSingleton();  
//  
// }  
  
return exposedObject;  
  
}

我们可以看到，有不同的初始化方法，也即SimpleInstantiationStrategy，比较简单的是反射，也可以用cglib,在创建完成后会有一些beanpostprocesser之类的步骤留到下一部分在进行说明。