翻译-精通python设计模式-工厂模式

cyrus

　　Creationaldesignpatternsdealwithanobjectcreation.Theaimofacreationaldesignpatternistoprovide
　　better alternativesforsituationswhereadirectobjectcreation(whichinPythonhappensbythe__init__()
　　function) isnotconvenient.
　　

　　创建型设计模式主要负责处理对象的创建。对于不适合直接创建对象的情况（一般在python的__init__()方法初始化对象的时候），它能够给我们提供更好的替代方案，同时这也是创建型设计模式的目标。
　　

　　IntheFactorydesignpattern,aclientasksforanobjectwithoutknowingwheretheobjectiscomingfrom
　　(thatis,whichclassisusedtogenerateit).Theideabehindafactoryistosimplifyanobjectcreation.
　　Itiseasiertotrackwhichobjectsarecreatedifthisisdonethroughacentralfunction,incontrasttoletting
　　aclientcreateobjectsusingadirectclassinstantiation.Afactoryreducesthecomplexityofmaintaining
　　anapplicationbydecouplingthecodethatcreatesanobjectfromthecodethatusesit.
　　

　　在工厂设计模式中，客户端只需要知道如何调用对象，而不需要知道对象是从哪里来的（也就是说，它不用知道对象是由哪个类来创建）。工厂模式背后的思想就是简化对象的创建。相对于直接实例化类来创建对象，如果可以通过中央函数来创建对象，将会使得对象更容易跟踪管理。使用工厂方法，可以分离对象的创建和使用，从而解耦代码，降低维护应用的复杂程度。
　　

　　Factoriestypicallycomeintwoforms:theFactoryMethod,whichisamethod(orinPythonicterms,
　　afunction)thatreturnsadifferentobjectperinputparameter;theAbstractFactory,whichisagroup
　　ofFactoryMethodsusedtocreateafamilyofrelatedproducts.
　　工厂模式主要有两种形式：
　　第一，工厂方法，它是根据不同的输入返回不同对象的方法；
　　第二，抽象工厂，它是创建系列相关对象的方法组。
　　FactoryMethod
　　工厂方法
　　IntheFactoryMethod,weexecuteasinglefunction,passingaparameterthatprovidesinformation
　　aboutwhatwewant.Wearenotrequiredtoknowanydetailsabouthowtheobjectisimplemented
　　andwhereitiscomingfrom.
　　在工厂方法中，我们只需要执行一个函数，然后当我们向函数传递一个参数，它就会返回我们想要的对象。关于对象创建的细节（对象是从哪里来的，是如何实现的），我们根本不需要知道。
　　Areal-lifeexample
　　一个生活实例
　　AnexampleoftheFactoryMethodpatternusedinrealityisinplastictoyconstruction.Themolding
　　powderusedtoconstructplastictoysisthesame,butdifferentfigurescanbeproducedusing
　　differentplasticmolds.ThisislikehavingaFactoryMethodinwhichtheinputisthenameofthefigure
　　thatwewant(duckandcar)andtheoutputistheplasticfigurethatwerequested.
　　Thetoyconstructioncaseisshowninthefollowingfigure,whichisprovidedby.
　　在实际的生活当中，工厂生产塑料玩具就是一个应用工厂方法模式的实例。虽然制造塑料玩具的原料（成型粉）是相同的，但是工厂可以通过使用不同的模具，制造出不同的玩具。这就像工厂方法模式一样，只要输入玩具的名称（例如：鸭和汽车），工厂就会生产出我们想要的塑料玩具。生产玩具案例的用例图如下图所示。
　　

　　

