注:本文基于jdk1.6和Clojure1.2
工厂方法
工厂方法模式定义了一个创建对象的接口,由子类来决定实例化哪一个类,意即将实例化推迟到子类。
当然,这个说法本身是干巴巴概念性的。让我们针对上篇简单工厂 的例子考虑一下,我们在SimpleFactory中
已经定义了产生IProduct实例的方法,这是在调用之前就定好了 产生IProduct实例的规则,可是如果遇到
需要在调用时才决定这个规则的情况时,SimpleFactory就无法满足了。
比如说,某次调用中需要在参数productType等于1时返回Product1, 参数productType等于2时返回
Product2, SimpleFactory正好能满足这种情况,没问题;但另外一次调用时需要在 参数productType等于
1时返回Product2, 参数productType等于2时返回null, 参数productType等于3时返回Product1,
SimpleFactory就傻眼了......
当然,我们一拍脑袋就想出办法了--在SimpleFactory的 factory方法中 再加一个参数来增加规则:
/**
* 根据产品类型和规则来生产产品
* @param productType
* @return
*/
public static IProduct factory(String productType,String regulation){
if(regulation.equals("1")){
if(productType.equals("1"))
return new Product1();
else if(productType.equals("2"))
return new Product2();
}else if(regulation.equals("2")){
if(productType.equals("1"))
return new Product2();
else if(productType.equals("3"))
return new Product1();
}
return null;
}
哈哈,这不就解决问题了吗?这样做确实解决了眼前的问题而且能够正常工作,但是,如果产品的规则再增添
一种,比如regulation3,毫无疑问,我们又需要再去修改SimpleFactory的factory方法;规则再增加一种,好的,
继续修改SimpleFactory的factory方法...以此类推, SimpleFactory的factory方法会变得越来越大,变成冗长
的、逻辑关系复杂的代码泥团,谁要再去修改这个方法,必须仔细研读代码,小心翼翼地添加类型和规则,生怕
影响到了所有调用它的地方。改完之后,大骂一通设计人员,然后到javaeye上面发一篇《碰到史上最烂JAVA项目》
这样的帖子,然后大家告诉你:“国内项目很多都这样,没办法,找到工资待遇高的就走吧”。
问题在于,这种解决方法是面向过程而非面向对象的。记得面向对象的设计原则吗,面向接口而非面向实现类
编程,对修改封闭对扩展开放。所以,工厂方法模式就出场了:
/**
* 工厂方法接口
* @author RoySong
*/
public interface IFactoryMethod {
/**
* 根据产品类型生产产品
* @param productType
* @return
*/
public IProduct factory(String productType);
}
/**
* 规则1工厂
* @author RoySong
*/
public class Regulation1Factory implements IFactoryMethod {
@Override
public IProduct factory(String productType) {
if(productType.equals("1"))
return new Product1();
else if(productType.equals("2"))
return new Product2();
return null;
}
}
/**
* 规则2工厂
* @author RoySong
*/
public class Regulation2Factory implements IFactoryMethod {
@Override
public IProduct factory(String productType) {
if(productType.equals("1"))
return new Product2();
else if(productType.equals("3"))
return new Product1();
return null;
}
}
/**
* 工厂方法调用
* @author RoySong
*/
public class FactoryMethodTest {
private IFactoryMethod iFactoryMethod;
public static void main(String[] args){
FactoryMethodTest fmt = new FactoryMethodTest();
//采用规则1工厂方法
fmt.setiFactoryMethod(new Regulation1Factory());
IProduct product1 = fmt.getiFactoryMethod().factory("1");
product1.use("regulation 1");
IProduct product2 = fmt.getiFactoryMethod().factory("2");
product2.use("regulation 1");
//采用规则2工厂方法
fmt.setiFactoryMethod(new Regulation2Factory());
product1 = fmt.getiFactoryMethod().factory("3");
product1.use("regulation 2");
product2 = fmt.getiFactoryMethod().factory("1");
product2.use("regulation 2");
}
public void setiFactoryMethod(IFactoryMethod iFactoryMethod) {
this.iFactoryMethod = iFactoryMethod;
}
public IFactoryMethod getiFactoryMethod() {
return iFactoryMethod;
}
}
调用的结果是:
Product1 use:regulation 1
Product2 use:regulation 1
Product1 use:regulation 2
Product2 use:regulation 2
而在Clojure当中,工厂方法简直是信手拈来。首先我们定义两个产品:
(defn product1 [msg] (println "Product1 use:" msg)) (defn product2 [msg] (println "Product2 use:" msg))
然后我们定义两个规则工厂:
(defn regar1-factory [type] (cond (= 1 type) #'product1 (= 2 type) #'product2 true nil)) (defn regar2-factory [type] (cond (= 3 type) #'product1 (= 1 type) #'product2 true nil))
最后定义一个调用函数:
(defn use-product [fn type msg] ((fn type) msg))
我们注意到代码中有一个奇特的符号” #‘ “,这是个什么玩意儿呢?
实际上,这是Clojure中的一种取值方式,用于取得符号(比如product1)所映射的对象值(意即product1所
代表的整个函数体),而并非符号储存的对象的引用值(指针)。换句话说,我们的规则函数(regar*-factory)
所返回的是整个函数,而调用函数接受的参数fn也是一个函数。这就是函数式编程语言的最大特征之一,函数即
数据。你可以把函数作为返回值或者是参数。这也是函数式编程语言比指令式编程语言更加灵活(也更加难懂)的
原因之一。
回到例子,我们开始使用调用函数:
(use-product #'regar1-factory 1 "anything")
毫无意外的结果:
Product1 use: anything nil
再来一个:
(use-product #'regar2-factory 1 "something")
仍然是预期的结果:
Product2 use: something nil
这样,我们在Clojure里面就达到了运行时根据规则产生不同的对象的目的了。严格来说,上面的例子并非在
运行时才进行的实例化,应该通过宏(macro)来产生product1和product2,不过,为了代码的清晰和简单,
这儿暂时就这么写了。
附注:很久没有写工厂了,概念模糊了,这里面的java代码实际上不是工厂方法,而是抽象工厂。经朋友提醒才
想起来,原文先保留不动吧。