ioc 的思考

开始学spring时，spring两大特性IOC 和AOP ，ioc的解释是：
IoC 　(Inversion of Control) 中文译为控制反转 又称为“依赖注入”（DI ＝Dependence Injection）
　　IOC的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器负责将这些联系在一起。
　　其原理是基于OO设计原则的The Hollywood Principle：Don't call us, we'll call you（别找我，我会来找你的）。也就是说，所有的组件都是被动的（Passive），所有的组件初始化和调用都由容器负责。组件处在一个容器当中，由容器负责管理。
　　简单的来讲，就是由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。AOP的解释是：
　　面向切面编程：Aspect Oriented Programming
　AOP是OOP的延续，是（Aspect Oriented Programming）的缩写，意思是面向切面编程。
主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。
主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。
可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。
在Spring中提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
上面这些概念都是我们开始学的时候，的一些理论知识，其实刚开始谁也不会完全懂这些。本篇文章主要解释IOC，对AOP只是介绍下。扯远点，谈谈面向对象和面向过程。为什么面向对象优于面向过程。其实就是在软件开发的过程中，软件变化的地方越来越多。各种各样的变化。导致用传统面向过程的设计。并不能适应软件变化越来越多。变的越来越庞大的需求。面向过程的程序设计方法并不是不好。如果我们的软件一开发出来就定型了，没有变化升级 了，我个人觉得面向对象和面向过程在某些方面应该没有区别，面向对象的优点就是它对应于软件开发过程中的变化，能够比面向过程更好的适应。更好的扩展系统。来适应变化。我觉得一句话概括：面向对象比面向过程能更好的适应变化，其实包含本篇讲的IOC，也是这样。如果软件开发中没有变化，IOC也就没有什么用。包括设计模式。AOP，软件的模式等等。我们首先要学会对比分析。首先要学会假设，学会假设需求的变化。这样才能更好的理解设计模式。IOC，AOP等这些经典的思想。扯远了，回到本文的讨论。举个例子。下面例子一步步的变化。注意变化后与上次对比，
好在哪里。这样我们才能够更好的理解IOC思想。举一个人去北京，他可以坐火车，汽车，飞机等工具的例子。类如下：

class Car{
    public void run(){
    System.out.println("-----------by Car-----------");   
}
}
class Person{
   public void goToBJ(){
      Car car=new Car();
      car.run();

}
}
public class Client(){
  public static void main(String args[]){
     Person person=new Person()
     person.goToBJ();

}
}

这是一个人坐汽车去北京的例子。当然这个人如果一直坐汽车去北京。没有什么事。他某天突然想坐火车去北京。那我们首先必须先增一个火车类。当然这个是必须的，也是
正确的，OCP原则，对扩展开放，对修改关闭。我们现在要新增功能，新增一个类是必须的。(这里我强调一下，是避免疑问),我们新增火车类后，发现我们还得必须修改我们
的Person类。这点是非常不好的。这也是我们所关注的地方。我们强调对修改关闭。我们应该尽量减少对我们类的修改。这里我们重构一下代码。新增一个工具接口。用接口来实现。

class Person{
	private GongJu gongju;
        public Person(GongJu gongju){//这里类似于IOC里面的构造注入。
	  	this.gongju=gongju;
	  }
      public void goToBJ(){
       gongju.run();        
     }
}

Class Car implements GongJu{
  public void run(){
  System.out.println("-----------by Car-----------");   

}
}
//新增的火车类
Class HuoChe implements GongJu{
     public void run(){
     System.out.println("-----------by HuoChe -----------");   
}
}
//工具接口
public interface GongJu{
	  public void run();
}

public Class Client(){
    public static void main(String args[]){
    GongJu gongju=new Car();//在这里变化。如果想坐火车，变成这样 GongJu gongju=new HuoChe();即可
    Person person=new Person(gongju);
    person.getToBJ();
 }
 }

通过重构后的代码，我们发现可扩展性，得到了极大的提高。以后人要是想坐飞机等其他方式去北京。我们只要新增一个类，实现GongJu接口。再在客户端稍微修改一下。不用去修该已有的代码。可维护性得到很大的提高。我们再次重构代码，新增一个工厂类。把客户端类的代码移到工厂类中去。变化如下：

class Factroy{
   public void BJ(){
    GongJu gongju=new Car();
    Person person=new Person(gongju);
    person.getToBJ();
 }
}
public Class Client {
   Factory factory =new Factory();
   factory.BJ();
}

在这里我们通过Factory类的依赖注入，实现了反转控制。以后需求的任何变化，我们只用关注工厂类的变化即可。当然修改代码对于我们来说始终是不太好。在这种情况是spring提出了一种比较好的更改方式。通过配置xml文件来实现依赖注入。以后我们修改只要修改xml文件即可。目前spring支持3中注入。包括set 注入。构造器注入，接口注入等，spring里面有个BeanFactory类。类似我们这里的Factory类。spring IOC的具体实例在这里不在详细描述了，对于IOC我的理解是它将类与类之间的依赖关系转移了。即所谓的好莱坞原则。(Don't call me ,I'll call you!)一般情况下。我们要使用实例时。需要创建对象的实例。然而通过我们的IOC容器框架后。我们只需要直接使用实例。将创建对象的任务交给IOC容器。这就是IOC。