　　Asoftwareexample
　　一个软件实例
　　TheDjangoframeworkusestheFactoryMethodpatternforcreatingthefieldsofaform.
　　TheformsmoduleofDjangosupportsthecreationofdifferentkindsoffields(CharField,
　　EmailField)andcustomizations(max_length,required).
　　Django框架就是使用工厂方法模式来创建表单的输入域。Django框架的表单模块不但支持不同输入域的创建（例如：文本输入域，电子邮件输入域），而且还支持自定义输入域的属性（例如：最大长度、是否必填）。
　　Usecases
　　用例
　　Ifyourealizethatyoucannottracktheobjectscreatedbyyourapplicationbecausethecode
　　thatcreatesthemisinmanydifferentplacesinsteadofasinglefunction/method,
　　youshouldconsiderusingtheFactoryMethodpattern.TheFactoryMethodcentralizes
　　anobjectcreationandtrackingyourobjectsbecomesmucheasier.Notethatitisabsolutelyfine
　　tocreatemorethanoneFactoryMethod,andthisishowitistypicallydoneinpractice.
　　EachFactoryMethodlogicallygroupsthecreationofobjectsthathavesimilarities.Forexample,
　　oneFactoryMethodmightberesponsibleforconnectingyoutodifferentdatabases(MySQL,SQLite),
　　anotherFactoryMethodmightberesponsibleforcreatingthegeometricalobject
　　thatyourequest(circle,triangle),andsoon.
　　如果你已经意识到，由于对象的创建存在于代码的各种地方，而使得你不能踪管理它们，这个时候你就应该考虑使用工厂方法模式，通过统一函数/方法来创建管理它们。使用工厂方法可以集中创建对象，并且更加容易跟踪管理它们。请注意，在实际操作当中，人们通常会建立多个工厂方法。然后把工厂方法逻辑分组，创建相类似对象的方法放在一个工厂里面。例如，一个工厂方法可能负责连接到不同的数据库（MySQL，SQLite），另一个工厂方法可能负责创造你请求的几何对象（圆，三角形），等等。
　　TheFactoryMethodisalsousefulwhenyouwanttodecoupleanobjectcreationfrom
　　anobjectusage.Wearenotcoupled/boundtoaspecificclasswhencreatinganobject,
　　wejustprovidepartialinformationaboutwhatwewantbycallingafunction.Thismeansthat
　　introducingchangestothefunctioniseasywithoutrequiringanychangestothecodethatusesit.
　　工厂方法模式对于分离对象的创建和使用是非常合适的。在创建对象的时候，我们不会耦合特定的类，我们只需把部分对象的信息传递到特定函数，然后函数就会返回我们需要的对象。这意味着，当应用程序的功能发生变化时，我们只需要修改创建对象的函数，而不需要对调用对象的代码进行任何更改。
　　Anotherusecaseworthmentioningisrelatedtoimprovingtheperformanceand
　　memoryusageofanapplication.AFactoryMethodcanimprovetheperformance
　　andmemoryusagebycreatingnewobjectsonlyifitisabsolutelynecessary.
　　Whenwecreateobjectsusingadirectclassinstantiation,extramemoryisallocatedeverytime
　　anewobjectiscreated(unlesstheclassusescachinginternally,whichisusuallynotthecase).
　　Wecanseethatinpracticeinthefollowingcode(fileid.py),itcreatestwoinstances
　　ofthesameclassAandusestheid()functiontocomparetheirmemoryaddresses.
　　Theaddressesarealsoprintedintheoutputsothatwecaninspectthem.Thefactthat
　　thememoryaddressesaredifferentmeansthattwodistinctobjectsarecreatedasfollows:
　　另外还有一个值得一提的用例，是关于提高应用程序的性能和内存使用。因为使用了工厂方法，使得只有当对象是必要的时候，工厂方法才会创建它，所以，应用程序的性能和内存的使用得以相应的提升。每当我们直接使用类实例化对象，都会开销额外的内存（除非在类的内部使用缓存机制，但一般不是这样的）。我们从在下面的代码（id.py）可以看到，它使用同一类的创建两个实例，并使用的内建函数id()来比较两者的内存地址。并且两者的内存地址都打印输出到前台，这样方便我们观察他们。根据结果，两个实例的内存地址是不同的，这意味着它们创建了两个独立的实例，代码如下：

class A(object):
pass
if __name__ == '__main__':
a = A()
b = A()
print(id(a) == id(b))
print(a, b)

　　Executing id.py on my computer gives the following output:


　　运行id.py，它输出如下内容：
　　


>> python3 id.py
False
<__main__.A object at 0x7f5771de8f60> <__main__.A object at 0x7f5771df2208>


