spring ioc详解

概览

image

应用上下文即是Spring容器抽象的一种实现，既那些继承了beanFactory的各种ApplicationContext

IOC控制反转

image

• 就是获取对象的方式反转了，以前是自己创建并管理对象，现在是spring管理对象。
• 要解决的问题：让你脱离对对象的维护，随取随用。

IOC的实现过程

https://www.cnblogs.com/ITtangtang/p/3978349.html#a4

1. IOC 容器的初始化

IoC容器的初始化包括BeanDefinition的Resource定位、载入和注册这三个基本的过程.

applicationContent.xml-->BeanDefinition(Map结构)-->beans

image

• Resource定位
  • 定位外部资源（xml配置文件）,由ResourceLoader通过统一的Resource接口来完成。

    Resource对各种形式的BeanDefinition的使用都提供了统一的接口

• BeanDefinition载入 BeanDefinitionReader读取、解析Resource定位的资源,也就是把用户定义的bean 转换成BeanDfinition（Map）结构
• 注册 把上面转换的到BeanDfinition对象注册到ioc容器中，用到了BeanDefinitionRegistery接口

  这里并没有完成依赖注入，依赖注册发生在应用第一次调用getBean时。当然我们可以设置预处理，对某个bean设置leayinit属性，那么这个bean以来注入就会在容易初始化完成。

2. 依赖注入过程

image

1. 依赖注入发生的时间

2. AbstractBeanFactory通过getBean向IoC容器获取被管理的Bean：

3. AbstractAutowireCapableBeanFactory创建Bean实例对象：

4. createBeanInstance方法创建Bean的java实例对象：

5. SimpleInstantiationStrategy类使用默认的无参构造方法创建Bean实例化对象：

6. populateBean方法对Bean属性的依赖注入：

7. BeanDefinitionValueResolver解析属性值：

8. BeanWrapperImpl对Bean属性的依赖注入：

• 用户第一次通过getBean方法向IoC容索要Bean时，IoC容器触发依赖注入。

  
  image
• AbstractBeanFactory

1.getBean调用doGetBean方法
2.先从缓存中取，如果有，则直接完成其他处理。
3.如果没有，判断其模式，单例和代理。然后是其他

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory{
    @Override
    public Object getBean(String name,……) throws BeansException {
    // doGetBean才是真正向IoC容器获取被管理Bean的过程  
        return doGetBean(name, null, null, false);
    }
    
        protected <T> T doGetBean(){
        //先从缓存中取，对于单例模式的对象只创建一次
            Object sharedInstance = getSingleton(beanName);
             //缓存有
            if (sharedInstance != null && args == null) {
        //获取给定Bean的实例对象，主要是完成FactoryBean的相关处理  
        //BeanFactory是管理容器中Bean的工厂，而FactoryBean是创建创建对象的工厂Bean，两者之间有区别
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
            }else{
             //缓冲中没有，则继续判断其模式
             // Create bean instance.
                if (mbd.isSingleton()) {
                //sharedInstance 单例
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }else if (mbd.isPrototype()) {
                //prototypeInstance 代理
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }else {
                //根据Bean定义资源中配置的生命周期范围，选择实例化Bean的合适方法
                    String scopeName = mbd.getScope();
                //scopedInstance
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
            }
        }
}

• AbstractAutowireCapableBeanFactory

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory (){
            protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    
        //生成Bean所包含的java对象实例
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        //对Bean属性的依赖注入进行处理
            populateBean(beanName, mbd, instanceWrapper);
        }
        }
    

看看上面两个方法 具体都是怎么干活的

AbstractAutowireCapableBeanFactory

        protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
         // 1.利用工厂模式进行实例化
        if (mbd.getFactoryMethodName() != null)  {
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }
        
        //2.使用容器的自动装配方法进行实例化  
         autowireNecessary = mbd.constructorArgumentsResolved;
         
         if (autowireNecessary) {  
               //配置了自动装配属性，使用容器的自动装配实例化  
                //容器的自动装配是根据参数类型匹配Bean的构造方法  
                return autowireConstructor(beanName, mbd, null, null);  
            }  
            else {  
              //使用默认的无参构造方法实例化  
                return instantiateBean(beanName, mbd);  
            }  
        
        //3. 使用Bean的构造方法进行实例化  
        Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);  
        //4.使用默认无参构造 实例化
        return instantiateBean(beanName, mbd);
        }

继续来看看4 默认无参构造方法

 protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
           // 根据初始化策略(JDK的反射机制或者CGLIB)创建实例对象  
             beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);  
        }
      

getInstantiationStrategy().instantiate调用了SimpleInstantiationStrategy.instantiate方法

根据初始化策略(JDK的反射机制或者CGLIB)创建实例对象  

public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {  
    if (bd.getMethodOverrides().isEmpty()) { 
    // 如果Bean有方法被覆盖了
    // 根据反射
        final Class<?> clazz = bd.getBeanClass();
         clazz.getDeclaredConstructor((Class[]) null);
    }else{
    // 使用CGLIB
        return instantiateWithMethodInjection(bd, beanName, owner);
    }
}

• 开始看看 populateBean

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
   //获取属性值
    PropertyValues pvs = mbd.getPropertyValues();
    
    //开始注入 首先处理autowire自动装配的注入 
    if(条件){
         MutablePropertyValues newPvs = new MutablePropertyValues(pvs);  
         //按名称注入
         if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
        }
        //按类型
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
        }
         pvs = newPvs;
    }
    
    // 对属性进行注入
    applyPropertyValues(beanName, mbd, bw, pvs);
}

