Saya perlu mengembangkan API, fungsi API adalah permintaan yang memanggil layanan yang diekspos oleh server.
Awalnya API bekerja seperti ini:
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')
Ada banyak kode duplikat dan saya tidak suka cara itu melewati argumen untuk permintaan. Karena ada banyak argumen, jadi saya ingin mengekstraknya dari permintaan dan membuat sesuatu yang lebih parametrik.
Jadi saya refactored dengan cara ini:
# 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)
Pola strategi berhasil, duplikasi dihapus. Terlepas dari ini saya takut memiliki hal-hal rumit, terutama dalam hal argumen, saya tidak suka cara saya menangani mereka, karena ketika saya melihat kode tidak tampak mudah dan jelas.
Jadi saya ingin tahu apakah ada pola atau cara yang lebih baik dan lebih jelas untuk menangani kode API sisi klien semacam ini.
1
Sudahkah Anda mempertimbangkan untuk menanyakan hal ini di Pertukaran Peninjauan Kode? Para pengguna di sana berspesialisasi dalam hal-hal seperti ini.
—
Nzall
@NateKerkhofs Ya saya telah mempertimbangkannya, tetapi kemudian saya memilih Programmer karena ini adalah papan tempat untuk bertanya tentang desain dan arsitektur ketika saya membaca di bagian bantuan . Dalam Peninjauan Kode bahkan tidak ada tag untuk refactoring.
—
k4ppa
Itu karena seluruh tujuan CR adalah kode refactoring. Pada dasarnya tersirat bahwa semua pertanyaan di sana adalah tentang kode refactoring. Kode Anda seharusnya sudah berfungsi, tetapi selain itu, jawaban berasumsi bahwa Anda ingin kode Anda diperiksa untuk bug dan refactoring.
—
Nzall