又是一天的修炼,今日主题是工厂模式-----Factory Pattern
工厂模式是一个很有意思的模式,因为它和另一个模式,装饰者模式,有着血缘关系,但是应用和表现形式都有着不同。其实在此之前本该先写装饰者模式-----Decorator Pattern,但是在看完这两个模式之后,决定先写工厂,主要装饰者的弊处不小,需要整合其他模式一起使用方显威力,不然其带来的不便甚至会是一场灾难。
这里先说明一下,这俩模式的血缘关系就在于同属于为了创建对象或者对象集而用。
好,进入正题。
心法(2):工厂模式。
第一层心法-----工厂方法模式-----Factory Method Pattern。(某些地方叫:简单工厂)
先简单解释下,为啥它是第一层,而且还有个“方法”存在。首先,它属于工厂模式中较容易理解的一层,逻辑简单,就是为了创建某个对象所用,并且,通过一个神秘的方法,叫Factory Method来实现,只要实现了Factory Method,就能实现工厂方法模式。
接下来,想象一下这样一个场景,星巴克要建立一套咖啡购买系统,考虑到今后可能会提供非咖啡饮品,于是,很自然的搭建了这样一个结构。
很清晰对不,不同咖啡继承自饮料这个基类。当需要某个具体的咖啡的时候,只要创建对应的对象即可。
继续想象,当咖啡越来越多的时候,会怎么样。
这是什么呢?Class Explosion。。。Boommm!!!! 氪金狗眼一阵乱瞎。。。。
怎么办呢?没有关系,这时候,我们可以请出工厂方法模式来帮忙。
我们先做这样一段分析,咖啡都来自于咖啡豆的研磨,冲泡和配料的添加。那我们是否可以首先根据咖啡豆的产地,讲咖啡做一个抽象的分类,然后在按照咖啡的种类,去具体实现某种特定的咖啡呢?
好,上代码,这里就贴上Africa的咖啡豆相关代码,巴西的类似,就不贴了。
CoffeeBean:
public abstract class CoffeeBean {
public Coffee orderCoffee(String type){
Coffee c=createCoffee(type);
c.bake();
c.deliver();
return c;
}
/**
* Factory method
* @return
*/
protected abstract Coffee createCoffee(String type);;
}
AfricaCoffeeBean:
public class AfricaCoffeeBean extends CoffeeBean {
@Override
protected Coffee createCoffee(String type) {
// TODO Auto-generated method stub
if (type.equals("mocha")) {
return new AfricaMochaCoffee();
} else if (type.equals("latie")) {
return new AfricaLatieCoffee();
} else if (type.equals("cappucino")) {
return new AfricaCappucinoCoffee();
} else {
return new AfricaBlackCoffee();
}
}
}
PS:以上所有咖啡都继承自以下这个Coffee类
Coffee:
public abstract class Coffee {
String name;
public String getName(){
return this.name;
}
public void bake() {
// TODO Auto-generated method stub
}
public void deliver() {
// TODO Auto-generated method stub
}
}
Main:
public static void main(String[] args) {
// TODO Auto-generated method stub
AfricaCoffeeBean c=new AfricaCoffeeBean();
c.orderCoffee("mocha");
}
乍看之下,所谓的工厂方法模式,只是把复杂的业务逻辑分割到了3个类里面去实现。但是,仔细看CoffeeBean这个虚基类里面的orderCoffee函数,它其实是整个制作咖啡业务逻辑的主函数,但是,其实它根本不知道我到底是用了Africa还是Brazil,更不知道createCoffee返回的是哪个具体对象。也就是,orderCoffee已经被彻底的剥离于具体实现,仅仅只是一套业务逻辑。而这一切幕后功臣,就是上面那个注释有Factory Method的createCoffee。它是一个虚函数,依赖于子类的实现。子类的实现?对,就是这个,这就是工厂方法模式的核心-----let the subclass implement the creation and get the super class away from knowledge of what type of object it is dealing with. 让子类去实现对象创建,让父类处理业务逻辑而不用关心到底处理哪个具体类。同时,这也引出了,我们另一条设计原则-----Depend upon abstractions. Do not depend upon concrete classes.
如何理解这条原则呢,其实仔细看以上程序结构,假如按照之前的设计,那么父类的实现就完全依赖于创建的实体类,也就是具体哪个咖啡,那么对应的业务逻辑必须有对应的实现。这就是depend on concrete classes. 而之后的设计,上层业务逻辑依赖于Coffee这个虚基类,下层的具体咖啡对象也依赖与咖啡这个虚基类,所有,他们都依赖于一个abstraction。这样,制作咖啡的操作就和具体品种选择操作分离,并且任何一处的修改都不会影响彼此。除非,他要做一个不是咖啡的饮料,那么就另当别论。
最后给出工厂方法模式的定义-----The Factory Method Pattern defines and interface for creating an object,but lets subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
第二层心法-----抽象工厂模式-----Abstract Factory Pattern。(就是俗称的工厂模式)
public interface CoffeeIngredientFactory {
public String putSugar();
public String putChocolate();
public String putMilk();
}
AfricaIngredientFactory:
public class AfricaIngredientFactory implements CoffeeIngredientFactory {
@Override
public String putSugar() {
// TODO Auto-generated method stub
return "Sugar for Africa coffee bean";
}
@Override
public String putChocolate() {
// TODO Auto-generated method stub
return "Chocolate for Africa coffee bean";
}
@Override
public String putMilk() {
// TODO Auto-generated method stub
return "Milk for Africa coffee bean";
}
}
public class AfricaCoffeeBean extends CoffeeBean {
CoffeeIngredientFactory factory;
public AfricaCoffeeBean() {
// TODO Auto-generated constructor stub
this.factory=new AfricaIngredientFactory();
}
@Override
protected Coffee createCoffee(String type) {
// TODO Auto-generated method stub
if (type.equals("mocha")) {
return new MochaCoffee(factory);
} else if (type.equals("latie")) {
return new LatieCoffee(factory);
} else if (type.equals("cappucino")) {
return new CappucinoCoffee(factory);
} else {
return new BlackCoffee(factory);
}
}
}
public abstract class Coffee {
String sugar;
String milk;
String chocolate;
public String getSugar() {
return sugar;
}
public String getMilk() {
return milk;
}
public String getChocolate() {
return chocolate;
}
public abstract void bake();
public void deliver() {
// TODO Auto-generated method stub
}
}
public class MochaCoffee extends Coffee {
CoffeeIngredientFactory factory;
public MochaCoffee(CoffeeIngredientFactory f) {
// TODO Auto-generated constructor stub
this.factory=f;
}
@Override
public void bake() {
// TODO Auto-generated method stub
this.sugar=factory.putSugar();
this.milk=factory.putMilk();
this.chocolate=factory.putChocolate();
}
}
类似的其他咖啡品种类就不创建了。
最后,我们要提到一个众人皆知的设计原则: 依赖倒置,dependency inversion. 个人理解为,就是依赖于abstraction,而不是concrete type。