Refactoriser un objet qui attend une chose et attend beaucoup de choses

éditeur php Yuzai En programmation, nous rencontrons souvent des situations où un objet veut assumer de multiples responsabilités. Ce type d'objet est appelé "refactoriser un objet qui attend une chose et attend beaucoup de choses". De tels objets conduisent généralement à un code volumineux, à un couplage élevé et à des difficultés de maintenance et d'extension. Dans cet article, nous explorerons comment refactoriser un tel objet pour le rendre plus clair, plus flexible et plus facile à maintenir. Nous allons jeter un coup d'oeil!

Contenu de la question

Je travaille sur la mise à jour de la base de code Go. Notre société dispose d'un magasin de données central, appelé fictivement DataStore, dans lequel vous pouvez publier et lire à partir de divers ensembles de données ou schémas. Notre base de code particulière contient du code qui couple des ensembles de données/schémas spécifiques à l'implémentation DataStore. Je dois refactoriser ce code pour pouvoir écrire dans d'autres ensembles de données (éventuellement plus).

Dans le code ci-dessous, dataStoreSchema représente un seul schéma, comme les données « Clients ». Mais j'ai d'autres schémas comme "Commandes", ou tout autre schéma comportant différents champs dans lesquels je souhaite écrire.

transformEvent prend les données qui seront transmises à transformEvent 获取将传递到 DataStore 的数据，并执行一些逻辑来创建 dataStoreSchema et exécute une certaine logique pour créer l'objet

, puis l'écrit dans le DataStore réel dans le cloud.

Je souhaite écrire potentiellement sur n'importe quel

schéma de la banque de données, pas seulement sur le schéma auquel cette implémentation est couplée.

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

Le comportement actuel est le suivant

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

Mais je veux pouvoir faire quelque chose comme ça

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

Ou tout ce qui a le plus de sens en termes Go

Solution de contournement

dataStoreSchema 结构和 transformEvent 方法与特定模式紧密耦合。 transformEvent 方法接受输入并将其转换为 dataStoreSchemaSi je comprends bien, votre implémentation actuelle est étroitement couplée à un mode spécifique via la structure

et la méthode transformEvent. La méthode transformEvent accepte les entrées et les convertit en un objet

, qui est ensuite écrit dans le DataStore.

Vous souhaiterez peut-être écrire dans n'importe quel schéma de votre magasin de données, pas seulement celui auquel votre implémentation actuelle est couplée. DataStore 客户端，每个客户端与不同的 schema 和相应的转换函数相关联（transformEvent1、transformEvent2、transformEvent3

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

Signification : Vous souhaitez créer un différent DataStore).

Cela devrait signifier découpler la logique de conversion de la structure

, permettant d'utiliser différentes fonctions de conversion pour gérer différents modes. Parameters 和 DataStore

Vous pouvez utiliser des interfaces pour effectuer différentes conversions de schéma et modifier les Paramètres et les

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

Les types de fonctions Transformer sont désormais paramétrés avec deux paramètres de type : E 和 S pour les types d'événements.
Les paramètres et les structures de stockage de données sont également paramétrés en utilisant les deux mêmes paramètres de type E 的事件并返回类型为S.

La méthode transformEvent de DataStore accepte désormais les modèles de type

. Transformer 函数签名的新函数类型或实例，以及相应的事件和模式结构。您不会定义实现 Transformer 接口的新结构，因为 Transformer
Pour gérer plus de modèles, vous pouvez définir des objets conformes aux désormais types de fonctions au lieu d'interfaces. Par conséquent, vous pouvez définir de nouvelles DataStorefonctions de transformation

et structures architecturales sans modifier les 🎜 implémentations existantes. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!