Clojure和JAVA设计模式（1） 工厂模式之简单工厂

序

 

    在java中，设计模式是多态和封装的重要表现形式，采用设计模式能够极大地提升可维护性和可扩展性，

那么，同样工作在jvm上面的Clojure能否运用这些模式，或者说是否同样需要这些模式呢？

 

注：本文基于jdk1.6和Clojure1.2

简单工厂

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

 

    首先定义产品的接口：

public interface IProduct {

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

 

 然后是实现了这个接口的两个具体产品Product1和Product2：

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);
	}

}

 

最后是根据类型获取产品的简单工厂：

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中就构建了能够生产出两个不同产品的简单工厂了。接下来，我们调用一下：

 

/**
 * 简单工厂调用
 * @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");
	}

}

 运行这个调用程序，我们能够得到预期的结果：

Product1 use:something
Product2 use:something

 

    那么，在Clojure中应该如何实现呢？

 

    首先，让我们再回顾一下采用简单工厂的目的，这是为了将业务对象的产生和业务方法的

执行进行解耦，使得业务方法执行时无须关注业务对象的类型。为了达到这个目的，我们提取

了业务对象的接口IProduct（在实际的应用中也有可能是一个父类Product），它的里面包含

了所有业务对象的共同操作use（在实际应用中可能不止这一种业务操作，当然也不叫use）

的方法声明。然后，由SimplyFactory来创建IProduct的实例对象，然后调用use业务方法。

在这个时候，调用方法是无须关注被调用的具体是哪个实例对象--Product1还是Product2。

 

    好吧，为了业务对象的产生和业务方法的执行解耦。然后，Clojure中没有对象一说，方法

倒是有，不过叫做函数。于是，问题解决了，没有对象，则无须对对象的产生进行解耦。本文结束。

 

    抛开上面的文字游戏不谈，实际上Clojure的解决方式更为灵活，这是由其语言特性所决定的。

在java中，一切都是对象（除了原始类型），而类和接口是对象的定义，包含了有关对象动作方式

的相关信息，比如名称、方法、属性和事件等。所以，在java应用中，能够使用的最小粒度的东西

就是对象，如果需要调用某个实例方法，首先需要实例化某个对象，然后调用这个对象的方法；如

果需要调用某个静态方法，需要找到静态方法所属的类，然后以类名.方法名的形式来调用。而在

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方法。

 

    接下来，我们就看看调用和产生的输出：

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代码似乎差别有点大，让我们对这个调用方式做一点小小的修改：

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代码一一对应了，其中

IProduct product1 = SimpleFactory.factory("1");

    对应

(def product1 (simply-factory 1))

    ，而

product1.use("something");

    对应

(product1 "something")

 

    这样子是不是就能看得更明白一些了？不过要注意的是，虽然调用形式看起来很类似，但是在

Clojure中product1是个函数，而java中product1是个对象。