工厂方法模式

1.简单工厂模式

     将对象的创建和使用分离，也就是在客户端与生产之间搭建一个中间类，这个类通过控制产品类的创建返回给客户端一个期望的值。

首先，为所有的产品创建一个接口或者抽象类。

【代码清单-1】

package com_1.huawei.product;
/**
 * 产品接口
 * @author Administrator
 *
 */
public interface IProduct 
{
    void work();
}

【代码清单-2】---具体产品类

package com_1.huawei.product.Impl;

import com_1.huawei.product.IProduct;

public class WasherProduct implements IProduct {

    @Override
    public void work() {
        System.out.println("Washer is working");
    }

}
============================
package com_1.huawei.product.Impl;

import com_1.huawei.product.IProduct;

public class IceboxProduct implements IProduct {

    @Override
    public void work() {
        System.out.println("Icebox is working");
    }

}

【代码清单-3】---工厂类

package com_1.huawei.factory;

import com_1.huawei.product.IProduct;
import com_1.huawei.product.Impl.IceboxProduct;
import com_1.huawei.product.Impl.WasherProduct;

/**
 * 工厂类
 * @author Administrator
 *
 */
public class Factory
{
    public static final int Washer = 0;
    public static final int Icebox = 1;
    
    public static IProduct create(int type)
    {
        if(type == Washer)
        {
            return new WasherProduct();
        }else if(type == Icebox)
        {
            return new IceboxProduct();
        }else
        {
            return null;
        }
        
    }
}

简单工厂模式的优点：

　　1- 客户端可以免除创建一个工厂类的实例，并且可以直接通过工厂类的静态方法来获得自己想要的产品，降低了客户端和工厂类的耦合，实现了

对象的创建和使用分离。

　　2- 工厂类只是去调用产品实现类去获得产品的实例，自己并没有去创建。

　　但是，当我们要去创建具体的产品对象时，还是需要到客户端去修改相关的代码，然后重新编译，违背了开闭原则。所以，借助于xml来适应变化的需求。

添加一个type.xml文件：

<thingtype>
    <type>Washer</type>
</thingtype>

以后，就只需修改xml文件中的值了，不用再修改客户端的代码。

【代码清单-4】

package utils;

import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.soap.Node;

import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import com_1.huawei.factory.Factory;
/**
 * 解析xml文件
 * @author Administrator
 *
 */
public class XMLUtil 
{
    public static int getType()
    {
        
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder(); 
            Document document = builder.parse(new File("thingtype.xml"));
            NodeList list = document.getElementsByTagName("type");
            org.w3c.dom.Node node = list.item(0).getFirstChild();
            String type = node.getNodeValue().trim();
            if(type.equals("Washer"))
            {
                return Factory.Washer;
            }else if(type.equals("Icebox"))
            {
                return Factory.Icebox;
            }
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return -1;
    }
}

 但是如果要增添产品类型，比如WasherB...这就要引入下面的工厂方法。

2.工厂方法

在简单工厂的设计思路上，我们可以用类似的方法，定义一个工厂接口类，让一种特定的产品由一个特定的Factory去创建。

这样上面的Factory就变成了下面的3个类。

【代码清单-5】

package com_1.huawei.gcff;

import com_1.huawei.product.IProduct;

public interface IFactory 
{
    public IProduct create();
}
=====================
package com_1.huawei.gcff.Impl;

import com_1.huawei.gcff.IFactory;
import com_1.huawei.product.IProduct;
import com_1.huawei.product.Impl.IceboxProduct;

public class IceboxFactory implements IFactory {

    @Override
    public IProduct create() {
        return new IceboxProduct();
    }

}
=========================
package com_1.huawei.gcff.Impl;

import com_1.huawei.gcff.IFactory;
import com_1.huawei.product.IProduct;
import com_1.huawei.product.Impl.WasherProduct;

public class WasherFactory implements IFactory {

    @Override
    public IProduct create() {
        return new WasherProduct();
    }

}

package com_1.huawei.gcff;

import com_1.huawei.gcff.Impl.WasherFactory;
import com_1.huawei.product.IProduct;

public class Main {

public static void main(String[] args)
{
IFactory factory = new WasherFactory();
IProduct product = factory.create();
product.work();
}

}

 这样就可以在客户端指定工厂去生产指定的产品了。不过如果需求改变时，还是你需要在客户端修改代码，所以升级为：

【代码清单-6】

<?xml version = "1.0" encoding = "utf-8">

<factory>
    <type>WasherFactory</type>
</faxtory>

      //客户端代码改为：    
                IFactory factory;
        IProduct product;
        factory = (IFactory) XMLUtil.getType2();
        product = factory.create();
        product.work();          
