工厂模式

定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

  • 主要解决：主要解决接口选择的问题。
  • 何时使用：我们明确地计划不同条件下创建不同实例时。
  • 使用场景：
    • 日志记录器
    • 数据库访问
    • 设计一个连接服务器的框架

      一个函数可以自行选择用什么类来实现一个或一套方法

  1. package Factory
  3. import (
  4.     "fmt"
  5.     "testing"
  6. )
  8. type Restaurant interface {
  9.     GetFood()
  10. }
  12. type Donglaishun struct {}
  14. func (d *Donglaishun) GetFood() {
  15.     fmt.Println("东来顺")
  16. }
  18. type Qingfeng struct {}
  20. func (q *Qingfeng) GetFood() {
  21.     fmt.Println("庆丰")
  22. }
  24. func NewRestaurant(name string) Restaurant{
  25.     switch name {
  26.     case "d":
  27.         return &Donglaishun{}
  28.     case "q":
  29.         return &Qingfeng{}
  30.     }
  31.     return nil
  32. }
  34. func TestNewRestaurant(t *testing.T) {
  35.     NewRestaurant(d).GetFood()
  36.     NewRestaurant(d).GetFood()
  37. }

抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

  • 主要解决：主要结局接口选择的问题
  • 何时使用：系统的产品有多于一个的产品族，而系统只消费其中的某一族产品
  • 使用场景：
    • qq换皮肤，一整套一起换
    • 生成不同操作系统的程序

      一个类通过不同的方法返回不同的类

  1. package Abstract_Factory
  3. import (
  4.     "fmt"
  5.     "testing"
  6. )
  8. type Lunch interface{
  9.     Cook()
  10. }
  12. type Rise struct {}
  14. func (r *Rise) Cook() {
  15.     fmt.Println("rice")
  16. }
  18. type Tomato struct {}
  20. func (t *Tomato) Cook() {
  21.     fmt.Println("tomato")
  22. }
  24. type LunchFactory interface {
  25.     CreateFood() Lunch
  26.     CreateVegetable() Lunch
  27. }
  29. type SimpleLunchFactory struct {}
  31. func NewSimpleLunchFactory() LunchFactory{
  32.     return &SimpleLunchFactory{}
  33. }
  35. func (s *SimpleLunchFactory) CreateFood() Lunch {
  36.     return &Rise{}
  37. }
  39. func (s *SimpleLunchFactory) CreateVegetable() Lunch {
  40.     return &Tomato{}
  41. }
  43. func TestNewSimpleLunchFactory(t *testing.T) {
  44.     factory := NewSimpleLunchFactory()
  46.     food := factory.CreateFood()
  47.     food.Cook()
  49.     vegetable := factory.CreateVegetable()
  50.     vegetable.Cook()
  51. }

外观模式

