:::tips 本质上, 工厂模式是为了解决 相似类初始化和初始化十分复杂的情况

:::

使用场景

我们来看一下这样的场景, 现在需要翻译接口, 能够翻译, 大概会写出下面这样的代码

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. //翻译接口
  9. type Translator interface {
  10.     Translate(string) string
  11. }
  14. //德语翻译类
  15. type GermanTranslator struct{}
  17. func (*GermanTranslator) Translate(words string) string {
  19.     return "德语"
  20. }
  22. //英语翻译类
  23. type EnglishTranslator struct{}
  25. func (*EnglishTranslator) Translate(words string) string {
  27.     return "英语"
  28. }
  30. //日语翻译类
  31. type JapaneseTranslator struct{}
  33. func (*JapaneseTranslator) Translate(words string) string {
  34.     return "日语"
  35. }
  39. func main()  {
  40.     defer func() {
  41.         if err := recover(); err != nil {
  42.             fmt.Println(err)
  43.         }
  44.         time.Sleep(3 * time.Second)
  45.     }()
  47.     var lan int
  48.     fmt.Printf("%s\r\n%s\r\n", "以下是可翻译的语言种类，请输入代表数字", "1：德语、2：英语、3：日语")
  49.     fmt.Scanln(&lan)
  51.     fmt.Println("请输入要翻译成中文的文本：")
  52.     var inputWords string
  53.     fmt.Scanln(&inputWords)
  55.     var translator Translator
  57.     //根据不同的语言种类，实例化不同的翻译类
  58.     switch lan {
  59.     case 1:
  60.         translator = new(GermanTranslator)
  61.     case 2:
  62.         translator = new(EnglishTranslator)
  63.     case 3:
  64.         translator = new(JapaneseTranslator)
  65.     default:
  66.         panic("no such translator")
  67.     }
  69.     fmt.Println(translator.Translate(inputWords))
  70. }
  • 违背了 开闭原则 : 这样创建类, 如果添加了其他翻译类, 每次都需要更改客户端代码, 一次修改, 处处漏水
  • 违背了 单一职责 : 客户端应该只接受用户输入, 然后返回输出, 现在还需要负责类的创建

简单工厂模式

golang

我们使用简单工厂模式进行改写

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. //翻译接口
  9. type Translator interface {
  10.     Translate(string) string
  11. }
  13. func CreatTranslator(lan int) Translator {
  14.     var translator Translator
  15.     switch lan {
  16.     case 1: translator = new(GermanTranslator)
  17.     case 2: translator = new(EnglishTranslator)
  18.     case 3: translator = new(JapaneseTranslator)
  19.     }
  21.     return translator
  22. }
  24. //德语翻译类
  25. type GermanTranslator struct{}
  27. func (*GermanTranslator) Translate(words string) string {
  29.     return "德语"
  30. }
  32. //英语翻译类
  33. type EnglishTranslator struct{}
  35. func (*EnglishTranslator) Translate(words string) string {
  37.     return "英语"
  38. }
  40. //日语翻译类
  41. type JapaneseTranslator struct{}
  43. func (*JapaneseTranslator) Translate(words string) string {
  44.     return "日语"
  45. }
  49. func main()  {
  50.     defer func() {
  51.         if err := recover(); err != nil {
  52.             fmt.Println(err)
  53.         }
  54.         time.Sleep(3 * time.Second)
  55.     }()
  57.     var lan int
  58.     fmt.Printf("%s\r\n%s\r\n", "以下是可翻译的语言种类，请输入代表数字", "1：德语、2：英语、3：日语")
  59.     fmt.Scanln(&lan)
  61.     fmt.Println("请输入要翻译成中文的文本：")
  62.     var inputWords string
  63.     fmt.Scanln(&inputWords)
  65.     translator := CreatTranslator(lan)
  67.     fmt.Println(translator.Translate(inputWords))
  68. }
  • 上面还需要检测工厂产出的是否成功, 这里没有写
  • 改写后, 职责划分更加清晰, 业务代码中不再负责类创建, 符合了 单一职责原则
  • 但是, 新增类的时候依然需要修改整个工厂类, 不符合 开闭原则 , 不过也需要根据场景来进行取舍, 如果这里不会增加太多新方法, 那么即便不符合也死能够接受的, 因为要完全符合原则, 会牺牲 代码可读性 提高代码复杂度

