Pemfaktoran semula berdasarkan prinsip reka bentuk: contoh sistem perangkak pengumpulan data

pengenalan

Meningkatkan kualiti kod sentiasa menjadi isu penting dalam pembangunan perisian. Dalam artikel ini, kami mengambil sistem perangkak pengumpulan data sebagai contoh dan menerangkan secara khusus cara menggunakan prinsip reka bentuk dan amalan terbaik melalui pemfaktoran semula langkah demi langkah.

Kod sebelum penambahbaikan

Mula-mula, kita mulakan dengan pengikis web yang sangat mudah dengan semua fungsi disepadukan ke dalam satu kelas.

Diterjemah dengan DeepL.com (versi percuma)

project_root/
├── web_scraper.py
├── main.py
└── requirements.txt

web_scraper.py

import requests
import json
import sqlite3

class WebScraper:
    def __init__(self, url):
        self.url = url

    def fetch_data(self):
        response = requests.get(self.url)
        data = response.text
        parsed_data = self.parse_data(data)
        enriched_data = self.enrich_data(parsed_data)
        self.save_data(enriched_data)
        return enriched_data

    def parse_data(self, data):
        return json.loads(data)

    def enrich_data(self, data):
        # Apply business logic here
        # Example: extract only data containing specific keywords
        return {k: v for k, v in data.items() if 'important' in v.lower()}

    def save_data(self, data):
        conn = sqlite3.connect('test.db')
        cursor = conn.cursor()
        cursor.execute('INSERT INTO data (json_data) VALUES (?)', (json.dumps(data),))
        conn.commit()
        conn.close()

main.py

from web_scraper import WebScraper

def main():
    scraper = WebScraper('https://example.com/api/data')
    data = scraper.fetch_data()
    print(data)

if __name__ == "__main__":
    main()

Mata untuk ditambah baik

1. Melanggar prinsip tanggungjawab tunggal: satu kelas bertanggungjawab untuk semua pemerolehan, analisis, pengayaan dan penyimpanan data
2. Logik perniagaan yang tidak jelas: logik perniagaan dibenamkan dalam kaedah enrich_data, tetapi dicampur dengan pemprosesan lain
3. Kurang kebolehgunaan semula: fungsi diganding rapat, menyukarkan penggunaan semula individu
4. Kesukaran ujian: sukar untuk menguji fungsi individu secara bebas
5. Ketegaran konfigurasi: laluan pangkalan data dan tetapan lain dibenamkan terus dalam kod

Fasa pemfaktoran semula

1. Pengasingan tanggungjawab: pengasingan pemerolehan, analisis dan penyimpanan data

• Perubahan Utama: Pengasingan tanggungjawab untuk pemerolehan, analisis dan penyimpanan data ke dalam kelas yang berasingan
• Objektif: Gunakan prinsip tanggungjawab tunggal, perkenalkan pembolehubah persekitaran

struktur direktori

project_root/
├── data_fetcher.py
├── data_parser.py
├── data_saver.py
├── data_enricher.py
├── web_scraper.py
├── main.py
└── requirements.txt

data_enricher.py

class DataEnricher:
    def enrich(self, data):
        return {k: v for k, v in data.items() if 'important' in v.lower()}

web_scraper.py

from data_fetcher import DataFetcher
from data_parser import DataParser
from data_enricher import DataEnricher
from data_saver import DataSaver

class WebScraper:
    def __init__(self, url):
        self.url = url
        self.fetcher = DataFetcher()
        self.parser = DataParser()
        self.enricher = DataEnricher()
        self.saver = DataSaver()

    def fetch_data(self):
        raw_data = self.fetcher.fetch(self.url)
        parsed_data = self.parser.parse(raw_data)
        enriched_data = self.enricher.enrich(parsed_data)
        self.saver.save(enriched_data)
        return enriched_data

Perubahan ini menjelaskan tanggungjawab setiap kelas dan meningkatkan kebolehgunaan semula dan kebolehujian. Walau bagaimanapun, logik perniagaan masih dibenamkan dalam kelas DataEnricher.

2. pengenalan antara muka dan suntikan pergantungan

• Perubahan utama: Memperkenalkan antara muka dan melaksanakan suntikan pergantungan.
• Tujuan: meningkatkan fleksibiliti dan kebolehlanjutan, melanjutkan pembolehubah persekitaran, logik perniagaan abstrak

struktur direktori

project_root/
├── interfaces/
│   ├── __init__.py
│   ├── data_fetcher_interface.py
│   ├── data_parser_interface.py
│   ├── data_enricher_interface.py
│   └── data_saver_interface.py
├── implementations/
│   ├── __init__.py
│   ├── http_data_fetcher.py
│   ├── json_data_parser.py
│   ├── keyword_data_enricher.py
│   └── sqlite_data_saver.py
├── web_scraper.py
├── main.py
└── requirements.txt

