Clojure And Java Design Pattern

Clojure和JAVA设计模式(1) 工厂模式之简单工厂

http://roysong.iteye.com/blog/1218694

博客分类: 原创javaClojure

java模式clojure工厂模式

在java中,设计模式是多态和封装的重要表现形式,采用设计模式能够极大地提升可维护性和可扩展性,
那么,同样工作在jvm上面的Clojure能否运用这些模式,或者说是否同样需要这些模式呢?

注:本文基于jdk1.6和Clojure1.2
简单工厂

先看看简单工厂的java代码:

首先定义产品的接口:
Java代码
public interface IProduct {

/**
* 使用产品
* @param msg
*/
public void use(String msg);
}

然后是实现了这个接口的两个具体产品Product1和Product2:
Java代码
public class Product1 implements IProduct {

@Override
public void use(String msg) {
System.out.println("Product1 use:"+msg);
}

}

public class Product2 implements IProduct {

@Override
public void use(String msg) {
System.out.println("Product2 use:"+msg);
}

}

最后是根据类型获取产品的简单工厂:
Java代码
public class SimpleFactory {

/**
* 根据产品类型生产产品
* @param productType
* @return
*/
public static IProduct factory(String productType){
if(productType.equals("1"))
return new Product1();
else if(productType.equals("2"))
return new Product2();
return null;
}
}

这样,我们在java中就构建了能够生产出两个不同产品的简单工厂了。接下来,我们调用一下:

Java代码
/**
* 简单工厂调用
* @author RoySong - 2011-10-27
*/
public class SimpleFactoryTest {

/**
* @param args
*/
public static void main(String[] args) {
IProduct product1 = SimpleFactory.factory("1");
product1.use("something");

IProduct product2 = SimpleFactory.factory("2");
product2.use("something");
}

}
运行这个调用程序,我们能够得到预期的结果:
Java代码
Product1 use:something
Product2 use:something

那么,在Clojure中应该如何实现呢?

首先,让我们再回顾一下采用简单工厂的目的,这是为了将业务对象的产生和业务方法的
执行进行解耦,使得业务方法执行时无须关注业务对象的类型。为了达到这个目的,我们提取
了业务对象的接口IProduct(在实际的应用中也有可能是一个父类Product),它的里面包含
了所有业务对象的共同操作use(在实际应用中可能不止这一种业务操作,当然也不叫use)
的方法声明。然后,由SimplyFactory来创建IProduct的实例对象,然后调用use业务方法。
在这个时候,调用方法是无须关注被调用的具体是哪个实例对象—Product1还是Product2。

好吧,为了业务对象的产生和业务方法的执行解耦。然后,Clojure中没有对象一说,方法
倒是有,不过叫做函数。于是,问题解决了,没有对象,则无须对对象的产生进行解耦。本文结束。

抛开上面的文字游戏不谈,实际上Clojure的解决方式更为灵活,这是由其语言特性所决定的。
在java中,一切都是对象(除了原始类型),而类和接口是对象的定义,包含了有关对象动作方式
的相关信息,比如名称、方法、属性和事件等。所以,在java应用中,能够使用的最小粒度的东西
就是对象,如果需要调用某个实例方法,首先需要实例化某个对象,然后调用这个对象的方法;如
果需要调用某个静态方法,需要找到静态方法所属的类,然后以类名.方法名的形式来调用。而在
Clojure中,函数是第一类对象,它无须依附对象或者类而存在(实际上,在几乎所有的函数式编程
语言中都是这样)。换句话说,我们调用某个方法无须首先实例化某个对象或者找到某个类。

那么,针对上面的例子,我们可以说,实际上我们需要的是根据不同的类型获取两个不同的业务
处理方法而已。
Clojure代码
(defn simply-factory [type]
(cond
(= 1 type) (fn [msg] (println "Product1 use:" msg))
(= 2 type) (fn [msg] (println "Product2 use:" msg))))

在上面的代码中,我们定义了一个函数simply-factory,它接受一个参数type,然后根据type的
值为1或者2返回对应的函数。实际上,我们从内容上可以看出来,这两个函数就分别对应了之前我们
定义的Product1和Product2中的use方法。

接下来,我们就看看调用和产生的输出:
Clojure代码
user> ((simply-factory 1) "something")
Product1 use: something
nil
user> ((simply-factory 2) "something")
Product2 use: something
nil

已经达到了我们之前想要的结果,对不对?让我们再看看调用方法的代码((simply-factory 1) "something"),
(simply-factory 1)代表传入参数1调用simply-factory函数,返回的是一个匿名函数;而
((simply-factory 1) "something")整体就代表将"something"传入simply-factory函数返回的匿名函数,然后
我们就得到了预期的结果:Product1 use: something。我相信你已经看出来了,Clojure中函数的调用方式是:
(函数名 参数)这个样子的。

不过这个样子跟上面的java代码似乎差别有点大,让我们对这个调用方式做一点小小的修改:
Clojure代码
user> (def product1 (simply-factory 1))
#'user/product1
user> (product1 "something")
Product1 use: something
nil
user> (def product2 (simply-factory 2))
#'user/product2
user> (product2 "something")
Product2 use: something
nil

这样子应该就能够和之前的java代码一一对应了,其中
Java代码
IProduct product1 = SimpleFactory.factory("1");
对应
Clojure代码
(def product1 (simply-factory 1))
,而
Java代码
product1.use("something");
对应
Clojure代码
(product1 "something")

这样子是不是就能看得更明白一些了?不过要注意的是,虽然调用形式看起来很类似,但是在
Clojure中product1是个函数,而java中product1是个对象。