Python 工廠模式解析：JSON 與 XML 資料提取

在資料處理的過程中，經常需要處理不同格式的資料，例如 JSON 和 XML。為了提高程式碼的彈性和可維護性，我們可以使用工廠模式來設計資料提取器。本文將介紹如何使用工廠方法和抽象工廠模式來實作 JSON 和 XML 資料的提取。工廠模式能根據不同的資料格式，動態地建立對應的資料提取器物件，而不需要修改既有的程式碼。如此一來，當需要新增支援新的資料格式時，只需新增對應的資料提取器類別和修改工廠方法，而不需要修改其他部分的程式碼，降低了程式碼的耦合性，也提升了程式碼的可擴充套件性。透過封裝資料提取的邏輯，工廠模式也能夠讓程式碼更加簡潔易懂，方便後續的維護和修改。

資料提取器基礎類別

為了統一資料提取器的介面，我們可以定義一個基礎類別 DataExtractor，它包含一個 parsed_data 屬性，該屬性傳回提取的資料。

from abc import ABC, abstractmethod
import json
import xml.etree.ElementTree as etree

class DataExtractor(ABC):
    @property
    @abstractmethod
    def parsed_data(self):
        pass

JSON 資料提取器

JSONDataExtractor 類別負責解析 JSON 檔案。它使用 json 模組載入 JSON 資料，並將其儲存在 data 屬性中。parsed_data 屬性傳回已解析的 JSON 資料。

class JSONDataExtractor(DataExtractor):
    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

XML 資料提取器

XMLDataExtractor 類別負責解析 XML 檔案。它使用 xml.etree.ElementTree 模組解析 XML 檔案，並將其儲存在 tree 屬性中。parsed_data 屬性傳回 XML 檔案的根節點。

class XMLDataExtractor(DataExtractor):
    def __init__(self, filepath):
        self.tree = etree.parse(filepath)

    @property
    def parsed_data(self):
        return self.tree

資料提取器工廠方法

dataextraction_factory 函式是一個工廠方法，根據輸入檔案路徑的副檔名傳回 JSONDataExtractor 或 XMLDataExtractor 的例項。

def dataextraction_factory(filepath):
    if filepath.endswith('json'):
        extractor = JSONDataExtractor(filepath)
    elif filepath.endswith('xml'):
        extractor = XMLDataExtractor(filepath)
    else:
        raise ValueError("Unsupported file type")
    return extractor

使用範例

# 建立 JSON 資料提取器
json_extractor = dataextraction_factory('data.json')
print(json_extractor.parsed_data)

# 建立 XML 資料提取器
xml_extractor = dataextraction_factory('data.xml')
print(xml_extractor.parsed_data)

圖表翻譯：

  flowchart TD
    A[資料提取器工廠] --> B[JSON 資料提取器]
    A --> C[XML 資料提取器]
    B --> D[解析 JSON 檔案]
    C --> E[解析 XML 檔案]
    D --> F[傳回 JSON 資料]
    E --> G[傳回 XML 資料]

內容解密：

以上程式碼實作了資料提取器工廠方法，根據輸入檔案路徑的副檔名傳回相應的資料提取器例項。JSONDataExtractor 類別負責解析 JSON 檔案，而 XMLDataExtractor 類別負責解析 XML 檔案。dataextraction_factory 函式根據檔案副檔名傳回對應的資料提取器例項。使用範例展示瞭如何使用工廠方法建立 JSON 和 XML 資料提取器，並傳回解析的資料。

使用工廠方法設計模式進行資料擷取

在本節中，我們將探討如何使用工廠方法設計模式來擷取不同格式的資料。這個模式允許我們根據檔案的型別動態地建立適合的資料擷取器。

資料擷取器介面

首先，我們定義一個抽象的資料擷取器介面 DataExtractor，它包含了 extract 方法，用於從檔案中擷取資料。

from abc import ABC, abstractmethod

class DataExtractor(ABC):
    @abstractmethod
    def extract(self, filepath):
        pass

具體資料擷取器

接下來，我們實作具體的資料擷取器類別，例如 JSONDataExtractor、CSVDataExtractor、XMLDataExtractor 等。每個類別都實作了 DataExtractor 介面的 extract 方法，以便從對應格式的檔案中擷取資料。

import json

class JSONDataExtractor(DataExtractor):
    def extract(self, filepath):
        with open(filepath, 'r') as file:
            return json.load(file)

import csv

