设计模式：Abstract Factory模式

by

2018-05-05

16:58:56

Leave a comment on 设计模式：Abstract Factory模式

Java

,

抽象工厂模式，通过抽象工厂将抽象零件组装成抽象产品；不用关心零件的具体实现，而是只关心接口，使用这些接口将零件组装成产品

与之前Factory，Template Method以及Builder模式一样，具体方法的实现在子类中，但不同的是，抽象工厂模式中，子类也有一个具体的工厂，负责将具体的零件组装成具体产品

来一个具体的案例，将带有层次关系的链接制作成HTML文件

最终浏览器显示如下：

LinkPage

李辉

对应的HTML源码如下

<html><head><title>LinkPage</title></head>
<body>
<h1>LinkPage</h1>
<ul>
<li>
 门户 
<ul>
 <li><a href="http://www.sina.com/"> 新浪 </a></li>
 <li><a href="http://www.sohu.com/"> 搜狐 </a></li>
</ul>
</li>
<li>
 搜索引擎 
<ul>
<li>
Google
<ul>
 <li><a href="http://www.google.com/">Google</a></li>
 <li><a href="http://www.google.cn/">Google.CN</a></li>
</ul>
</li>
 <li><a href="http://www.baidu.com/">BaiDu</a></li>
 <li><a href="http://www.sogou.com/">Sogou</a></li>
</ul>
</li>
</ul>
<hr><address> 李辉 </address></body></html>

该程序可以划分为3个包：

abstractfactory.factory包：包含抽象工厂，抽象零件，抽象产品的包

abstractfactory.listfactory包：包含具体工厂，具体零件，具体产品的包，这里代表以HTML的<ul>标签输出

具体的类如下：

Factory类：factory包，表示抽象工厂的类，制作Link，Tray，Page

Item类：factory包，用来统一处理Link和Tray的类

Link类：factory包，表示HTML连接的类，是抽象零件

Tray类：factory包，表示含有Link和Tray的类，是抽象零件

Page类：factory包，表示HTML页面的类，是抽象零件

Main类：main，测试

ListFactory类：listfactory包，表示具体工厂的类，制作ListLink，ListTray，ListPage

ListLink类：listfactory包，表示HTML链接的类，是具体零件

ListTray类：listfactory包，表示含有Link和Tray的类，是具体零件

ListPage类：listfactory包，表示HTML页面的类，是具体零件

抽象零件，Item类

Item类是Link类和Tray类的父类，相当于项目类，caption字段表示项目的标题，makeHTML方法是抽象方法，返回HTML文件的内容

package abstractfactory.factory;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: Item
 * Author:   lihui
 * Date:     2018/5/4 23:00
 */

public abstract class Item {
    protected String caption;
    public Item(String caption) {
        this.caption = caption;
    }
    public abstract String makeHTML();
}

抽象零件，Link类

Link类是HTML超链接的抽象类，url字段保存超链接指向的地址

package abstractfactory.factory;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: Link
 * Author:   lihui
 * Date:     2018/5/4 23:00
 */

public abstract class Link extends Item {
    protected String url;
    public Link(String caption, String url) {
        super(caption);
        this.url = url;
    }
}

抽象零件，Tray类

Tray类表示一个含有多个Link类和Tray类的容器，可以想象托盘上放置着一个一个的项目

Tray类使用add方法将Link类和Tray类集合在一起，设置add方法的参数为Link类和Tray类的父类Item类；Tray类没有重写了Item类的抽象方法，也是一个抽象类

package abstractfactory.factory;

import java.util.ArrayList;
import java.util.List;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: Tray
 * Author:   lihui
 * Date:     2018/5/4 23:00
 */

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

抽象产品，Page类

Page类是表示HTML页面的抽象类，相当于Link和Tray是抽象零件，Page就是抽象产品，title和author就是页面的标题和作者

可以使用add方法从页面中添加Item（也就是Link或者Tray），然后再页面上显示出来

output方法根据页面的标题来确定文件名，接着调用makeHTML方法将自身保存的HTML内容写入到文件中

package abstractfactory.factory;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.List;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: Page
 * Author:   lihui
 * Date:     2018/5/4 23:01
 */