　　NotethattheaddressesthatyouseeifyouexecutethefilearenotthesameasIsee
　　becausetheydependonthecurrentmemorylayoutandallocation.Buttheresult
　　mustbethesame:thetwoaddressesshouldbedifferent.There'soneexception
　　thathappensifyouwriteandexecutethecodeinthePythonRead-Eval-PrintLoop(REPL)
　　(interactiveprompt),butthat'saREPL-specificoptimizationwhichisnothappeningnormally.
　　请注意，如果你运行该文件，你看到的输出的结果（两个实例的内存地址），应该跟我这里输出的结果不一样，因为它们依赖于当前的内存布局和分配。但是，两者对比的结果应该是一样的，就是输出的内存地址应该不一样。如果你编写与执行代码都是在Python的REPL（交互式解释器）里面进行，也是会有例外的，但是这种特殊的REPL优化一般不会出现。
　　Implementation
　　实现
　　Datacomesinmanyforms.Therearetwomainfilecategoriesforstoring/retrievingdata:
　　human_readablefilesandbinaryfiles.Examplesofhuman_readablefilesareXML,Atom,
　　YAML,andJSON.Examplesofbinaryfilesarethe.sq3fileformatusedbySQLiteand
　　the.mp3fileformatusedtolistentomusic.
　　数据在现实中是以多种形式存在。一般用于存储或者检索数据的文件格式主要有两种：文字文件格式和二进制文件格式。而文字文件的常用格式有：XML，Atom，YAML和JSON。二进制文件的常用格式有：用于SQLite存储数据的.sq3文件格式，用于保存音乐数据的.mp3文件格式。
　　Inthisexample,wewillfocusontwopopularhuman-readableformats:XMLandJSON.
　　Althoughhuman_readablefilesaregenerallyslowertoparsethanbinaryfiles,
　　theymakedataexchange,inspection,andmodificationmucheasier.Forthisreason,
　　itisadvisedtopreferworkingwithhuman_readablefiles,unlessthereareotherrestrictions
　　thatdonotallowit(mainlyunacceptableperformanceandproprietarybinaryformats).
　　在下面的例子中，我们将集中介绍XML和JSON这两种文字文件格式。虽然文字文件的解析速度一般比二进制文件慢，但它对于数据交换、检查和修改来得更简单。出于这个理由，我们推荐人们在工作的时候使用文字文件，除非有其他限制（一般是不能接收的性能问题或者是需要专有二进制格式）。
　　Inthisproblem,wehavesomeinputdatastoredinanXMLandaJSONfile,
　　andwewanttoparsethemandretrievesomeinformation.Atthesametime,
　　wewanttocentralizetheclient'sconnectiontothose(andallfuture)externalservices.
　　WewillusetheFactoryMethodtosolvethisproblem.
　　TheexamplefocusesonlyonXMLandJSON,butaddingsupportformoreservices
　　shouldbestraightforward.
　　在下面的例子中，我们先输入一些数据，将它们分别存储在XML文件和JSON文件里面，然后解析它们，并且检索某些信息。同时，我们需要把解析这一部分外接服务集中起来管理。我们将使用工厂方法来解决这个问题。虽然这个例子仅仅只是XML和JSON解析，但是当应用程序添加更多支持服务的时候，代码必须具备良好的扩展能力。
　　First,let'stakealookatthedatafiles.TheXMLfile,person.xml,isbasedon
　　theWikipediaexampleandcontainsinformationaboutindividuals
　　(firstName,lastName,gender,andsoon)asfollows:
　　首先，让我们先看看这两个数据文件。第一个是xml文件，person.xml，它是摘自维基百科的一个例子，包含一些个人信息（名字，姓氏，性别，等等），具体文件如下：
　　


