Java 设计模式之工厂方法模式

---

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

1. 通用代码模板

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

1.1. 抽象产品类

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

1.2. 具体产品类

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

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

1.3. 抽象工厂类

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

1.4. 具体工厂类

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.5. 使用示例

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. 简单工厂模式（静态工厂模式）

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

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

2.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.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);
        //继续业务处理
    }
}

3. 多工厂模式

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

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

3.1. 抽象工厂类

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

3.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();
    }
}

3.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();
        //继续业务处理
    }
}

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

4. 单例工厂模式

通过工厂方法模式在内存中仅产生一个对象，叫做单例工厂模式。

4.1. 单例类

public class Singleton {
	/**
     * 私有构造方法
     */
    private Singleton(){}

    public void doSomething(){
        //业务方法
    }
}

4.2. 单例工厂类

public class SingletonFactory {
    private static Singleton singleton;
    
    static {
        try {
            Class<?> aClass = Class.forName(Singleton.class.getName());
            //获取无参构造函数
            Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
            //设置无参构造函数是可访问的
            declaredConstructor.setAccessible(true);
            //产生一个实例对象
            singleton = (Singleton) declaredConstructor.newInstance();
        }catch (Exception e){
            //异常处理
        }
    }
    
    public static Singleton getSingleton(){
        return singleton;
    }
}

4.3. 使用示例

public class Test {
    public static void main(String[] args) {
        Singleton singleton = SingletonFactory.getSingleton();
        //继续业务处理
    }
}

5. 延迟加载模式

延迟加载可以限制某个产品类的最大实例化数量。还可以用在对象初始化比较复杂的情况下，可以通过延迟加载降低对象的产生和销毁带来的复杂性。

5.1. 延迟加载的工厂类

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

    public static synchronized Product createProduct(String type) {
        Product product;
        if (PRODUCT_MAP.containsKey(type)) {
            product = PRODUCT_MAP.get(type);
        } else {
            if ("Product1".equals(type)) {
                product = new ConcreteProduct1();
            } else {
                product = new ConcreteProduct2();
            }
            //把对象放到缓存Map中
            PRODUCT_MAP.put(type, product);
        }
        return product;
    }
}