So rufen Sie ein Strategiemuster basierend auf dem eingehenden Typ auf

php-Editor Youzi zeigt Ihnen, wie Sie das Strategiemuster basierend auf dem eingehenden Typ aufrufen. Das Strategiemuster ist ein objektorientiertes Entwurfsmuster, das die Auswahl unterschiedlicher Algorithmen oder Strategien je nach Situation ermöglicht. In der tatsächlichen Entwicklung müssen wir häufig unterschiedliche Vorgänge basierend auf unterschiedlichen Typen ausführen. Durch die Verwendung des Strategiemusters können wir diese verschiedenen Operationen in verschiedene Strategieklassen kapseln und die entsprechenden Strategien basierend auf den eingehenden Typen aufrufen, um eine flexible Logiksteuerung zu erreichen. Als nächstes werden wir detailliert beschreiben, wie das Strategiemuster in PHP verwendet wird, um die entsprechende Strategie basierend auf dem eingehenden Typ aufzurufen.

Frageninhalt

Ich habe zwei Strategien. Basierend auf den angeforderten Daten möchte ich meine gewünschte Strategie aufrufen und die Aktion in einer Zeile ausführen. Wie kann ich dieses Ziel erreichen? Mein Code sieht bisher so aus

package strategy

type strategy interface {
    distribute(request model.routerequest) (*model.distributeresponse, error)
    getstrategytype() int
}

package strategy

type strategy interface {
    distribute(request model.routerequest) (*model.distributeresponse, error)
    getstrategytype() int
}

package strategies

import (
    "github.com/x/internal/enum"
    "github.com/x/internal/model"
    "github.com/x/internal/repository"
)

type distributebranchstrategy struct {
    repo repository.repository
}

func newdistributebranchstrategy(repo repository.repository) *distributebranchstrategy {
    return &distributebranchstrategy{
        repo: repo,
    }
}

func (d *distributebranchstrategy) distribute(request model.routerequest) (*model.distributeresponse, error) {
    return nil, nil
}

func (d *distributebranchstrategy) getstrategytype() int {
    return enum.branch
}

package strategies

import (
    "github.com/x/internal/enum"
    "github.com/x/internal/model"
    "github.com/x/internal/repository"
)

type distributetransfercenterstrategy struct {
    repo repository.repository
}

func newdistributetransfercenterstrategy(repo repository.repository) *distributetransfercenterstrategy {
    return &distributetransfercenterstrategy{
        repo: repo,
    }
}

func (d *distributetransfercenterstrategy) distribute(request model.routerequest) (*model.distributeresponse, error) {
    return nil, nil
}

func (d *distributetransfercenterstrategy) getstrategytype() int {
    return enum.transfer_center
}

Meine Leistungen:

package service

import (
    "github.com/x/internal/model"
    "github.com/x/internal/repository"
    "github.com/x/internal/strategy/strategies"
)

type DistributeService struct {
    repo                     repository.Repository
    distributeBranchStrategy strategies.DistributeBranchStrategy
}

type Distribute interface {
    Distribute(vehicleNumberPlate string, request model.DistributeRequest) *model.DistributeResponse
}

func NewDistributeService(repo repository.Repository, strategy strategies.DistributeBranchStrategy) *DistributeService {
    return &DistributeService{
        repo:                     repo,
        distributeBranchStrategy: strategy,
    }
}

func (d *DistributeService) Distribute(vehicleNumberPlate string, request model.DistributeRequest) *model.DistributeResponse {
    // TODO: Implement this method
    for _, x := range request.RouteRequest {
        d.distributeBranchStrategy.Distribute(x)
    }

    return nil
}

Vor ein paar Jahren habe ich eine Operation mit make[] durchgeführt. Ich konnte die entsprechende Richtlinie erstellen und Aktionen basierend auf den Parametern in der Anfrage ausführen, indem ich sie mit der Aufzählung abgleichte. Ich kann mich jetzt nicht daran erinnern und kann im Internet keine Beispiele finden. Kannst du mir helfen?

Workaround

Sie können alle verfügbaren Strategien in die Karte einfügen:

var strategies = map[int]func(repository.repository) strategy {
   enum.branch: func(repo repository.repository) strategy {
      return newdistributebranchstrategy(repo)
   },
   ...
}

Dann rufen Sie an:

s, ok: = strategies[x]
if !ok {
  // error
}
s(repo).Distribute(...)

Das obige ist der detaillierte Inhalt vonSo rufen Sie ein Strategiemuster basierend auf dem eingehenden Typ auf. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!