• applyPropertyValues 解析并注入依赖属性的过程

  • 对属性的注入过程分以下两种情况：

    • 属性值类型不需要转换时，不需要解析属性值，直接准备进行依赖注入。
    • 属性值需要进行类型转换时，如对其他对象的引用等，首先需要解析属性值，然后对解析后的属性值进行依赖注入。

主要做属性值转换

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
 
         //获取属性值大小 
        original = mpvs.getPropertyValueList();

    //创建一个Bean定义属性值解析器，将Bean定义中的属性值解析为Bean实例对象的实际值  
    BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
     //为属性的解析值创建一个拷贝，将拷贝的数据注入到实例对象中  
     List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());  
     for (PropertyValue pv : original) {
            if (pv.isConverted()) {
            //不需要转换
                deepCopy.add(pv);
            }else {
            //需要转换
              deepCopy.add(new PropertyValue(pv, convertedValue));
            }
         
     }
     //进行属性值注入
     bw.setPropertyValues(new MutablePropertyValues(deepCopy));  
}  

image

• BeanDefinitionValueResolver 解析属性值
  • 如果发现属性值需要进行类型转换。如：属性值是容器中另一个 Bean实例对象的引用，则需要先解析出所引用的对象，然后才能将该引用对象注入到目标实例对象的属性上去。
    对属性进行解析的由resolveValueIfNecessary方法实现

public Object resolveValueIfNecessary(Object argName, Object value) {  
    
}

BeanWrapperImpl对Bean属性的依赖注入
BeanWrapperImpl类主要是对容器中完成初始化的Bean实例对象进行属性的依赖注入，即把Bean对象设置到它所依赖的另一个Bean的属性中去
依赖注入源码

private void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
    
}

(1).对于集合类型的属性，将其属性值解析为目标类型的集合后直接赋值给属性。

(2).对于非集合类型的属性，大量使用了JDK的反射和内省机制，通过属性的getter方法(reader method)获取指定属性注入以前的值，同时调用属性的setter方法(writer method)为属性设置注入后的值。

autowiring的实现过程：

• 对Bean的属性迭代调用getBean方法，完成依赖Bean的初始化和依赖注入。
• 将依赖Bean的属性引用设置到被依赖的Bean属性上。
• 将依赖Bean的名称和被依赖Bean的名称存储在IoC容器的集合中。

Bean

• 特点:
  • 可序列化，
  • 提供无参构造器
  • 提供getter方法和setter方法访问对象的属性
• bean作用域（scope）spring 创建bean的规则
  • 单例 singleton:在整个应用中，只创建一个实例
  • 原型 prototype：每次注入或者通过spring应用上下文获取的时候，创建一个新的bean。即每次调用getBean()时，相当于执行new Bean()的操作
  • request :每次http请求，就会创建bean，只在http内有效
  • session：针对http session有效
  • global session:全局的session有效

<bean id="userInfo" class="cn.***.UserInfo" scope="singleton"></bean>  

• bean的生命周期

  • 参考文章
  • 流程
  image

1. Spring对bean进行实例化；
2. Spring将值和bean的引用注入到bean对应的属性中；
3. 如果bean实现了BeanNameAware接口，Spring将bean的ID传递给setBeanName()方法；
4. 如果bean实现了BeanFactoryAware接口，Spring将调用setBeanFactory()方法，将BeanFactory容器实例传入；
5. 如果bean实现了ApplicationContextAware接口，Spring将调用setApplicationContext()方法，将bean所在的应用上下文的引用传入进来；
6. 如果bean实现了BeanPostProcessor接口，Spring将调用它们的post-ProcessBeforeInitialization()方法；
7. 如果bean实现了InitializingBean接口，Spring将调用它们的after-PropertiesSet()方法。类似地，如果bean使用init-method声明了初始化方法，该方法也会被调用；
8. 如果bean实现了BeanPostProcessor接口，Spring将调用它们的post-ProcessAfterInitialization()方法；
9. 此时，bean已经准备就绪，可以被应用程序使用了，它们将一直驻留在应用上下文中，直到该应用上下文被销毁；
10. 如果bean实现了DisposableBean接口，Spring将调用它的destroy()接口方法。同样，如果bean使用destroy-method声明了销毁方法，该方法也会被调用。

IOC容器

• ioc对对象的管理要实现两个
  • 对象的构建
  • 对象的绑定
• 对于这两个技术实现方式主要有
  • 配置文件
  • 注解
• sring提供了两种类型的容器
  • BeanFactory
  • ApplicationContent(BeanFactory高级版)

ioc的实现方式（如何注入）

依赖注入方式：

• 构造注入
  当person对象生成的时候，就会把food注入

public Person(Food food) {
    this.food = food;
}

• setter注入
  只有需要吃food的时候，调用setFood 才会注入food

public void setFood(Food food) {
    this.food = food;
}

注入方式对比

• setter 优势
  1. 让依赖关系更直观
  2. 对于复杂的依赖关系，构造器会臃肿。而且spring创建实例时，会创建依赖的所有示例，性能下降。setter方式不会出现这个问题。
  3. 某些属性可选的情况下，所参数的构造器会更加笨重。
• 构造器 优势
  1. 可以决定依赖关系的注入顺序。
  2. 对于依赖关系没有变化的bean，不用担心后续代码会对依赖关系产生破坏。
  3. 只有组建的创建者可以改变组建的依赖关系，对调用者来说，内部关系透明。

ioc中涉及到的设计模式