工厂模式，控制反转（依赖注入）

  在介绍工厂模式与控制反转（Inversion of Control）及依赖注入（Dependency Injection）之前，先介绍下类的调用方法。目前调用方法总共有3种：1.自己创建；2.工厂模式；3.外部注入，其中外部注入即为控制反转/依赖注入模式（IoC/DI）。我们可以用3个形象的东西来分别表示它们，就是new、get、set。顾名思义，new表示自己创建，get表示主动去取（即工厂），set表示是被别人送进来的（即注入）,其中get和set分别表示了主动去取和等待送来两种截然相反的特性，这3个单词代表了3种方法的思想精髓。     无论是那一种方法，都存在两个角色，那就是调用者和被调用者。下面我们通过实例来讲解这3种方法的具体含义。首先，我们设定调用对象为学生对象Student,被调用者对象为图书对象Book,要设计的代码功能是学生学习图书。我们一般习惯于一种思维编程方式：接口驱动，可以提供不同灵活的子类实现：

//Book接口 
public interface IBook{    

  public void learn();

 } 
//BookA实现类 
public class BookA implements IBook {   

  public void learn(){ 
        System.out.println("学习BookA");  

   } 

} 
//BookB实现类 
public class BookB implements IBook {   

  public void learn(){ 
        System.out.println("学习BookB");     }

 }

下面就来演示这三种方法是如何调用图书类的

1） new 自己创建
public class Student {    

public void learnBookA(){  

      IBook book = new BookA();      

  book.learn();    

} 

 public void learnBookB(){ 

   

  

  

 IBook book = new BookB(); 

   

  

  

 book.learn(); 

   

 }  

}

        public void learnBookB(){      

   IBook book = new BookB();        

 book.learn();    

}  

}

该方法在调用者Student需要调用被调用者IBook时，需要自己来创建一个IBook对象。这种做法的缺点是无法更换被调用者，并且要负责被调用者的整个生命周期。

2）get  工厂模式

//图书工厂 

 public class BookFactory{     

public static IBook getBookA() {         

IBook book = new BookA();        

 return book;     

} 
         public static IBook getBookB() {         I

Book book = new BookB();        

 return book;     } 

}

//学生类

public class Student {    

public void learnBookA(){ 
        IBook book = BookFactory.getBookA();    

    book.learn();  

  } 
      public void learnBookB(){ 
        IBook book = BookFactory.getBookB();      

  book.learn();    

}

}

此时多了一个工厂类，将对象创建提取到工厂类中，调用者无需考虑对象的创建，只管从工厂中拿，
在修改被调用者是也无需改动太多的代码。但是，对象的创建依然不灵活，以为兑现的取得完全取决于工厂，有多了一道中间的工序。

3）set 外部注入

此时多了一个工厂类，将对象创建提取到工厂类中，调用者无需考虑对象的创建，只管从工厂中拿，
在修改被调用者是也无需改动太多的代码。但是，对象的创建依然不灵活，以为兑现的取得完全取决于工厂，有多了一道中间的工序。

3.1) 接口注入

public class Student{    

private IBook bookA;    

public init(){ 
        bookA = (IBook)Class.forName("BookA").newInstance();    

}

}    
    通过动态的创建BookA的实例来注入，这种方式仍然依赖于IBook的实现。

3.2) 构造注入

依赖关系是通过类的构造函数建立的，容器通过调用类的构造方法，将其所需的依赖关系注入其中。 
public class Student {    

private BookA bookA;    

public Student (BookA booA){

this.bookA = bookA;  

  } 
    public void learn() {

bookA.learn();    

}

} 
public class Factory {  

  public static getInstance(){ 
Class clazz = BookA.class;    //创建类BookA的Class对象

Class[] param = new Class[]{BookA.class}; try{ 
      Constructor con = clazz.getConstructor(param);  

   BookA bookA = (BookA)con.newInstance(str);    

  Student student1 = new Student(bookA);

}catch (Exception e){    

  e.p rintStackTrace();

} 
return student1;     }

}

  这样就通过Factory.getInstance()直接获取又有属性bookA的一个Student实例。

3.设置注入 
  受控对象通过属性来表达自己所以来的对象和所需配置的值。只要为对象添加setter方法即可。 
public class Student {     private BookA bookA; 
    public BookA getBookA(BookA booA){ return bookA;     } 
    public void setBookA(BookA booA){ this.bookA = bookA;     } 
    public void learn() { bookA.learn();     } }

public class Factory { 
    public static getInstance(String fieldName){ 
Class clazz = BookA.class;    //创建类BookA的Class对象 Class student = Student.class; 
Class[] param = new Class[]{BookA.class}; try{ 

Method method = student.getMethod("set"+change(fieldName),param);      BookA bookA = (BookA)clazz.newInstance();      BookA[] book = new BookA[] {bookA};      Object obj = student.newInstance();      method.invoke(obj,book);      Student student1 = (Student) obj; }catch (Exception e){      e.printStackTrace(); } 
return student1;     } 
    public static String change(String str) { String subString = str.substring(0,1); subString = subString.toUpperCase(); str = str.substring(1,str.length()); str = subString + str; return str;     } } 

这样只需调用Factory.getInstance("bookA")即可获得Student的实例。 
    依赖注入的优点在于在容器中定义对象，容器会自动组建出一个实例，缺点就是生成一个对象的步骤变得复杂了，对于不习惯这种方式的人会觉得有些别扭和不直观。 
    总结：从工厂模式到依赖注入，搞得那么复杂究竟为了什么呢？工厂模式的作用就是将对象的创建击中到工厂容器中，这样对于对象的修改也集中到容器中进行，便于维护。而工厂模式由于不通用，故对于不同的对象就需要在容器中创建不同的方法，因此利用基于反射机制的动态编程技术又可以解决此问题，但是生成对象的过程越来越繁琐。