设计模式案例(二)

案例(二)"/>

设计模式案例(二)

系列文章目录

第一章 设计模式案例 (一)
第一章 设计模式案例 （二)

文章目录

• 系列文章目录
• 前言
• 一、责任链模式
• • case 包
• 二、策略模式
• • case 包
• 三、工厂模式
• • case 包

前言

上一篇文章介绍了常用的几种设计模式和常用场景，便于对设计模式加深理解，此文章主要讲解设计模式的案例。

一、责任链模式

case 包

代码如下（示例）：

package _case
import "fmt"
func DutyCase() {pm := &ProjectManager{}dm := &DepartmentManager{}gm := &GeneralManager{}pm.SetNext(dm).SetNext(gm)pm.Handle("张三", 300)pm.Handle("李四", 800)pm.Handle("王五", 1800)
}
type Handler interface {SetNext(h Handler) HandlerHandle(user string, amount int64)
}
// 项目经理
type ProjectManager struct {next Handler
}
func (pm *ProjectManager) Handle(user string, amount int64) {if amount <= 500 {fmt.Printf("%s 申请聚餐费用 %d 元，项目经理审批通过\n", user, amount)return}// 项目经理没有权限，交给下一个人处理pm.next.Handle(user, amount)
}
func (pm *ProjectManager) SetNext(h Handler) Handler {pm.next = hreturn h
}
// 部门经理
type DepartmentManager struct {next Handler
}
func (dm *DepartmentManager) Handle(user string, amount int64) {if amount > 500 && amount <= 1000 {fmt.Printf("%s 申请聚餐费用 %d 元，部门经理审批通过\n", user, amount)return} else if amount > 1000 {fmt.Printf("%s 申请聚餐费用 %d 元，部门经理审批通过，总经理加签\n", user, amount)dm.next.Handle(user, amount)} else {dm.next.Handle(user, amount)}
}
func (dm *DepartmentManager) SetNext(h Handler) Handler {dm.next = hreturn h
}
// 总经理
type GeneralManager struct {next Handler
}
func (gm *GeneralManager) Handle(user string, amount int64) {if amount > 1000 {fmt.Printf("%s 申请聚餐费用 %d 元，总经理审批通过\n", user, amount)return}gm.next.Handle(user, amount)
}
func (gm *GeneralManager) SetNext(h Handler) Handler {gm.next = hreturn h
}

代码如下（示例）：main

package main
import _case "design-pattern/duty/case"
func main() {_case.DutyCase()
}

二、策略模式

case 包

代码如下（示例）：

package _caseimport "fmt"func StrategyCase() {arr := []int{1, 3, 8, 2, 4, 5}arr1 := []int{5, 2, 4, 6, 9, 8}ctx := &Context{}//设置排序策略- 冒泡算法ctx.SetStrategy(&bubble{})ctx.ExecuteStrategy(arr)fmt.Println(arr)//设置排序策略-选择策略ctx.SetStrategy(&selection{})ctx.ExecuteStrategy(arr1)fmt.Println(arr1)
}// 排序策略定义
type SortStrategy interface {Sort(arr []int)
}// 冒泡排序
type bubble struct{}func (*bubble) Sort(arr []int) {fmt.Println("冒泡算法")n := len(arr)for i := 0; i < n-1; i++ {flag := falsefor j := 0; j < n-1-i; j++ {if arr[j] > arr[j+1] {arr[j], arr[j+1] = arr[j+1], arr[j]flag = true}}if !flag {break}}
}// 选择排序
type selection struct{}func (*selection) Sort(arr []int) {fmt.Println("选择排序")size := len(arr)for i := 0; i < size-1; i++ {minIndex := ifor j := i + 1; j < size; j++ {if arr[j] < arr[minIndex] {minIndex = j}}if minIndex != i {arr[i], arr[minIndex] = arr[minIndex], arr[i]}}
}type Context struct {stratety SortStrategy
}func (ctx *Context) SetStrategy(s SortStrategy) {ctx.stratety = s
}func (ctx *Context) ExecuteStrategy(arr []int) {ctx.stratety.Sort(arr)
}

代码如下（示例）：main

package mainimport _case "design-pattern/trategy/case"func main() {_case.StrategyCase()
}
}

三、工厂模式

case 包

代码如下（示例）：简单工厂

package _case
type Product interface {GetName() string
}
type ProductA struct {name string
}
func (a *ProductA) GetName() string {return a.name
}
type ProductB struct {name string
}
func (b *ProductB) GetName() string {return b.name
}
type ProductC struct {name string
}
func (c *ProductC) GetName() string {return c.name
}

package _case
import ("fmt"
)
type SimpleFactory struct {
}
func (f *SimpleFactory) CreateProduct(productType string) Product {switch productType {case "A":return &ProductA{name: "product A",}case "B":return &ProductB{name: "product B",}case "C":return &ProductC{name: "product C",}}return nil
}
func SimpleFactoryCase() {factory := &SimpleFactory{}var product Productproduct = factory.CreateProduct("A")fmt.Println(product.GetName())product = factory.CreateProduct("B")fmt.Println(product.GetName())product = factory.CreateProduct("C")if product != nil {fmt.Println(product.GetName())}
}

代码如下（示例）：简单工厂

package _case
type Product interface {GetName() string
}
type ProductA struct {name string
}
func (a *ProductA) GetName() string {return a.name
}
type ProductB struct {name string
}
func (b *ProductB) GetName() string {return b.name
}
type ProductC struct {name string
}
func (c *ProductC) GetName() string {return c.name
}

package _case
import "fmt"
type Factory interface {CreateProduct() Product
}
type FactoryA struct {
}
func (f *FactoryA) CreateProduct() Product {return &ProductA{name: "product A",}
}
type FactoryB struct {
}
func (f *FactoryB) CreateProduct() Product {return &ProductB{name: "product B",}
}
type FactoryC struct {
}
func (f *FactoryC) CreateProduct() Product {return &ProductC{name: "product C",}
}
func FactoryMethodCase() {var factory Factoryvar product Productfactory = &FactoryA{}product = factory.CreateProduct()fmt.Println(product.GetName())factory = &FactoryB{}product = factory.CreateProduct()fmt.Println(product.GetName())factory = &FactoryC{}product = factory.CreateProduct()fmt.Println(product.GetName())
}

代码如下（示例）：main

package main
import _case "design-pattern/factory/case"
func main() {//_case.SimpleFactoryCase()_case.FactoryMethodCase()
}