public abstract class Page {
    protected String title;
    protected String author;
    protected List content = new ArrayList();
    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();
}

抽象工厂，Factory类

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

Class类属于java.lang包，用来表示类的类；Class类包含在Java标准库中，forName是java.lang.Class的静态方法，类方法，newInstance是java.lang.Class实例方法

有一点，getFactory方法生成的是具体工厂的实例，但是返回值的类型却是抽象工厂类型

createLink，createTray，createPage方法都是在抽象工厂中生成零件和产品的抽象方法，而具体实现都交给了Factory的子类，但是这里确定了方法的名字和签名

package abstractfactory.factory;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: Factory
 * Author:   lihui
 * Date:     2018/5/4 23:00
 */

public abstract class Factory {
    public static Factory getFactory(String classname) {
        Factory factory = null;
        try {
            factory = (Factory)Class.forName(classname).newInstance();
        } catch (ClassNotFoundException e) {
            System.out.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);
}

Main类，使用工厂将零件组装成为产品

package abstractfactory;

import abstractfactory.factory.Factory;
import abstractfactory.factory.Link;
import abstractfactory.factory.Page;
import abstractfactory.factory.Tray;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: Main
 * Author:   lihui
 * Date:     2018/5/4 22:59
 */

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 listfactory.ListFactory");
            System.out.println("Example 2: java Main tablefactory.TableFactory");
            System.exit(0);
        }
        Factory factory = Factory.getFactory(args[0]);

        Link people = factory.createLink(" 新浪 ", "http://www.sina.com/");
        Link gmw = factory.createLink(" 搜狐 ", "http://www.sohu.com/");
        
        Link us_yahoo = factory.createLink("Google", "http://www.google.com/");
        Link jp_yahoo = factory.createLink("Google.CN", "http://www.google.cn/");
        Link excite = factory.createLink("BaiDu", "http://www.baidu.com/");
        Link google = factory.createLink("Sogou", "http://www.sogou.com/");

        Tray traynews = factory.createTray(" 门户 ");
        traynews.add(people);
        traynews.add(gmw);
        
        Tray trayyahoo = factory.createTray("Google");
        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();
    }
}

这里只导入了factory包，并没有使用任何具体零件，产品和工厂，而具体工厂的类名要通过命令行参数来指定

具体源文件目录格式

lihui@MacBook  ~/IdeaProjects/cloud/src/main/java/abstractfactory  tree -F -L 2
.
├── Main.java
├── factory/
│   ├── Factory.java
│   ├── Item.java
│   ├── Link.java
│   ├── Page.java
│   └── Tray.java
├── listfactory/
│   ├── ListFactory.java
│   ├── ListLink.java
│   ├── ListPage.java
│   └── ListTray.java

由于Main类只使用了factory包，没有使用listfactory包；Main.java编译的时候，只有抽象类几个java文件会被编译，但是几个具体类的java文件并不会被编译，因此需要在编译的时候加上参数来保证具体类文件也能被编译，比如IDEA里，对比Main的路径

abstractfactory.listfactory.ListFactory

Main类使用getFactory方法生成arg[0]参数对应的工厂，并保存在factory变量中；然后Main类会使用factory生成Link和Tray，将Link和Tray都放入Tray中，最后生成Page并将生成结果输出至文件

具体工厂，ListFactory类

ListFactory类实现了Factory类的createLink，createTray，createPage方法，每个方法的实现new出了ListLink类，ListTray类，ListPage类的实例

package abstractfactory.listfactory;

import abstractfactory.factory.Factory;
import abstractfactory.factory.Link;
import abstractfactory.factory.Page;
import abstractfactory.factory.Tray;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: ListFactory
 * Author:   lihui
 * Date:     2018/5/4 23:01
 */

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

具体零件，ListLink类

ListLink类是Link类的子类，实现了超类Link里的makeHTML抽象方法，ListLink使用<li>标签和<a>标签来制作HTML片段，这段HTML片段也可以和ListTray和ListPage的结果合并起来

package abstractfactory.listfactory;

import abstractfactory.factory.Link;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: ListLink
 * Author:   lihui
 * Date:     2018/5/4 23:01
 */

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>\n";
    }
}

