持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第4天，点击查看活动详情

1. 工厂方法模式

工厂方法模式（Factory Method Pattern）定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。

抽象产品类Product负责定义产品的共性，实现对事物最抽象的定义，Creator为抽象工厂类，具体如何创建产品类是由具体工厂类ConcreteCreator完成的。

1.1. 产品类

1.1.1. 抽象产品类

public abstract class Product {
    /**
     * 产品类的公共方法
     */
    public void method1() {
        //业务逻辑处理
    }
    /**
     * 抽象方法
     */
    public abstract void method2();
}

1.1.2. 具体产品类

public class ConcreteProduct1 extends Product {
    @Override
    public void method2() {
        //业务处理逻辑
    }
}

public class ConcreteProduct2 extends Product {
    @Override
    public void method2() {
        //业务处理逻辑
    }
}

1.2. 工厂类

1.2.1. 抽象工厂类

public abstract class Creator {
    /**
     * 创建一个产品对象
     *
     * @param c   Product类的子类Class
     * @param <T> 泛型
     * @return Product类的子类对象
     */
    public abstract <T extends Product> T createProduct(Class<T> c);
}

1.2.2. 具体工厂类

public class ConcreteCreator extends Creator {
    @Override
    public <T extends Product> T createProduct(Class<T> c) {
        Product product = null;
        try {
            product = (Product)Class.forName(c.getName()).newInstance();
        }catch (Exception e){
            //异常处理
        }
        return (T)product;
    }
}

1.3. 使用示例

public class Test {
    public static void main(String[] args) {
        Creator creator = new ConcreteCreator();
        
        Product product1 = creator.createProduct(ConcreteProduct1.class);
        Product product2 = creator.createProduct(ConcreteProduct2.class);
        
        ConcreteProduct1 concreteProduct1 = creator.createProduct(ConcreteProduct1.class);
        ConcreteProduct2 concreteProduct2 = creator.createProduct(ConcreteProduct2.class);
        //继续业务处理
    }
}

2. 工厂方法模式扩展

2.1. 简单工厂模式

该模式是工厂方法模式的弱化，因为简单，所以称为简单工厂模式（Simple Factory Pattern），也叫做静态工厂模式。缺点是工厂类的扩展比较困难，不符合开闭原则。但是一般一个模块也就需要一个工厂类，所以该模式用的还是比较多的。

对比工厂方法模式，该模式去掉了抽象工厂类Creator ，具体工厂类ConcreteCreator去掉继承，方法做了静态修改。

2.1.1. 静态工厂类

public class ConcreteCreator {
    public static <T extends Product> T createProduct(Class<T> c) {
        Product product = null;
        try {
            product = (Product) Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            //异常处理
        }
        return (T) product;
    }
}

2.1.2. 使用示例

public class Test {
    public static void main(String[] args) {
        Product product1 = ConcreteCreator.createProduct(ConcreteProduct1.class);
        Product product2 = ConcreteCreator.createProduct(ConcreteProduct2.class);

        ConcreteProduct1 concreteProduct1 = ConcreteCreator.createProduct(ConcreteProduct1.class);
        ConcreteProduct2 concreteProduct2 = ConcreteCreator.createProduct(ConcreteProduct2.class);
        //继续业务处理
    }
}

2.2. 多工厂模式

如果每个产品类的初始化都不同，这时候所有的产品类都放到一个工厂方法中进行初始化会使代码结构不够清晰，所以可以采用多工厂模式（Multiple Factory Pattern），每个产品都实现一个工厂类，各自的初始化使用各自对应的工厂类进行。

对比工厂方法模式，该模式修改了抽象工厂类Creator的抽象方法，去掉了具体工厂类ConcreteCreator，替代为各自具体产品的工厂类。

2.2.1. 抽象工厂类

public abstract class Creator {
    /**
     * 创建一个产品对象
     *
     * @return Product类的子类对象
     */
    public abstract Product createProduct();
}

2.2.2. 多工厂类

public class CreatorFactory1 extends Creator {
    @Override
    public Product createProduct() {
        return new ConcreteProduct1();
    }
}

public class CreatorFactory2 extends Creator {
    @Override
    public Product createProduct() {
        return new ConcreteProduct2();
    }
}

2.2.3. 使用示例

public class Test {
    public static void main(String[] args) {
        CreatorFactory1 creatorFactory1 = new CreatorFactory1();
        Product product1 = creatorFactory1.createProduct();

        CreatorFactory2 creatorFactory2 = new CreatorFactory2();
        Product product2 = creatorFactory2.createProduct();
        //继续业务处理
    }
}

复杂的应用中一般采用多工厂模式，然后再增加一个协调类，用来封装子工厂类，避免调用者与各个子工厂类交流，对高层模块提供统一的访问接口。

2.3. 替代单例模式

2.3.1. 单例类

public class Singleton {
    private Singleton(){}
    public void doSomething(){
        //业务处理
    }
}

2.3.2. 生产单例的工厂类

public class SingletonFactory {
    private static Singleton singleton;

    static {
        try {
            Class<?> c = Class.forName(Singleton.class.getName());
            //获得无参构造
            Constructor<?> constructor = c.getDeclaredConstructor();
            //设置无参构造是可访问的
            constructor.setAccessible(true);
            //生产一个实例对象
            singleton = (Singleton) constructor.newInstance();
        } catch (Exception e) {
            //异常处理
        }
    }

    public static Singleton getSingleton(){
        return singleton;
    }
}

2.4. 延迟初始化？

这里用到 1.1.1. 抽象产品类和 1.1.2. 具体产品类。

2.4.1. 抽象产品类

public abstract class Product {
    /**
     * 产品类的公共方法
     */
    public void method1() {
        //业务逻辑处理
    }
    /**
     * 抽象方法
     */
    public abstract void method2();
}

2.4.2. 具体产品类

public class ConcreteProduct1 extends Product {
    @Override
    public void method2() {
        //业务处理逻辑
    }
}

public class ConcreteProduct2 extends Product {
    @Override
    public void method2() {
        //业务处理逻辑
    }
}

2.4.3. 延迟加载工厂类？

public class ProductFactory {
    private static final Map<String, Product> prMap = new HashMap<>();

    public static synchronized Product createProduct(String type) throws Exception {
        Product product = null;
        //如果Map中已经有这个对象
        if (prMap.containsKey(type)) {
            product = prMap.get(type);
        } else {
            if (type.equals("Product1")) {
                product = new ConcreteProduct1();
            } else if (type.equals("Product2")) {
                product = new ConcreteProduct2();
            } else {
                //type参数错误，抛异常
            }
            prMap.put(type, product);
        }
        return product;
    }
}

创建型设计模式之工厂方法模式