为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

  • 主要解决：降低访问复杂系统的内部子系统时的复杂度，简化客户端与之的接口。
  • 何时使用：
    • 客户端不需要知道系统内部的复杂联系，整个系统只需提供一个”接待员”即可。
    • 定义系统的入口。
  • 使用场景：
    • 为复杂的模块或子系统提供外界访问的模块
    • 子系统相对独立
    • 预防低水平人员带来的风险

      通过返回一个简单的接口而实现了复杂的操作

  1. package Facade
  3. import (
  4.     "fmt"
  5.     "testing"
  6. )
  7. type CarModel struct {}
  9. func NewCarModel() *CarModel {
  10.     return &CarModel{}
  11. }
  13. func (c *CarModel) SetModel() {
  14.     fmt.Fprintf(outputWriter, " CarModel - SetModel\n")
  15. }
  17. type CarEngine struct {}
  19. func NewCarEngine() *CarEngine {
  20.     return &CarEngine{}
  21. }
  23. func (c *CarEngine) SetEngine() {
  24.     fmt.Fprintf(outputWriter, " CarEngine - SetEngine\n")
  25. }
  27. type CarBody struct {}
  29. func NewCarBody() *CarBody {
  30.     return &CarBody{}
  31. }
  33. func (c *CarBody) SetBody() {
  34.     fmt.Fprintf(outputWriter, " CarBody - SetBody\n")
  35. }
  37. type CarAccessories struct {}
  39. func NewCarAccessories() *CarAccessories {
  40.     return &CarAccessories{}
  41. }
  43. func (c *CarAccessories) SetAccessories() {
  44.     fmt.Fprintf(outputWriter, " CarAccessories - SetAccessories\n")
  45. }
  47. type CarFacade struct {
  48.     accessories *CarAccessories
  49.     body        *CarBody
  50.     engine      *CarEngine
  51.     model       *CarModel
  52. }
  54. func NewCarFacade() *CarFacade {
  55.     return &CarFacade{
  56.         accessories: NewCarAccessories(),
  57.         body:        NewCarBody(),
  58.         engine:      NewCarEngine(),
  59.         model:       NewCarModel(),
  60.     }
  61. }
  63. func (c *CarFacade) CreateCompleteCar() {
  64.     fmt.Fprintf(outputWriter, "******** Creating a Car **********\n")
  65.     c.model.SetModel()
  66.     c.engine.SetEngine()
  67.     c.body.SetBody()
  68.     c.accessories.SetAccessories()
  69.     fmt.Fprintf(outputWriter, "******** Car creation is completed. **********\n")
  70. }
  72. func TestCarFacade_CreateCompleteCar(t *testing.T) {
  73.     facade := NewCarFacade()
  74.     facade.CreateCompleteCar()
  75. }

建造者模式

将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

  • 主要解决：主要解决在软件系统中，有时候面临着”一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
  • 何时使用：一些基本部件不会变，而其组合经常变化的时候
  • 场景：
    • 套餐，东西不变，但组合一直变

      一些基本部件不会变，而组合经常变化

  1. package Builder
  3. import (
  4.     "fmt"
  5.     "testing"
  6. )
  8. type Builder interface {
  9.     Build()
  10. }
  12. type Director struct {
  13.     builder Builder
  14. }
  16. func NewDirector(b Builder) Director {
  17.     return Director{builder: b}
  18. }
  20. func (d *Director) Construct() {
  21.     d.builder.Build()
  22. }
  24. type ConcreteBuilder struct {
  25.     built bool
  26. }
  28. func NewConcreteBuilder() ConcreteBuilder {
  29.     return ConcreteBuilder{false}
  30. }
  32. func (b *ConcreteBuilder) Build() {
  33.     b.built = true
  34. }
  36. type Product struct {
  37.     Built bool
  38. }
  40. func (b *ConcreteBuilder) GetResult() Product {
  41.     return Product{b.built}
  42. }
  44. func TestConcreteBuilder_GetResult(t *testing.T) {
  45.     builder := NewConcreteBuilder()
  46.     director := NewDirector(&builder)
  47.     director.Construct()
  48.     product := builder.GetResult()
  49.     fmt.Println(product.Built)
  50. }

桥接模式

