1、什么是IOC？

1.1 DI和IOC

依赖注入DI和控制反转IOC其实都是同一个东西，只是从不同的方面去形象地解读组合模式而已。没错，我认为IOC就是一种将组合模式运用到极致的软件设计概念，从而达到了松耦合的目标。说这么多，不如举一个例子来说明一下。

我们或多或少都学过面向对象的语言，如：c++，java等，它们要求我们要继承、封闭、多态。然而在实际的软件实践中继承是一个很糟糕的想法，是一种hardcode，对于程序的可扩展性极差。所以，我们要多用接口少用继承（继承抽象类不算，至于原因我后面会提到）。
现在有一个场景：老师让你设计一个能吃饭的人的类。于是乎你会这么写代码：

class Person{
  private String name;
  private int age;
  public Person(String name, int age){
    this.name = name;
    this.age = age;
  }

  public void eatRice(){
      handUpBowl();
      eatRace();
      digest();
    }
  private void handUpBowl(){
  }
  private void eatRace(){
  }
  private void digest(){
  }
}

很完美，我们设计了一个类，一个可以拿碗，可以吃饭还能消化的一个Person类，我们感觉已经很perfect了。
但是，突然有一天老师说我不想吃饭了，我想吃面。然后机智的我们想到区别不就是将eatRice这个方法进行修改就可以达到需求了吗。
于是我们将eatRace()用eat()方法进行替换，eat方法中通过一个参数进行选择吃饭还是吃面，perfect！
改变之后的代码如下：

class Person{
  private String name;
  private int age;
  private int food_type;
  public static final int RACE = 1;
  public static final int NOODLE = 2;
  public Person(String name, int age, int food_type){
    this.name = name;
    this.age = age;
    this.food_type = food_type;
  }

  public void eatRice(){
      handUpBowl();
      eat();
      digest();
    }
  private void handUpBowl(){
  }
  private void eat(){
    //这里已经可以进行重构了，应该拉出去作为工厂模式，以后有机会说设计模式与重构的时候再论述
    if(food_type == RICE){
      eatRice();
      }else if(food_type == NOODLE){
      eatNoodle();
      }
  }
  private eatRice(){}
  private eatNoodle(){}
  private void digest(){
  }
}

好了，我们又通过改变一些代码实现了可以吃饭也可以吃面的人的类。但是，如果我们需要吃粉、吃炒饭呢？没关系，我们可以如代码中说的，把这个准备食材的功能交给一个工厂，让它准备食材。（不对劲，怎么写到工厂方法去了。。。），没事，扭回来。
现在我们考虑一下这个解决方案：我们让eatRice()和eatNoodle()都派生于一个父类Eat，那么我们可以通过以下的代码来实现一个人中午吃面，晚上吃饭。

interface Eat{
 void eat();
}
class EatNoodle implements Eat{
  public void eat(){
    //吃面逻辑
  }
}

class EatRice implements Eat{
  public void eat(){
    //吃饭逻辑
  }
}
class Person{
  private String name;
  private int age;
  private Eat eat;
  public Person(String name, int age){
    this.name = name;
    this.age = age;
  }

  public void eat(){
      handUpBowl();
      eat.eat();
      digest();
    }
  private void handUpBowl(){
  }
  private void digest(){
  }
}


//以下为main函数
public static void main(String[] args){
  //这里没有在构造器里面注入eat属性，可能会导致NullException，但如果是spring却可以用@require注解来注入
  Person p = new Person("小明", 24);
  EatRice eatRice = new EatRice();
  EatNoodle eatNoodle = new EatNoodle();
  p.setEat(eatRice);
  p.eat();
  p.setEat(eatNoodle);
  p.eat();
}

好了，现在我们可以随时改变p的饮食，而不需要新建一个人却只为了吃米饭这样的小事。而且我们也可以发现，无论添加多少人，吃饭，吃面两种行为类都可以满足，所以啊，它们在main函数里面是singleton的，哦，我们发现spring默认对待bean也是单例的
就是基于这样的出发点，记忆web服务中大量的公用服务，如：连接池、过滤器、拦截器以及各种大量的配置文件，Spring大量采用单例模式来减少初始化实例和销毁的代价。对于注入则采用了构造器注入以及set方法注入，一般来说构造器注入安全，但set注入可以运行时改变实例的行为。对于实例的注入，Spring又提供了一种自动装配的技术autowire，这种技术要详说又得搞个两点了，大体方法就是基于Java的反射机制去得到类名或者class来字符串匹配注入。
好困，2点了。