====================================
public static Object getType2()
    {

        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder(); 
            Document document = builder.parse(new File("factory.xml"));
            NodeList list = document.getElementsByTagName("type");
            Node node = list.item(0).getFirstChild();
            String mFactory = "com_1.huawei.gcff.Impl." + node.getNodeValue();
            Class mclass = Class.forName(mFactory);
            Object mObject = mclass.newInstance();
            return mObject;
        } catch (Exception e) {
            e.printStackTrace();
        }
    
        return null;
        
    }          

1.工厂模式的缺点：

      可以看出工厂方法的加入，使得对象的数量成倍增加。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。我们可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子互为）兄弟的使用简单工厂模式来实现。

2.工厂方法和简单工厂的区别：

      从上面创建产品对象的代码可以看出：简单工厂是把创建产品的职能都放在一个工厂类里面，而工厂方法则把不同的产品放在实现了工厂接口的不同工厂类里面，这样就算其中一个工厂类出了问题，其他工厂类也能正常工作，互相不受影响。以后增加新产品，也只需要新增一个实现工厂接口工厂类，不用修改已经有的代码。

3.抽象工厂

1.引入

  工厂方法模式有一个问题就是：类的创建依赖工厂类，也就是说，当要扩展程序时，必须对工厂类进行修改，这就违背了闭包原则，所以引入了下面的抽象工厂模式。创建多个工厂类，这样当有新的功能时，直接增加新的工厂类就可以了，不需要修改之前的代码。

2.概念

     在于创建一系列互相关联活相互依赖的对象。类似于在工厂方法的基础上引进了分类管理的概念。工厂方法用来创建一个产品，他没有分类的概念，而抽象工厂则用于创建一系列产品，所以产品分类成了抽象工厂的重点。

3.举例

【代码清单-7】---产品接口

package com.huawei.lwx349758.product;

/**
 * Washer(洗衣机)产品接口
 * @author Administrator
 *
 */
public interface Washer {

}

=============================
package com.huawei.lwx349758.product;

/**
 * Icebox(冰箱)接口
 * @author Administrator
 *
 */
public interface Icebox {

}

【代码清单-8】---产品实现类

package com.huawei.lwx349758.product.Impl;

import com.huawei.lwx349758.product.Washer;
/**
 * Washer产品实现类A
 * @author Administrator
 *
 */
public class WasherA implements Washer 
{
    public WasherA()
    {
        System.out.println("WasherA is created!");
    }
}
===================================
package com.huawei.lwx349758.product.Impl;

import com.huawei.lwx349758.product.Washer;
/**
 * Washer产品实现类B
 * @author Administrator
 *
 */
public class WasherB implements Washer 
{
    public WasherB()
    {
        System.out.println("WasherB is created!");
    }
}
===================================
package com.huawei.lwx349758.product.Impl;

import com.huawei.lwx349758.product.Icebox;
/**
 * Icebox产品实现类A
 * @author Administrator
 *
 */
public class IceboxA implements Icebox 
{
    public IceboxA()
    {
        System.out.println("IceboxA is created!");
    }
}

====================================
package com.huawei.lwx349758.product.Impl;

import com.huawei.lwx349758.product.Icebox;
/**
 * Icebox产品实现类B
 * @author Administrator
 *
 */
public class IceboxB implements Icebox 
{
    public IceboxB()
    {
        System.out.println("IceboxA is created!");
    }
}

【代码清单-9】---抽象工厂类（接口）

package com.huawei.lwx349758.factory;

import com.huawei.lwx349758.product.Icebox;
import com.huawei.lwx349758.product.Washer;
/**
 * 抽象工厂类，生产Washer Icebox
 * @author Administrator
 *
 */
public interface Factory 
{
    Washer createWasher();
    Icebox createIcebox();
}

【代码清单-10】---工厂实现类（具体工厂类）

package com.huawei.lwx349758.factory.Impl;

import com.huawei.lwx349758.factory.Factory;
import com.huawei.lwx349758.product.Icebox;
import com.huawei.lwx349758.product.Washer;
import com.huawei.lwx349758.product.Impl.IceboxA;
import com.huawei.lwx349758.product.Impl.WasherA;

public class FactoryA implements Factory {

    @Override
    public Washer createWasher() {
        return new WasherA();
    }

    @Override
    public Icebox createIcebox() {
        return new IceboxA();
    }
}

package com.huawei.lwx349758.factory.Impl;

import com.huawei.lwx349758.factory.Factory;
import com.huawei.lwx349758.product.Icebox;
import com.huawei.lwx349758.product.Washer;
import com.huawei.lwx349758.product.Impl.IceboxB;
import com.huawei.lwx349758.product.Impl.WasherB;

public class FactoryB implements Factory {

    @Override
    public Washer createWasher() {
    return new WasherB();
    }

    @Override
    public Icebox createIcebox() {
        return new IceboxB();
    }
}

【代码清单-11】---测试类

package com.huawei.lwx349758.test;

