Spring

一、 IOC(Inversion of Control)，即控制反转，意思是将对象的创建和依赖关系交给第三方容器处理，我们要用的时候告诉容器我们需要什么然后直接去拿就行了。举个例子，

 我们有一个工厂，它生产各种产品，当你需要某个产品，比如你需要一辆汽车，你就告诉工厂你需要一辆汽车，工厂就会直接返回给你一辆汽车，而不需要你自己通过付

 出劳动来得到这辆汽车，你也不用关心工厂是如何生产这辆汽车。对应到我们的程序中就是，IOC容器会帮我们创建和管理对象，当你告诉容器你需要某个对象时，

 容器会把这个对象返回给你，而不需要自己去new出一个对象来，对象的创建和管理会由容器自动进行，直接从容器中拿来用就可以了。IOC可以说是Spring最核心的思想，

 它使我们的开发变得简单（对象之间的依赖关系可以通过配置文件或者注解来创建），对于这种优秀的设计思想，我们当然有必要研究一下它的底层实现原理。

 public interface BeanFactory {  

    String FACTORY_BEAN_PREFIX = "&";   

    Object getBean(String name) throws BeansException;  

    <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException;   

    Object getBean(String name, Object... args) throws BeansException;   

    <T> T getBean(Class<T> requiredType) throws BeansException;   

    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;   

    boolean containsBean(String name);

    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

    @Nullable

    Class<?> getType(String name) throws NoSuchBeanDefinitionException;

    String[] getAliases(String name);

}

这个接口便是spring核心的bean工厂定义，它是IOC容器的顶层接口，spring中所有bean工厂都直接或间接的继承或实现了这个接口。我们平时使用的最多的

ApplicationContext接口也继承了BeanFactory接口，因此它具有BeanFactory接口的所有功能，这里顺便提一下，从BeanFactory获取bean时，实例化BeanFactory容器并不会

实例化所配置的bean，只有当使用某个bean(getBean)时，才会实时的实例化该bean；从ApplicationContext获取bean时，实例化ApplicationContext容器时会一并实例化容器

中的所有的bean。

从BeanFactory的源码可以看出，它实现的核心功能就是根据名称或类型来返回一个bean实例。一个工厂如果要具备这种功能，结合工厂模式的思想，我们可以试想一下它需要具备以下几个条件：

       1、持有各种bean的定义，只有拿到了bean的定义信息，才能根据这些信息进行实例化；

       2、持有各种bean之间的依赖关系，如果一个类中持有对另一个类的引用，那么在对该类进行实例化时，必须根据类之间的依赖关系对相关类也进行实例化，因此，工厂必须获得类之间的依赖关系，否则无法正确实例化；

       3、以上两种信息都依赖于我们的配置信息定义，比如xml配置文件，工厂需要一个工具来读取配置文件的信息。

       以上是我们设想IOC的实现思路，只要满足以上三个条件，就能构造一个工厂，生产各种bean。但是我们还是有一些疑问，比如在第一个条件中，我们如何持有bean的定义呢？我们先来看另外一个接口：

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

     String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;

     String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

    int ROLE_APPLICATION = 0;

    int ROLE_SUPPORT = 1;

    int ROLE_INFRASTRUCTURE = 2;

    void setParentName(@Nullable String parentName);

       @Nullable

    String getParentName();

    void setBeanClassName(@Nullable String beanClassName);

    @Nullable

    String getBeanClassName();

    void setScope(@Nullable String scope);

    @Nullable

    String getScope();

    void setLazyInit(boolean lazyInit);

    boolean isLazyInit();

    /**

     * Set the names of the beans that this bean depends on being initialized.

     * The bean factory will guarantee that these beans get initialized first.

     */

    void setDependsOn(String... dependsOn);

    /**

     * Return the bean names that this bean depends on.

     */

    @Nullable

    String[] getDependsOn();

    void setAutowireCandidate(boolean autowireCandidate);

    boolean isAutowireCandidate();    

    void setPrimary(boolean primary);    

    boolean isPrimary();   

    void setFactoryBeanName(@Nullable String factoryBeanName);   

    @Nullable

    String getFactoryBeanName();

    void setFactoryMethodName(@Nullable String factoryMethodName);  

    @Nullable

    String getFactoryMethodName();  

    ConstructorArgumentValues getConstructorArgumentValues();    

    MutablePropertyValues getPropertyValues();

    boolean isSingleton();    

    boolean isPrototype();    

    boolean isAbstract();    

    int getRole();    

    @Nullable

    String getDescription();    

    @Nullable

    String getResourceDescription();    

    @Nullable

    BeanDefinition getOriginatingBeanDefinition();

 

}

