工厂模式与抽象工厂模式

在软件设计中，工厂模式和抽象工厂模式是比较常用的两种模式。下面来对其分别进行介绍。

一、工厂模式

工厂方法模式继承了简单工厂模式的优点，也弥补了简单工厂模式的缺点，符合了“开闭原则”。如果不清楚什么是简单工厂模式，不用担心，接下来所讲的内容不会涉及简单工厂模式。

工厂模式的基本原则是：工厂父类负责创建产品对象的公共接口，而工厂子类来负责生产具体的产品对象。
是不是有点抽象，下面我们直接来看一个例子。

上图是一个UML类图，实现了一个最基本的工厂模式。其中Client是客户类，当它需要生产鞋的时候，会去调用ShoeFactory中的produceShoes()方法。

而鞋厂（ShoeFactory）本身是能生产男鞋（MaleShoes）和女鞋（FemaleShoes）的，因此在这里必然会使用到多态，即在ShoeFactory下还有两个子工厂（MaleShoesFactory和FemaleShoesFactory），子工厂负责创建真正的产品对象，而父工厂只负责提供一个接口。而当客户需要生产鞋的时候，只需申明一个ShoeFactory的变量指向一个MaleShoesFactory或者FemaleShoesFactory的对象即可。

然而如果仅仅是这样，仍旧是不符合开闭原则的，当需要生产男鞋或女鞋时我们仍然需要去修改代码，但是在此，我们引入了一个神奇的东西：利用DOM和java的反射，设计一个XML文件，保存需要新生成的类名，而再设计一个XML操作工具类XMLUtil，即可实现在程序运行时才能动态获取所需要生成的类。

是不是还是很抽象，没关系，看完代码就明白了。
下面是上面UML类图的实现代码。
先放上代码结构图：

Shoes

public interface Shoes {
    public void wear();
}

MaleShoes

public class MaleShoes implements Shoes{
    @Override
    public void wear() {
        System.out.println("Wear Male Shoes");
    }
}

FemaleShoes

public class FemaleShoes implements Shoes{
    @Override
    public void wear() {
        System.out.println("Wear Female Shoes");
    }
}

ShoeFactory

public interface ShoeFactory {
    public Shoes produceShoes();
}

MaleShoesFactory

public class MaleShoesFactory implements ShoeFactory{
    @Override
    public Shoes produceShoes() {
        System.out.println("Produce Male Shoes");
        return new MaleShoes();
    }
}

FemaleShoesFactory

public class FemaleShoesFactory implements ShoeFactory {
    @Override
    public Shoes produceShoes() {
        System.out.println("Produce Female Shoes");
        return null;
    }
}

XMLUtil

import javax.xml.parsers.*;
import org.xml.sax.SAXException;
import java.io.*;
import org.w3c.dom.*;

public class XMLUtil {
    public static Object getBean(){
        try{
            //创建DOM文档对象
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File("config.xml"));

            //获取包含类名的文本节点
            NodeList nl = doc.getElementsByTagName("className");
            Node classNode = nl.item(0).getFirstChild();
            String cName = classNode.getNodeValue();

            //通过类名生成实例对象并将其返回
            Class c = Class.forName(cName);
            Object obj = c.newInstance();
            return obj;

        }catch(Exception e){
            e.printStackTrace();
            return null;
        }

    }
}

config.xml

<?xml version="1.0" encoding="UTF-8"?>
<config>
    <className>com.zk.factory.MaleShoesFactory</className>
</config>

接下来就可以运行Client类进行试验了

public class Client {
    public static void main(String[] args) {
        try{
            Shoes shoes;
            ShoeFactory factory;
            factory = (ShoeFactory) XMLUtil.getBean();

            shoes = factory.produceShoes();
            shoes.wear();
        }catch(Exception e){

            System.out.println(e.getMessage());
        }
    }
}

运行结果为：

可以看见，程序正确执行并创建了MaleShoesFactory的实例，并成功调用了其produceShoes()方法和wear()方法。
需要注意的是，在XML配置文件中，如果xml文件不和java代码保存在同一个包下，一定要记得加上包名，否则可能会出现类名找不到的错误。

