重构一个期望一件事期望很多事情的对象

php小编鱼仔在编程中，我们经常会遇到一个对象希望承担多个职责的情况。这种对象被称为"重构一个期望一件事期望很多事情的对象"。这样的对象通常会导致代码臃肿、耦合度高，难以维护和扩展。在这篇文章中，我们将探讨如何重构这样的对象，使其更加清晰、灵活和易于维护。让我们一起来看看吧！

问题内容

我正在努力更新 Go 代码库。我们公司有一个中央数据存储，虚构地称为 DataStore，您可以将其发布到各种数据集或模式或从中读取。我们特定的代码库有一些代码将特定的数据集/模式耦合到 DataStore 实现。我需要重构此代码以能够写入其他（可能还有更多）数据集。

在下面的代码中，dataStoreSchema 表示单个架构，例如“Customers”数据。但我有其他模式，例如“订单”，或者任何具有我想要写入的不同字段的模式。

transformEvent 获取将传递到 DataStore 的数据，并执行一些逻辑来创建 dataStoreSchema 对象，然后将其写入云中的实际 DataStore。

我想写入数据存储上的潜在任何模式，而不仅仅是该实现所耦合的模式。

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

现在的行为是这样的

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

但我希望能够做这样的事情

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

或者任何 Go 术语中最有意义的内容

解决方法

如果我理解正确，您当前的实现通过 dataStoreSchema 结构和 transformEvent 方法与特定模式紧密耦合。 transformEvent 方法接受输入并将其转换为 dataStoreSchema 对象，然后将其写入 DataStore。

您可能希望写入数据存储上的任何模式，而不仅仅是当前实现所耦合的模式。

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

含义：您想要创建不同的 DataStore 客户端，每个客户端与不同的 schema 和相应的转换函数相关联（transformEvent1、transformEvent2、transformEvent3）。
这应该意味着将转换逻辑与 DataStore 结构解耦，允许使用不同的转换函数处理不同的模式。

您可以使用接口进行不同的架构转换并修改 Parameters 和 DataStore 结构：

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: ¶ms}, 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 函数类型现在使用两个类型参数进行参数化：用于事件类型的 E 和用于架构类型的 S。
参数和数据存储结构也使用相同的两个类型参数 E 和 S 进行参数化。
DataStore 的transformEvent 方法现在接受类型为E 的事件并返回类型为S 的模式。

要处理更多模式，您可以定义符合 Transformer 函数签名的新函数类型或实例，以及相应的事件和模式结构。您不会定义实现 Transformer 接口的新结构，因为 Transformer 现在是函数类型，而不是接口。
因此，您可以通过定义新的 转换函数和架构结构，无需修改现有的 DataStore 实现。

以上就是重构一个期望一件事期望很多事情的对象的详细内容，更多请关注编程网其它相关文章！