Refaktorieren Sie ein Objekt, das eine Sache und viele Dinge erwartet

php-Editor Yuzai Beim Programmieren begegnen wir oft Situationen, in denen ein Objekt mehrere Verantwortlichkeiten übernehmen möchte. Diese Art von Objekt wird als „Refactoring eines Objekts, das eine Sache und viele Dinge erwartet“ bezeichnet. Solche Objekte führen normalerweise zu aufgeblähtem Code, hoher Kopplung und Schwierigkeiten bei der Wartung und Erweiterung. In diesem Artikel untersuchen wir, wie man ein solches Objekt umgestaltet, um es klarer, flexibler und einfacher zu warten. Lass uns einen Blick darauf werfen!

Frageninhalt

Ich arbeite an der Aktualisierung der Go-Codebasis. Unser Unternehmen verfügt über einen zentralen Datenspeicher, fiktiv DataStore genannt, den Sie in verschiedenen Datensätzen oder Schemata veröffentlichen und daraus lesen können. Unsere spezielle Codebasis enthält Code, der bestimmte Datensätze/Schemas mit der DataStore-Implementierung koppelt. Ich muss diesen Code umgestalten, um in andere (möglicherweise mehr) Datensätze schreiben zu können.

Im folgenden Code stellt dataStoreSchema ein einzelnes Schema dar, z. B. die „Kunden“-Daten. Aber ich habe andere Schemata wie „Bestellungen“ oder jedes andere Schema, das andere Felder hat, in die ich schreiben möchte.

transformEvent nimmt die Daten, die an transformEvent 获取将传递到 DataStore 的数据，并执行一些逻辑来创建 dataStoreSchema übergeben werden, und führt eine Logik aus, um das

-Objekt zu erstellen und schreibt es dann in den eigentlichen DataStore in der Cloud.

Ich möchte in potenziell jedes

Schema im Datenspeicher schreiben, nicht nur das Schema, an das diese Implementierung gekoppelt ist.

type Parameters struct {
    SchemaName              string
    Host                    string
    Secret                  string
}

type DataStore struct {
    params                *Parameters
    url                   string
    request               *http.Client
}

// imagine this defines an Order, but other schemas might be for Customer
type dataStoreSchema struct {
    eventUrl string `json:"url"`
    objectID string `json:"object_id"`
}

func New(parameters) (*DataStore, error) {
    // implementation

    return &stream, nil
}

// takes input and converts it into a schema object that can be written to the datastore
func (ds *DataStore) transformEvent(...) dataStoreSchema {

    // .... implementation

    return dataStoreSchema{
        eventUrl: url,
        objectID: objectId,
    }
}

func (ds *DataStore) writeEvents(...) error {

    // .... implementation
    payload := ds.transformEvent(event)
        

    ds.produce(payload)
}

func (ds *DataStore) produce(msg []events) {
        ds.WriteToDatastore(msg)
}

Das aktuelle Verhalten ist so

myDatasetClient := DataStore.New(params)
myDatasetClient.write(<-messages chan)

Aber ich möchte so etwas tun können

myDatasetClient1 := DataStore.New(params{schema1, transformEvent1})
myDatasetClient2 := DataStore.New(params{schema2, transformEvent2})
myDatasetClient3 := DataStore.New(params{schema3, transformEvent3})

Oder was auch immer in Go-Begriffen am sinnvollsten ist

Workaround

dataStoreSchema 结构和 transformEvent 方法与特定模式紧密耦合。 transformEvent 方法接受输入并将其转换为 dataStoreSchemaWenn ich das richtig verstehe, ist Ihre aktuelle Implementierung über die

-Struktur und die transformEvent-Methode eng an einen bestimmten Modus gekoppelt. Die transformEvent-Methode akzeptiert Eingaben und wandelt sie in ein

-Objekt um, das dann in den DataStore geschrieben wird.

Vielleicht möchten Sie in ein beliebiges Schema in Ihrem Datenspeicher schreiben, nicht nur in das, an das Ihre aktuelle Implementierung gekoppelt ist. DataStore 客户端，每个客户端与不同的 schema 和相应的转换函数相关联（transformEvent1、transformEvent2、transformEvent3

myDatasetClient1 := DataStore.New(params{schema1, transformEvent1})
myDatasetClient2 := DataStore.New(params{schema2, transformEvent2})
myDatasetClient3 := DataStore.New(params{schema3, transformEvent3})

Bedeutung: Sie möchten ein anderes DataStore erstellen.

Dies sollte bedeuten, dass die Konvertierungslogik von der

-Struktur entkoppelt wird, sodass unterschiedliche Konvertierungsfunktionen zur Handhabung unterschiedlicher Modi verwendet werden können. Parameters 和 DataStore

Sie können Schnittstellen verwenden, um verschiedene Schemakonvertierungen durchzuführen und Parameter und

Strukturen zu ändern: E 和用于架构类型的 S

package main

import (
    "net/http"
)

// Define a Transformer function type that takes an event of type E and returns a schema of type S
type Transformer[E any, S any] func(event E) S

type Parameters[E any, S any] struct {
    SchemaName  string
    Host        string
    Secret      string
    TransformFn Transformer[E, S]
}

type DataStore[E any, S any] struct {
    params  *Parameters[E, S]
    url     string
    request *http.Client
}

// Define structs for different schemas and events
type OrderSchema struct {
    eventUrl string `json:"url"`
    objectID string `json:"object_id"`
    // other fields
}

type OrderEvent struct {
    // fields
}

type CustomerSchema struct {
    eventUrl string `json:"url"`
    objectID string `json:"object_id"`
    // other fields
}

type CustomerEvent struct {
    // fields
}

// New creates a new DataStore
func New[E any, S any](params Parameters[E, S]) (*DataStore[E, S], error) {
    // implementation
    return &DataStore[E, S]{params: &params}, nil
}

func (ds *DataStore[E, S]) transformEvent(event E) S {
    return ds.params.TransformFn(event)
}

// rest of the code remains the same

// Usage:
func main() {
    orderTransformFn := func(event OrderEvent) OrderSchema {
        // implementation for Order schema
    }

    customerTransformFn := func(event CustomerEvent) CustomerSchema {
        // implementation for Customer schema
    }

    myDatasetClient1, _ := New[OrderEvent, OrderSchema](Parameters[OrderEvent, OrderSchema]{SchemaName: "schema1", TransformFn: orderTransformFn})
    myDatasetClient2, _ := New[CustomerEvent, CustomerSchema](Parameters[CustomerEvent, CustomerSchema]{SchemaName: "schema2", TransformFn: customerTransformFn})
    // ...
}

Transformer-Funktionstypen werden jetzt mit zwei Typparametern parametrisiert: E 和 S für Ereignistypen.
Parameter und Datenspeicherstrukturen werden ebenfalls mit denselben beiden Typparametern parametrisiert E 的事件并返回类型为S.

Die transformEvent-Methode von DataStore akzeptiert jetzt Muster vom Typ

. Transformer 函数签名的新函数类型或实例，以及相应的事件和模式结构。您不会定义实现 Transformer 接口的新结构，因为 Transformer
Um mehr Muster zu verarbeiten, können Sie Objekte definieren, die jetzt Funktionstypen anstelle von Schnittstellen entsprechen. Daher können Sie neue DataStoreTransformationsfunktionen

und Architekturstrukturen definieren, ohne bestehende 🎜 Implementierungen zu ändern. 🎜

Das obige ist der detaillierte Inhalt vonRefaktorieren Sie ein Objekt, das eine Sache und viele Dinge erwartet. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!