BeanDefinition，顾名思义便是spring中的bean定义接口，spring的工厂里持有的就是此接口定义的内容。从源码可以看出，这个接口继承了两个另外两个接口，一个是AttributeAccessor接口，继承这个接口就意味着BeanDefinition接口拥有了处理属性的能力，另外一个接口是BeanMetedataElement，它可以获得bean的配置定义的元素，对于xml文件来说就是会持有bean的标签。从源码中我们可以看出，BeanDefinition接口定义了两个方法，分别是void setDependsOn(String… dependsOn)和String[] getDependsOn()，从方法的说明可以看出，这两个方法就是设置依赖的bean的名称和获取依赖的bean的名称，这就意味着只要我们有一个BeanDefinition，就能得到得到bean的定义信息和bean之间的依赖关系，从而可以生产一个完整的bean实例。

? ? ? ?从上面两个接口，我们大致可以猜出spring是如何持有bean的定义信息及依赖关系了，没错，就是让bean工厂持有一个Map<String，BeanDefinition>，String型的beanName作为key，BeanDefinition型的bean定义作为value，这样就能生产一个bean实例。BeanFactory接口当然不能持有这个map对象，那么一定是在它的某个实现类里所持有的，我们找到了这个实现类，来看看源码：

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory

        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

 

    @Nullable

    private static Class<?> javaxInjectProviderClass;

 

    static {

        try {

            javaxInjectProviderClass =

                    ClassUtils.forName("javax.inject.Provider", DefaultListableBeanFactory.class.getClassLoader());

        }

        catch (ClassNotFoundException ex) {

            // JSR-330 API not available - Provider interface simply not supported then.

            javaxInjectProviderClass = null;

        }

    }

 

 

    /** Map from serialized id to factory instance */

    private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =

            new ConcurrentHashMap<>(8);

 

    /** Optional id for this factory, for serialization purposes */

    @Nullable

    private String serializationId;

 

    /** Whether to allow re-registration of a different definition with the same name */

    private boolean allowBeanDefinitionOverriding = true;

 

    /** Whether to allow eager class loading even for lazy-init beans */

    private boolean allowEagerClassLoading = true;

 

    /** Optional OrderComparator for dependency Lists and arrays */

    @Nullable

    private Comparator<Object> dependencyComparator;

 

    /** Resolver to use for checking if a bean definition is an autowire candidate */

    private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();

 

    /** Map from dependency type to corresponding autowired value */

    private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);

 

    /** Map of bean definition objects, keyed by bean name */

    //beanFactory持有此map,这样就可以在任何时候获取bean的BeanDefinition来创建一个bean实例

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

 

    /** Map of singleton and non-singleton bean names, keyed by dependency type */

    private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);

 

    /** Map of singleton-only bean names, keyed by dependency type */

    private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);

 

    /** List of bean definition names, in registration order */

    private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

 

    /** List of names of manually registered singletons, in registration order */

    private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

 

    /** Cached array of bean definition names in case of frozen configuration */

    @Nullable

    private volatile String[] frozenBeanDefinitionNames;

 

    /** Whether bean definition metadata may be cached for all beans */

    private volatile boolean configurationFrozen = false;

}

? ? ? ?DefaultListableBeanFactory类，这个类是默认的bean工厂实现类，这里只贴出了部分源码，完整的代码太长。我们来看其中的一行代码：

? ? ? ?

/** Map of bean definition objects, keyed by bean name */

    //beanFactory持有此map,这样就可以在任何时候获取bean的BeanDefinition来创建一个bean实例

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

? ? ? ?这行代码证明了我们的猜测，从方法是说明就可以看出这是bean定义的map对象，以bean的名称作为key。到这里思路就明确了，bean工厂的初始化就是往这个map对象里加东西，把我们xml文件里定义的bean填充到这个对象里，bean工厂就可以工作了。

? ? ? ?那么怎样将xml文件配置的bean注册到这个map对象里呢？我们可以试试以下思路：

? ? ? ?1、需要一个工具来找到xml配置文件，可以称之为资源定位；

? ? ? ?2、需要一个Reader来读取xml配置信息，即DOM解析；

? ? ? ?3、将读取出来的信息注册到map对象里。