Ruby 工厂模式

工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。通过工厂模式，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向不同的子类实现，这样既使得代码结构清晰，又可以轻松地扩展新的对象而无需修改原有的代码。

工厂模式的基本概念

简单工厂

简单工厂模式并不是GoF定义的23种设计模式之一，但它确实是一个非常实用的设计模式。简单工厂模式的核心思想是：根据传入的不同参数来决定实例化哪个具体的类。

示例代码

// www.javascriptcn.com code example
class Product
end

class ConcreteProductA < Product
end

class ConcreteProductB < Product
end

class SimpleFactory
  def self.create_product(type)
    case type
    when 'A'
      ConcreteProductA.new
    when 'B'
      ConcreteProductB.new
    else
      raise ArgumentError, "Unknown product type: #{type}"
    end
  end
end

# 使用工厂创建对象
product = SimpleFactory.create_product('A')

在这个例子中，SimpleFactory类根据传入的参数类型决定返回哪种类型的对象。

工厂方法

工厂方法模式定义了一个创建对象的接口，但由子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类。

示例代码

// www.javascriptcn.com code example
class Creator
  # 子类需要实现这个方法
  def factory_method
    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
  end

  def some_operation
    # 创建产品
    product = factory_method
    # 使用产品
    result = "Creator: The same creator's code has just worked with #{product}"
    result
  end
end

class ConcreteCreatorA < Creator
  def factory_method
    ConcreteProductA.new
  end
end

class ConcreteCreatorB < Creator
  def factory_method
    ConcreteProductB.new
  end
end

# 使用工厂方法
creator_a = ConcreteCreatorA.new
puts creator_a.some_operation

creator_b = ConcreteCreatorB.new
puts creator_b.some_operation

在这个例子中，Creator类中的factory_method方法是一个抽象方法，必须由子类实现。some_operation方法则是用来调用factory_method方法并使用其结果。

抽象工厂

抽象工厂模式提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

示例代码

// www.javascriptcn.com code example
module AbstractFactory
  class AbstractProductA
  end

  class AbstractProductB
  end

  class AbstractFactory
    def create_product_a
      raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
    end

    def create_product_b
      raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
    end
  end

  class ConcreteFactory1 < AbstractFactory
    def create_product_a
      ConcreteProductA1.new
    end

    def create_product_b
      ConcreteProductB1.new
    end
  end

  class ConcreteFactory2 < AbstractFactory
    def create_product_a
      ConcreteProductA2.new
    end

    def create_product_b
      ConcreteProductB2.new
    end
  end

  class ConcreteProductA1 < AbstractProductA
  end

  class ConcreteProductA2 < AbstractProductA
  end

  class ConcreteProductB1 < AbstractProductB
  end

  class ConcreteProductB2 < AbstractProductB
  end
end

# 使用抽象工厂
factory1 = AbstractFactory::ConcreteFactory1.new
product_a1 = factory1.create_product_a
product_b1 = factory1.create_product_b

factory2 = AbstractFactory::ConcreteFactory2.new
product_a2 = factory2.create_product_a
product_b2 = factory2.create_product_b

在这个例子中，AbstractFactory模块定义了创建产品的接口，而ConcreteFactory1和ConcreteFactory2则实现了这些接口，提供了不同的产品实现。

工厂模式的优点

• 解耦：客户端不需要知道创建对象的具体过程。
• 灵活性：增加新的产品类时，只需要添加相应的工厂类即可，无需修改原有代码。
• 易于扩展：新产品的引入变得简单，只需添加相应的工厂类和产品类即可。

总结

工厂模式是一种非常有用的设计模式，它可以简化对象的创建过程，提高代码的可维护性和扩展性。无论是简单工厂、工厂方法还是抽象工厂，它们都有各自的适用场景，选择合适的工厂模式可以大大提高代码的质量和可读性。