工厂模式

golang

golang没有继承, 基于匿名组合完成

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. // Translator 翻译接口
  9. type Translator interface {
  10.     Translate(string) string
  11. }
  13. // TranslatorFactory 工厂接口
  14. type TranslatorFactory interface {
  15.     Create() Translator
  16. }
  18. // TranslatorBase 是 Translator接口实现的基类, 封装公用方法
  19. type TranslatorBase struct {
  21. }
  23. func (*TranslatorBase) PublicMethod() string  {
  24.     return "public"
  25. }
  27. // GermanTranslatorFactory 德语翻译类工厂
  28. type GermanTranslatorFactory struct{}
  29. func (GermanTranslatorFactory) Create() Translator {
  30.     return &GermanTranslator{
  31.         TranslatorBase:&TranslatorBase{},
  32.     }
  33. }
  35. // GermanTranslator 德语翻译类
  36. type GermanTranslator struct{
  37.     *TranslatorBase
  38. }
  39. func (g *GermanTranslator) Translate(words string) string {
  40.     g.PublicMethod()
  41.     return "德语"
  42. }
  44. // EnglishTranslatorFactory 英语翻译类工厂
  45. type EnglishTranslatorFactory struct{}
  46. func (EnglishTranslatorFactory) Create() Translator {
  47.     return &EnglishTranslator{
  48.         TranslatorBase:&TranslatorBase{},
  49.     }
  50. }
  52. // EnglishTranslator 英语翻译类
  53. type EnglishTranslator struct{
  54.     *TranslatorBase
  55. }
  57. func (e *EnglishTranslator) Translate(words string) string {
  58.     e.PublicMethod()
  59.     return "英语"
  60. }
  63. // JapaneseTranslatorFactory 日语翻译类工厂
  64. type JapaneseTranslatorFactory struct{}
  65. func (JapaneseTranslatorFactory) Create() Translator {
  66.     return &JapaneseTranslator{
  67.         TranslatorBase:&TranslatorBase{},
  68.     }
  69. }
  71. // JapaneseTranslator 日语翻译类
  72. type JapaneseTranslator struct{
  73.     *TranslatorBase
  74. }
  76. func (j *JapaneseTranslator) Translate(words string) string {
  77.     j.PublicMethod()
  78.     return "日语"
  79. }
  83. func main()  {
  84.     defer func() {
  85.         if err := recover(); err != nil {
  86.             fmt.Println(err)
  87.         }
  88.         time.Sleep(3 * time.Second)
  89.     }()
  91.     var lan int
  92.     fmt.Printf("%s\r\n%s\r\n", "以下是可翻译的语言种类，请输入代表数字", "1：德语、2：英语、3：日语")
  93.     fmt.Scanln(&lan)
  95.     fmt.Println("请输入要翻译成中文的文本：")
  96.     var inputWords string
  97.     fmt.Scanln(&inputWords)
  99.     switch lan {
  100.     case 1: TranslatorFuc(GermanTranslatorFactory{}, "1")
  101.     case 2: TranslatorFuc(EnglishTranslatorFactory{}, "2")
  102.     case 3: TranslatorFuc(JapaneseTranslatorFactory{}, "3")
  103.     }
  104. }
  106. func TranslatorFuc(factory TranslatorFactory, input string){
  107.     fmt.Println(factory.Create().Translate(input))
  108. }
  • 工厂模式多了很多代码, 主要每一个类都需要一个工厂, 这里其实导致了类的膨胀, 过多的类给维护带来了麻烦
  • 在构造并不复杂的情况下, 工厂模式其实不如简单工厂来得直接
  • 并且这里使用工厂之后, 逻辑又被混入到业务代码中了, 这样是不行的, 你还需要封装出一个创建工厂的工厂

:::tips 这里就体现了过度设计的弊端, 如果构造类并不复杂, 很多时候简单工厂比工厂要实用很多

:::