Java设计模式--工厂方法模式FactoryMethod

应用场景

通常由应用程序直接使用new创建新的对象，为了将对象的创建和使用相分离，采用工厂模式,即应用程序将对象的创建及初始化职责交给工厂对象。
一般情况下,应用程序有自己的工厂对象来创建Bean.如果将应用程序自己的工厂对象交给Spring管理,那么Spring
管理的就不是普通的Bean,而是工厂Bean。

归类

创建型模式

特点

对于调用者来说，隐藏了复杂的逻辑处理过程，调用者只关心执行结果。
对于工厂来说要对结果负责，保证生产出符合规范的产品。

穷举

流水线生产

工厂方法模式的介绍

工厂方法模型，又称为多态性工厂模型，在工厂方法模型中，核心的工厂类不再负责所有的产品的创建，而是将具体实例化的工作交给了子类完成。该核心工厂类成为一个抽象工厂角色，作用是给具体的工厂子类必须实现的接口，不接触具体实例化哪些产品的细节。

模式组成

模式组成.png 模式组成.png

表述代码

我们先实现抽象产品类Product

public abstract class Product {

    //产品类的公共方法
    public void method1() {
        
    }
    
    public abstract void method2();
}

有了抽象产品类还不行，我们还需要具体的产品ConcreteProduct1：

public class ConcreteProduct1 extends Product {

    public void method2() {
        //业务逻辑处理
        System.out.println("this is product 1...");
    }
}

ConcreteProduct2:

public class ConcreteProduct2 extends Product {

    public void method2() {
        //业务逻辑处理
        System.out.println("this is product 2...");
    }
}

现在我们定义一个抽象的工厂类，让它声明带实现的接口Creator：

public abstract class Creator {

    public abstract <T extends Product> T createProduct(Class<T> c);
}

实现具体工厂类ConcreCreator：

public class ConcreCreator extends Creator {

    @Override
    public <T extends Product> T createProduct(Class<T> c) {
        // TODO Auto-generated method stub
        Product product = null;
        try {
            product = (Product)Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            //异常处理
        }
        return (T)product;
    }
}

我们的客户端：

public class Client {

    public static void main(String[] args) {
        Creator creator = new ConcreCreator();
        Product product = creator.createProduct(ConcreteProduct2.class);
        product.method2();
        
        /**
         * 继续业务处理
         */
    }
}

替代单例模式

import java.lang.reflect.Constructor;

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;
    }
}

延迟初始化

什么是延迟初始化？一个对象被消费完毕后，并不立即释放，工厂类保持其初始状态，等待再次被使用，延迟初始化是工厂方法模式的一个扩展应用。

图片.png

public class ProductFactory {

    private static final Map<String, Product> prMap = new HashMap();
    public static synchronized Product createProduct(String type) throws Exception {
        Product product = null;
        if(prMap.containsKey(type)) {
            product = prMap.get(type);
        }
        else {
            if(type.equals("Product1")) {
                product = new ConcreteProduct1();
            }
            else {
                product = new ConcreteProduct2();
            }
            prMap.put(type, product);
        }
        return product;
    }
    
}

工厂方法模型的优点

• 更加符合开闭原则,新增一种产品时，只需要增加相应的具体产品类和相应的工厂子类即可
• 不使用静态工厂方法，可以形成基于继承的等级结构,简单工厂模式的工厂类使用静态工厂方法
• 具有良好的封闭性和可扩展性，代码的结构更加清晰

工厂方法模型的缺点

• 增加新产品类型时，除了增加新产品类，还需要增加具体的工厂类，使得系统类的数目成对增加，一定程度上增加了系统的复杂度
• 虽然保证了工厂方法内的对修改关闭，但对于使用工厂方法的类，如果要更换另外一种产品，仍然需要修改实例化的具体工厂类