import com.huawei.lwx349758.factory.Factory;
import com.huawei.lwx349758.factory.Impl.FactoryA;
import com.huawei.lwx349758.product.Icebox;
import com.huawei.lwx349758.product.Washer;
/**
 * 测试类
 * @author Administrator
 *
 */
public class Main 
{
    public static void main(String[] args)
    {
        Factory factory = new FactoryA();
        Washer washer = factory.createWasher();
        Icebox icebox = factory.createIcebox();
    }
}

总结：

　　

　　　　1.简单工厂：由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。

　　　　2.工厂方法：有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。

　　　　3.抽象工厂：提供一个创建一系列相关活相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。当抽象工厂模式中只有一个产品族时，就退化为工厂方法了。

  优点：

　　　　1-良好的封装性，代码结构清晰。 调用一个产品对象，只要知道这个产品对象的类名就可以了，不需要知道这个创建对象的过程，减少了代码间的耦合度。

　　　　2-扩展性很好。 在增加产品类的时候，只需要修改一下具体的工厂类或者增加一个工厂类，就可以实现业务扩展。

　　　　3-屏蔽产品类。 产品类的实现如何变化，调用者都不需要关心，它只关心产品的调用接口。只要接口保持不变，系统中的上层模块就不会发生变化，因为产品类的实例化工作是有工厂类负责，一个产品对象具体由哪一个产品生成是由工厂决定的。

使用案例：

　　数据库开发时，如果使用JDBC连接数据库，数据库从Mysql切换到Oracle的时候，需要改动的地方就是切换一下驱动的名称，其他都不需要修改，这就是工厂方法模式的一个直接案例。

4.应用

4.1 --替代单例模式：

单例模式的核心是要求在内存中只有一个对象，通过工厂方法模式也可以在内存中只生产一个对象。

【代码清单-12】

package com.huawei.singleton;
/**
 * 通过工厂方法模式来实现单例模式，
 * @author Administrator
 *
 */
public class Singleton 
{
    //不允许通过new产生一个对象
    private Singleton()
    {
        
    }
    public void doSomething()
    {
        //业务处理
    } 

}

【代码清单-13】

package com.huawei.singleton;

import java.lang.reflect.Constructor;

/**
 * 通过反射方式创建一个单例对象
 * @author Administrator
 *
 */
public class SingletonFactory 
{
    private static Singleton singleton;
    
    static 
    {
        try
        {
            Class cl = Class.forName(Singleton.class.getName());
            //获得无参构造
            Constructor constructor = cl.getDeclaredConstructor();
            
            //设置无参构造是可访问的
            constructor.setAccessible(true);
            
            //产生一个实例对象
            singleton = (Singleton) constructor.newInstance();
            
        }catch(Exception e)
        {
            //异常处理
        }
    }
    
    public static Singleton getSingleton()
    {
        return singleton;
        
    }

}

通过获得类构造器，然后设置访问权限，生成一个对象，然后提供外部访问，保证了内存中的对象唯一。
以上通过工厂方法模式创建了一个单例对象，该框架可以继续扩展，在一个项目中可以产生一个单例构造器，所有需要产生
单例的类都遵循一定的规则（构造方法私有化），然后通过扩展改框架，只要输入一个类型就可以获得唯一的实例。

4.2--延迟初始化：

一个对象被消费完毕后，并不立刻释放，工厂类保持其初始化状态，等待再次被使用。

【代码清单-14】

package com.huawei.lazy_init;

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

【代码清单-15】：具体产品类

package com.huawei.lazy_init;

public class ProductAImpl extends Product {

    @Override
    public void method2() {
        //业务处理
        System.out.println("productA is created！");
    }

}

====================================
package com.huawei.lazy_init;

public class ProductBImpl extends Product {

    @Override
    public void method2() {
        //业务处理
        System.out.println("productA is created！");
    }

}

【代码清单-16】---工厂类

package com.huawei.lazy_init;

import java.util.HashMap;
import java.util.Map;

/**
 * 该类负责产品类对象的创建工作，并且通过prMap变量产生一个缓存，对需要再次
 * 被重用的对象保留。
 * @author Administrator
 *
 */
public class ProductFactory 
{
    public 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("productA"))
            {
                product = new ProductAImpl();
            }else
            {
                product = new ProductBImpl();
            }
            
            //同时把对象放到缓存容器中
            prMap.put(type, product);
        }
        return product;
        
    }

}

   延迟加载框架是可以扩展的，例如限制某一个产品类的最大实例化数量，可以通过判断Map中已经有的数量来实现，例如：JDBC连接数据库，都会要求设置一个MaxConnection最大连接数量，改数量就是内存中最大的实例化的数量。

延迟加载还可以使用在一个对象初始化比较复杂的情况，例如硬件访问，设计多方面的交互，则可以通过延迟加载降低对象的产生和销毁带来的复杂性。