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