python 设计模式之工厂模式 Factory Pattern (简单工厂模式，工厂方法模式，抽象工厂模式)

十一回了趟老家，十一前工作一大堆忙成了狗，十一回来后又积累了一大堆又 忙成了狗，今天刚好抽了一点空开始写工厂方法模式

我看了《Head First 设计模式》P109--P133 这25页，讲述了我们为什么要用工厂模式，里面用做pizza的例子讲的特别细腻。看完了就能很清楚的知道为什么要用工厂模式。

年龄越大越不喜欢一知半解，深刻的了解某些未知的事或物以后，它再出现就不怕了

#'New'有什么不对劲?

在技术上，new没有错，这是语言的基础部分。真正的犯人是我们的老朋友 ‘改变’， 以及它是如何影响new使用的。

如果代码是通过接口而写，通过多态，可以与任何新类实现该接口。

但是当代码使用大量的具体类时，那就麻烦了，因为一旦加入新的具体类，就必须改变代码。意思是代码没 " 对修改关闭"。想用新的具体类来扩展代码，必须重新打开它。

这可咋办？  只能改代码

　

很明显，如果实例化某些具体类，将使orderPizza()出问题，没办法让orderPizza()对修改关闭，

但是咱们还是能很明显的看出哪些会变，哪些不会变，这个时候就可以考虑封装了，

　　

　上面这些引出了下面的简单工厂模式

#简单工厂模式

1)算是定义吧

简单工厂模式其实并不是一个模设计模式，反而比较像一种编程习惯，还请不要把这个习惯认为是“工厂模式”。

不要因为简单工厂不是一个真正的模式，就忽略它的用法。

2)类图

3)举个例子（java）

public class PizzaStore {
    SimplePizzaFactory factory;

    public PizzaStore(SimplePizzaFactory factory){
        this.factory=factory;
    }

    public Pizza orderPizza(String type){
        Pizza pizza;
        pizza=factory.createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

############################

public class SimplePizzaFactory {
    public Pizza createPizza(String type){
        Pizza pizza=null;
            if(type.equals("cheese")){
                pizza=new CheesePizza();
            }else if (type.equals("greek")){
                pizza=new GreekPizza();
            }else if(type.equals("pepperoni")){
                pizza=new PepperoniPizza();
            }else if (type.equals("clam")){
                pizza=new ClamPizza();
            }else if (type.equals("veggie")){
                pizza=new VeggiePizza();
            }
        return pizza;
    }
}

########################################################
public abstract class Pizza {
    String name;
    String dough;
    String sauce;

    void prepare(){
        System.out.print("Preparing");
    };
    void bake(){
        System.out.print("Baking");
    };
    void cut(){
        System.out.print("cut");
    };
    void box(){
        System.out.print("box");
    };

}

public class VeggiePizza extends Pizza{
}

public class ClamPizza extends Pizza {
}

public class PepperoniPizza extends Pizza {
}

public class PepperoniPizza extends Pizza {
}

#################################

public static void main(String[] args) {
    PizzaStore store=new PizzaStore();
    Pizza pizza=store.orderPizza("cheese");
    System.out.println("eat Pizza");
}

　4)举个例子（python）

#工厂方法模式

#引入

#匹萨生意火爆，现在有很多人要开加盟店，不同地区的加盟店口味有差异。PizzaStore有个不错的订单系统，希望所有加盟店对订单的处理一致。

各区域匹萨店之间的差异在于他们制作匹萨的风味（比如 NYStyle 饼薄， ChicagoStyle 饼厚等），我们现在让createPizza()来应对这些变化负责创建正确种类的匹萨。

做法是让PizzaStore的各个子类负责定义自己的createPizza()方法。所以我们会得到PizzaStore的具体类。

#定义

定义了一个创建对象的接口，但有子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

所有工厂模式都是用来封装对象的创建。工厂方法模式(Factory Method Pattern) 通过让子类决定该创建的对象是什么，来达到对象创建的过程封装的目的。

原本是由一个对象负责所有具体的实例化，现在变成一群子类负责实例化

#类图

#举个例子(java)

public abstract class PizzaStore {

