GO orienté objet (étant un expert CRUD) trois : cas implémentation orientée objet

Code:

package domain

// 价格计算器接口
type ItemPriceCalculator interface {
   Price() int
}

type Items []*Item

// 基类商品
type Item struct {
   ID       int
   Category int
   Title    string
   Stock    int

   PriceMarket int
}

func (dom *Item) OfInstance() interface{} {
   switch dom.Category {
   case ItemCategoryRebate:
      return dom.OfInstanceRebate()
   case ItemCategoryDiscount:
      return dom.OfInstanceDiscount()
   }

   return nil
}

// 折扣商品
type ItemDiscount struct {
   *Item
}

// 实现价格计算器接口 封装变化
func (dom *ItemDiscount) Price() int {
   return dom.PriceMarket / 2
}

// 返利商品
type ItemRebate struct {
   *Item
}

// 实现价格计算器接口 封装变化
func (dom *ItemRebate) Price() int {
   return dom.PriceMarket
}

response模型： 
package response

type Item struct {
   ID          int    `json:"id"`
   Category    int    `json:"category"`
   Title       string `json:"title"`
   Stock       int    `json:"stock"`
   PriceMarket int    `json:"priceMarket"`
   Price       int    `json:"price"`
}

func (resp *Item) Mapping(dom *domain.Item) {
   resp.ID = dom.ID
   resp.Category = dom.Category
   resp.Title = dom.Title
   resp.Stock = dom.Stock
   resp.PriceMarket = dom.PriceMarket

   instance := dom.OfInstance()
   // 断言计算价格 针对接口（或抽象）编程，而不是针对细节（或实现）编程
   if priceCalculator, ok := instance.(domain.ItemPriceCalculator); ok {
      resp.Price = priceCalculator.Price()
   }
}

Analyse de code : ajout de l'interface ItemPriceCalculator. Le produit de remise ItemRebate et le produit de remise ItemDiscount implémentent l'interface ItemPriceCalculator via leur propre fonction Price et calculent le prix du produit via l'interface d'assertion lors de la conversion des données.

Orienté processus vs orienté objet :

	Variété	ciblé	Code intuitif
orienté processus	sinon changement fractionné	pour les détails	Intuitif et facile à comprendre
orienté objet	Modifications de l'isolation de la hiérarchie des classes	pour l'interface	Résumé difficile à comprendre

Pensée : Orientée processus, un problème qui peut être résolu par if else, la méthode orientée objet ajoute une classe d'interface et deux objets, est-ce rentable ?

Nous mettrons ensuite en œuvre le calcul du montant de la remise et déterminerons si le prix du marché initial est masqué.

package domain

// 返利计算器接口
type ItemRebateCalculator interface {
   Rebate() *int
}

// 市场价是否显示接口
type ItemPriceMarketDisplay interface {
   PriceMarketDisplay() bool
}

// 实现返利计算器接口 封装变化
func (dom *ItemRebate) Rebate() *int {
   rebate := dom.PriceMarket * 5 / 100
   return &rebate
}

// 实现市场价显示接口 封装变化
func (dom *ItemRebate) PriceMarketDisplay() bool {
   return true
}


package response

// 断言计算返利
if rebateCalculator, ok := instance.(domain.ItemRebateCalculator); ok {
   resp.Rebate = rebateCalculator.Rebate()
}

// 断言市场价是否显示
if rebateCalculator, ok := instance.(domain.ItemPriceMarketDisplay); ok {
   resp.PriceMarketHidden = rebateCalculator.PriceMarketDisplay()
}

Lien source