蓝天白云很快了1. 工厂模式：对象创建的优雅解耦方案
在软件开发中，我们经常遇到需要创建对象的场景。当对象的创建逻辑变得复杂，或者需要根据不同的条件创建不同类型的对象时，直接使用new关键字可能会导致代码耦合度高、难以维护。工厂模式就是为了解决这个问题而生的。
工厂模式属于创建型设计模式，它提供了一种将对象实例化过程封装起来的方式，让客户端代码不需要关心具体的对象创建细节。这种模式特别适合以下场景：
- 当创建对象需要复杂的初始化逻辑时
- 当系统需要根据不同的条件创建不同的对象时
- 当希望将对象的创建与使用分离，降低耦合度时
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 工厂模式的核心思想与类型
2.1 工厂模式的三种实现形式
工厂模式主要分为三种形式，每种形式适用于不同的场景：
- 简单工厂模式（Simple Factory）
- 工厂方法模式（Factory Method）
- 抽象工厂模式（Abstract Factory）
这三种形式从简单到复杂，提供了不同级别的灵活性和扩展性。
2.2 简单工厂模式解析
简单工厂模式是最基础的形式，它通过一个工厂类来封装对象的创建逻辑。客户端只需要告诉工厂"我需要什么"，而不需要知道具体如何创建。
java复制public class SimplePizzaFactory {
public Pizza createPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese")) {
pizza = new CheesePizza();
} else if (type.equals("pepperoni")) {
pizza = new PepperoniPizza();
} else if (type.equals("veggie")) {
pizza = new VeggiePizza();
}
return pizza;
}
}
这种模式的优点是简单直接，缺点是不符合开闭原则（对扩展开放，对修改关闭），因为每次添加新产品类型都需要修改工厂类。
提示：简单工厂模式适合产品类型较少且不太可能频繁变化的场景。
2.3 工厂方法模式详解
工厂方法模式通过引入抽象工厂类和具体工厂类来解决简单工厂模式的问题。它为每种产品定义一个工厂类，这样新增产品时只需要新增对应的工厂类，不需要修改现有代码。
java复制// 抽象工厂
public abstract class PizzaStore {
public Pizza orderPizza(String type) {
Pizza pizza = createPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
// 工厂方法
protected abstract Pizza createPizza(String type);
}
// 具体工厂
public class NYPizzaStore extends PizzaStore {
protected Pizza createPizza(String type) {
if (type.equals("cheese")) {
return new NYStyleCheesePizza();
} else if (type.equals("pepperoni")) {
return new NYStylePepperoniPizza();
}
return null;
}
}
工厂方法模式符合开闭原则，扩展性强，但类的数量会随着产品类型的增加而增加。
2.4 抽象工厂模式深入
抽象工厂模式提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。它适用于需要创建多个相关产品对象的场景。
java复制// 抽象工厂接口
public interface PizzaIngredientFactory {
public Dough createDough();
public Sauce createSauce();
public Cheese createCheese();
public Veggies[] createVeggies();
public Pepperoni createPepperoni();
public Clams createClam();
}
// 具体工厂实现
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
public Dough createDough() {
return new ThinCrustDough();
}
public Sauce createSauce() {
return new MarinaraSauce();
}
public Cheese createCheese() {
return new ReggianoCheese();
}
// 其他方法实现...
}
抽象工厂模式的优点是可以确保创建的产品是兼容的，缺点是一旦需要支持新的产品种类，就需要修改抽象工厂接口及其所有实现。
3. 工厂模式的实现细节与技巧
3.1 参数化工厂方法
工厂方法可以接收参数来决定创建哪种对象。参数可以是枚举、字符串或任何其他类型的标识符。
java复制public class VehicleFactory {
public enum VehicleType {
CAR, TRUCK, BUS
}
public static Vehicle createVehicle(VehicleType type) {
switch (type) {
case CAR: return new Car();
case TRUCK: return new Truck();
case BUS: return new Bus();
default: throw new IllegalArgumentException("Unknown vehicle type");
}
}
}
3.2 使用反射实现灵活工厂
在某些语言中，可以利用反射机制来实现更灵活的工厂：
java复制public class ReflectionFactory {
public static <T> T createInstance(Class<T> clazz) {
try {
return clazz.getDeclaredConstructor().newInstance();
} catch (Exception e) {
throw new RuntimeException("Failed to create instance", e);
}
}
}
3.3 工厂模式与依赖注入
现代框架如Spring广泛使用工厂模式的思想来实现依赖注入：
java复制@Service
public class OrderService {
private final PaymentProcessor paymentProcessor;
@Autowired
public OrderService(PaymentProcessor paymentProcessor) {
this.paymentProcessor = paymentProcessor;
}
// 业务方法...
}
Spring容器本质上就是一个大型的工厂，负责创建和管理各种bean。
4. 工厂模式的最佳实践与常见问题
4.1 何时使用工厂模式
工厂模式特别适用于以下场景：
- 当一个类无法预知它必须创建的对象的类时
- 当一个类希望由它的子类来指定它所创建的对象时
- 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化时
4.2 工厂模式的优缺点分析
优点：
- 将对象的创建与使用分离，降低耦合度
- 客户端不需要知道具体产品类的类名，只需要知道对应的工厂
- 可以轻松扩展新的产品类型（特别是工厂方法模式）
- 可以为创建过程提供更精细的控制
缺点：
- 引入了额外的类和接口，增加了系统的复杂度
- 在某些情况下可能会造成类的爆炸性增长
- 增加了系统的抽象性和理解难度
4.3 常见问题与解决方案
问题1：工厂类职责过重
当工厂类需要创建太多不同类型的对象时，会导致工厂类变得庞大而难以维护。
解决方案：
- 考虑将工厂类拆分为多个专门的工厂类
- 使用工厂方法模式，为每种产品类型创建专门的工厂
问题2：产品构造参数不一致
当不同产品需要不同的构造参数时，工厂方法的接口设计变得困难。
解决方案：
- 使用Builder模式来构造复杂对象
- 将参数封装为一个配置对象
- 为不同的产品类型提供不同的工厂方法
问题3：循环依赖
当产品之间或产品与工厂之间存在循环依赖时，会导致初始化问题。
解决方案：
- 重新设计消除循环依赖
- 使用依赖注入框架
- 引入中间层或代理
5. 工厂模式在不同语言中的实现
5.1 Java中的工厂模式实现
Java中除了基本的工厂模式实现外，还可以利用枚举来实现单例工厂：
java复制public enum LoggerFactory {
INSTANCE;
public Logger getLogger(String name) {
return new ConsoleLogger(name);
}
}
// 使用方式
Logger logger = LoggerFactory.INSTANCE.getLogger("main");
5.2 C++中的工厂模式实现
C++中可以利用模板和智能指针来实现类型安全的工厂：
cpp复制template<typename T>
class Factory {
public:
template<typename... Args>
static std::unique_ptr<T> create(Args&&... args) {
return std::make_unique<T>(std::forward<Args>(args)...);
}
};
// 使用方式
auto widget = Factory<Widget>::create(42, "example");
5.3 Python中的工厂模式实现
Python可以利用其动态特性实现灵活的工厂：
python复制class Animal:
@classmethod
def create(cls, animal_type):
if animal_type == "dog":
return Dog()
elif animal_type == "cat":
return Cat()
else:
raise ValueError(f"Unknown animal type: {animal_type}")
class Dog(Animal): pass
class Cat(Animal): pass
# 使用方式
animal = Animal.create("dog")
5.4 JavaScript/TypeScript中的工厂模式
JavaScript中可以利用闭包实现工厂函数：
javascript复制function createUserFactory(role) {
switch (role) {
case 'admin':
return () => new AdminUser();
case 'user':
return () => new RegularUser();
default:
throw new Error('Invalid role');
}
}
// 使用方式
const createAdmin = createUserFactory('admin');
const admin = createAdmin();
TypeScript中可以利用泛型实现类型安全的工厂：
typescript复制interface Animal {
makeSound(): void;
}
class Dog implements Animal {
makeSound() { console.log('Woof!'); }
}
class Cat implements Animal {
makeSound() { console.log('Meow!'); }
}
function createAnimal<T extends Animal>(type: new () => T): T {
return new type();
}
// 使用方式
const dog = createAnimal(Dog);
dog.makeSound();
6. 工厂模式在实际项目中的应用案例
6.1 数据库连接工厂
数据库连接是工厂模式的典型应用场景：
java复制public interface ConnectionFactory {
Connection createConnection() throws SQLException;
}
public class MySQLConnectionFactory implements ConnectionFactory {
private final String url;
private final String username;
private final String password;
public MySQLConnectionFactory(String url, String username, String password) {
this.url = url;
this.username = username;
this.password = password;
}
@Override
public Connection createConnection() throws SQLException {
return DriverManager.getConnection(url, username, password);
}
}
6.2 日志系统工厂
日志系统通常需要支持多种日志实现：
java复制public interface Logger {
void log(String message);
}
public class FileLogger implements Logger {
private final String filePath;
public FileLogger(String filePath) {
this.filePath = filePath;
}
@Override
public void log(String message) {
// 实现文件日志记录
}
}
public class LoggerFactory {
public static Logger getLogger(String type, String param) {
switch (type) {
case "file": return new FileLogger(param);
case "console": return new ConsoleLogger();
default: throw new IllegalArgumentException("Unknown logger type");
}
}
}
6.3 UI组件工厂
跨平台UI框架通常使用抽象工厂模式：
java复制public interface Button {
void render();
void onClick(Runnable action);
}
public interface Checkbox {
void render();
void setChecked(boolean checked);
}
public interface UIFactory {
Button createButton();
Checkbox createCheckbox();
}
public class WindowsUIFactory implements UIFactory {
public Button createButton() {
return new WindowsButton();
}
public Checkbox createCheckbox() {
return new WindowsCheckbox();
}
}
public class MacUIFactory implements UIFactory {
// 类似实现...
}
7. 工厂模式的高级应用与变体
7.1 延迟初始化工厂
有些对象的创建成本很高，可以使用延迟初始化的工厂：
java复制public class LazyFactory<T> {
private Supplier<T> supplier;
private volatile T instance;
public LazyFactory(Supplier<T> supplier) {
this.supplier = supplier;
}
public T getInstance() {
if (instance == null) {
synchronized (this) {
if (instance == null) {
instance = supplier.get();
}
}
}
return instance;
}
}
7.2 多例工厂
当需要控制某个类的实例数量时，可以使用多例工厂：
java复制public class MultitonFactory {
private static final int MAX_INSTANCES = 3;
private static final List<Resource> instances = new ArrayList<>();
private static int nextIndex = 0;
public static synchronized Resource getInstance() {
if (instances.size() < MAX_INSTANCES) {
Resource instance = new Resource();
instances.add(instance);
return instance;
}
Resource instance = instances.get(nextIndex);
nextIndex = (nextIndex + 1) % MAX_INSTANCES;
return instance;
}
}
7.3 带缓存的工厂
对于创建成本高的对象，可以使用带缓存的工厂：
java复制public class CachingFactory<K, V> {
private final Function<K, V> creator;
private final Map<K, V> cache = new ConcurrentHashMap<>();
public CachingFactory(Function<K, V> creator) {
this.creator = creator;
}
public V get(K key) {
return cache.computeIfAbsent(key, creator);
}
}
7.4 组合工厂
将多个工厂组合起来创建复杂对象：
java复制public class ComputerFactory {
private final CPUFactory cpuFactory;
private final MemoryFactory memoryFactory;
private final DiskFactory diskFactory;
public ComputerFactory(CPUFactory cpuFactory, MemoryFactory memoryFactory, DiskFactory diskFactory) {
this.cpuFactory = cpuFactory;
this.memoryFactory = memoryFactory;
this.diskFactory = diskFactory;
}
public Computer createComputer(ComputerSpec spec) {
CPU cpu = cpuFactory.createCPU(spec.getCpuType());
Memory memory = memoryFactory.createMemory(spec.getMemorySize());
Disk disk = diskFactory.createDisk(spec.getDiskType(), spec.getDiskSize());
return new Computer(cpu, memory, disk);
}
}
8. 工厂模式与其他设计模式的关系
8.1 工厂模式与单例模式
工厂类本身通常实现为单例：
java复制public class SingletonFactory {
private static final SingletonFactory INSTANCE = new SingletonFactory();
private SingletonFactory() {}
public static SingletonFactory getInstance() {
return INSTANCE;
}
public Product createProduct() {
return new ConcreteProduct();
}
}
8.2 工厂模式与策略模式
工厂模式创建对象，策略模式使用对象，二者经常配合使用：
java复制public interface CompressionStrategy {
byte[] compress(byte[] data);
}
public class CompressionContext {
private CompressionStrategy strategy;
public void setStrategy(CompressionStrategy strategy) {
this.strategy = strategy;
}
public byte[] compress(byte[] data) {
return strategy.compress(data);
}
}
public class CompressionStrategyFactory {
public static CompressionStrategy createStrategy(String type) {
switch (type) {
case "zip": return new ZipCompression();
case "rar": return new RarCompression();
default: throw new IllegalArgumentException("Unknown compression type");
}
}
}
8.3 工厂模式与装饰器模式
工厂可以创建装饰后的对象：
java复制public interface DataSource {
void writeData(String data);
String readData();
}
public class DataSourceFactory {
public static DataSource createDataSource(boolean encrypted, boolean compressed) {
DataSource source = new FileDataSource("data.txt");
if (encrypted) {
source = new EncryptionDecorator(source);
}
if (compressed) {
source = new CompressionDecorator(source);
}
return source;
}
}
8.4 工厂模式与原型模式
原型工厂可以克隆现有对象而不是新建：
java复制public class PrototypeFactory {
private static final Map<String, Shape> prototypes = new HashMap<>();
static {
prototypes.put("circle", new Circle());
prototypes.put("rectangle", new Rectangle());
}
public static Shape getShape(String type) {
try {
return prototypes.get(type).clone();
} catch (CloneNotSupportedException e) {
throw new RuntimeException("Clone failed", e);
}
}
}
9. 工厂模式的性能考量与优化
9.1 对象创建开销分析
工厂模式的主要性能开销在于：
- 工厂类本身的初始化开销
- 对象创建过程中的计算开销
- 可能的内存分配开销
对于性能敏感的场景，可以考虑以下优化策略：
- 使用对象池复用已有对象
- 缓存频繁创建的对象
- 使用轻量级对象或值对象
9.2 线程安全实现方案
工厂模式需要考虑线程安全问题，特别是在延迟初始化时：
java复制public class ThreadSafeFactory {
private volatile Product product;
public Product getProduct() {
Product p = product;
if (p == null) {
synchronized (this) {
p = product;
if (p == null) {
p = createProduct();
product = p;
}
}
}
return p;
}
protected Product createProduct() {
return new ConcreteProduct();
}
}
9.3 内存使用优化
对于大量创建小对象的场景，可以考虑：
- 使用Flyweight模式共享内在状态
- 使用对象池减少GC压力
- 使用值对象替代完整对象
java复制public class ProductPool {
private final Queue<Product> pool = new ConcurrentLinkedQueue<>();
private final int maxSize;
public ProductPool(int maxSize) {
this.maxSize = maxSize;
}
public Product borrowProduct() {
Product product = pool.poll();
if (product == null) {
product = new ConcreteProduct();
}
return product;
}
public void returnProduct(Product product) {
if (pool.size() < maxSize) {
pool.offer(product);
}
}
}
10. 工厂模式的测试与调试技巧
10.1 单元测试工厂类
测试工厂类时主要关注：
- 工厂是否能正确创建预期类型的对象
- 创建的对象是否具有正确的初始状态
- 异常情况的处理是否正确
java复制public class FactoryTest {
@Test
public void testCreateProductA() {
ProductFactory factory = new ProductFactory();
Product product = factory.createProduct("A");
assertTrue(product instanceof ProductA);
}
@Test
public void testInvalidProductType() {
ProductFactory factory = new ProductFactory();
assertThrows(IllegalArgumentException.class, () -> {
factory.createProduct("INVALID");
});
}
}
10.2 模拟工厂进行测试
在测试依赖工厂的代码时，可以使用模拟工厂：
java复制public class ServiceTest {
@Test
public void testServiceWithMockFactory() {
// 创建模拟工厂
ProductFactory mockFactory = mock(ProductFactory.class);
when(mockFactory.createProduct("A")).thenReturn(new ProductA());
// 创建被测试的服务
Service service = new Service(mockFactory);
// 测试服务方法
String result = service.doSomething("A");
assertEquals("expected result", result);
}
}
10.3 调试工厂创建过程
调试工厂模式时常见问题：
- 创建了错误类型的对象
- 对象初始化不完整
- 依赖注入失败
调试技巧：
- 在工厂方法中添加日志记录
- 使用断点跟踪对象创建过程
- 检查依赖关系是否正确设置
java复制public class DebuggableFactory {
private static final Logger logger = LoggerFactory.getLogger(DebuggableFactory.class);
public Product createProduct(String type) {
logger.debug("Creating product of type: {}", type);
// 创建逻辑...
}
}
11. 工厂模式在现代框架中的应用
11.1 Spring框架中的工厂模式
Spring框架的核心就是一个大型的工厂（ApplicationContext），它管理着所有bean的创建和生命周期：
java复制@Configuration
public class AppConfig {
@Bean
public DataSource dataSource() {
return new DriverManagerDataSource("jdbc:h2:mem:test");
}
@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
}
// 使用方式
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
JdbcTemplate jdbcTemplate = context.getBean(JdbcTemplate.class);
11.2 JPA中的EntityManagerFactory
JPA使用EntityManagerFactory来创建EntityManager实例：
java复制EntityManagerFactory emf = Persistence.createEntityManagerFactory("my-pu");
EntityManager em = emf.createEntityManager();
11.3 JavaFX中的FXML加载器
JavaFX使用FXMLLoader作为视图工厂：
java复制FXMLLoader loader = new FXMLLoader(getClass().getResource("view.fxml"));
Parent root = loader.load();
MyController controller = loader.getController();
11.4 React中的组件工厂
React使用工厂函数创建组件：
javascript复制function createButtonComponent(type) {
return function Button(props) {
return <button className={`btn-${type}`} {...props} />;
};
}
const PrimaryButton = createButtonComponent('primary');
const SecondaryButton = createButtonComponent('secondary');
12. 工厂模式的替代方案与比较
12.1 直接实例化 vs 工厂模式
直接实例化：
java复制Product product = new ConcreteProduct();
优点：简单直接
缺点：耦合度高，难以应对变化
工厂模式：
java复制Product product = ProductFactory.createProduct();
优点：解耦，灵活
缺点：增加了复杂度
12.2 依赖注入 vs 工厂模式
依赖注入（如通过构造函数）：
java复制public class Client {
private final Product product;
public Client(Product product) {
this.product = product;
}
}
优点：更松散的耦合，易于测试
缺点：需要依赖注入框架支持
12.3 服务定位器 vs 工厂模式
服务定位器模式：
java复制Product product = ServiceLocator.getService("product");
优点：集中管理服务
缺点：隐藏依赖关系
12.4 建造者模式 vs 工厂模式
建造者模式：
java复制Product product = new ProductBuilder()
.withPartA(a)
.withPartB(b)
.build();
适用场景：当对象构造过程复杂，需要分步构建时
13. 工厂模式的演进与未来趋势
13.1 函数式编程中的工厂
在函数式编程中，工厂可以表示为高阶函数：
javascript复制function createLogger(type) {
switch (type) {
case 'file': return (message) => fs.appendFile('log.txt', message);
case 'console': return (message) => console.log(message);
default: throw new Error('Unknown logger type');
}
}
const fileLogger = createLogger('file');
fileLogger('This goes to file');
13.2 响应式编程中的工厂
RxJS中的操作符工厂：
javascript复制function createCustomOperator(config) {
return (source) => source.pipe(
filter(config.filterFn),
map(config.mapFn)
);
}
const customOp = createCustomOperator({
filterFn: x => x > 10,
mapFn: x => x * 2
});
observable$.pipe(customOp).subscribe(...);
13.3 云原生中的工厂模式
在云原生应用中，工厂模式用于创建云资源客户端：
java复制public interface CloudClientFactory {
StorageClient createStorageClient();
DatabaseClient createDatabaseClient();
}
public class AwsClientFactory implements CloudClientFactory {
public StorageClient createStorageClient() {
return new AwsS3Client();
}
public DatabaseClient createDatabaseClient() {
return new AwsDynamoDBClient();
}
}
13.4 微服务中的工厂应用
在微服务架构中，工厂模式常用于创建服务客户端：
java复制public interface ServiceClientFactory {
UserServiceClient createUserServiceClient();
OrderServiceClient createOrderServiceClient();
}
public class HttpServiceClientFactory implements ServiceClientFactory {
private final String baseUrl;
public HttpServiceClientFactory(String baseUrl) {
this.baseUrl = baseUrl;
}
public UserServiceClient createUserServiceClient() {
return new HttpUserServiceClient(baseUrl + "/users");
}
// 其他方法...
}
14. 工厂模式的反模式与误用
14.1 过度设计的工厂
当简单对象创建也使用工厂模式时，会导致不必要的复杂性：
java复制// 不推荐 - 过度设计
public class StringFactory {
public static String createString(String value) {
return new String(value);
}
}
// 应该直接使用
String str = "value";
14.2 违反单一职责原则的工厂
工厂类应该只负责对象创建，不应该包含业务逻辑：
java复制// 不推荐 - 工厂包含业务逻辑
public class OrderFactory {
public Order createOrder(OrderRequest request) {
Order order = new Order();
// 创建订单逻辑...
// 业务逻辑 - 不应该在这里
if (order.getTotal() > 1000) {
applyDiscount(order);
}
return order;
}
}
14.3 滥用静态工厂方法
过度使用静态工厂方法会导致代码难以测试和扩展：
java复制// 不推荐 - 过度使用静态方法
public class Product {
private Product() {}
public static Product createA() { ... }
public static Product createB() { ... }
}
14.4 忽略依赖注入的工厂
当依赖注入框架可用时，手动实现工厂可能是多余的：
java复制// 不推荐 - 当有DI框架时
public class ServiceFactory {
public static Service createService() {
Repository repo = new Repository();
Validator validator = new Validator();
return new Service(repo, validator);
}
}
// 推荐 - 使用DI框架
@Service
public class Service {
private final Repository repo;
private final Validator validator;
@Autowired
public Service(Repository repo, Validator validator) {
this.repo = repo;
this.validator = validator;
}
}
15. 工厂模式面试常见问题解析
15.1 工厂模式与抽象工厂模式的区别
工厂方法模式：
- 关注单个产品的创建
- 通过子类决定实例化哪个类
- 一个工厂类创建一个产品
抽象工厂模式：
- 关注产品家族的创建
- 通过组合不同的工厂接口来创建相关对象
- 一个工厂类创建多个相关产品
15.2 何时选择工厂方法模式而非抽象工厂模式
选择工厂方法模式当：
- 只需要创建一种产品时
- 产品的创建过程相对简单时
- 不需要强制产品间的兼容性时
选择抽象工厂模式当：
- 需要创建多个相关产品时
- 需要确保产品间的兼容性时
- 产品家族可能在未来扩展时
15.3 工厂模式如何支持开闭原则
工厂模式支持开闭原则体现在：
- 对扩展开放：可以通过添加新的工厂类或产品类来扩展系统，而不需要修改现有代码
- 对修改关闭：客户端代码依赖于抽象工厂和抽象产品，不需要因为具体产品的变化而修改
15.4 工厂模式在框架设计中的应用价值
工厂模式在框架设计中的价值：
- 解耦框架代码与客户代码
- 提供扩展点允许客户自定义行为
- 集中管理对象的创建逻辑
- 支持复杂的对象创建和初始化过程
16. 工厂模式的实际编码练习
16.1 简单工厂模式实现
实现一个形状工厂，可以创建圆形、矩形和三角形：
java复制interface Shape {
void draw();
}
class Circle implements Shape {
public void draw() { System.out.println("Drawing Circle"); }
}
class Rectangle implements Shape {
public void draw() { System.out.println("Drawing Rectangle"); }
}
class ShapeFactory {
public Shape createShape(String type) {
switch (type.toLowerCase()) {
case "circle": return new Circle();
case "rectangle": return new Rectangle();
default: throw new IllegalArgumentException("Unknown shape type");
}
}
}
16.2 工厂方法模式实现
实现一个日志记录器工厂，支持文件日志和数据库日志：
java复制interface Logger {
void log(String message);
}
class FileLogger implements Logger {
public void log(String message) {
System.out.println("File Log: " + message);
}
}
class DatabaseLogger implements Logger {
public void log(String message) {
System.out.println("Database Log: " + message);
}
}
abstract class LoggerFactory {
public abstract Logger createLogger();
public void log(String message) {
Logger logger = createLogger();
logger.log(message);
}
}
class FileLoggerFactory extends LoggerFactory {
public Logger createLogger() {
return new FileLogger();
}
}
class DatabaseLoggerFactory extends LoggerFactory {
public Logger createLogger() {
return new DatabaseLogger();
}
}
16.3 抽象工厂模式实现
实现一个UI组件工厂，支持Windows和Mac风格：
java复制interface Button {
void render();
}
interface Checkbox {
void render();
}
class WindowsButton implements Button {
public void render() { System.out.println("Windows style button"); }
}
class MacButton implements Button {
public void render() { System.out.println("Mac style button"); }
}
interface GUIFactory {
Button createButton();
Checkbox createCheckbox();
}
class WindowsFactory implements GUIFactory {
public Button createButton() { return new WindowsButton(); }
public Checkbox createCheckbox() { return new WindowsCheckbox(); }
}
class MacFactory implements GUIFactory {
public Button createButton() { return new MacButton(); }
public Checkbox createCheckbox() { return new MacCheckbox(); }
}
17. 工厂模式的项目实战建议
17.1 在现有项目中引入工厂模式
引入工厂模式的步骤：
- 识别对象创建的热点区域
- 将创建逻辑提取到工厂类中
- 逐步替换直接实例化为工厂调用
- 确保不影响现有功能
17.2 工厂模式的代码审查要点
审查工厂模式实现时关注：
- 工厂类是否单一职责
- 是否支持扩展而不需要修改
- 命名是否清晰表达意图
- 异常处理是否合理
- 是否考虑了线程安全
17.3 工厂模式的文档编写建议
为工厂模式编写文档时应包括：
- 工厂的用途和创建的对象类型
- 使用示例
- 可用的产品类型及其区别
- 任何特殊的初始化要求
- 线程安全说明
17.4 工厂模式的演进策略
随着项目发展，工厂模式可能需要演进：
- 从简单工厂升级为工厂方法
- 引入抽象工厂支持产品家族
- 与依赖注入框架集成
- 增加缓存或对象池优化性能
18. 工厂模式的扩展阅读与资源
18.1 经典设计模式书籍推荐
- 《设计模式：可复用面向对象软件的基础》- GoF
- 《Head First设计模式》- Eric Freeman等
- 《设计模式之禅》- 秦小波
18.2 工厂模式相关技术文章
- "工厂方法模式深度解析" - Java Code Geeks
- "抽象工厂模式在现代应用中的应用" - DZone
- "设计模式实战：工厂模式的最佳实践" - Dev.to
18.3 开源项目中的工厂模式实例
- Spring Framework中的BeanFactory
- Java Collections中的Collections类
- Google Guava中的Suppliers类
18.4 工厂模式的在线学习资源
- Refactoring.Guru的设计模式教程
- Java设计模式实战课程 - Udemy
- 设计模式系列视频 - Pluralsight
19. 工厂模式的个人实践心得
在实际项目中使用工厂模式多年，我总结了以下几点经验：
-
不要为了模式而模式：只有当对象创建确实变得复杂或需要灵活性时，才引入工厂模式。简单的对象创建直接使用new即可。
-
命名至关重要：工厂类和方法的命名应该清晰地表达其意图。比如createFileLogger()比createLogger()更明确。
-
考虑测试便利性：良好的工厂设计应该使单元测试更容易，能够轻松注入模拟对象。
-
文档化产品类型：特别是当使用字符串或枚举来标识产品类型时，确保所有可用选项都有文档说明。
-
性能敏感处谨慎使用：在性能关键路径上，工厂的间接调用可能带来开销，必要时可以考虑其他优化方案。
-
与DI框架协同工作：在现代应用中，工厂模式通常与依赖注入框架配合使用，而不是替代它们。
-
保持工厂的纯洁性：避免在工厂中加入业务逻辑，工厂应该只负责对象的创建和初始化。
-
渐进式复杂化：从简单工厂开始，只有当需求变得更复杂时，才升级到工厂方法或抽象工厂。
20. 工厂模式的未来展望
随着编程语言和范式的发展，工厂模式也在不断演进：
-
函数式风格的工厂：在现代语言中，工厂可以表示为函数或lambda表达式，更加简洁灵活。
-
响应式工厂：在响应式编程中，工厂可能返回Observable或Future，支持异步创建。
-
DSL构建器：通过领域特定语言(DSL)提供更声明式的对象创建方式。
-
AI辅助工厂：未来可能会有AI根据上下文自动生成最适合的对象实例。
-
云原生工厂：在云环境中，工厂可能需要处理分布式创建和跨服务边界的问题。
无论形式如何变化，工厂模式的核心思想——将对象创建与使用分离——仍将是软件设计中的重要原则。作为开发者，我们应该理解其本质，而不是拘泥于特定的实现形式。