    public Pizza orderPizza(String type){
        Pizza pizza;
        pizza=createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    abstract Pizza createPizza(String type);

}

###########################################################
public class NYPizzaStore extends PizzaStore{
    Pizza createPizza(String item){
        if(item.equals("cheese")){
            return new NYStyleCheesePizza();
        }else if (item.equals("greek")){
            return new NYStyleGreekPizza();
        }else if(item.equals("pepperoni")){
            return new NYStylePepperoniPizza();
        }else if (item.equals("clam")){
            return new NYStyleClamPizza();
        }else if (item.equals("veggie")){
            return new NYStyleVeggiePizza();
        }else return null
}

########
public class ChicagoPizzaStore extends PizzaStore {
    Pizza createPizza(String item){
        if(item.equals("cheese")){
            return new ChicagoStyleCheesePizza();
        }else if (item.equals("greek")){
            return new ChicagoStyleGreekPizza();
        }else if(item.equals("pepperoni")){
            return new ChicagoStylePepperoniPizza();
        }else if (item.equals("clam")){
            return new ChicagoStyleClamPizza();
        }else if (item.equals("veggie")){
            return new ChicagoStyleVeggiePizza();
        }else return null;
    }

}

##########################################################
public abstract class Pizza {
    String name;
    String dough;
    String sauce;

    void prepare(){

    }
    void bake(){

    }
    void cut(){

    }
    void box(){

    }
}

##############
public class NYStyleCheesePizza extends Pizza {
    public NYStyleCheesePizza(){
        name="NY Style Sauce and Cheese Pizza";
        dough="Thin Crust Dough";
        sauce="Marinara Sauce";

    }
}

########

public class NYStyleClamPizza extends Pizza {

}

######
public class NYStyleGreekPizza extends Pizza{

}

####

public class NYStylePepperoniPizza extends Pizza {

}
#######

public class NYStyleVeggiePizza extends Pizza {

}
#########

public class ChicagoStyleCheesePizza extends Pizza {
    public ChicagoStyleCheesePizza(){
        name="Chicago Style Sauce and Cheese Pizza";
        dough="Thick Crust Dough";
        sauce="Plum Tomato Sauce";

    }
}

#########
public class ChicagoStyleGreekPizza extends Pizza{

}
########

public class ChicagoStylePepperoniPizza extends Pizza {

}

#######
public class ChicagoStyleClamPizza extends Pizza{

}
######
public class ChicagoStyleVeggiePizza extends Pizza {

}

#####################################################################
public class javatest1 {
    public static void main(String[] args) throws IOException,ClassNotFoundException{
        PizzaStore nyStore=new NYPizzaStore();
        PizzaStore chicagoStore=new ChicagoPizzaStore();
        Pizza pizza=nyStore.orderPizza("cheese");
        System.out.println("eat NYStylePizza");

        pizza = chicagoStore.orderPizza("cheese");
        System.out.println("eat ChicagoStylePizza");
    }
}

#举个例子(python)　　

class Person(object):
	def __init__(self,name):
		self.name = name

	def work(self):
		print(self.name+"工作开始了")

		axe = Stone_Factory().create_axe()

		axe.cut_tree()

class Axe(object):
	def __init__(self,name):
		self.name = name

	def cut_tree(self):
		print("使用%s斧头砍树"%self.name)

class StoneAxe(Axe):

	def cut_tree(self):
		print("使用石斧头砍树")

class SteelAxe(Axe):

	def cut_tree(self):
		print("使用铁斧头砍树")

class Tree(object):
	pass

#工厂类
'''
class Factory(object):
	@staticmethod
	def create_axe(type):
		if type == "stone":
			return StoneAxe("花岗岩斧头")
		if type == "steel":
			return SteelAxe("铁斧头")
'''
class Factory(object):

