在软件开发领域,solid 原则是一组五个设计原则,旨在创建健壮、可维护和可扩展的软件系统。这些原则由 robert c. martin(也称为 bob 叔叔)提出,为开发人员提供了遵循的指南,以确保他们的代码库干净且可扩展。在这里,我们将探索每个 solid 原则,并通过 python 示例演示如何实现它们。
1.单一职责原则(srp)
定义:一个类应该只有一个改变的理由,这意味着它应该只有一项工作或职责。
示例:
class order:
def __init__(self, items):
self.items = items
def calculate_total(self):
return sum(item.price for item in self.items)
class invoiceprinter:
@staticmethod
def print_invoice(order):
print("invoice:")
for item in order.items:
print(f"{item.name}: ${item.price}")
print(f"total: ${order.calculate_total()}")
# usage
class item:
def __init__(self, name, price):
self.name = name
self.price = price
items = [item("apple", 1), item("banana", 2)]
order = order(items)
invoiceprinter.print_invoice(order)
在这个例子中,order类只负责管理订单,而invoiceprinter类负责打印发票。这通过确保每个类都有单一职责来遵守 srp。
2. 开闭原理(ocp)
定义:软件实体应该对扩展开放,对修改关闭。
示例:
class discount:
def apply(self, total):
return total
class percentagediscount(discount):
def __init__(self, percentage):
self.percentage = percentage
def apply(self, total):
return total - (total * self.percentage / 100)
class fixeddiscount(discount):
def __init__(self, amount):
self.amount = amount
def apply(self, total):
return total - self.amount
def calculate_total(order, discount):
total = order.calculate_total()
return discount.apply(total)
# usage
discount = percentagediscount(10)
print(calculate_total(order, discount))
在此示例中,discount 类由 percentagediscount 和 fixdiscount 扩展,无需修改基类,遵循 ocp。
3.里氏替换原理(lsp)
定义:子类型必须可以替换其基本类型,而不改变程序的正确性。
示例:
class bird:
def fly(self):
pass
class sparrow(bird):
def fly(self):
print("sparrow is flying")
class ostrich(bird):
def fly(self):
raise exception("ostrich can't fly")
def make_bird_fly(bird):
bird.fly()
# usage
sparrow = sparrow()
make_bird_fly(sparrow)
ostrich = ostrich()
try:
make_bird_fly(ostrich)
except exception as e:
print(e)
这里,ostrich 违反了 lsp,因为它不能飞,因此它不能替代 bird 基类。
4. 接口隔离原则(isp)
定义:客户端不应该被迫依赖他们不使用的接口。
示例:
from abc import abc, abstractmethod
class printer(abc):
@abstractmethod
def print_document(self, document):
pass
class scanner(abc):
@abstractmethod
def scan_document(self, document):
pass
class multifunctionprinter(printer, scanner):
def print_document(self, document):
print(f"printing: {document}")
def scan_document(self, document):
print(f"scanning: {document}")
class simpleprinter(printer):
def print_document(self, document):
print(f"printing: {document}")
# usage
mfp = multifunctionprinter()
mfp.print_document("report")
mfp.scan_document("report")
printer = simpleprinter()
printer.print_document("report")
在此示例中,multifunctionprinter 实现了 printer 和 scanner 接口,而 simpleprinter 只实现了 printer,遵循 isp。
5. 依赖倒置原则(dip)
定义:高层模块不应该依赖于低层模块。两者都应该依赖于抽象。抽象不应该依赖于细节。细节应该取决于抽象。
示例:
from abc import ABC, abstractmethod
class Database(ABC):
@abstractmethod
def save(self, data):
pass
class MySQLDatabase(Database):
def save(self, data):
print("Saving data to MySQL database")
class MongoDBDatabase(Database):
def save(self, data):
print("Saving data to MongoDB database")
class UserService:
def __init__(self, database: Database):
self.database = database
def save_user(self, user_data):
self.database.save(user_data)
# Usage
mysql_db = MySQLDatabase()
mongo_db = MongoDBDatabase()
user_service = UserService(mysql_db)
user_service.save_user({"name": "John Doe"})
user_service = UserService(mongo_db)
user_service.save_user({"name": "Jane Doe"})
在此示例中,userservice 依赖于数据库抽象,允许灵活性并遵守 dip。
结论
通过坚持 solid 原则,开发人员可以创建更加模块化、更易于维护和可扩展的软件。这些原则有助于管理软件开发的复杂性,确保代码保持整洁和可扩展。通过python中的实际示例,我们可以看到如何应用这些原则来创建健壮且可维护的系统。