class CSVDataExtractor(DataExtractor):
    def extract(self, filepath):
        data = []
        with open(filepath, 'r') as file:
            reader = csv.DictReader(file)
            for row in reader:
                data.append(row)
        return data

import xml.etree.ElementTree as ET

class XMLDataExtractor(DataExtractor):
    def extract(self, filepath):
        tree = ET.parse(filepath)
        root = tree.getroot()
        data = []
        for child in root:
            data.append({child.tag: child.text})
        return data

工廠方法

現在，我們定義工廠方法 dataextraction_factory，它根據檔案的副檔名（例如 .json、.csv、.xml）傳回對應的資料擷取器例項。

def dataextraction_factory(filepath):
    if filepath.endswith('.json'):
        return JSONDataExtractor()
    elif filepath.endswith('.csv'):
        return CSVDataExtractor()
    elif filepath.endswith('.xml'):
        return XMLDataExtractor()
    else:
        raise ValueError('Cannot extract data from {}'.format(filepath))

包裝函式和主函式

為了增加程式的健壯性，我們可以使用包裝函式 extract_data_from 來呼叫工廠方法，並新增例外處理機制。

def extract_data_from(filepath):
    try:
        factory_obj = dataextraction_factory(filepath)
        return factory_obj
    except ValueError as e:
        print(e)
        return None

def main():
    # 測試 JSON 檔案
    json_extractor = extract_data_from('data/person.json')
    if json_extractor:
        print(json_extractor.extract('data/person.json'))

    # 測試 CSV 檔案
    csv_extractor = extract_data_from('data/person.csv')
    if csv_extractor:
        print(csv_extractor.extract('data/person.csv'))

    # 測試 XML 檔案
    xml_extractor = extract_data_from('data/person.xml')
    if xml_extractor:
        print(xml_extractor.extract('data/person.xml'))

    # 測試不支援的檔案格式
    unsupported_extractor = extract_data_from('data/person.txt')
    if unsupported_extractor is None:
        print("無法從檔案中擷取資料")

if __name__ == '__main__':
    main()

圖表翻譯

以下是使用 Mermaid 語法繪製的工廠方法設計模式流程圖：

  flowchart TD
    A[開始] --> B[呼叫工廠方法]
    B --> C{判斷檔案格式}
    C -->|JSON| D[建立 JSON 資料擷取器]
    C -->|CSV| E[建立 CSV 資料擷取器]
    C -->|XML| F[建立 XML 資料擷取器]
    C -->|其他| G[丟擲例外]
    D --> H[呼叫 JSON 資料擷取器的 extract 方法]
    E --> I[呼叫 CSV 資料擷取器的 extract 方法]
    F --> J[呼叫 XML 資料擷取器的 extract 方法]
    H --> K[傳回 JSON 資料]
    I --> K[傳回 CSV 資料]
    J --> K[傳回 XML 資料]
    G --> L[顯示錯誤訊息]

圖表翻譯：

此圖表描述了工廠方法設計模式的流程。程式開始時呼叫工廠方法，根據檔案的格式（JSON、CSV 或 XML）建立對應的資料擷取器。然後，程式呼叫資料擷取器的 extract 方法來從檔案中擷取資料。如果檔案格式不支援，程式丟擲例外並顯示錯誤訊息。

工廠模式（Factory Pattern）在JSON和XML檔案中的應用

在前面的章節中，我們已經瞭解了工廠模式的基本概念和它在軟體開發中的應用。在本節中，我們將探討如何使用工廠模式來處理JSON和XML檔案。

JSON檔案處理

首先，我們需要建立一個工廠類別，負責從JSON檔案中提取資料。以下是示例程式碼：

import json

class JsonFactory:
    def __init__(self, file_path):
        self.file_path = file_path
        self.parsed_data = self.parse_data()

    def parse_data(self):
        with open(self.file_path, 'r') as f:
            data = json.load(f)
        return data

    def get_movies(self):
        return self.parsed_data

json_factory = JsonFactory('data/movies.json')
json_data = json_factory.get_movies()

print(f'Found: {len(json_data)} movies')

for movie in json_data:
    print(f"Title: {movie['title']}")
    year = movie['year']
    if year:
        print(f"Year: {year}")
    director = movie['director']
    if director:
        print(f"Director: {director}")
    genre = movie['genre']
    if genre:
        print(f"Genre: {genre}")
    print()