<persons>
<person>
<firstName>John</firstName>
<lastName>Smith</lastName>
<age>25</age>
<address>
<streetAddress>21 2nd Street</streetAddress>
<city>New York</city>
<state>NY</state>
<postalCode>10021</postalCode>
</address>
<phoneNumbers>
<phoneNumber type="home">212 555-1234</phoneNumber>
<phoneNumber type="fax">646 555-4567</phoneNumber>
</phoneNumbers>
<gender>
<type>male</type>
</gender>
</person>
<person>
<firstName>Jimy</firstName>
<lastName>Liar</lastName>
<age>19</age>
<address>
<streetAddress>18 2nd Street</streetAddress>
<city>New York</city>
<state>NY</state>
<postalCode>10021</postalCode>
</address>
<phoneNumbers>
<phoneNumber type="home">212 555-1234</phoneNumber>
</phoneNumbers>
<gender>
<type>male</type>
</gender>
</person>
<person>
<firstName>Patty</firstName>
<lastName>Liar</lastName>
<age>20</age>
<address>
<streetAddress>18 2nd Street</streetAddress>
<city>New York</city>
<state>NY</state>
<postalCode>10021</postalCode>
</address>
<phoneNumbers>
<phoneNumber type="home">212 555-1234</phoneNumber>
<phoneNumber type="mobile">001 452-8819</phoneNumber>
</phoneNumbers>
<gender>
<type>female</type>
</gender>
</person>
</persons>

　　TheJSONfile,donut.json,comesfromtheGitHubaccountofAdobeand
　　containsdonutinformation(type,price/unitthatis,ppu,topping,andsoon)asfollows:
　　第二个是json文件，donut.json，它由Adobe在GitHub上面的账户提供的，主要描述甜甜圈的信息，包括种类、价格等等），具体文件如下：
　　


[
{
"id": "0001",
"type": "donut",
"name": "Cake",
"ppu": 0.55,
"batters": {
"batter": [
{ "id": "1001", "type": "Regular" },
{ "id": "1002", "type": "Chocolate" },
{ "id": "1003", "type": "Blueberry" },
{ "id": "1004", "type": "Devil's Food" }
]
},
"topping": [
{ "id": "5001", "type": "None" },
{ "id": "5002", "type": "Glazed" },
{ "id": "5005", "type": "Sugar" },
{ "id": "5007", "type": "Powdered Sugar" },
{ "id": "5006", "type": "Chocolate with Sprinkles" },
{ "id": "5003", "type": "Chocolate" },
{ "id": "5004", "type": "Maple" }
]
},
{
"id": "0002",
"type": "donut",
"name": "Raised",
"ppu": 0.55,
"batters": {
"batter": [
{ "id": "1001", "type": "Regular" }
]
},
"topping": [
{ "id": "5001", "type": "None" },
{ "id": "5002", "type": "Glazed" },
{ "id": "5005", "type": "Sugar" },
{ "id": "5003", "type": "Chocolate" },
{ "id": "5004", "type": "Maple" }
]
},
{
"id": "0003",
"type": "donut",
"name": "Old Fashioned",
"ppu": 0.55,
"batters": {
"batter": [
{ "id": "1001", "type": "Regular" },
{ "id": "1002", "type": "Chocolate" }
]
},
"topping": [
{ "id": "5001", "type": "None" },
{ "id": "5002", "type": "Glazed" },
{ "id": "5003", "type": "Chocolate" },
{ "id": "5004", "type": "Maple" }
]
}
]

　　WewillusetwolibrariesthatarepartofthePythondistributionforworkingwithXMLandJSON:
　　xml.etree.ElementTreeandjsonasfollows:
　　我们将使用Python的XML库和JSON库来实现功能，它们是xml.etree.elementtree和json，具体引入代码如下：
　　


import xml.etree.ElementTree as etree
import json

　　TheJSONConnectorclassparsestheJSONfileandhasaparsed_data()method
　　thatreturnsalldataasadictionary(dict).Thepropertydecoratorisusedto
　　makeparsed_data()appearasanormalvariableinsteadofamethodasfollows:
　　我们使用JSONConnector来解析JSON文件，json库里面有parsed_data()这个方法，它可以以字典的形式返回所有数据。通过@property这个装饰器，使得parsed_data()当成变量使用而不是作为方法使用，具体代码如下：
　　


class JSONConnector:
def __init__(self, filepath):
self.data = dict()
with open(filepath, mode='r', encoding='utf-8') as f:
self.data = json.load(f)
@property
def parsed_data(self):
return self.data

