浅谈工厂模式-优快云博客

什么是工厂模式

工厂模式（Factory Pattern）是一种常见的创建模型设计模式，其核心思想是通过封装对象的创建逻辑，将对象的创建与使用分离，从而提高代码的可维护性和可扩展性。

工厂模式主要核心思想

        解耦：将对象的创建逻辑与使用逻辑分离，降低代码的耦合度
        扩展性：当需要新增产品时，只需扩展工厂和产品类，无需修改现有代码
        灵活性：通过工厂接口，客户端代码可以动态决定创建哪种具体对象

工厂模式通常分以下三种类型

1、简单工厂模式
定义：通过一个工厂类根据传入的参数决定创建哪种具体对象
特点：工厂类直接包含创建逻辑，通常使用静态方法
适用场景：产品种类较少且创建逻辑简单、客户端不需要动态切换产品类型

代码示例

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("画一个圆形");
    }
}

public class ShapeFactory {
    public static Shape createShape(String type) {
        if ("circle".equalsIgnoreCase(type)) {
            return new Circle();
        } else if ("rectangle".equalsIgnoreCase(type)) {
            return new Rectangle();
        } else {
            throw new IllegalArgumentException("未知图形类型");
        }
    }
}

2、工厂方法模式
定义：定义一个创建对象的接口（抽象工厂），由子类决定实例化哪个具体类
特点：新增产品时只需添加新的工厂类和产品类，符合开闭原则
适用场景：产品种类较多且需要动态切换、需要将创建逻辑分散到多个子类中

示例代码

// 抽象产品
public interface Coffee {
    void make();
}

// 具体产品
public class Latte implements Coffee {
    @Override
    public void make() {
        System.out.println("制作拿铁咖啡");
    }
}

// 抽象工厂
public interface CoffeeFactory {
    Coffee create();
}

// 具体工厂
public class LatteFactory implements CoffeeFactory {
    @Override
    public Coffee create() {
        return new Latte();
    }
}

// 客户端调用
public class Client {
    public static void main(String[] args) {
        CoffeeFactory factory = new LatteFactory();
        Coffee coffee = factory.create();
        coffee.make();
    }
}

3、抽象工厂模式
定义：提供一个创建一系列相关嚯依赖对象的接口，而无需指定它们的具体类
特点：适用于创建产品类，如不同品牌的系列产品、需要定义多个抽象产品接口和对应的工厂
适用场景：需要创建一组相互关联或依赖的对象、产品类的扩展需求较高，如操作系统主体、数据库驱动等

示例代码

// 抽象产品A
public interface ProductA {
    void methodA();
}

// 具体产品A1
public class ProductA1 implements ProductA {
    @Override
    public void methodA() {
        System.out.println("ProductA1 的方法");
    }
}

// 抽象产品B
public interface ProductB {
    void methodB();
}

// 具体产品B1
public class ProductB1 implements ProductB {
    @Override
    public void methodB() {
        System.out.println("ProductB1 的方法");
    }
}

// 抽象工厂
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1
public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 客户端调用
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();
        ProductA a = factory.createProductA();
        ProductB b = factory.createProductB();
        a.methodA();
        b.methodB();
    }
}

工厂模式的优缺点
优点
   解耦：将对象的创建与使用分离，降低代码的耦合度
   可维护性：修改或扩展对象的创建逻辑时，只需修改工厂类，无需改动客户端代码
   可扩展性：新增产品时，只需添加新的工厂和产品类，符合开闭原则
   代码复用：工厂类可以被多个客户端复用，减少重复代码

缺点
   类数量增加：工厂模式会引入多个工厂类和产品类，增加系统的复杂度
   抽象层次高：对于初学者类说，理解工厂模式的抽象层次可能需要消耗不少的时间
   违反开闭原则（简单工厂）：简单工厂模式在新增产品时需要修改工厂类的判断逻辑，违反开闭原则

工厂模式的应用场景
日志记录：日志可能需要写入不同的位置，通过工厂模式动态选择实现
数据库访问：当需要支持多种数据库，通过工厂模式切换数据库驱动
协议处理：支持多种通信协议，通过工厂模式动态选择协议实现
框架设计：spring框架中的BeanFactory，通过工厂模式管理Bean的创建

总结来说，工厂模式的核心是封装对象的创建逻辑，通过将创建过程交给工厂类，使客户端代码更简结、灵活。根据需求选择不同类型的工厂模式，比如简单工厂，适用于产品种类少且创建逻辑简单的场景，如工厂方法，适用于需要动态切换产品类型且符合开闭原则的场景，如抽象工厂，适用于需要创建多个相关或依赖对象的场景。