在上述程式碼中，JsonFactory類別負責從JSON檔案中提取資料。parse_data方法負責解析JSON檔案，並傳回解析後的資料。get_movies方法則傳回解析後的資料。

XML檔案處理

接下來，我們需要建立一個工廠類別，負責從XML檔案中提取資料。以下是示例程式碼：

import xml.etree.ElementTree as ET

class XmlFactory:
    def __init__(self, file_path):
        self.file_path = file_path
        self.parsed_data = self.parse_data()

    def parse_data(self):
        tree = ET.parse(self.file_path)
        root = tree.getroot()
        return root

    def get_liars(self):
        liars = self.parsed_data.findall(".//person[lastName='Liar']")
        return liars

xml_factory = XmlFactory('data/person.xml')
xml_data = xml_factory.get_liars()

for person in xml_data:
    print(f"Name: {person.find('firstName').text} {person.find('lastName').text}")
    phone = person.find('phone')
    if phone:
        print(f"Phone: {phone.text}")
    print()

在上述程式碼中，XmlFactory類別負責從XML檔案中提取資料。parse_data方法負責解析XML檔案，並傳回解析後的資料。get_liars方法則傳回所有姓氏為"Liar"的人員資料。

實作資料提取工廠方法

在這個例子中，我們將實作一個工廠方法來提取 JSON 和 XML 資料。首先，我們需要定義 JSON 和 XML 資料提取器類別。

JSON 資料提取器類別

import json

class JSONDataExtractor:
    def __init__(self, data):
        self.data = json.loads(data)

    def extract(self):
        # 在這裡實作 JSON 資料的提取邏輯
        return self.data

XML 資料提取器類別

import xml.etree.ElementTree as ET

class XMLDataExtractor:
    def __init__(self, data):
        self.root = ET.fromstring(data)

    def extract(self):
        # 在這裡實作 XML 資料的提取邏輯
        liars = self.root.findall(".//person[lastName='Liar']")
        for liar in liars:
            firstname = liar.find('firstName').text
            lastname = liar.find('lastName').text
            phone_numbers = liar.find('phoneNumbers')
            for p in phone_numbers:
                print(f"phone number ({p.attrib['type']}): {p.text}")
        return liars

工廠方法

def data_extraction_factory(data, data_type):
    if data_type == 'json':
        return JSONDataExtractor(data)
    elif data_type == 'xml':
        return XMLDataExtractor(data)
    else:
        raise ValueError("不支援的資料型別")

例子使用

json_data = '{"name": "John", "age": 30}'
xml_data = '''
<persons>
    <person>
        <firstName>John</firstName>
        <lastName>Liar</lastName>
        <phoneNumbers>
            <phone type="home">123456</phone>
            <phone type="office">789012</phone>
        </phoneNumbers>
    </person>
</persons>
'''

json_extractor = data_extraction_factory(json_data, 'json')
xml_extractor = data_extraction_factory(xml_data, 'xml')

print(json_extractor.extract())
xml_extractor.extract()

在這個例子中，我們定義了 JSON 和 XML 資料提取器類別，然後實作了工廠方法 data_extraction_factory 來根據資料型別傳回相應的資料提取器例項。這樣，我們就可以使用工廠方法來提取不同型別的資料。

抽象工廠設計模式

抽象工廠設計模式是工廠方法設計模式的一種推廣。它是一個邏輯上的工廠方法群，每個工廠方法都負責生成不同的物件。這種模式常用於需要建立一系列相關物件的情況下。

實際應用案例

在汽車製造業中，抽象工廠模式被用於生產不同車型的零件。同一套機械可以用於生產不同車型的門、車身板、引擎蓋、翼子板和鏡子等零件。最終組裝的車型由工廠決定。

在軟體開發中，抽象工廠模式也被廣泛應用。例如，在一個圖形使用者介面中，需要建立不同型別的按鈕、文字框和選單等元件。抽象工廠模式可以用於建立這些元件的工廠，從而實作不同型別的元件的建立。

實作抽象工廠模式

抽象工廠模式的實作通常涉及以下步驟：

定義抽象工廠介面：定義一個抽象工廠介面，該介面包含了一系列的工廠方法，每個工廠方法都負責生成不同的物件。
實作具體工廠：實作具體工廠類別，該類別實作了抽象工廠介面的工廠方法。
客戶端程式碼：客戶端程式碼使用抽象工廠介面建立物件，而不需要知道具體工廠的實作細節。

優點和缺點

