设计模式（八）Abstract Factory模式

　　抽象工厂的工作是将“抽象零件”组装为“抽象产品”。在抽象工厂模式中将会出现抽象工厂，它会将抽象零件组装为抽象产品。也就是说，我们并不关心零件的具体实现，而是只关心接口。我们仅适用该接口将零件组装起来成为产品。

　　

　　示例程序的功能是将带有层次关系的链接的集合制作成HTML文件。

package bigjunoba.bjtu.factory;

public abstract class Item {
    protected String caption;

    public Item(String caption) {
        this.caption = caption;
    }

    public abstract String makeHTML();
}

　　Item类是Link类和Tray类的父类。这样，Link类和Tray类就具有可替换性了。caption字段表示项目的“标题”。

package bigjunoba.bjtu.factory;

public abstract class Link extends Item {
    protected String url;

    public Link(String caption, String url) {
        super(caption);
        this.url = url;
    }
}

　　Link类是抽象地表示HTML的超链接的类。url字段中保存的是超链接所指向的地址。由于Link类中没有实现父类的抽象方法makeHTML，因此它也是抽象类。

package bigjunoba.bjtu.factory;
import java.util.ArrayList;

public abstract class Tray extends Item {
    protected ArrayList<Item> tray = new ArrayList<Item>();
    public Tray(String caption) {
        super(caption);
    }
    public void add(Item item) {
        tray.add(item);
    }
}

　　Tray类表示的是一个含有多个Link类和Tray类的容器。add方法将Link类和Tray类集合在一起。同理，也没有实现父类的抽象方法makeHTML，因此它也是抽象类。

package bigjunoba.bjtu.factory;

import java.io.*;
import java.util.ArrayList;

public abstract class Page {
    protected String title;
    protected String author;
    protected ArrayList<Item> content = new ArrayList<Item>();

    public Page(String title, String author) {
        this.title = title;
        this.author = author;
    }

    public void add(Item item) {
        content.add(item);
    }