antara muka/data_fetcher_interface.py

from abc import ABC, abstractmethod

class DataFetcherInterface(ABC):
    @abstractmethod
    def fetch(self, url: str) -> str:
        pass

antara muka/data_parser_interface.py

from abc import ABC, abstractmethod
from typing import Dict, Any

class DataParserInterface(ABC):
    @abstractmethod
    def parse(self, raw_data: str) -> Dict[str, Any]:
        pass

antara muka/data_enricher_interface.py

from abc import ABC, abstractmethod
from typing import Dict, Any

class DataEnricherInterface(ABC):
    @abstractmethod
    def enrich(self, data: Dict[str, Any]) -> Dict[str, Any]:
        pass

antara muka/data_saver_interface.py

from abc import ABC, abstractmethod
from typing import Dict, Any

class DataSaverInterface(ABC):
    @abstractmethod
    def save(self, data: Dict[str, Any]) -> None:
        pass

implementations/keyword_data_enricher.py

import os
from interfaces.data_enricher_interface import DataEnricherInterface

class KeywordDataEnricher(DataEnricherInterface):
    def __init__(self):
        self.keyword = os.getenv('IMPORTANT_KEYWORD', 'important')

    def enrich(self, data):
        return {k: v for k, v in data.items() if self.keyword in str(v).lower()}

web_scraper.py

from interfaces.data_fetcher_interface import DataFetcherInterface
from interfaces.data_parser_interface import DataParserInterface
from interfaces.data_enricher_interface import DataEnricherInterface
from interfaces.data_saver_interface import DataSaverInterface

class WebScraper:
    def __init__(self, fetcher: DataFetcherInterface, parser: DataParserInterface, 
                 enricher: DataEnricherInterface, saver: DataSaverInterface):
        self.fetcher = fetcher
        self.parser = parser
        self.enricher = enricher
        self.saver = saver

    def fetch_data(self, url):
        raw_data = self.fetcher.fetch(url)
        parsed_data = self.parser.parse(raw_data)
        enriched_data = self.enricher.enrich(parsed_data)
        self.saver.save(enriched_data)
        return enriched_data

Perubahan utama pada peringkat ini ialah

1. pengenalan antara muka untuk memudahkan penukaran kepada pelaksanaan yang berbeza
2. suntikan kebergantungan untuk menjadikan kelas WebScraper lebih fleksibel
3. Kaedah fetch_data telah ditukar untuk mengambil url sebagai hujah, menjadikan spesifikasi URL lebih fleksibel.
4. Logik perniagaan telah disarikan sebagai DataEnricherInterface dan dilaksanakan sebagai KeywordDataEnricher.
5. Logik perniagaan telah dibuat lebih fleksibel dengan membenarkan kata kunci ditetapkan menggunakan pembolehubah persekitaran.

Perubahan ini telah meningkatkan fleksibiliti dan kebolehlanjutan sistem. Walau bagaimanapun, logik perniagaan kekal tertanam dalam DataEnricherInterface dan pelaksanaannya. Langkah seterusnya ialah memisahkan lagi logik perniagaan ini dan mentakrifkannya dengan jelas sebagai lapisan domain.

3. pengenalan lapisan domain dan pemisahan logik perniagaan

Dalam langkah sebelumnya, pengenalan antara muka meningkatkan fleksibiliti sistem. Walau bagaimanapun, logik perniagaan (dalam kes ini, penentuan dan penapisan kepentingan data) masih dianggap sebagai sebahagian daripada lapisan data. Berdasarkan konsep reka bentuk dipacu domain, menganggap logik perniagaan ini sebagai konsep pusat sistem dan melaksanakannya sebagai lapisan domain bebas memberikan faedah berikut

1. pengurusan logik perniagaan berpusat
2. kod yang lebih ekspresif melalui model domain
3. fleksibiliti yang lebih besar untuk menukar peraturan perniagaan
4. kemudahan ujian

Struktur direktori dikemas kini:

project_root/
├── domain/
│   ├── __init__.py
│   ├── scraped_data.py
│   └── data_enrichment_service.py
├── data/
│   ├── __init__.py
│   ├── interfaces/
│   │   ├── __init__.py
│   │   ├── data_fetcher_interface.py
│   │   ├── data_parser_interface.py
│   │   └── data_saver_interface.py
│   ├── implementations/
│   │   ├── __init__.py
│   │   ├── http_data_fetcher.py
│   │   ├── json_data_parser.py
│   │   └── sqlite_data_saver.py
├── application/
│   ├── __init__.py
│   └── web_scraper.py
├── main.py
└── requirements.txt