具体零件，ListTray类

ListTray类是Tray的子类，makeHTML方法的实现中，tray字段保存了所有需要以HTML格式输出的Item，而负责将它们以HTML格式输出的就是makeHTML方法了

makeHTML方法首先用<li>标签输出标题caption，接着使用<ul>和<li>标签输出每个Item，输出的结果先暂时保存在StringBuffer中，最后再通过toString方法将输出结果转换为String类型并返回给调用者

面向对象理解：

每个Item输出HTML格式通过调用每个Item的makeHTML方法，这里并不关心变量item中保存的实例是ListLink还是ListTray的实例，只是简单地调用了item.makeHTML()；这里不能使用switch或者if去判断变量item中保存的实例的类型，否则就是非对象编程了；变量item是Item类型的，而Item类又声明了makeHTML方法，而且ListLink类和ListTray类都是Item泪的子类，可以放心调用，之后item会帮忙处理，至于item究竟进行了什么样的处理，只有item的实例对象才知道，这就是面向对象的优点

package abstractfactory.listfactory;

import abstractfactory.factory.Item;
import abstractfactory.factory.Tray;

import java.util.Iterator;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: ListTray
 * Author:   lihui
 * Date:     2018/5/4 23:01
 */

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

具体产品，ListPage类

ListPage类是Page类的子类，将字段中保存的内容输出为HTML格式，author用<address>标签输出

while语句放在<ul></ul>之间，是因为在while语句中append的item.makeHTML()的输出结果需要被嵌入在<ul></ul>之间

package abstractfactory.listfactory;

import abstractfactory.factory.Item;
import abstractfactory.factory.Page;

import java.util.Iterator;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: ListPage
 * Author:   lihui
 * Date:     2018/5/4 23:01
 */

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>\n");
        buffer.append("<body>\n");
        buffer.append("<h1>" + title + "</h1>\n");
        buffer.append("<ul>\n");
        Iterator it = content.iterator();
        while (it.hasNext()) {
            Item item = (Item)it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</ul>\n");
        buffer.append("<hr><address>" + author + "</address>");
        buffer.append("</body></html>\n");
        return buffer.toString();
    }
}

这样就OK了

 

假如需要增加其他的工厂

上面listfactory包功能以超链接条目显示，现在新增一种以tablefactory将超链接以表格的形式展示，如下

LinkPage

门户 
新浪  搜狐 
搜索引擎 
Google
Google Google.CN
BaiDu Sogou
李辉

对应的HTML源码如下

<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.sina.com/"> 新浪 </a></td>
<td><a href="http://www.sohu.com/"> 搜狐 </a></td>
</tr></table></td></tr><tr><td><table width="100%" border="1"><tr><td bgcolor="#cccccc" align="center" colspan="3"><b> 搜索引擎 </b></td></tr>
<tr>
<td><table width="100%" border="1"><tr><td bgcolor="#cccccc" align="center" colspan="2"><b>Google</b></td></tr>
<tr>
<td><a href="http://www.google.com/">Google</a></td>
<td><a href="http://www.google.cn/">Google.CN</a></td>
</tr></table></td><td><a href="http://www.baidu.com/">BaiDu</a></td>
<td><a href="http://www.sogou.com/">Sogou</a></td>
</tr></table></td></tr></table>
<hr><address> 李辉 </address></body></html>

同时命令行参数

abstractfactory.tablefactory.TableFactory

需要新增一个包，tablefactory，对应的类

TableFactory类：具体工厂的类，制作TableLink，TableTray，TablePage

TableLink类：具体零件的类，表示HTML的超链接的类

TableTray类：具体零件的类，表示含有Link和Tray的类

TablePage类：具体产品的类，表示HTML页面的类

具体工厂，TableFactory类

Factory类的子类，createLink，createTray以及createPage方法分别生成TableLink，TableTray，TablePage的实例

package abstractfactory.tablefactory;

import abstractfactory.factory.Factory;
import abstractfactory.factory.Link;
import abstractfactory.factory.Page;
import abstractfactory.factory.Tray;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: TableFactory
 * Author:   lihui
 * Date:     2018/5/4 23:55
 */