将抽象部分与实现部分分离，使它们都可以独立的变化。

  • 主要解决：在有很多种可能会变化的情况下，用继承会造成类爆炸问题，扩展起来不方便
  • 何时使用：实现系统可能有多个角度分类，每一种角度都可能变化
  • 场景：
    • 系统需要在构建的抽象化角色于具体化角色之间增加更多灵活性(模型-实例)
    • 不希望使用继承或因为多层次导致系统类的个数急剧增加的系统
    • 一个类存在两个独立变化的维度，且两个维度都需要扩展

      具体的描述某些维度

  1. package Bridage
  3. import (
  4.     "fmt"
  5.     "time"
  6.     "testing"
  7. )
  9. type Draw interface {
  10.     DrawCircle(radius, x, y int)
  11. }
  13. type RedCircle struct {}
  15. func (g *RedCircle) DrawCircle(radius, x, y int) {
  16.     fmt.Println("radius、x、y:", radius, x, y)
  17. }
  19. type YellowCircle struct {}
  21. func (g *YellowCircle) DrawCircle(radius, x, y int) {
  22.     fmt.Println("radius、x、y:", radius, x, y)
  23. }
  25. type Shape struct {
  26.     draw Draw
  27. }
  29. func (s *Shape) Shape(d Draw) {
  30.     s.draw = d
  31.     time.Now().Unix()
  32. }
  34. type Circle struct {
  35.     shape  Shape
  36.     x      int
  37.     y      int
  38.     radius int
  39. }
  41. func (c *Circle) Constructor(x int, y int, radius int, draw Draw) {
  42.     c.x = x
  43.     c.y = y
  44.     c.radius = radius
  45.     c.shape.Shape(draw)
  46. }
  48. func (c *Circle) Cook() {
  49.     c.shape.draw.DrawCircle(c.radius, c.x, c.y)
  50. }
  52. func TestCircle_Draw(t *testing.T) {
  53.     redCircle := Circle{}
  54.     redCircle.Constructor(100, 100, 10, &RedCircle{})
  55.     yellowCircle := Circle{}
  56.     yellowCircle.Constructor(200, 200, 20, &YellowCircle{})
  57.     redCircle.Cook()
  58.     yellowCircle.Cook()
  59. }

命令模式

将一个请求封装成一个对象，从而可以用不同的请求对客户进行参数化。

  • 主要解决：某些场合下，紧耦合的设计无法满足行为
  • 何时使用：在某些场合，比如要对行为进行”记录、撤销/重做、事务”等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如何将”行为请求者”与”行为实现者”解耦？将一组行为抽象为对象，可以实现二者之间的松耦合。
  • 使用场景：
    • GUI的每一个按钮
    • 模拟CMD

      使用一个函数可以灵活的使用其方法

  1. package Command
  3. import (
  4.     "fmt"
  5.     "testing"
  6. )
  7. type Person struct {
  8.     name string
  9.     cmd  Command
  10. }
  11. type Command struct {
  12.     person *Person
  13.     method func()
  14. }
  16. func NewCommand(p *Person, method func()) Command {
  17.     return Command{
  18.         person: p,
  19.         method: method,
  20.     }
  21. }
  22. func (c *Command) Execute() {
  23.     c.method()
  24. }
  26. func NewPerson(name string, cmd Command) Person {
  27.     return Person{
  28.         name: name,
  29.         cmd:  cmd,
  30.     }
  31. }
  33. func (p *Person) Buy() {
  34.     fmt.Println(fmt.Sprintf("%s is buying ", p.name))
  35.     p.cmd.Execute()
  36. }
  38. func (p *Person) Cook() {
  39.     fmt.Println(fmt.Sprintf("%s is cooking ", p.name))
  40.     p.cmd.Execute()
  41. }
  43. func (p *Person) Wash() {
  44.     fmt.Println(fmt.Sprintf("%s is washing ", p.name))
  45.     p.cmd.Execute()
  46. }
  48. func (p *Person) Listen() {
  49.     fmt.Println(fmt.Sprintf("%s is Listening ", p.name))
  50. }
  52. func (p *Person) Talk() {
  53.     fmt.Println(fmt.Sprintf("%s is Talking ", p.name))
  54.     p.cmd.Execute()
  55. }
  57. func TestCommand_Execute(t *testing.T) {
  58.     laowang := NewPerson("wang", NewCommand(nil, nil))
  59.     laozhang := NewPerson("zhang", NewCommand(&laowang, laowang.Listen))
  60.     laofeng := NewPerson("feng", NewCommand(&laozhang, laozhang.Buy))
  61.     laoding := NewPerson("ding", NewCommand(&laofeng, loafeng.Cook))
  62.     laoli := NewPerson("li", NewCommand(&laoding, laoding.Wash))
  64.     laoli.Talk()
  66. }