　　TheXMLConnectorclassparsestheXMLfileandhasaparsed_data()methodthat
　　returnsalldataasalistofxml.etree.Elementasfollows:
　　我们使用XMLConnector解析XML文件，xml库里面有parsed_data()这个方法，它以xml.etree.element列表的形式返回所有数据，具体代码如下：
　　


class XMLConnector:
def __init__(self, filepath):
self.tree = etree.parse(filepath)
@property
def parsed_data(self):
return self.tree

　　Theconnection_factory()functionisaFactoryMethod.Itreturnsaninstance
　　ofJSONConnectororXMLConnectordependingontheextensionoftheinputfilepath
　　asfollows:
　　connection_factory()函数是一个工厂方法。它根据输入的文件路径，返回JSONConnector或者XMLConnector的实例，具体代码如下：
　　


def connection_factory(filepath):
if filepath.endswith('json'):
connector = JSONConnector
elif filepath.endswith('xml'):
connector = XMLConnector
else:
raise ValueError('Cannot connect to {}'.format(filepath))
return connector(filepath)


　　Theconnect_to()functionisawrapperofconnection_factory().Itaddsexceptionhandling
　　asfollows:
　　connect_to()方法封装了connection_factory()，并且增加了异常处理功能，具体代码如下：
　　


def connect_to(filepath):
factory = None
try:
factory = connection_factory(filepath)
except ValueError as ve:
print(ve)
return factory

　　Themain()functiondemonstrateshowtheFactoryMethoddesignpatterncanbeused.
　　Thefirstpartmakessurethatexceptionhandlingiseffectiveasfollows:
　　main()方法演示如何使用工厂方法，方法的第一部分测试异常处理的有效性，具体代码如下：

def main():
sqlite_factory = connect_to('data/person.sq3')

　　ThenextpartshowshowtoworkwiththeXMLfilesusingtheFactoryMethod.XPathisusedto
　　findallpersonelementsthathavethelastnameLiar.Foreachmatchedperson,
　　thebasicnameandphonenumberinformationareshownasfollows:
　　跟着那部分代码演示如何使用工厂方法来解析这个xml文件。它使用XPath来查询所有姓Liar的人。对于匹配的人，需要把他的姓名以及电话号码显示出来，具体代码如下：

xml_factory = connect_to('data/person.xml')
xml_data = xml_factory.parsed_data()
liars = xml_data.findall(".//{person}[{lastName}='{}']".format('Liar'))
print('found: {} persons'.format(len(liars)))
for liar in liars:
print('first name: {}'.format(liar.find('firstName').text))
print('last name: {}'.format(liar.find('lastName').text))
[print('phone number ({}):'.format(p.attrib['type']), p.text) for p in liar.find('phoneNumbers')]
　　ThefinalpartshowshowtoworkwiththeJSONfilesusingtheFactoryMethod.Here,
　　there'snopatternmatching,andthereforethename,price,andtoppingofalldonuts
　　areshownasfollows:
　　

　　最后一部分的代码演示如何使用工厂方法来解析这个JSON文件。在这里，不需要匹配甜甜圈的信息，因此，所有甜甜圈的信息（包括名称，价格等）都会显示出来，具体代码如下：
　　


  json_factory = connect_to('data/donut.json')
json_data = json_factory.parsed_data
print('found: {} donuts'.format(len(json_data)))
for donut in json_data:
print('name: {}'.format(donut['name']))
print('price: ${}'.format(donut['ppu']))
[print('topping: {} {}'.format(t['id'], t['type'])) for t in donut['topping']]
　　Forcompleteness,hereisthecompletecodeoftheFactoryMethodimplementation
　　(factory_method.py)asfollows:
　　下面是完整的工厂方法实现代码（factory_method.py），具体代码如下：
　　


