PrototypePra原型_设计订单保存
PrototypePra原型_设计订单保存
通过克隆实现新实例
需求
- 有一个文件保存系统
- 订单分为两个，一个是个人订单，一个是公司订单
- 保存订单时候，需要按照订单分类，数量大于1000的就要重新拆分
没涉及模式的实现
// 实现个人订单超过1000的拆分
// 公司名单也是
package main
import "fmt"
type Order interface {
getOrderName() string
getNum() int
setNum(n int)
}
type OrderSave interface {
saveOrder(order Order)
}
// 订单处理系统
type OsOrder struct {
name string
maxCount int
}
func NewOsOrder(max int) *OsOrder {
return &OsOrder{name: "订单处理系统", maxCount: max}
}
func (oo *OsOrder) saveOrder(order Order) {
for order.getNum() > oo.maxCount {
// 判断订单类型，继续创建新的
if order.getOrderName() == "个人订单" {
order.setNum(order.getNum() - oo.maxCount)
fmt.Println(order.getOrderName(), "被处理1000")
}
if order.getOrderName() == "公司订单" {
order.setNum(order.getNum() - oo.maxCount)
fmt.Println(order.getOrderName(), "被处理1000")
}
}
fmt.Println(order.getOrderName(), "被处理最后一点完毕", order.getNum())
}
type CompanyOrder struct {
name string
num int
}
func NewCompanyOrder(n int) *CompanyOrder {
return &CompanyOrder{
name: "公司订单",
num: n,
}
}
func (co *CompanyOrder) setNum(n int) {
co.num = n
}
func (co *CompanyOrder) getOrderName() string {
return co.name
}
func (co *CompanyOrder) getNum() int {
return co.num
}
type PersonOrder struct {
name string
num int
}
func NewPersonOrder(n int) *PersonOrder {
return &PersonOrder{
name: "个人订单",
num: n,
}
}
func (po *PersonOrder) setNum(n int) {
po.num = n
}
func (po *PersonOrder) getOrderName() string {
return po.name
}
func (po *PersonOrder) getNum() int {
return po.num
}
func main() {
osOrder := NewOsOrder(1000)
personOrder := NewPersonOrder(5050)
companyOrder := NewCompanyOrder(5006)
osOrder.saveOrder(personOrder)
osOrder.saveOrder(companyOrder)
}
# 输出
个人订单 被处理1000
个人订单 被处理1000
个人订单 被处理1000
个人订单 被处理1000
个人订单 被处理1000
个人订单 被处理最后一点完毕 50
公司订单 被处理1000
公司订单 被处理1000
公司订单 被处理1000
公司订单 被处理1000
公司订单 被处理1000
公司订单 被处理最后一点完毕 6
痛点
假如假如更多订单类型，没办法拓展
func (oo *OsOrder) saveOrder(order Order) {
for order.getNum() > oo.maxCount {
// 判断订单类型，继续创建新的
if order.getOrderName() == "个人订单" {
order.setNum(order.getNum() - oo.maxCount)
fmt.Println(order.getOrderName(), "被处理1000")
}
if order.getOrderName() == "公司订单" {
order.setNum(order.getNum() - oo.maxCount)
fmt.Println(order.getOrderName(), "被处理1000")
}
}
fmt.Println(order.getOrderName(), "被处理最后一点完毕", order.getNum())
}
原型涉及模式解决
// 实现个人订单超过1000的拆分
// 公司名单也是
package main
import "fmt"
type Order interface {
getOrderName() string
getNum() int
setNum(n int)
clone() Order
}
type OrderSave interface {
saveOrder(order Order)
}
// 订单处理系统
type OsOrder struct {
name string
maxCount int
}
func NewOsOrder(max int) *OsOrder {
return &OsOrder{name: "订单处理系统", maxCount: max}
}
func (oo *OsOrder) saveOrder(order Order) {
for order.getNum() > oo.maxCount {
// 判断订单类型，继续创建新的
clone := order.clone()
clone.setNum(oo.maxCount)
fmt.Println("拆分的订单保存", clone.getNum())
order.setNum(order.getNum() - oo.maxCount)
}
fmt.Println(order.getOrderName(), "被处理最后一点完毕", order.getNum())
}
type CompanyOrder struct {
name string
num int
}
func NewCompanyOrder(n int) *CompanyOrder {
return &CompanyOrder{
name: "公司订单",
num: n,
}
}
func (co *CompanyOrder) clone() Order {
return NewCompanyOrder(co.getNum())
}
func (co *CompanyOrder) setNum(n int) {
co.num = n
}
func (co *CompanyOrder) getOrderName() string {
return co.name
}
func (co *CompanyOrder) getNum() int {
return co.num
}
type PersonOrder struct {
name string
num int
}
func NewPersonOrder(n int) *PersonOrder {
return &PersonOrder{
name: "个人订单",
num: n,
}
}
func (po *PersonOrder) clone() Order {
return NewPersonOrder(po.getNum())
}
func (po *PersonOrder) setNum(n int) {
po.num = n
}
func (po *PersonOrder) getOrderName() string {
return po.name
}
func (po *PersonOrder) getNum() int {
return po.num
}
func main() {
osOrder := NewOsOrder(1000)
personOrder := NewPersonOrder(1050)
companyOrder := NewCompanyOrder(5006)
osOrder.saveOrder(personOrder)
osOrder.saveOrder(companyOrder)
}
# 输出
拆分的订单保存 1000
个人订单 被处理最后一点完毕 50
拆分的订单保存 1000
拆分的订单保存 1000
拆分的订单保存 1000
拆分的订单保存 1000
拆分的订单保存 1000
公司订单 被处理最后一点完毕 6
