《设计模式之禅》读书笔记-2.2-工厂方法模式

2.2 工厂方法模式

** 定义：**
定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

2.2.1 工厂方法模式

优点：

1. 良好的封装性，代码结构清晰。对象创建只需要知道产品的类名，不用知道对象创建的过程
2. 扩展性非常优秀。增加产品，只要适当修改具体的工厂类或扩展一个工厂类
3. 屏蔽产品类。产品类的实现如何变化，调用者都不用关心。

ex：使用JDBC连接数据库，数据库从MySQL切换到Oracle，只需要改动一下驱动的名称。

4. 典型的解耦扩建。高层模块只需要知道产品的抽象类，符合迪米特法则；只依赖产品类的抽象，符合依赖倒置原则；可用产品的子类代替父类，符合里氏替换原则

使用场景：

1. 工厂方法模式是new一个对象的替代品，所以在需要new 对象的地方都可以使用。但需慎重考虑是否要增加一个工厂类进行管理，以免增加代码复杂度。
2. 需要灵活的、可扩展的框架时，可以考虑。

ex：设计一个连接邮件服务器的框架，POP3、IMAP、HTTP三协议的连接方式作为产品类来处理。当某些邮件服务器扩展了webservice协议时，只需要增加webservice的产品类

3. 可以用在异构项目中。

ex：通过webservice与一个非java的项目交互，虽然webServcie号称是可以做到异构系统的同构化，但是在实际的开发中，会碰到类型问题、WSDL文件的支持问题等。从WSDL中产生的对象都认为是一个产品，然后由具体工厂管理，减少与外围的耦合。

4. 可以使用在测试框架中。

ex：测试类A，就需要把与A有联系的B也同时产生出来。可以使用工厂方法模式把B虚拟出来，避免A与B 的耦合。可对比JMock、EasyMock。

代码：

//抽象产品类
abstract class Product{
    public void method1(){}//公共方法
    public abstract void method2();//抽象方法
}

//具体产品类
class CreateProduct1 extends Product{
    public void method2(){}
}

class CreateProduct2 extends Product{
    public void method2(){}
}

//抽象工厂
abstract class Creator{
    public abstract  T createProduct(Class c);
}

//具体工厂
class CreateCreator extends Creator{
    public  T createProduct(Class c){
        Product p = null;
        try{
            p = (Product) Class.forName(c.getName()).newInstance();
        }catch(Exception e){
            
        }
        return (T)p;
    }
}

//场景类
class Client{
    public static void main(String[] args){
        Creator creator = new CreateCreator();
        Product p = creator.createProduct(CreateProduct1.class);
    }
} 

2.2.2 扩展-简单工厂模式

需求：

一个模块仅需要一个工厂类，没有必要把它new 出来，使用静态方法就可以了。

代码：

//具体工厂
class CreateCreator {
    public static  T createProduct(Class c){
        Product p = null;
        try{
            p = (Product) Class.forName(c.getName()).newInstance();
        }catch(Exception e){
            
        }
        return (T)p;
    }
}

//场景类
class Client{
    public static void main(String[] args){
            Product p = CreateCreator.createProduct(CreateProduct1.class);
    }
}

2.2.3 扩展-多个工厂类

需求：

项目比较复杂，初始化一个对象比较费力（设定初始值），所有产品类都放在一个工厂方法中进行初始化会使代码结构不清晰。

如：一个抽象产品类有5个具体实现，每个实现类的初始化方法都不相同，如果写在一个方法中，会导致该方法巨大无比。

解决：

为每个产品定义一个创造者，然后由调用者自己去选择与哪个工厂方法关联。

结果：

每个产品类对应一个具体工厂，好处是工厂类的职责清晰且结构简单，但可扩展性和可维护性有影响：

如果要扩展一个产品类，就要建立一相应的工厂，这样就增加了扩展的难度；具体工厂类和产品类的数目相同，维护需要考虑两者的关系。

代码：

//具体工厂1
class CreateCreator1 extends Creator{
    public Product createProduct(){
        return new CreateProduct1();
    }
}
//具体工厂2
class CreateCreator2 extends Creator{
    public Product createProduct(){
        return new CreateProduct2();
    }
}

//场景类
class Client{
    public static void main(String[] args){
        Product cp1 = (new CreateCreator1()).createProduct();
        Product cp2 = (new CreateCreator2()).createProduct();
    }
}

2.2.4 替代单例模式

扩展：

项目中可以建一个单例构造器，只要输入单例的类型就可以获得唯一的实例

代码：

class Singleton{
    private Singleton(){}
    public void doSomething(){}
}

class SingletonFactory{
    private static Singleton single;
    static{
        try {
            Class cls = Class.forName(Singleton.class.getName());
            Constructor constructor = cls.getDeclaredConstructor();
            constructor.setAccessible(true);
            single = (Singleton) constructor.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static Singleton getSingleton(){
        return single;
    }
}

2.2.5 延迟初始化

延迟初始化：lazy initialization 一个对象被消费完毕，不立即释放，工厂类保持其初始状态，等待再次被使用。

扩展：

限制某个产品类的最大实例化数量，可以通过判断map中的已有对象数量来实现。参考：JDBC连接数据库，可以设置一个MaxConnection最大连接数，该数量就是内存中的最大实例化的数量。

其它应用场景：

对象初始化比较复杂，如硬件访问，涉及多方面的交互，可以通过延迟加载降低对象的产生和销毁带来的复杂性。