在軟體開發過程中，隨著專案規模的擴大，程式碼的結構會變得越來越複雜，進而影響到程式碼的可讀性、可維護性和可擴充套件性。重構是改善程式碼品質的有效手段，而設計模式則提供了一系列經過驗證的解決方案，可以幫助開發者更好地組織程式碼結構。本文介紹的建立型模式和結構型模式，可以有效地解決物件建立和系統結構方面的問題，提升程式碼的可重用性和靈活性。透過結合依賴注入等技術，更能進一步提升系統的可測試性和可維護性，讓程式碼更易於理解和修改。
結構化程式碼：進階重構技術與實務應用
在軟體開發領域中，重構（Refactoring）是一項至關重要的技術實踐，旨在改善程式碼的結構、可讀性和可維護性，而不改變其外部行為。隨著系統規模的擴大和複雜度的增加，採用適當的設計模式（Design Patterns）可以顯著提升重構的效率和成效。本篇文章將探討如何利用建立型模式（Creational Patterns）和結構型模式（Structural Patterns）進行進階重構，以最佳化程式碼架構並提升系統的可擴充套件性。
建立型模式在重構中的應用
建立型模式主要關注物件的建立機制，旨在降低系統中物件建立的複雜度，並提高程式碼的靈活性和可重用性。在重構過程中，這些模式可以有效地簡化物件建立邏輯、減少耦合度，並增強系統的可測試性。
簡單工廠模式的重構
在未重構的程式碼中，物件建立往往依賴於具體的類別，這使得系統難以擴充套件和維護。例如：
class WindowsButton:
def render(self):
print("Rendering Windows button")
class MacOSButton:
def render(self):
print("Rendering MacOS button")
def create_button(os_type):
if os_type == 'Windows':
return WindowsButton()
elif os_type == 'MacOS':
return MacOSButton()
這種實作方式在面對新作業系統的加入時，容易出現錯誤。透過引入抽象工廠（Abstract Factory）模式，可以封裝平台特定的例項化邏輯，從而提高系統的可擴充套件性。
from abc import ABC, abstractmethod
class Button(ABC):
@abstractmethod
def render(self):
pass
class WindowsButton(Button):
def render(self):
print("Rendering Windows button")
class MacOSButton(Button):
def render(self):
print("Rendering MacOS button")
class GUIFactory(ABC):
@abstractmethod
def create_button(self) -> Button:
pass
class WindowsFactory(GUIFactory):
def create_button(self) -> Button:
return WindowsButton()
class MacOSFactory(GUIFactory):
def create_button(self) -> Button:
return MacOSButton()
def get_factory(os_type) -> GUIFactory:
if os_type == 'Windows':
return WindowsFactory()
elif os_type == 'MacOS':
return MacOSFactory()
factory = get_factory('Windows')
button = factory.create_button()
button.render()
#### 內容解密：
1. **抽象工廠模式**：透過定義`GUIFactory`抽象類別及其具體子類別（如`WindowsFactory`和`MacOSFactory`），將物件建立的邏輯封裝起來，使得客戶端程式碼可以根據不同的作業系統型別，獲得相應的UI物件。
2. **多型性**：`get_factory`函式傳回的是一個`GUIFactory`型別的物件，實際上可能是`WindowsFactory`或`MacOSFactory`的例項。這種多型性使得客戶端程式碼能夠以統一的方式處理不同平台的UI元件建立。
3. **解耦**：客戶端程式碼不再直接依賴於具體的UI元件類別（如`WindowsButton`或`MacOSButton`），而是透過工廠介面間接建立物件，從而實作了物件建立邏輯與客戶端程式碼的解耦。
### 單例模式的重構
在某些場景下，系統中某些資源（如組態管理器、記錄系統或連線池）只需要一個例項。此時，單例（Singleton）模式可以確保這些資源的全域唯一性，避免重複例項化帶來的同步問題和資源浪費。
```python
class SingletonMeta(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super().__call__(*args, **kwargs)
return cls._instances[cls]
class ConfigManager(metaclass=SingletonMeta):
def __init__(self):
self.config_data = {}
def load(self, filename):
# 從檔案載入組態
pass
def get(self, key):
return self.config_data.get(key)
內容解密：
- 執行緒安全：透過元類別（metaclass）
SingletonMeta實作單例模式，確保在多執行緒環境下，ConfigManager類別只會被例項化一次。 - 全域存取點：
ConfigManager類別提供了一個全域存取點，用於管理和存取組態資料，避免了多個例項間的資料不一致問題。 - 簡化測試：由於
ConfigManager是單例，因此在測試時可以更容易地進行模擬（mocking），從而簡化單元測試的實作。
依賴注入與工廠模式的結合
在大型專案中，將依賴注入（Dependency Injection, DI）與建立型模式結合使用，可以進一步提升系統的可維護性和可測試性。透過將物件的建立和依賴關係的管理交由外部容器處理，可以實作控制反轉（Inversion of Control, IoC），使得程式碼更加模組化。
from abc import ABC, abstractmethod
class Service(ABC):
@abstractmethod
def execute(self):
pass
class ConcreteService(Service):
def execute(self):
print("Executing the concrete service logic.")
class ServiceFactory:
def create_service(self) -> Service:
return ConcreteService()
class Container:
def __init__(self):
self._registrations = {}
def register(self, key, factory):
self._registrations[key] = factory
def resolve(self, key):
factory = self._registrations.get(key)
if factory:
return factory.create_service()
raise ValueError("No factory registered for key: " + key)
container = Container()
container.register("service", ServiceFactory())
service = container.resolve("service")
service.execute()
#### 內容解密：
1. **依賴注入容器**：`Container`類別作為依賴注入容器，負責註冊和管理不同服務的工廠類別，使得客戶端可以透過容器解析出所需的服務例項。
2. **工廠模式與DI結合**：透過將`ServiceFactory`註冊到容器中，客戶端程式碼可以根據需要取得`Service`介面的具體實作，而無需直接依賴於具體的實作類別。
3. **控制反轉**：客戶端程式碼不再負責服務物件的建立，而是由容器根據註冊的工廠動態提供所需的依賴，實作了控制反轉，提升了程式碼的靈活性和可測試性。
## 結構型模式在重構中的應用
結構型模式主要關注類別和物件之間的組織結構，旨在提高系統的可擴充套件性和可維護性。在重構過程中，這些模式可以有效地簡化複雜的系統架構，並提升程式碼的可讀性和可理解性。
### 介面卡模式的重構
在大型系統中，不同模組或元件之間的介面不相容是常見的問題。介面卡（Adapter）模式提供了一種解決方案，透過引入介面卡類別，將不相容的介面轉換為客戶端所期望的介面，從而實作不同元件之間的協同工作。
```python
from abc import ABC, abstractmethod
class LegacyService:
def old_method(self, data):
# 舊有的處理邏輯
return f"Processed {data}"
class StandardInterface(ABC):
@abstractmethod
def process(self, payload):
pass
class LegacyAdapter(StandardInterface):
def __init__(self, legacy_service: LegacyService):
self.legacy_service = legacy_service
def process(self, payload):
return self.legacy_service.old_method(payload)
legacy_service = LegacyService()
adapter = LegacyAdapter(legacy_service)
result = adapter.process("some data")
print(result)
#### 內容解密：
1. **介面轉換**：透過引入`LegacyAdapter`類別，將`LegacyService`類別的舊有介面`old_method`轉換為符合`StandardInterface`的新介面`process`，使得客戶端可以統一使用標準介面與不同的服務進行互動。
2. **解耦與相容性**：介面卡模式使得舊有的元件可以在不修改原有程式碼的情況下，與新的系統架構相容，提升了系統的可擴充套件性和可維護性。
3. **提高可讀性**：透過介面卡模式，可以將複雜的介面轉換邏輯封裝起來，使得客戶端程式碼更加簡潔和易於理解。
## 結構設計模式在程式碼重構中的應用
在軟體開發的過程中，重構是一種常見的做法，旨在改善現有程式碼的結構、可讀性和可維護性，而不改變其外部行為。結構設計模式提供了一系列解決方案，用於處理類別和物件之間的關係，從而最佳化系統的架構。本文將探討幾種常見的結構設計模式，包括Adapter、Facade、Composite、Decorator和Bridge，並透過Python範例展示它們在重構中的應用。
### 介面卡模式（Adapter Pattern）
介面卡模式是一種結構設計模式，它允許將一個類別的介面轉換成客戶端所期望的另一個介面。這在重構遺留系統時特別有用，因為它允許新程式碼與舊程式碼共存，而不需要對舊程式碼進行大幅度的修改。
```python
class LegacyService:
def old_method(self, payload):
return f"Processed {payload}"
class ServiceAdapter:
def __init__(self, legacy_service: LegacyService):
self.legacy_service = legacy_service
def process(self, payload):
# 將新的方法呼叫轉換為舊的介面
return self.legacy_service.old_method(payload)
# 在重構的程式碼中使用
legacy = LegacyService()
adapter = ServiceAdapter(legacy)
result = adapter.process("input data")
print(result) # 輸出: Processed input data
內容解密：
LegacyService類別代表了一個具有舊方法的遺留服務。ServiceAdapter類別包裝了LegacyService，並將新的process方法呼叫轉換為對old_method的呼叫。- 這種做法使得客戶端程式碼可以與標準化的介面一起工作，而不必直接與遺留介面互動。
外觀模式（Facade Pattern）
外觀模式提供了一個簡化的介面給一個複雜的子系統。它隱藏了子系統的複雜性，並提供了一個統一的API，使得客戶端可以更容易地與子系統互動。
class SubsystemA:
def operation_a(self):
return "A"
class SubsystemB:
def operation_b(self):
return "B"
class SubsystemC:
def operation_c(self):
return "C"
class SystemFacade:
def __init__(self):
self.subsystem_a = SubsystemA()
self.subsystem_b = SubsystemB()
self.subsystem_c = SubsystemC()
def execute(self):
result = []
result.append(self.subsystem_a.operation_a())
result.append(self.subsystem_b.operation_b())
result.append(self.subsystem_c.operation_c())
return "-".join(result)
# 重構後的客戶端使用
facade = SystemFacade()
output = facade.execute()
print(output) # 輸出: A-B-C
內容解密：
SubsystemA、SubsystemB和SubsystemC代表了子系統的不同元件。SystemFacade類別封裝了這些子系統，並提供了一個統一的execute方法來執行相關操作。- 這種做法簡化了客戶端與子系統之間的互動，降低了耦合度。
組合模式（Composite Pattern）
組合模式允許將物件組合成樹狀結構，以表示部分-整體的層次關係。它使得客戶端可以統一地處理單個物件和組合物件。
from abc import ABC, abstractmethod
class UIComponent(ABC):
@abstractmethod
def render(self):
pass
class Button(UIComponent):
def render(self):
return "Rendering Button"
class TextField(UIComponent):
def render(self):
return "Rendering TextField"
class Panel(UIComponent):
def __init__(self):
self.children = []
def add(self, component: UIComponent):
self.children.append(component)
def render(self):
rendered_components = [child.render() for child in self.children]
return "Panel[" + "; ".join(rendered_components) + "]"
# 建構一個組合的UI結構
button = Button()
text_field = TextField()
panel = Panel()
panel.add(button)
panel.add(text_field)
display = panel.render()
print(display) # 輸出: Panel[Rendering Button; Rendering TextField]
內容解密：
UIComponent是所有UI元件的抽象基礎類別，定義了render方法。Button和TextField是葉節點元件，而Panel是可以包含其他元件的容器元件。- 客戶端可以統一呼叫
render方法，無論是葉元件還是組合元件。
裝飾模式（Decorator Pattern）
裝飾模式允許動態地為物件新增額外的職責，而不需要修改其原始程式碼。它透過包裝物件並提供額外的行為來實作這一點。
from abc import ABC, abstractmethod
class DataSource(ABC):
@abstractmethod
def read_data(self):
pass
class FileDataSource(DataSource):
def __init__(self, filename):
self.filename = filename
def read_data(self):
with open(self.filename, 'r') as file:
return file.read()
class DataSourceDecorator(DataSource):
def __init__(self, wrappee: DataSource):
self.wrappee = wrappee
def read_data(self):
return self.wrappee.read_data()
class EncryptionDecorator(DataSourceDecorator):
def read_data(self):
data = self.wrappee.read_data()
# 進行解密（示例用途）
return f"decrypted({data})"
class CompressionDecorator(DataSourceDecorator):
def read_data(self):
data = self.wrappee.read_data()
# 進行解壓縮（示例用途）
return f"decompressed({data})"
# 使用裝飾器重構物件建立
file_source = FileDataSource("data.txt")
encrypted_source = EncryptionDecorator(file_source)
compressed_source = CompressionDecorator(encrypted_source)
final_data = compressed_source.read_data()
print(final_data) # 輸出: decompressed(decrypted(data content))
內容解密：
DataSource是資料來源的抽象介面，定義了read_data方法。FileDataSource是具體的資料來源實作，而DataSourceDecorator是裝飾器的基礎類別。EncryptionDecorator和CompressionDecorator是具體的裝飾器，分別為資料來源新增瞭解密和解壓縮的功能。
橋接模式（Bridge Pattern）
橋接模式用於將抽象部分與其實作部分分離，使它們可以獨立地變化。它透過將抽象類別與其實作類別分開來達到這一目的。
from abc import ABC, abstractmethod
class Renderer(ABC):
@abstractmethod
def render_text(self, text: str) -> str:
pass
class HTMLRenderer(Renderer):
def render_text(self, text: str) -> str:
return f"<p>{text}</p>"
class PDFRenderer(Renderer):
def render_text(self, text: str) -> str:
# 假設一個複雜的PDF渲染實作
return f"PDF: {text}"
class Document:
def __init__(self, renderer: Renderer):
self.renderer = renderer
def render(self, text: str) -> str:
return self.renderer.render_text(text)
# 使用橋接模式
html_renderer = HTMLRenderer()
pdf_renderer = PDFRenderer()
html_document = Document(html_renderer)
pdf_document = Document(pdf_renderer)
print(html_document.render("Hello, World!")) # 輸出: <p>Hello, World!</p>
print(pdf_document.render("Hello, World!")) # 輸出: PDF: Hello, World!
內容解密：
Renderer是渲染器的抽象介面，定義了render_text方法。HTMLRenderer和PDFRenderer是具體的渲染器實作，分別用於HTML和PDF格式的渲染。Document類別透過持有Renderer的參照，實作了抽象與實作的分離。