Pada peringkat ini, peranan DataEnricherInterface dan KeywordDataEnricher akan dialihkan ke model ScrapedData dan DataEnrichmentService pada lapisan domain. Butiran perubahan ini disediakan di bawah.

Sebelum tukar (Bahagian 2)

class DataEnricherInterface(ABC):
    @abstractmethod
    def enrich(self, data: Dict[str, Any]) -> Dict[str, Any]:
        pass

class KeywordDataEnricher(DataEnricherInterface):
    def __init__(self):
        self.keyword = os.getenv('IMPORTANT_KEYWORD', 'important')

    def enrich(self, data):
        return {k: v for k, v in data.items() if self.keyword in str(v).lower()}

Selepas pengubahsuaian (Seksyen 3)

@dataclass
class ScrapedData:
    content: Dict[str, Any]
    source_url: str

    def is_important(self) -> bool:
        important_keyword = os.getenv('IMPORTANT_KEYWORD', 'important')
        return any(important_keyword in str(v).lower() for v in self.content.values())

class DataEnrichmentService:
    def __init__(self):
        self.important_keyword = os.getenv('IMPORTANT_KEYWORD', 'important')

    def enrich(self, data: ScrapedData) -> ScrapedData:
        if data.is_important():
            enriched_content = {k: v for k, v in data.content.items() if self.important_keyword in str(v).lower()}
            return ScrapedData(content=enriched_content, source_url=data.source_url)
        return data

Perubahan ini menambah baik perkara berikut.

1. logik perniagaan telah dialihkan ke lapisan domain, menghapuskan keperluan untuk DataEnricherInterface.

2. the KeywordDataEnricher functionality has been merged into the DataEnrichmentService, centralizing the business logic in one place.

3. The is_important method has been added to the ScrapedData model. This makes the domain model itself responsible for determining the importance of data and makes the domain concept clearer.

4. DataEnrichmentService now handles ScrapedData objects directly, improving type safety.

The WebScraper class will also be updated to reflect this change.

from data.interfaces.data_fetcher_interface import DataFetcherInterface
from data.interfaces.data_parser_interface import DataParserInterface
from data.interfaces.data_saver_interface import DataSaverInterface
from domain.scraped_data import ScrapedData
from domain.data_enrichment_service import DataEnrichmentService

class WebScraper:
    def __init__(self, fetcher: DataFetcherInterface, parser: DataParserInterface, 
                 saver: DataSaverInterface, enrichment_service: DataEnrichmentService):
        self.fetcher = fetcher
        self.parser = parser
        self.saver = saver
        self.enrichment_service = enrichment_service

    def fetch_data(self, url: str) -> ScrapedData:
        raw_data = self.fetcher.fetch(url)
        parsed_data = self.parser.parse(raw_data)
        scraped_data = ScrapedData(content=parsed_data, source_url=url)
        enriched_data = self.enrichment_service.enrich(scraped_data)
        self.saver.save(enriched_data)
        return enriched_data

This change completely shifts the business logic from the data layer to the domain layer, giving the system a clearer structure. The removal of the DataEnricherInterface and the introduction of the DataEnrichmentService are not just interface replacements, but fundamental changes in the way business logic is handled.

Summary

This article has demonstrated how to improve code quality and apply design principles specifically through a step-by-step refactoring process for the data collection crawler system. The main areas of improvement are as follows.

1. Separation of Responsibility: Applying the principle of single responsibility, we separated data acquisition, parsing, enrichment, and storage into separate classes.
2. Introduction of interfaces and dependency injection: greatly increased the flexibility and scalability of the system, making it easier to switch to different implementations.
3. Introduction of domain model and services: clearly separated the business logic and defined the core concepts of the system.
4. Adoption of Layered Architecture: Clearly separated the domain, data, and application layers and defined the responsibilities of each layer. 5.Maintain interfaces: Maintained abstraction at the data layer to ensure flexibility in implementation.

These improvements have greatly enhanced the system's modularity, reusability, testability, maintainability, and scalability. In particular, by applying some concepts of domain-driven design, the business logic became clearer and the structure was more flexible to accommodate future changes in requirements. At the same time, by maintaining the interfaces, we ensured the flexibility to easily change and extend the data layer implementation.

It is important to note that this refactoring process is not a one-time event, but part of a continuous improvement process. Depending on the size and complexity of the project, it is important to adopt design principles and DDD concepts at the appropriate level and to make incremental improvements.

Finally, the approach presented in this article can be applied to a wide variety of software projects, not just data collection crawlers. We encourage you to use them as a reference as you work to improve code quality and design.

Atas ialah kandungan terperinci Pemfaktoran semula berdasarkan prinsip reka bentuk: contoh sistem perangkak pengumpulan data. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!