public class TableFactory extends Factory {
    public Link createLink(String caption, String url) {
        return new TableLink(caption, url);
    }
    
    public Tray createTray(String caption) {
        return new TableTray(caption);
    }
    
    public Page createPage(String title, String author) {
        return new TablePage(title, author);
    }
}

具体零件，TableLink类

package abstractfactory.tablefactory;

import abstractfactory.factory.Link;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: TableLink
 * Author:   lihui
 * Date:     2018/5/4 23:55
 */

public class TableLink extends Link {
    public TableLink(String caption, String url) {
        super(caption, url);
    }
    
    public String makeHTML() {
        return "<td><a href=\"" + url + "\">" + caption + "</a></td>\n";
    }
}

具体零件，TableTray类，makeHTML使用<td>和<table>标签输出Item

package abstractfactory.tablefactory;

import abstractfactory.factory.Item;
import abstractfactory.factory.Tray;

import java.util.Iterator;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: TableTray
 * Author:   lihui
 * Date:     2018/5/4 23:55
 */

public class TableTray extends Tray {
    public TableTray(String caption) {
        super(caption);
    }
    
    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<td>");
        buffer.append("<table width=\"100%\" border=\"1\"><tr>");
        buffer.append("<td bgcolor=\"#cccccc\" align=\"center\" colspan=\"" + tray.size() + "\"><b>" + caption + "</b></td>");
        buffer.append("</tr>\n");
        buffer.append("<tr>\n");
        Iterator it = tray.iterator();
        while (it.hasNext()) {
            Item item = (Item)it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</tr></table>");
        buffer.append("</td>");
        return buffer.toString();
    }
}

具体产品，TablePage类

package abstractfactory.tablefactory;

import abstractfactory.factory.Item;
import abstractfactory.factory.Page;

import java.util.Iterator;

/**
 * Copyright (C), 2014-2018, maoxiaomeng.com
 * FileName: TablePage
 * Author:   lihui
 * Date:     2018/5/4 23:55
 */

public class TablePage extends Page {
    public TablePage(String title, String author) {
        super(title, author);
    }
    
    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<html><head><title>" + title + "</title></head>\n");
        buffer.append("<body>\n");
        buffer.append("<h1>" + title + "</h1>\n");
        buffer.append("<table width=\"80%\" border=\"3\">\n");
        Iterator it = content.iterator();
        while (it.hasNext()) {
            Item item = (Item)it.next();
            buffer.append("<tr>" + item.makeHTML() + "</tr>");
        }
        buffer.append("</table>\n");
        buffer.append("<hr><address>" + author + "</address>");
        buffer.append("</body></html>\n");
        return buffer.toString();
    }
}

 

抽象工厂模式的角色：

 AbstractProduct：抽象产品，例子中的Link，Tray，Page类；负责定义AbstractFactory角色所生成的抽象零件和产品的接口

AbstractFactory：抽象工厂，例子中的Factory类；负责定义用于生成抽象产品的接口

Client：委托者，例子中的Main类；调用AbstractFactory角色和AbstractProduct角色的接口进行工作，对于具体零件，产品和工厂一无所知

ConcreteProduct：具体产品，例子中的ListLink，ListTray，ListPage，TableLink，TableTray，TablePage类；负责实现AbstractProduct角色的接口

ConcreteFactory：具体工厂，例子中的ListFactory和TableFactory类；负责实现AbstractFactory角色的接口

思考：

易于新增具体工厂

如果要新增新的具体工厂，那么就需要编写Factory，Link，Tray，Page这四个超类的子类，并且要实现它们的抽象方法，也就是将factory包里抽象的部分全部具体化就行了，因此无论需要增加多少个具体工厂，或者修改，都无需要修改抽象工厂和Main部分

难于新增新的零件

如果要在AbstractFactory模式新增加新的零件，比如factory包里增加一个表示图像的Picture零件，这时候必须要对所有的具体工厂进行修改才行，比如listfactory包中，修改

在ListFactory中假如createPicture方法

新增ListPicture类

具体工厂越多，需要修改的越麻烦

发表回复