go: Generators Pattern

项目结构：

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Generators Pattern 生成器模式
# 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/6/14 21:30
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : lang.go
*/
package common

type Language string

const (
	ZH Language = "zh"
	EN Language = "en"
)



/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Generators Pattern 生成器模式
# 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/6/14 21:31
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : req_type.go
*/
package common

type RequestType string

const (
	Procurement  RequestType = "procurement"
	Production   RequestType = "production"
	QualityCheck RequestType = "quality_check"
	Sales        RequestType = "sales"
	AfterSales   RequestType = "after_sales"
	Inventory    RequestType = "inventory"
)

// GetDisplayName 获取多语言名称（关键：纯中文/纯英文）
func (r RequestType) GetDisplayName(lang Language) string {
	m := map[Language]map[RequestType]string{
		ZH: {
			Procurement:  "原料采购",
			Production:   "首饰加工",
			QualityCheck: "品质检验",
			Sales:        "销售订单",
			AfterSales:   "售后维保",
			Inventory:    "库存管理",
		},
		EN: {
			Procurement:  "Procurement",
			Production:   "Production",
			QualityCheck: "Quality Check",
			Sales:        "Sales",
			AfterSales:   "After Sales",
			Inventory:    "Inventory",
		},
	}
	return m[lang][r]
}



/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Generators Pattern 生成器模式
# 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/6/14 21:32
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : zh].go
*/
package i18n

import "godesginpattern/generators/common"

func InitZH() {
	Messages[common.ZH] = map[string]string{
		"title":         "===== 企业级珠宝业务系统 - 生成器模式并发处理 =====",
		"procurement":   "已处理：{material} 询价，报价：{price}/克",
		"production":    "已接收：{product}，工期：{days} 天",
		"quality_check": "{product}：钻石等级 {grade}，合格✅",
		"sales":         "{product} 已下单，会员：{member}",
		"after_sales":   "{service} 已受理，取件时间：3天后",
		"inventory":     "{warehouse} 库存：{stock} 件",
		"unsupported":   "不支持的请求类型",
		"error":         "处理失败：{err}",

		// 动态数据翻译
		"999黄金":    "999黄金",
		"18K金钻石戒指": "18K金钻石戒指",
		"50分钻戒":    "50分钻戒",
		"古法黄金手镯":   "古法黄金手镯",
		"钻戒改圈口":    "钻戒改圈口",
		"上海总仓":     "上海总仓",
	}
}



/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Generators Pattern 生成器模式
# 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/6/14 21:33
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : en.go
*/
package i18n

import "godesginpattern/generators/common"

func InitEN() {
	Messages[common.EN] = map[string]string{
		"title":         "===== Enterprise Jewelry System - Generator Pattern Processing =====",
		"procurement":   "Processed: {material} inquiry, price: {price}/g",
		"production":    "Accepted: {product}, lead time: {days} days",
		"quality_check": "{product}: Diamond grade {grade}, Passed✅",
		"sales":         "{product} ordered, member: {member}",
		"after_sales":   "{service} accepted, ready in 3 days",
		"inventory":     "{warehouse} stock: {stock} pcs",
		"unsupported":   "Unsupported request type",
		"error":         "Processing error: {err}",

		// 动态数据翻译
		"999黄金":    "999 Gold",
		"18K金钻石戒指": "18K Gold Diamond Ring",
		"50分钻戒":    "0.5ct Diamond Ring",
		"古法黄金手镯":   "Ancient Gold Bracelet",
		"钻戒改圈口":    "Ring Resizing",
		"上海总仓":     "Shanghai Main Warehouse",
	}
}



/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Generators Pattern 生成器模式
# 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/6/14 21:33
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : i18n.go
*/
package i18n

import (
	"godesginpattern/generators/common"
	"strings"
)

var Messages = map[common.Language]map[string]string{}

// GetMessage 获取多语言文案 + 自动替换参数
func GetMessage(lang common.Language, key string, args map[string]interface{}) string {
	msg := Messages[lang][key]

	// 动态参数翻译（关键：无中文混杂）
	for k, v := range args {
		val, ok := v.(string)
		if ok {
			transVal := Messages[lang][val]
			if transVal != "" {
				val = transVal
			}
			msg = strings.ReplaceAll(msg, "{"+k+"}", val)
		}
	}
	return msg
}

　　

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Generators Pattern 生成器模式
# 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/6/14 21:34
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : registry.go
*/
package service

import (
	"godesginpattern/generators/common"
	"godesginpattern/generators/i18n"
)

type HandlerFunc func(data map[string]interface{}, lang common.Language) string

// HandlerRegistry 处理器注册表
var HandlerRegistry = map[common.RequestType]HandlerFunc{}