	def create_axe(self):
		pass

class Stone_Factory(Factory):
	def create_axe(self):
		return StoneAxe("花岗岩斧头")

class Steel_Factory(Factory):
	def create_axe(self):
		return SteelAxe("铁斧头")

code来自https://blog.csdn.net/Mr_Quiet/article/details/80998337

#抽象工厂模式

#引入

纽约匹萨店生意火爆，越来越好，需要开好多家纽约披萨店，芝加哥也是面临同样的情况。为了保证质量，就得控制原料。所以我们得建造原料工厂，来生产不同区域的原料。

#定义

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

允许客户用抽象的借口创建一组产品，不需要知道实际产出的具体产品是什么，这样客户就从具体的产品解耦了。

#结构图

#使用场景

）客户端不依赖于产品类实例如何被创建、实现等细节

）强调一系列相关的产品对象（属于统一产品族）一起使用创建对象需要大量重复的代码

）提供一个产品类的库，所以的产品以同样或者大部分相同的接口出现，从而使客户端不依赖具体实现

#优点

实现解耦

#缺点

）规定了所有可能被创建的产品集合，产品族扩展新的产品困难，需要修改抽象工厂的接口

）增加了系统的抽象性和理解难度

#举个例子(java)

public interface Cheese {

}
#############
public interface Pepperoni {

}
##########
public interface Sauce {

}

##################
public interface Clams {

}
public class BlackOlives implements Veggies {

}

#########
public interface Dough {

}
##########
public interface Veggies {

}

######################################################################
public class MozzarellaCheese implements Cheese{

}
########
public class ReggianoCheese implements Cheese {

}
#####

public class Eggplant implements Veggies {

}
#####
public class Garlic implements Veggies{

}
#######
public class Mushroom implements Veggies {

}
###########
public class RedPepper implements Veggies{

}
########
public class Spinach implements Veggies{

}
#####
public class FreshClams implements Clams{

}

######
public class FrozenClams implements Clams{

}

#######
public class MarinaraSauce implements Sauce {

}
#########
public class PlumTomatoSauce implements Sauce {
}
########
public class SlicedPepperoni implements Pepperoni{

}
#########
public class SlicePepperoni implements Pepperoni{

}
########
public class ThinCrustDough implements Dough {

}
########
public class ThickCrustDough implements Dough {

}
########################################################
public interface PizzaIngredientFactory {

	public Sauce createSauce();
	public Cheese createCheese();
	public Veggies[] createVeggies();
	public Pepperoni createPepperoni();
	public Clams createClam();
	public Dough createDough();
}
###################
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
	public Dough createDough(){
		return new ThinCrustDough();
	}
	public Sauce createSauce(){
		return new MarinaraSauce();
	}
	public Cheese createCheese(){
		return new ReggianoCheese();
	}
	public Veggies[] createVeggies(){
		Veggies veggies[]={new Garlic(),new Mushroom(),new RedPepper()};
		return veggies;
	}
	public Pepperoni createPepperoni(){
		return new SlicePepperoni();
	}
	public Clams createClam(){
		return new FreshClams();
	}
}

#########

public class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory {
	public Dough createDough(){
		return new ThickCrustDough();
	}
	public Sauce createSauce(){
		return new PlumTomatoSauce();
	}
	public Cheese createCheese(){
		return new MozzarellaCheese();
	}
	public Veggies[] createVeggies(){
		Veggies veggies[]={new BlackOlives(),new Spinach(),new Eggplant()};
		return veggies;
	}
	public Pepperoni createPepperoni(){
		return new SlicedPepperoni();
	}
	public Clams createClam(){
		return new FrozenClams();
	}
}

#######

###############################################
public abstract class Pizza {
	String name;
    Dough dough;
    Sauce sauce;
    Veggies veggies[];
    Cheese cheese;
    Pepperoni pepperoni;
    Clams clam;

