spring源码分析IOC(1)

我们都知道spring有2个最重要的概念，IOC（控制反转）和AOP(依赖注入)。今天我就分享一下spring源码的IOC。

IOC的定义：直观的来说，就是由spring来负责控制对象的生命周期和对象间的关系，将对象之间的关系抽象出来，通过spring容器控制对象生成时机，减少对象之间的耦合度。

更通俗一点的说就是，JAVA程序中，当你在代码中需要使用某个类提供的功能时，你首先需要new一个对象，给它传递必要的参数，然后才能使用它提供的功能；有了IOC之后，IOC的容器类似一个中介，所有的对象都会注册到这个中介，当需要用到某个对象的时候就告诉中介（配置bean信息），中介会帮你注入对象。

IOC的体系结构： BeanFactory和BeanDefinition

　　BeanFactory：类图如下

　　

　　beanFactory的接口可以分为四层

　　第一层：BeanFactory是主接口，定义了IOC容器的基本功能规范

　　第二层：BeanFactory的三个子接口：HierarchicalBeanFactory（分层工厂接口）、AutowireCapableBeanFactory（自动装配工厂接口）和ListableBeanFactory（可将集合列出工厂接口）

　　第三次：HierarchicalBeanFactory的子接口ConfigurableBeanFactory（复杂可配置工厂）

　　第四层：ListableBeanFactory，ConfigurableBeanFactory，AutowireCapableBeanFactory的共同接口：ConfigurableBeanFactory

　　看到这个结构其实我们很容易想到设计模式的----接口隔离模式（不清楚的自行百度吧）

       下面我们看下每个接口的源码

　　  BeanFactory

public interface BeanFactory {
//这里是对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象，(用来区分是获取BeanFactory工厂本身还是工厂创建的对象) ，如果需要得到工厂本身，需要转义
　　String FACTORY_BEAN_PREFIX = "&";
 　　 //四个不同形式的getBean方法，获取实例 
　　Object getBean(String var1) throws BeansException;

    <T> T getBean(String var1, Class<T> var2) throws BeansException;

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

    Object getBean(String var1, Object... var2) throws BeansException;

    <T> T getBean(Class<T> var1, Object... var2) throws BeansException;
　　//是否包含bean
    boolean containsBean(String var1);
　　//是否单例模式
    boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;
　　//是否多例
    boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;
　　//是否匹配类型
    boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;
　　//获取bean类型
    Class<?> getType(String var1) throws NoSuchBeanDefinitionException;
　　//获取bean别名
    String[] getAliases(String var1);
}

BeanFactory对IOC容器的基本行为作了定义，但是并不关心bean怎样加载的

HierarchicalBeanFactory代码

public interface HierarchicalBeanFactory extends BeanFactory {
    BeanFactory getParentBeanFactory();

    boolean containsLocalBean(String var1);
}

这个工厂接口定义的Bean都是可以继承的，都是有parent

ListableBeanFactory代码

public interface ListableBeanFactory extends BeanFactory {
    boolean containsBeanDefinition(String var1);

    int getBeanDefinitionCount();

    String[] getBeanDefinitionNames();

    String[] getBeanNamesForType(Class<?> var1);

    String[] getBeanNamesForType(Class<?> var1, boolean var2, boolean var3);

    <T> Map<String, T> getBeansOfType(Class<T> var1) throws BeansException;

    <T> Map<String, T> getBeansOfType(Class<T> var1, boolean var2, boolean var3) throws BeansException;

    String[] getBeanNamesForAnnotation(Class<? extends Annotation> var1);

    Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> var1) throws BeansException;

    <A extends Annotation> A findAnnotationOnBean(String var1, Class<A> var2) throws NoSuchBeanDefinitionException;
}

这个工厂接口定义的Bean都是可以列表化的,可以批量获取bean的信息

AutowireCapableBeanFactory代码

public interface AutowireCapableBeanFactory extends BeanFactory {
    int AUTOWIRE_NO = 0;
    int AUTOWIRE_BY_NAME = 1;
    int AUTOWIRE_BY_TYPE = 2;
    int AUTOWIRE_CONSTRUCTOR = 3;
    /** @deprecated */
    @Deprecated
    int AUTOWIRE_AUTODETECT = 4;

    <T> T createBean(Class<T> var1) throws BeansException;

    void autowireBean(Object var1) throws BeansException;

    Object configureBean(Object var1, String var2) throws BeansException;

    Object resolveDependency(DependencyDescriptor var1, String var2) throws BeansException;

    Object createBean(Class<?> var1, int var2, boolean var3) throws BeansException;

    Object autowire(Class<?> var1, int var2, boolean var3) throws BeansException;

    void autowireBeanProperties(Object var1, int var2, boolean var3) throws BeansException;

    void applyBeanPropertyValues(Object var1, String var2) throws BeansException;

    Object initializeBean(Object var1, String var2) throws BeansException;

    Object applyBeanPostProcessorsBeforeInitialization(Object var1, String var2) throws BeansException;

    Object applyBeanPostProcessorsAfterInitialization(Object var1, String var2) throws BeansException;

    void destroyBean(Object var1);

    Object resolveDependency(DependencyDescriptor var1, String var2, Set<String> var3, TypeConverter var4) throws BeansException;
}

这个工厂接口定义 Bean 的自动装配规则。也就是非容器注册的Bean托管成容器管理，如tomcat的Filter（属于服务器），可以用这个接口来装配spring的bean

以上四个接口共同定义了 Bean 的集合、Bean 之间的关系、以及 Bean 行为

ConfigurableBeanFactory提供bean的扩配置功能,它的子接口ConfigurableListableBeanFactory,除了ConfigurableBeanFactory的功能之外，它还提供了访问和修改BeanDefinition，预实例化singletons（这连个接口代码太长就不帖出来了）　

BeanFactory相关的接口只对IOC容器的最基本行为作了定义，根本不关心你的bean是怎样定义怎样加载的。

　根据上面的类图，我们发现默认实现类是DefaultListableBeanFactory，这个类很复杂，下面我们重点分析这个类的源码

　　未完。。。。