抽象工廠模式的優點包括：

提高了系統的靈活性和擴充套件性：抽象工廠模式允許客戶端程式碼建立不同型別的物件，而不需要知道具體工廠的實作細節。
減少了系統的耦合度：抽象工廠模式可以減少系統的耦合度，因為客戶端程式碼不需要知道具體工廠的實作細節。

抽象工廠模式的缺點包括：

增加了系統的複雜度：抽象工廠模式需要定義抽象工廠介面和具體工廠類別，這增加了系統的複雜度。
需要更多的程式碼：抽象工廠模式需要更多的程式碼來實作抽象工廠介面和具體工廠類別。

實踐案例

以下是使用 Python 實作抽象工廠模式的例子：

from abc import ABC, abstractmethod

# 抽象工廠介面
class AbstractFactory(ABC):
    @abstractmethod
    def create_button(self):
        pass

    @abstractmethod
    def create_text_box(self):
        pass

# 具體工廠類別
class WindowsFactory(AbstractFactory):
    def create_button(self):
        return WindowsButton()

    def create_text_box(self):
        return WindowsTextBox()

class MacFactory(AbstractFactory):
    def create_button(self):
        return MacButton()

    def create_text_box(self):
        return MacTextBox()

# 產品類別
class Button(ABC):
    @abstractmethod
    def click(self):
        pass

class TextBox(ABC):
    @abstractmethod
    def input(self, text):
        pass

class WindowsButton(Button):
    def click(self):
        print("Windows 按鈕被點選")

class MacButton(Button):
    def click(self):
        print("Mac 按鈕被點選")

class WindowsTextBox(TextBox):
    def input(self, text):
        print(f"Windows 文字框輸入：{text}")

class MacTextBox(TextBox):
    def input(self, text):
        print(f"Mac 文字框輸入：{text}")

# 客戶端程式碼
def main():
    factory = WindowsFactory()
    button = factory.create_button()
    text_box = factory.create_text_box()

    button.click()
    text_box.input("Hello, World!")

if __name__ == "__main__":
    main()

在這個例子中，AbstractFactory 介面定義了兩個工廠方法：create_button 和 create_text_box。WindowsFactory 和 MacFactory 類別實作了這兩個工廠方法，分別建立 Windows 和 Mac 的按鈕和文字框。客戶端程式碼使用 WindowsFactory 類別建立按鈕和文字框，並呼叫它們的方法。

使用抽象工廠模式建立 Django 模型例項

在 Django 中，建立模型例項是一個常見的任務，特別是在測試中。為了使測試更加可讀和易於維護，我們可以使用抽象工廠模式來建立模型例項。這種方法可以幫助我們避免在測試中分享不必要的程式碼，並使得測試更加模組化。

什麼是抽象工廠模式？

抽象工廠模式是一種建立型模式，它提供了一種方式來建立一系列相關的物件，而無需指定具體的類別。這種模式通常用於當我們需要建立多個相關的物件時，例如在遊戲中建立不同型別的遊戲物件。

如何實作抽象工廠模式？

要實作抽象工廠模式，我們需要定義一個抽象工廠類別，它負責建立相關的物件。然後，我們需要定義具體的工廠類別，它們繼承自抽象工廠類別，並實作建立具體物件的方法。

從技術架構視角來看，本文介紹了資料提取器的設計與實作，涵蓋了基礎類別的定義、JSON 和 XML 資料提取器的具體實作，以及工廠方法和抽象工廠模式的應用。透過定義 DataExtractor 基礎類別和利用工廠方法，程式碼達成了更佳的結構和擴充性，方便日後支援更多資料格式。同時，抽象工廠模式的引入，更進一步提升了系統的彈性，允許根據不同需求建立特定型別的物件，例如在圖形介面或 Django 模型的應用案例中。然而，目前提供的 XML 解析僅針對特定結構，缺乏通用性，未來可考慮整合更強大的 XML 處理函式庫，例如 lxml，以提升解析效率和處理複雜 XML 檔案的能力。此外，錯誤處理機制也較為簡略，建議加入更完善的日誌記錄和例外處理，以提升程式碼的穩定性和可維護性。展望未來，可以整合資料驗證機制，確保資料的完整性和一致性，並探索更進階的設計模式，例如策略模式，以進一步最佳化資料提取和處理流程。玄貓認為，此架構已具備良好的基礎，透過持續迭代和最佳化，可發展成為更強大且通用的資料處理框架。

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。