	abstract void prepare();

	void bake(){
		System.out.print("Baking");
	};

	void cut(){
		System.out.print("cut");
	};

	void box(){
		System.out.print("box");
	};

	void setName(String name){
		this.name=name;
	}

	String getName(){
		return name;
	}

	public String toString(){
		return name;
	}
}
###############
public class CheesePizza extends Pizza{
	PizzaIngredientFactory ingreditentFactory;
	public CheesePizza(PizzaIngredientFactory ingredientFactory){
		this.ingreditentFactory=ingredientFactory;
	}

	void prepare(){
		System.out.print("Preparing"+name);
		dough=ingreditentFactory.createDough();
		sauce=ingreditentFactory.createSauce();
		cheese=ingreditentFactory.createCheese();
	}
}

#############
public class ClamPizza extends Pizza {
	PizzaIngredientFactory ingredientFactory;

	public ClamPizza(PizzaIngredientFactory ingredientFactory){

		this.ingredientFactory=ingredientFactory;
	}

	void prepare(){
		System.out.print("Preparing"+name);
		dough=ingredientFactory.createDough();
		sauce=ingredientFactory.createSauce();
		clam=ingredientFactory.createClam();
	}
}

######################
public class PepperoniPizza extends Pizza {
	PizzaIngredientFactory ingreditentFactory;
	public PepperoniPizza(PizzaIngredientFactory ingredientFactory){
		this.ingreditentFactory=ingredientFactory;
	}

	void prepare(){
		System.out.print("Preparing"+name);
		dough=ingreditentFactory.createDough();
		sauce=ingreditentFactory.createSauce();
		cheese=ingreditentFactory.createCheese();
	}
}
################
public class VeggiePizza extends Pizza {
	PizzaIngredientFactory ingreditentFactory;
	public VeggiePizza(PizzaIngredientFactory ingredientFactory){
		this.ingreditentFactory=ingredientFactory;
	}

	void prepare(){
		System.out.print("Preparing"+name);
		dough=ingreditentFactory.createDough();
		sauce=ingreditentFactory.createSauce();
		cheese=ingreditentFactory.createCheese();
	}

}
###############################################################################################
public abstract class PizzaStore {

    public Pizza orderPizza(String type){
        Pizza pizza;
        pizza=createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    abstract Pizza createPizza(String type);

}
############################
public class NYPizzaStore extends PizzaStore{
	protected Pizza createPizza(String item){
		Pizza pizza=null;
		PizzaIngredientFactory nyIngredientFactory=new NYPizzaIngredientFactory();
		if(item.equals("cheese")){
			pizza=new CheesePizza(nyIngredientFactory);
			pizza.setName("New York Style Cheese Pizza");
		}else if(item.equals("veggie")){
			pizza=new VeggiePizza(nyIngredientFactory);
			pizza.setName("New York Style Veggie Pizza");
		}else if(item.equals("clam")){
			pizza=new ClamPizza(nyIngredientFactory);
			pizza.setName("New York Style Clam Pizza");
		}else if(item.equals("pepperoni")){
			pizza=new PepperoniPizza(nyIngredientFactory);
			pizza.setName("New York Style Pepperoni Pizza");
		}
        return pizza;
	}
}
###################
public class ChicagoPizzaStore extends PizzaStore{
	protected Pizza createPizza(String item){
		Pizza pizza=null;
		PizzaIngredientFactory nyIngredientFactory=new ChicagoPizzaIngredientFactory();
		if(item.equals("cheese")){
			pizza=new CheesePizza(nyIngredientFactory);
			pizza.setName("New York Style Cheese Pizza");
		}else if(item.equals("veggie")){
			pizza=new VeggiePizza(nyIngredientFactory);
			pizza.setName("New York Style Veggie Pizza");
		}else if(item.equals("clam")){
			pizza=new ClamPizza(nyIngredientFactory);
			pizza.setName("New York Style Clam Pizza");
		}else if(item.equals("pepperoni")){
			pizza=new PepperoniPizza(nyIngredientFactory);
			pizza.setName("New York Style Pepperoni Pizza");
		}
        return pizza;
	}
}

###########################################################################
public class javatest1 {
	public static void main(String[] args) throws IOException,ClassNotFoundException{
		PizzaStore nyPizzaStore=new NYPizzaStore();
		nyPizzaStore.orderPizza("cheese");
		System.out.print("\n");
		PizzaStore chicagoPizzaStore=new ChicagoPizzaStore();
		chicagoPizzaStore.orderPizza("clam");
	}
}

#举个例子(python)

#!/usr/bin/env python
# -*- coding:utf-8 -*-

__author__ = 'Andy'
"""
大话设计模式
设计模式——抽象工厂模式
抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的类
"""
import sys

#抽象用户表类
class User(object):