二、抽象工厂模式

前面讲了工厂模式，有没有发现其还是有缺点，比如说鞋厂只能生产同一款鞋，而设想下一家代加工的鞋厂，里面可能既加工Adidas的鞋，同时还加工Nike的鞋，或者再想想，Nike和Adidas公司在生产鞋的同时，都还在生产衣服，那么，这种情况用工厂模式就不能做到了，因此产生了抽象工厂模式。
抽象工厂模式的适用范围比工厂模式更加广泛，它与工厂模式最大的区别在于：
工厂模式中一个工厂只能生产一种产品，而抽象工厂可以生产多个。

下面来看一个例子：

这里有一家劳工工厂，里面分别为Nike和Adidas代加工产品，而Nike和Adidas都需要该厂为其加工衣服和鞋子。

下面放上代码：
这是代码结构图：

Shoes

public interface Shoes {
    public void wear();
}

AdidasShoes

public class AdidasShoes implements Shoes{
    @Override
    public void wear() {
        System.out.println("Wear Adidas Shoes");
    }
}

NikeShoes

public class NikeShoes implements Shoes{
    @Override
    public void wear() {
        System.out.println("Wear Nike Shoes");
    }
}

Clothes

public interface Clothes {
    public void wear();
}

NikeClothes

public class NikeClothes implements Clothes{
    @Override
    public void wear() {
        System.out.println("Wear Nike Clothes");
    }
}

AdidasClothes

public class AdidasClothes implements Clothes{
    @Override
    public void wear() {
        System.out.println("Wear Adidas Clothes");
    }
}

LabourFactory

public interface LabourFactory {
    Shoes produceShoes();
    Clothes produceClothes();
}

NikeFactory

public class NikeFactory implements LabourFactory{

    @Override
    public Shoes produceShoes() {
        System.out.println("Produce Nike Shoes");
        return new NikeShoes();
    }

    @Override
    public Clothes produceClothes() {
        System.out.println("Produce Nike Clothes");
        return new NikeClothes();
    }

}

AdidasFactory

public class AdidasFactory implements LabourFactory{

    @Override
    public Shoes produceShoes() {
        System.out.println("Produce Adidas Shoes");
        return new AdidasShoes();
    }

    @Override
    public Clothes produceClothes() {
        System.out.println("Produce Adidas Clothes");
        return new AdidasClothes();
    }

}

XMLUtil

import javax.xml.parsers.*;
import org.xml.sax.SAXException;
import java.io.*;
import org.w3c.dom.*;

public class XMLUtil {
    public static Object getBean(){
        try{
            //创建DOM文档对象
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File("config_abstract.xml"));

            //获取包含类名的文本节点
            NodeList nl = doc.getElementsByTagName("className");
            Node classNode = nl.item(0).getFirstChild();
            String cName = classNode.getNodeValue();

            //通过类名生成实例对象并将其返回
            Class c = Class.forName(cName);
            Object obj = c.newInstance();
            return obj;

        }catch(Exception e){
            e.printStackTrace();
            return null;
        }

    }
}

config_abstract.xml

<?xml version="1.0" encoding="UTF-8"?>
<config>
    <className>com.zk.abstractFactory.AdidasFactory</className>
</config>

接下来同样的写一个Client类来试着运行看看效果。

public class Client {
    public static void main(String[] args) {
        try{
            LabourFactory lFactory;
            Shoes shoes;
            Clothes clothes;
            lFactory = (LabourFactory) XMLUtil.getBean();
            shoes = lFactory.produceShoes();
            clothes = lFactory.produceClothes();
            shoes.wear();
            clothes.wear();
        }catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

运行结果如图：

程序再次正确运行啦

总结：工厂模式与抽象工厂模式都属于创建型模式，在工厂模式中弥补了简单工厂模式的缺陷（不符合开闭原则），而在抽象工厂模式中弥补了工厂模式的不足（一个工厂只能生产一种产品）。

嘻嘻最后放一张萌猫壁纸