    public void output() {
        try {
            String filename = title + ".html";
            Writer writer = new FileWriter(filename);
            writer.write(this.makeHTML());
            writer.close();
            System.out.println(filename + " 编写完成。");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public abstract String makeHTML();
}

　　Page是抽象地表示HTML页面的类。如果将Link和Tray比喻成抽象的“零件”，那么Page类就是抽象的“产品”。使用add方法向页面中增加Item，output方法首选根据页面标题确定文件名，接着调用makeHTML方法（为了强调调用的是自己的makeHTML方法，直接显式地加上了this）将自身保存的HTML内容写入到文件中。

package bigjunoba.bjtu.factory;

public abstract class Factory {
    public static Factory getFactory(String classname) {
        Factory factory = null;
        try {
            factory = (Factory)Class.forName(classname).newInstance();
        } catch (ClassNotFoundException e) {
            System.err.println("没有找到 " + classname + "类。");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return factory;
    }
    public abstract Link createLink(String caption, String url);
    public abstract Tray createTray(String caption);
    public abstract Page createPage(String title, String author);
　}

　　Factory类中的getFactory方法，可以根据指定的类名生成具体工厂的实例。getFactory方法通过调用Class类的forName方法来动态地读取类信息，接着使用newInstance方法生成该类的实例，并将其作为返回值返回给调用者。

package bigjunoba.bjtu.test;

import bigjunoba.bjtu.factory.*;

public class Main {
    public static void main(String[] args) {
        if (args.length != 1) {
            System.out.println("Usage: java Main class.name.of.ConcreteFactory");
            System.out.println("Example 1: java Main bigjunoba.bjtu.listfactory.ListFactory");
            System.out.println("Example 2: java Main bigjunoba.bjtu.tablefactory.TableFactory");
            System.exit(0);
        }
        Factory factory = Factory.getFactory(args[0]);

        Link people = factory.createLink("人民日报", "http://www.people.com.cn/");
        Link gmw = factory.createLink("光明日报", "http://www.gmw.cn/");

        Link us_yahoo = factory.createLink("Yahoo!", "http://www.yahoo.com/");
        Link jp_yahoo = factory.createLink("Yahoo!Japan", "http://www.yahoo.co.jp/");
        Link excite = factory.createLink("Excite", "http://www.excite.com/");
        Link google = factory.createLink("Google", "http://www.google.com/");

        Tray traynews = factory.createTray("日报");
        traynews.add(people);
        traynews.add(gmw);

        Tray trayyahoo = factory.createTray("Yahoo!");
        trayyahoo.add(us_yahoo);
        trayyahoo.add(jp_yahoo);

        Tray traysearch = factory.createTray("检索引擎");
        traysearch.add(trayyahoo);
        traysearch.add(excite);
        traysearch.add(google);

        Page page = factory.createPage("LinkPage", "杨文轩");
        page.add(traynews);
        page.add(traysearch);
        page.output();
    }
}

　　Main类使用抽象工厂生产零件并将零件组装成产品。由于Main类只引入了一个包，所以可以看出，该类并没有使用任何具体零件、产品和工厂。

package bigjunoba.bjtu.listfactory;

import bigjunoba.bjtu.factory.*;

public class ListFactory extends Factory {
    public Link createLink(String caption, String url) {
        return new ListLink(caption, url);
    }

    public Tray createTray(String caption) {
        return new ListTray(caption);
    }

    public Page createPage(String title, String author) {
        return new ListPage(title, author);
    }
}

　　ListFactory类只是简单地new出了ListLink、ListTray和ListPage的实例。

package bigjunoba.bjtu.listfactory;

import bigjunoba.bjtu.factory.*;;

public class ListLink extends Link {
    public ListLink(String caption, String url) {
        super(caption, url);
    }

    public String makeHTML() {
        return "  <li><a href="" + url + "">" + caption + "</a></li>
";
    }
}

　　ListLink类使用<li>和<a>标签来制作HTML片段。

package bigjunoba.bjtu.listfactory;

import bigjunoba.bjtu.factory.*;
import java.util.Iterator;

public class ListTray extends Tray {
    public ListTray(String caption) {
        super(caption);
    }

    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<li>
");
        buffer.append(caption + "
");
        buffer.append("<ul>
");
        Iterator<Item> it = tray.iterator();
        while (it.hasNext()) {
            Item item = (Item) it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</ul>
");
        buffer.append("</li>
");
        return buffer.toString();
    }
}

　　ListTray类中tray字段保存了所有需要以HTML格式输出的Item，而负责将它们以HTML格式输出的就是makeHTML方法。makeHTML方法首先使用<li>标签输出标题，接着使用</ul>和</li>标签输出每个Item。

　　每个Item输出为HTML格式的方法就是调用每个Item的makeHTML方法了。这里并不关心变量item中保存的实例的类型究竟是ListLink还是ListTray，只是简单地调用了item.makeHTML()而已。变量item是Item类型的，而Item类又声明了makeHTML方法，而且ListLink类和ListTray类都是Item类的子类，因此可以放心调用。这就是面向对象的优点。

package bigjunoba.bjtu.listfactory;

import bigjunoba.bjtu.factory.*;
import java.util.Iterator;

public class ListPage extends Page {
    public ListPage(String title, String author) {
        super(title, author);
    }

    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<html><head><title>" + title + "</title></head>
");
        buffer.append("<body>
");
        buffer.append("<h1>" + title + "</h1>
");
        buffer.append("<ul>
");
        Iterator<Item> it = content.iterator();
        while (it.hasNext()) {
            Item item = (Item) it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</ul>
");
        buffer.append("<hr><address>" + author + "</address>");
        buffer.append("</body></html>
");
        return buffer.toString();
    }
}

　　ListPage类和ListTray类差不多。

　　当只有一个具体工厂的时候，是完全没有必要划分“抽象类”与“具体类”的。还要增加一个tablefactoty将链接以表格形式展示出来。

　　代码结构如上图，这里就不写tablefactory部分的代码了。

<html><head><title>LinkPage</title></head>
<body>
<h1>LinkPage</h1>
<ul>
<li>
日报
<ul>
  <li><a href="http://www.people.com.cn/">人民日报</a></li>
  <li><a href="http://www.gmw.cn/">光明日报</a></li>
</ul>
</li>
<li>
检索引擎
<ul>
<li>
Yahoo!
<ul>
  <li><a href="http://www.yahoo.com/">Yahoo!</a></li>
  <li><a href="http://www.yahoo.co.jp/">Yahoo!Japan</a></li>
</ul>
</li>
  <li><a href="http://www.excite.com/">Excite</a></li>
  <li><a href="http://www.google.com/">Google</a></li>
</ul>
</li>
</ul>
<hr><address>杨文轩</address></body></html>

 　　执行javac Main.java bigjunoba.bjtu.listfactory/ListFactory.java后的结果如上。

<html><head><title>LinkPage</title></head>
<body>
<h1>LinkPage</h1>
<table width="80%" border="3">
<tr><td><table width="100%" border="1"><tr><td bgcolor="#cccccc" align="center" colspan="2"><b>日报</b></td></tr>
<tr>
<td><a href="http://www.people.com.cn/">人民日报</a></td>
<td><a href="http://www.gmw.cn/">光明日报</a></td>
</tr></

 　　执行javac Main.java bigjunoba.bjtu.tablefactory/TableFactory.java后的结果如上。

　　抽象工厂模式的类图。

　　抽象工厂的特点：

　　1.易于增加具体的工厂。假如要增加新的具体工厂，那么需要做的就是编写Factory、Link、Tray和Page这4个类的子类，并实现它们定义的抽象方法。这样，无论增加多少个具体工厂，都无需修改抽象工厂和Main部分。

　　2.难以增加新的零件。假如要在factory包中增加一个表示图像的Picture零件，那就必须要对所有的具体工厂进行相应的修改才行。例如，需要在listfactory包中就必须做到假如createPicture方法和新增ListPictrue类，这样编写完成的具体工厂越多，修改的工作量就会越大。