工厂模式（Factory Pattern）是一种常用的设计模式，属于创建型模式。它提供了一种创建对象的方式，而无需指定具体的类。工厂模式的核心思想是将对象的创建逻辑封装在一个工厂类中，从而将对象的创建与使用分离，提高代码的可维护性和可扩展性。
### **1. 工厂模式的类型**
工厂模式主要有两种形式：
1. **简单工厂模式（Simple Factory Pattern）**：
- 通过一个工厂类来创建对象，但不涉及继承和多态。
- 适用于对象创建逻辑相对简单的情况。
2. **工厂方法模式（Factory Method Pattern）**：
- 定义了一个创建对象的接口，但让子类决定实例化哪一个类。
- 适用于对象创建逻辑较为复杂，且需要扩展的情况。
### **2. 简单工厂模式**
#### 示例
假设我们有一个简单的场景，需要根据用户输入创建不同类型的宠物。
```python
class Dog:
def speak(self):
return "Woof"
class Cat:
def speak(self):
return "Meow"
class PetFactory:
@staticmethod
def get_pet(pet_type):
if pet_type == "dog":
return Dog()
elif pet_type == "cat":
return Cat()
else:
raise ValueError("Unknown pet type")
# 使用
pet = PetFactory.get_pet("dog")
print(pet.speak()) # 输出：Woof
pet = PetFactory.get_pet("cat")
print(pet.speak()) # 输出：Meow
```
在这个例子中：
- `PetFactory` 是一个工厂类，提供了一个静态方法 `get_pet`，用于根据输入的类型创建对应的宠物对象。
- `Dog` 和 `Cat` 是具体的宠物类，实现了 `speak` 方法。
### **3. 工厂方法模式**
#### 示例1
#我们继续使用宠物的例子来说明工厂方法模式。在工厂方法模式
# 中，我们定义了一个工厂类，它提供了一个方法来创建对象，但
# 具体的创建逻辑由子类实现。这样可以方便地扩展和维护代码。
from abc import ABC, abstractmethod
#首先，我们定义一个宠物类的接口，以及具体的宠物类。
# 定义宠物类的抽象基类
class Pet(ABC):
@abstractmethod
def speak(self):
pass
# 定义具体的宠物类
class Dog(Pet):
def speak(self):
return "Woof"
class Cat(Pet):
def speak(self):
return "Meow"
#接下来，我们定义一个工厂类，它提供了一个方法来
# 创建宠物对象，但具体的创建逻辑由子类实现。
# 定义宠物工厂类的抽象基类
class PetFactory(ABC):
@abstractmethod
def create_pet(self):
pass
# 定义具体的工厂类
class DogFactory(PetFactory):
def create_pet(self):
return Dog()
class CatFactory(PetFactory):
def create_pet(self):
return Cat()
#现在，我们可以使用具体的工厂类来创建宠物对象，
# 而不需要直接调用具体的宠物类。
# 定义一个函数来使用工厂方法
def get_pet(factory: PetFactory):
pet = factory.create_pet()
print(pet.speak())
# 使用
dog_factory = DogFactory()
get_pet(dog_factory) # 输出：Woof
cat_factory = CatFactory()
get_pet(cat_factory) # 输出：Meow
#### 示例2
假设我们有一个更复杂的场景，需要根据不同的需求创建不同类型的日志记录器。
from abc import ABC, abstractmethod
# 定义一个日志记录器的抽象基类
class Logger(ABC):
@abstractmethod
def log(self, message):
pass
# 实现具体的日志记录器
class FileLogger(Logger):
def log(self, message):
with open("log.txt", "a") as file:
file.write(message + "\n")
print("Logged to file")
class ConsoleLogger(Logger):
def log(self, message):
print(f"Logged to console: {message}")
# 定义一个工厂类
class LoggerFactory:
def create_logger(self, logger_type):
if logger_type == "file":
return FileLogger()
elif logger_type == "console":
return ConsoleLogger()
else:
raise ValueError("Unknown logger type")
# 使用
factory = LoggerFactory()
logger = factory.create_logger("file")
logger.log("This is a log message") # 输出：Logged to file
logger = factory.create_logger("console")
logger.log("This is a log message") # 输出：Logged to console: This is a log message
```
在这个例子中：
- `Logger` 是一个抽象基类，定义了日志记录器的接口。
- `FileLogger` 和 `ConsoleLogger` 是具体的日志记录器类，实现了 `log` 方法。
- `LoggerFactory` 是一个工厂类，提供了一个方法 `create_logger`，用于根据输入的类型创建对应的日志记录器对象。
### **4. 工厂模式的优点**
1. **封装性**：
- 将对象的创建逻辑封装在工厂类中，用户不需要知道具体的创建细节。
2. **可扩展性**：
- 添加新的对象类型时，只需扩展工厂类，而不需要修改客户端代码。
3. **解耦**：
- 将对象的创建与使用分离，降低了代码的耦合度。
### **5. 工厂模式的缺点**
1. **复杂性**：
- 工厂模式可能会增加代码的复杂性，特别是当工厂类变得庞大时。
2. **性能**：
- 工厂方法可能会引入额外的性能开销，特别是在创建大量对象时。
### **6. 使用场景**
1. **对象创建逻辑复杂**：
- 当对象的创建逻辑较为复杂，且需要根据不同的条件创建不同的对象时。
2. **需要扩展**：
- 当需要添加新的对象类型时，工厂模式可以方便地扩展。
3. **解耦对象创建与使用**：
- 当需要将对象的创建与使用分离，降低代码的耦合度时。
### **7. 总结**
- **工厂模式**：提供了一种创建对象的方式，而无需指定具体的类。
- **简单工厂模式**：适用于对象创建逻辑相对简单的情况。
- **工厂方法模式**：适用于对象创建逻辑较为复杂，且需要扩展的情况。
- **优点**：封装性、可扩展性、解耦。
- **缺点**：复杂性、性能开销。
