Refactor objek yang mengharapkan satu perkara dan mengharapkan banyak perkara

editor php Yuzai Dalam pengaturcaraan, kita sering menghadapi situasi di mana objek ingin memikul pelbagai tanggungjawab. Objek jenis ini dipanggil "memfaktorkan semula objek yang mengharapkan satu perkara dan mengharapkan banyak perkara". Objek sedemikian biasanya membawa kepada kod kembung, gandingan tinggi, dan kesukaran untuk mengekalkan dan memanjangkan. Dalam artikel ini, kami akan meneroka cara memfaktorkan semula objek sedemikian untuk menjadikannya lebih jelas, lebih fleksibel dan lebih mudah diselenggara. Mari lihat!

Kandungan soalan

Saya sedang berusaha untuk mengemas kini asas kod Go. Syarikat kami mempunyai stor data pusat, secara fiksyen dipanggil DataStore, yang anda boleh terbitkan dan baca daripada pelbagai set data atau skema. Pangkalan kod khusus kami mempunyai beberapa kod yang menggabungkan set data/skema tertentu dengan pelaksanaan DataStore. Saya perlu memfaktorkan semula kod ini untuk dapat menulis kepada set data lain (mungkin lebih banyak).

Dalam kod di bawah, dataStoreSchema mewakili satu skema, seperti data "Pelanggan". Tetapi saya mempunyai skema lain seperti "Pesanan", atau mana-mana skema yang mempunyai medan berbeza yang ingin saya tulis.

transformEvent mengambil data yang akan dihantar ke transformEvent 获取将传递到 DataStore 的数据，并执行一些逻辑来创建 dataStoreSchema dan melakukan beberapa logik untuk mencipta objek

dan kemudian menulisnya ke DataStore sebenar dalam awan.

Saya ingin menulis kepada berpotensi mana-mana

skema pada stor data, bukan hanya skema yang digabungkan dengan pelaksanaan ini.

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)
}

Gelagat sekarang macam ni

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

Tapi nak boleh buat macam ni

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

Atau apa sahaja yang paling masuk akal dalam istilah Go

Penyelesaian

dataStoreSchema 结构和 transformEvent 方法与特定模式紧密耦合。 transformEvent 方法接受输入并将其转换为 dataStoreSchemaJika saya faham dengan betul, pelaksanaan semasa anda digandingkan rapat dengan mod tertentu melalui struktur

dan kaedah transformEvent. Kaedah transformEvent menerima input dan menukarnya menjadi objek

, yang kemudiannya ditulis ke DataStore.

Anda mungkin mahu menulis kepada mana-mana skema pada stor data anda, bukan hanya pada satu pelaksanaan semasa anda digabungkan. DataStore 客户端，每个客户端与不同的 schema 和相应的转换函数相关联（transformEvent1、transformEvent2、transformEvent3

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

Maksud: Anda ingin mencipta DataStore yang berbeza).

Ini bermakna menyahganding logik penukaran daripada struktur

, membenarkan fungsi penukaran yang berbeza digunakan untuk mengendalikan mod yang berbeza. Parameters 和 DataStore

Anda boleh menggunakan antara muka untuk melakukan penukaran skema yang berbeza dan mengubah suai Parameter dan

struktur: 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})
    // ...
}

Jenis fungsi transformer kini diparameterkan dengan dua jenis parameter: E 和 S untuk jenis acara.
Parameter dan struktur storan data juga diparameterkan menggunakan dua jenis parameter yang sama E 的事件并返回类型为S.

Kaedah transformEvent DataStore kini menerima corak jenis

. Transformer 函数签名的新函数类型或实例，以及相应的事件和模式结构。您不会定义实现 Transformer 接口的新结构，因为 Transformer
Untuk mengendalikan lebih banyak corak, anda boleh menentukan objek yang mematuhi kini jenis fungsi dan bukannya antara muka. Oleh itu, anda boleh menentukan DataStorefungsi transformasi

dan struktur seni bina baharu tanpa mengubah suai 🎜 pelaksanaan sedia ada. 🎜

Atas ialah kandungan terperinci Refactor objek yang mengharapkan satu perkara dan mengharapkan banyak perkara. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!