import xml.etree.ElementTree as etree
import json
class JSONConnector:
def __init__(self, filepath):
self.data = dict()
with open(filepath, mode='r', encoding='utf-8') as f:
self.data = json.load(f)
@property
def parsed_data(self):
return self.data
class XMLConnector:
def __init__(self, filepath):
self.tree = etree.parse(filepath)
@property
def parsed_data(self):
return self.tree
def connection_factory(filepath):
if filepath.endswith('json'):
connector = JSONConnector
elif filepath.endswith('xml'):
connector = XMLConnector
else:
raise ValueError('Cannot connect to {}'.format(filepath))
return connector(filepath)
def connect_to(filepath):
factory = None
try:
factory = connection_factory(filepath)
except ValueError as ve:
print(ve)
return factory
def main():
sqlite_factory = connect_to('data/person.sq3')
print()
xml_factory = connect_to('data/person.xml')
xml_data = xml_factory.parsed_data
liars = xml_data.findall(".//{}[{}='{}']".format('person', 'lastName', 'Liar'))
print('found: {} persons'.format(len(liars)))
for liar in liars:
print('first name: {}'.format(liar.find('firstName').text))
print('last name: {}'.format(liar.find('lastName').text))
[print('phone number ({}):'.format(p.attrib['type']), p.text) for p in liar.find('phoneNumbers')]
print()
json_factory = connect_to('data/donut.json')
json_data = json_factory.parsed_data
print('found: {} donuts'.format(len(json_data)))
for donut in json_data:
print('name: {}'.format(donut['name']))
print('price: ${}'.format(donut['ppu']))
[print('topping: {} {}'.format(t['id'], t['type'])) for t in donut['topping']]
if __name__ == '__main__':
main()
　　

　　Hereistheoutputofthisprogramasfollows:
　　下面是程序的输出，具体如下：
　　


>>> python3 factory_method.py
Cannot connect to data/person.sq3
found: 2 persons
first name: Jimy
last name: Liar
phone number (home): 212 555-1234
first name: Patty
last name: Liar
phone number (home): 212 555-1234
phone number (mobile): 001 452-8819
found: 3 donuts
name: Cake
price: $0.55
topping: 5001 None
topping: 5002 Glazed
topping: 5005 Sugar
topping: 5007 Powdered Sugar
topping: 5006 Chocolate with Sprinkles
topping: 5003 Chocolate
topping: 5004 Maple
name: Raised
price: $0.55
topping: 5001 None
topping: 5002 Glazed
topping: 5005 Sugar
topping: 5003 Chocolate
topping: 5004 Maple
name: Old Fashioned
price: $0.55
topping: 5001 None
topping: 5002 Glazed
topping: 5003 Chocolate
topping: 5004 Maple
　　

　　NoticethatalthoughJSONConnectorandXMLConnectorhavethesameinterfaces,
　　whatisreturnedbyparsed_data()isnothandledinauniformway.Differentpythoncode
　　mustbeusedtoworkwitheachconnector.Althoughitwouldbenicetobeableto
　　usethesamecodeforallconnectors,thisisatmosttimesnotrealisticunless
　　weusesomekindofcommonmappingforthedatawhichisveryoftenprovided
　　byexternaldataproviders.Assumingthatyoucanuseexactlythesamecode
　　forhandlingtheXMLandJSONfiles,whatchangesarerequiredtosupportathirdformat,
　　forexample,SQLite?FindanSQLitefileorcreateyourownandtryit.
　　注意，虽然JSONConnector和XMLConnector具有相同的接口，但是，parsed_data()返回的数据不是以统一的方式处理。不同的Python代码必须使用不同的连接器工作。虽然所有连接器能使用相同的代码是非常好的，但是在大多数时间里，这是不现实的，除非我们使用数据供应商提供的常见映射来处理数据。假设，你是使用相同的代码来处理XML和JSON文件，现在需要增加处理第三种文件格式，例如，SQLite呢？你可以找一个SQLite文件，然后尝试一下。
　　Asitisnow,thecodedoesnotforbidadirectinstantiationofaconnector.Isitpossibletodothis?Trydoingit.
　　到现在为止，代码都不禁止直接实例化一个连接器。它有可能用这种方式实现吗？你可以自己尝试一下。
　　Tip
　　

　　提示
　　

　　Hint:FunctionsinPythoncanhavenestedclasses.
　　

　　提示：在Python函数可以有嵌套类。
　　

　　

　　译者：由于水平有限，暂时只能翻译成这样子了，请大家指出相应的问题，谢谢。