// Register 注册处理器
func Register(t common.RequestType, fn HandlerFunc) {
	HandlerRegistry[t] = fn
}

// 统一处理器模板
func createHandler(msgKey string) HandlerFunc {
	return func(data map[string]interface{}, lang common.Language) string {
		return i18n.GetMessage(lang, msgKey, data)
	}
}



/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Generators Pattern 生成器模式
# 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/6/14 21:35
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : handlers.go
*/
package handlers

import (
	"godesginpattern/generators/common"
	"godesginpattern/generators/service"
)

// RegisterAll 注册所有业务处理器
func RegisterAll() {
	service.Register(common.Procurement, createHandler("procurement"))
	service.Register(common.Production, createHandler("production"))
	service.Register(common.QualityCheck, createHandler("quality_check"))
	service.Register(common.Sales, createHandler("sales"))
	service.Register(common.AfterSales, createHandler("after_sales"))
	service.Register(common.Inventory, createHandler("inventory"))
}

func createHandler(key string) service.HandlerFunc {
	return func(data map[string]interface{}, lang common.Language) string {
		return service.GetMsg(lang, key, data)
	}
}



/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Generators Pattern 生成器模式
# 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/6/14 21:36
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : generator.go
*/
package service

import (
	"godesginpattern/generators/common"
	"godesginpattern/generators/i18n"
)

// Request 请求结构
type Request struct {
	ReqType common.RequestType
	Data    map[string]interface{}
	Lang    common.Language
}

// Response 响应结构
type Response struct {
	ReqType     string
	DisplayName string
	Result      string
	Success     bool
}

// Dispatch 生成器分发：核心 = 解复用并发请求 + 分发到处理器
func Dispatch(reqs []Request) []Response {
	var resps []Response

	for _, req := range reqs {
		handler, exists := HandlerRegistry[req.ReqType]
		if !exists {
			resps = append(resps, Response{
				ReqType:     string(req.ReqType),
				DisplayName: req.ReqType.GetDisplayName(req.Lang),
				Result:      i18n.GetMessage(req.Lang, "unsupported", nil),
				Success:     false,
			})
			continue
		}

		result := handler(req.Data, req.Lang)
		resps = append(resps, Response{
			ReqType:     string(req.ReqType),
			DisplayName: req.ReqType.GetDisplayName(req.Lang),
			Result:      result,
			Success:     true,
		})
	}
	return resps
}

func GetMsg(lang common.Language, key string, args map[string]interface{}) string {
	return i18n.GetMessage(lang, key, args)
}

　　

调用：

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Generators Pattern 生成器模式
# 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/6/14 21:37
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : generatorsbll.go
*/
package bll

import (
	"fmt"
	"godesginpattern/generators/common"
	"godesginpattern/generators/i18n"
	"godesginpattern/generators/service"
	"godesginpattern/generators/service/handlers"
)

func GeneratorsMain() {
	// ====================== 切换语言 ======================
	lang := common.EN // 纯英文
	// lang := common.ZH // 纯中文

	// 初始化多语言
	i18n.InitZH()
	i18n.InitEN()

	// 注册所有处理器
	handlers.RegisterAll()

	// 打印标题
	fmt.Println(i18n.GetMessage(lang, "title", nil))

	// 构造请求（和 Python 版完全一致）
	reqs := []service.Request{
		{
			ReqType: common.Procurement,
			Data:    map[string]interface{}{"material": "999黄金", "price": 628},
			Lang:    lang,
		},
		{
			ReqType: common.Production,
			Data:    map[string]interface{}{"product": "18K金钻石戒指", "days": 7},
			Lang:    lang,
		},
		{
			ReqType: common.QualityCheck,
			Data:    map[string]interface{}{"product": "50分钻戒", "grade": "VS1/D"},
			Lang:    lang,
		},
		{
			ReqType: common.Sales,
			Data:    map[string]interface{}{"product": "古法黄金手镯", "member": "VIP888"},
			Lang:    lang,
		},
		{
			ReqType: common.AfterSales,
			Data:    map[string]interface{}{"service": "钻戒改圈口"},
			Lang:    lang,
		},
		{
			ReqType: common.Inventory,
			Data:    map[string]interface{}{"warehouse": "上海总仓", "stock": 126},
			Lang:    lang,
		},
	}

	// 生成器分发处理
	resps := service.Dispatch(reqs)

	// 输出结果
	for _, resp := range resps {
		mark := "✅"
		if !resp.Success {
			mark = "❌"
		}
		fmt.Printf("%s [%-14s] %s\n", mark, resp.DisplayName, resp.Result)
	}
}

　　

输出：