Ich muss eine API entwickeln. Die Funktionen der API sind Anforderungen, die den von einem Server bereitgestellten Dienst aufrufen.
Anfangs funktionierte die API folgendermaßen:
class Server:
def firstRequest(self, arg1, arg2):
# block of code A
async = Async()
async.callFirstRequest(arg1, arg2)
# block of code B
def secondRequest(self, argA, argB, argC):
# block of code A (identical to that of firstRequest)
async = Async()
async.callSecondRequest(argA, argB, argC)
# block of code B (identical to that of firstRequest)
class Async:
def callFirstRequest(self, arg1, arg2):
doFirstRequest(arg1, arg2)
# run the real request and wait for the answer
def doFirstRequest(self, arg1, arg2):
response = client.firstRequest(arg1, arg2)
def callSecondRequest(self, argA, argB, argC):
doSecondRequest(argA, argB, argC)
# run the real request and wait for the answer
def doSecondRequest(self, argA, argB, argC):
response = client.secondRequest(argA, argB, argC)
server = Server()
server.firstRequest(arg1=1, arg2=2)
server.secondRequest(argA='A', argB='B', argC='C')
Es gab viel duplizierten Code und mir hat nicht gefallen, wie die Argumente für die Anfrage übergeben wurden. Da es viele Argumente gibt, wollte ich sie aus der Anfrage extrahieren und etwas parametrischeres machen.
Also habe ich folgendermaßen umgestaltet:
# using a strategy pattern I was able to remove the duplication of code A and code B
# now send() receive and invoke the request I wanna send
class Server:
def send(self, sendRequest):
# block of code A
asynch = Async()
sendRequest(asynch)
# block of code B
# Request contains all the requests and a list of the arguments used (requestInfo)
class Request:
# number and name of the arguments are not the same for all the requests
# this function take care of this and store the arguments in RequestInfo for later use
def setRequestInfo(self, **kwargs):
if kwargs is not None:
for key, value in kwargs.iteritems():
self.requestInfo[key] = value
def firstRequest(async)
async.doFirstRequest(self.requestInfo)
def secondRequest(async)
async.doSecondRequest(self.requestInfo)
# Async run the real request and wait for the answer
class Async:
def doFirstRequest(requestInfo):
response = client.firstRequest(requestInfo['arg1'], requestInfo['arg2'])
def doSecondRequest(requestInfo)
response = client.secondRequest(requestInfo['argA'], requestInfo['argB'], requestInfo['argC'])
server = Server()
request = Request()
request.setRequestInfo(arg1=1, arg2=2) # set of the arguments needed for the request
server.send(request.firstRequest)
request.setRequestInfo(argA='A', argB='B', argC='C')
server.send(request.secondRequest)
Das Strategiemuster hat funktioniert, die Duplizierung wird entfernt. Unabhängig davon habe ich Angst, komplizierte Dinge zu haben, insbesondere in Bezug auf die Argumente. Ich mag es nicht, wie ich damit umgehe, denn wenn ich mir den Code anschaue, erscheint das nicht einfach und klar.
Ich wollte wissen, ob es ein Muster oder eine bessere und klarere Möglichkeit gibt, mit dieser Art von clientseitigem API-Code umzugehen.