/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Factory Method Pattern  Go 工厂方法模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/12 12:16
# User      :  geovindu
# Product   : GoLand
# Project   : sudydemo
# File      : jewelry.go
*/
package factorymethod

// Jewelry 珠宝产品接口
type Jewelry interface {
	// 核心属性
	GetMaterial() string // 获取材质
	GetWeight() float64  // 获取克重
	GetGem() string      // 获取宝石

	// 统一生产流程
	Design() // 设计
	Make()   // 制作
	Check()  // 质检
	Price()  // 定价
}





/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Factory Method Pattern  Go 工厂方法模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/12 12:16
# User      :  geovindu
# Product   : GoLand
# Project   : sudydemo
# File      : factory.go
*/
package factorymethod

// JewelryFactory 珠宝工厂接口
type JewelryFactory interface {
	CreateJewelry(material string, weight float64, gem string) Jewelry
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Factory Method Pattern  Go 工厂方法模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/12 12:17
# User      :  geovindu
# Product   : GoLand
# Project   : sudydemo
# File      : ring.go
*/
package factorymethod

import "fmt"

// Ring 戒指（具体产品）
type Ring struct {
	material string  // 材质
	weight   float64 // 克重
	gem      string  // 宝石
}

// 实现 Jewelry 接口的核心属性
func (r *Ring) GetMaterial() string { return r.material }
func (r *Ring) GetWeight() float64  { return r.weight }
func (r *Ring) GetGem() string      { return r.gem }

// 实现 Jewelry 接口的生产流程
func (r *Ring) Design() {
	fmt.Printf("【戒指】设计：%s材质，镶嵌%s\n", r.material, r.gem)
}

// 生产
func (r *Ring) Make() {
	fmt.Printf("【戒指】制作：%.2f克，打造戒托\n", r.weight)
}

// 选择
// @pagram
func (r *Ring) Check() {
	fmt.Println("【戒指】质检：尺寸、镶嵌、抛光合格")
}

// 价格
func (r *Ring) Price() {
	price := r.weight*500.0 + 2000.0 // 简化定价公式
	fmt.Printf("【戒指】定价：%.2f 元\n\n", price)
}

// RingFactory 戒指工厂（具体工厂）
type RingFactory struct{}

// 实现工厂接口，只生产戒指
// @Param material
// @Param weight
// @Param gem
// @Return ${return_types}
func (r *RingFactory) CreateJewelry(material string, weight float64, gem string) Jewelry {
	return &Ring{
		material: material,
		weight:   weight,
		gem:      gem,
	}
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Factory Method Pattern  Go 工厂方法模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/12 12:18
# User      :  geovindu
# Product   : GoLand
# Project   : sudydemo
# File      : necklace.go
*/
package factorymethod

import "fmt"

// Necklace 项链（具体产品）
type Necklace struct {
	material string
	weight   float64
	gem      string
}

// 核心属性实现
func (n *Necklace) GetMaterial() string { return n.material }
func (n *Necklace) GetWeight() float64  { return n.weight }
func (n *Necklace) GetGem() string      { return n.gem }

// 生产流程实现
func (n *Necklace) Design() {
	fmt.Printf("【项链】设计：%s材质，链条镶嵌%s\n", n.material, n.gem)
}

func (n *Necklace) Make() {
	fmt.Printf("【项链】制作：%.2f克，锻造链条+吊坠\n", n.weight)
}

func (n *Necklace) Check() {
	fmt.Println("【项链】质检：链条韧性、宝石牢固度合格")
}

func (n *Necklace) Price() {
	price := n.weight*480.0 + 1800.0
	fmt.Printf("【项链】定价：%.2f 元\n\n", price)
}

// NecklaceFactory 项链工厂
type NecklaceFactory struct{}

// 只生产项链
// @Param material
// @Param weight
// @Param gem
// @Return Necklace
func (n *NecklaceFactory) CreateJewelry(material string, weight float64, gem string) Jewelry {
	return &Necklace{
		material: material,
		weight:   weight,
		gem:      gem,
	}
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Factory Method Pattern  Go 工厂方法模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/12 12:18
# User      :  geovindu
# Product   : GoLand
# Project   : sudydemo
# File      : bracelet.go
*/
package factorymethod

import "fmt"

// Bracelet 手镯（具体产品）
type Bracelet struct {
	material string
	weight   float64
	gem      string
}

// 核心属性实现
func (b *Bracelet) GetMaterial() string { return b.material }
func (b *Bracelet) GetWeight() float64  { return b.weight }
func (b *Bracelet) GetGem() string      { return b.gem }

// 生产流程实现
// @Title 生产流程实现
// @Description ${user}
// @Author geovindu ${date} ${time}
// @Param name
// @Return string
func (b *Bracelet) Design() {
	fmt.Printf("【手镯】设计：%s材质，镯身镶嵌%s\n", b.material, b.gem)
}

// @Title 生产流程实现
// @Description ${user}
// @Author geovindu ${date} ${time}
// @Param name
// @Return string
func (b *Bracelet) Make() {
	fmt.Printf("【手镯】制作：%.2f克，弯曲成型+打磨\n", b.weight)
}

// @Title 生产流程实现
// @Description ${user}
// @Author geovindu ${date} ${time}
// @Param name
// @Return string
func (b *Bracelet) Check() {
	fmt.Println("【手镯】质检：弧度、舒适度、镶嵌合格")
}

// @Title 生产流程实现
// @Description ${user}
// @Author geovindu ${date} ${time}
// @Param name
// @Return string
func (b *Bracelet) Price() {
	price := b.weight*450.0 + 1500.0
	fmt.Printf("【手镯】定价：%.2f 元\n\n", price)
}

// BraceletFactory 手镯工厂
type BraceletFactory struct{}

// 只生产手镯
// @Title 生产流程实现 手镯
// @Description ${user}
// @Author geovindu ${date} ${time}
// @Param name
// @Return string
func (b *BraceletFactory) CreateJewelry(material string, weight float64, gem string) Jewelry {
	return &Bracelet{
		material: material,
		weight:   weight,
		gem:      gem,
	}
}　

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/12 18:56
# User      :  geovindu
# Product   : GoLand
# Project   : sudydemo
# File      : factorymethodbll.go
*/
package bll

import (
	"fmt"
	"sudydemo/factorymethod"
)

// 统一执行珠宝生产流程
func produceJewelry(f factorymethod.JewelryFactory, material string, weight float64, gem string) {
	jewelry := f.CreateJewelry(material, weight, gem)
	jewelry.Design()
	jewelry.Make()
	jewelry.Check()
	jewelry.Price()
}

// 显示示例
func FactoryMethodMain() {

	fmt.Println("===Factory Method Pattern工厂方法模式===")
	// 1. 戒指工厂生产钻戒
	ringFactory := &factorymethod.RingFactory{}
	produceJewelry(ringFactory, "铂金", 5.8, "钻石")

	// 2. 项链工厂生产宝石项链
	necklaceFactory := &factorymethod.NecklaceFactory{}
	produceJewelry(necklaceFactory, "黄金", 12.3, "红宝石")

	// 3. 手镯工厂生产翡翠手镯
	braceletFactory := &factorymethod.BraceletFactory{}
	produceJewelry(braceletFactory, "足银", 20.5, "翡翠")
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:37
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : jewelry.go
*/
package entity

// Jewelry 产品接口（工厂方法的 产品基类）
type Jewelry interface {
	// 生产流程
	//设计
	Design()
	//生产
	Make()
	//质检
	Check()
	//报价
	Price() float64

	// 属性
	//名称
	GetName() string
	//材质
	GetMaterial() string
	//重量
	GetWeight() float64
	//
	GetGem() string
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:37
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : factory.go
*/
package factory

import "godesginpattern/factorymethodone/app/entity"

// Factory 工厂方法核心接口
type Factory interface {
	Create(material string, weight float64, gem string) entity.Jewelry
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:38
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : ring_factory.go
*/
package factory

import (
	"fmt"
	"godesginpattern/factorymethodone/app/entity"
)

// Ring 戒指实体
type Ring struct {
	Material string
	Weight   float64
	Gem      string
}

func (r *Ring) GetName() string     { return "戒指" }
func (r *Ring) GetMaterial() string { return r.Material }
func (r *Ring) GetWeight() float64  { return r.Weight }
func (r *Ring) GetGem() string      { return r.Gem }

func (r *Ring) Design() {
	// 企业级：这里可写日志、埋点、事件...
	fmt.Printf("【戒指】设计：%s材质，镶嵌%s\n", r.Material, r.Gem)
}
func (r *Ring) Make() {
	fmt.Printf("【戒指】制作：%.2f克\n", r.Weight)

}
func (r *Ring) Check() {
	fmt.Println("【戒指】质检：尺寸、镶嵌、抛光合格")
}
func (r *Ring) Price() float64 {
	price := r.Weight*500 + 2000
	fmt.Printf("【戒指】价格：%.2f 元\n\n", price)
	return price
}

// === 工厂 ===
type RingFactory struct{}

func (r *RingFactory) Create(material string, weight float64, gem string) entity.Jewelry {
	return &Ring{
		Material: material,
		Weight:   weight,
		Gem:      gem,
	}
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:41
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : necklace_factory.go
*/
package factory

import (
	"fmt"
	"godesginpattern/factorymethodone/app/entity"
)

type Necklace struct {
	Material string
	Weight   float64
	Gem      string
}

func (n *Necklace) Design() {
	fmt.Printf("【项链】设计：%s材质，镶嵌%s\n", n.Material, n.Gem)
}
func (n *Necklace) Make() {
	fmt.Printf("【项链】制作：%.2f克\n", n.Weight)
}
func (n *Necklace) Check() {
	fmt.Println("【项链】质检：链条韧性、宝石牢固度合格")
}
func (n *Necklace) Price() float64 {
	price := n.Weight*480 + 1800
	fmt.Printf("【项链】价格：%.2f 元\n\n", price)
	return price
}

func (n *Necklace) GetName() string     { return "项链" }
func (n *Necklace) GetMaterial() string { return n.Material }
func (n *Necklace) GetWeight() float64  { return n.Weight }
func (n *Necklace) GetGem() string      { return n.Gem }

type NecklaceFactory struct{}

func (n *NecklaceFactory) Create(material string, weight float64, gem string) entity.Jewelry {
	return &Necklace{material, weight, gem}
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:41
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : bracelet_factory.go
*/
package factory

import (
	"fmt"
	"godesginpattern/factorymethodone/app/entity"
)

type Bracelet struct {
	Material string
	Weight   float64
	Gem      string
}

func (b *Bracelet) Design() {
	fmt.Printf("【手镯】设计：%s材质，镶嵌%s\n", b.Material, b.Gem)
}
func (b *Bracelet) Make() {
	fmt.Printf("【手镯】制作：%.2f克\n", b.Weight)
}
func (b *Bracelet) Check() {
	fmt.Println("【手镯】质检：弧度、舒适度、镶嵌合格")
}
func (b *Bracelet) Price() float64 {
	price := b.Weight*450 + 1500
	fmt.Printf("【手镯】价格：%.2f 元\n\n", price)
	return price
}
func (b *Bracelet) GetName() string     { return "手镯" }
func (b *Bracelet) GetMaterial() string { return b.Material }
func (b *Bracelet) GetWeight() float64  { return b.Weight }
func (b *Bracelet) GetGem() string      { return b.Gem }

type BraceletFactory struct{}

func (b *BraceletFactory) Create(material string, weight float64, gem string) entity.Jewelry {
	return &Bracelet{material, weight, gem}
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:42
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : jewelry_service.go
*/
package service

import (
	"godesginpattern/factorymethodone/app/entity"
	"godesginpattern/factorymethodone/factory"
)

type JewelryService struct{}

// Produce 统一生产流程
func (s *JewelryService) Produce(f factory.Factory, material string, weight float64, gem string) entity.Jewelry {
	// 工厂创建产品
	j := f.Create(material, weight, gem)

	// 标准业务流程
	j.Design()
	j.Make()
	j.Check()
	j.Price()

	return j
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/18 22:42
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : jewelry_api.go
*/
package api

import (
	"godesginpattern/factorymethodone/app/entity"
	"godesginpattern/factorymethodone/factory"
	"godesginpattern/factorymethodone/service"
)

type JewelryAPI struct {
	Service *service.JewelryService
}

func NewJewelryAPI() *JewelryAPI {
	return &JewelryAPI{
		Service: &service.JewelryService{},
	}
}

// 生产戒指
func (j *JewelryAPI) MakeRing(material string, weight float64, gem string) entity.Jewelry {
	return j.Service.Produce(&factory.RingFactory{}, material, weight, gem)
}

// 生产项链
func (j *JewelryAPI) MakeNecklace(material string, weight float64, gem string) entity.Jewelry {
	return j.Service.Produce(&factory.NecklaceFactory{}, material, weight, gem)
}

// 生产手镯
func (j *JewelryAPI) MakeBracelet(material string, weight float64, gem string) entity.Jewelry {
	return j.Service.Produce(&factory.BraceletFactory{}, material, weight, gem)
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/12 18:56
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : factorymethodbll.go
jewelry-app/
├── go.mod            // 模块文件（自动生成）
├── main.go           // 程序入口（调用包）
└── jewelry/          // 珠宝工厂包（全部封装在这里）

	├── jewelry.go    // 产品接口
	├── factory.go    // 工厂接口
	├── ring.go       // 戒指产品+工厂
	├── necklace.go   // 项链产品+工厂
	└── bracelet.go   // 手镯产品+工厂

2.
jewelry-app/
├── go.mod
├── main.go                     // 入口（路由/启动）
├── app/
│   └── entity/                 // 实体层（模型定义）
│       └── jewelry.go          // 珠宝接口 & 模型
├── factory/                    // 工厂层（核心：工厂方法）
│   ├── factory.go              // 工厂接口
│   ├── ring_factory.go         // 戒指工厂
│   ├── necklace_factory.go     // 项链工厂
│   └── bracelet_factory.go     // 手镯工厂
├── service/                    // 业务逻辑层（Service）
│   └── jewelry_service.go      // 统一生产服务
└── api/                        // 接口层（对外提供调用）

	└── jewelry_api.go
*/

package bll

import (
	"fmt"
	"godesginpattern/factorymethodone/api"
)

func FactoryMethodMain() {
	// 初始化接口层
	jAPI := api.NewJewelryAPI()

	// 生产钻戒
	ring := jAPI.MakeRing("铂金", 5.8, "钻石")
	fmt.Printf("生产 %s 成功，价格：%.2f\n", ring.GetName(), ring.Price())

	// 生产项链
	necklace := jAPI.MakeNecklace("黄金", 12.3, "红宝石")
	fmt.Printf("生产 %s 成功，价格：%.2f\n", necklace.GetName(), necklace.Price())

	// 生产手镯
	bracelet := jAPI.MakeBracelet("足银", 20.5, "翡翠")
	fmt.Printf("生产 %s 成功，价格：%.2f\n", bracelet.GetName(), bracelet.Price())
}