    def get_user(self):
        pass

    def insert_user(self):
        pass

#抽象部门表类
class Department(object):

    def get_department(self):
        pass

    def insert_department(self):
        pass

#操作具体User数据库类-Mysql
class MysqlUser(User):

    def get_user(self):
        print 'MysqlUser get User'

    def insert_user(self):
        print 'MysqlUser insert User'

#操作具体Department数据库类-Mysql
class MysqlDepartment(Department):

    def get_department(self):
        print 'MysqlDepartment get department'

    def insert_department(self):
        print 'MysqlDepartment insert department'

#操作具体User数据库-Orcal
class OrcaleUser(User):

    def get_user(self):
        print 'OrcalUser get User'

    def insert_user(self):
        print 'OrcalUser insert User'

#操作具体Department数据库类-Orcal
class OrcaleDepartment(Department):

    def get_department(self):
        print 'OrcalDepartment get department'

    def insert_department(self):
        print 'OrcalDepartment insert department'

#抽象工厂类
class AbstractFactory(object):

    def create_user(self):
        pass

    def create_department(self):
        pass

class MysqlFactory(AbstractFactory):

    def create_user(self):
        return MysqlUser()

    def create_department(self):
        return MysqlDepartment()

class OrcaleFactory(AbstractFactory):

    def create_user(self):
        return OrcalUser()

    def create_department(self):
        return OrcalDepartment()

if __name__ == "__main__":

    db = sys.argv[1]
    myfactory = ''
    if db == 'Mysql':
        myfactory = MysqlFactory()
    elif db == 'Orcal':
        myfactory = OrcaleFactory()
    else:
        print "不支持的数据库类型"
        exit(0)
    user = myfactory.create_user()
    department = myfactory.create_department()
    user.insert_user()
    user.get_user()
    department.insert_department()
    department.get_department()

代码来自https://www.cnblogs.com/onepiece-andy/p/python-abstract-factory-pattern.html

#工厂方法模式与抽象工厂模式对比

）都是负责创建对象，工厂方法模式  用的方法是通过继承，抽象工厂模式 用的方法是对象的组合

）工厂方法模式 通过子类来创建对象，客户只需要知道所使用的抽象类型，右子类来负责决定具体类型。换句话说 工厂方法模式只负责将客户从具体类型中解耦。

）抽象工厂模式 用来创建一个产品家族的抽象类型，也可以把客户从所使用的具体产品中解耦。可以把一组相关的产品集合起来。

如果需要扩展这组相关产品，就必须改变接口，这是抽象工厂的缺点。工厂方法模式只涉及一个产品。

）抽象工厂模式经常使用工厂方法模式来实现它（抽象工厂模式）的具体工厂，纯粹是用来创建产品。

参考

《Head First设计模式》

https://blog.csdn.net/qq_28859325/article/details/60580578

https://www.jianshu.com/p/610a26d9d958