组合模式小试

组合模式是一种功能比较单一的设计模式，一般与其他设计模式搭配使用。本篇简单模拟了一下自动构建xml文件的小程序。

转载请注明出处http://www.cnblogs.com/zrtqsk/p/3725154.html，谢谢！

一、介绍

　　还是先来看一下《研磨设计模式》的介绍——将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

　　组合模式的本质——统一叶子对象和组合对象。

　　什么是组合模式呢？说白了，就是用一个抽象类把对象的整体和部分的操作统一起来。在外部看来，整个对象无论是整体还是部分，操作都是一样的。最常见使用组合模式的譬如我们的数据结构——树。树有3种模块，分别是根、枝、叶。这3个都分别有各自的特征。我们就可以用组合模式构建一个抽象类，将3者一样的操作在抽象类中实现，不一样的操作构建成抽象方法留给子类实现。这样在外界看来，整棵树自成一体，无须区分哪个是根、哪个是枝、叶。

二、我的实现

　　在这里，我们利用组合模式来做一个自动构建xml文件的小程序，也算是简单模拟了一下dom4j的功能。

　　xml文件分别有哪些部分组成？完整的xml文件，最顶端是xml声明，下面是xml的处理指令，然后下面是文档类型声明，然后下面是一个根元素，根元素包括了一个或多个子元素。而作为元素而言，又包括了元素内容、属性键值对等等。同时，xml注释可以在任意地方添加。

　　通常简单的xml文件只包括了xml声明、根元素（包含各种内容）以及xml注释。

　　由于xml声明只出现一次，可以在总的构建类中再处理。这里我们主要处理元素和xml注释。因为注释可以在任何地方添加，也可以抽象为元素的一种。

1、组合模式最麻烦的，就是这个抽象类，下面是我的抽象类，包含了元素和xml注释所有可能的方法：

package composite.qsk;

import java.util.List;

public abstract class AbstractElement {

    // 内容(包含在"<X>"和"</X>"之间的部分，没有用“<”和“>”括起来)
    protected String content = null;

    // 元素层，根层数为0，其子元素层数为1，依次
    private int level = 0;

    // 抽象方法、得到本元素所有内容（类似“<a c=d>efgh </a>”）
    public abstract String getAllContent();

    public List<XMLElement> getChildElements()
    {
        throw new UnsupportedOperationException("对象不支持此功能");
    }

    public int getLevel()
    {
        return level;
    }

    public void setLevel(int level)
    {
        this.level = level;
    }

    // 设置本元素内容
    public boolean setContent(String content)
    {
        boolean flag = false;
        if (content != null)
        {
            this.content = content;
            flag = true;
        }
        return flag;
    }

    // 得到本元素的内容
    public String getContent()
    {
        return content;
    }

    // 增加属性
    public boolean addAttribute(XMLAttribute xmlAttribute)
    {
        throw new UnsupportedOperationException("对象不支持此功能");
    }

    public boolean addAttribute(String aName, String aValue)
    {
        throw new UnsupportedOperationException("对象不支持此功能");
    }

    // 根据属性名移除属性
    public boolean removeAtrribute(String name)
    {
        throw new UnsupportedOperationException("对象不支持此功能");
    }

    // 增加子元素
    public boolean addElement(AbstractElement xmlElement)
    {
        throw new UnsupportedOperationException("对象不支持此功能");
    }

    // 根据索引移除子元素
    public AbstractElement removeElement(int index)
    {
        throw new UnsupportedOperationException("对象不支持此功能");
    }

    // 根据索引得到子元素
    public AbstractElement getElement(int index)
    {
        throw new UnsupportedOperationException("对象不支持此功能");
    }

    // 得到本元素元素名
    public String getName()
    {
        throw new UnsupportedOperationException("对象不支持此功能");
    }

    // 设置元素名
    public boolean setName(String elementName)
    {
        throw new UnsupportedOperationException("对象不支持此功能");
    }
}

如上，由于我们将注释定位为元素的一种，那么原本一些元素有的方法，注释都是不支持的，那么注释操作这些方法时，就会自动调用父类的方法，抛出异常UnsupportedOperationException("对象不支持此功能")。

2、接下来就是我们的元素类，继承了AbstractElement，当然要重写里面的很多方法，如下：

package composite.qsk;

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

public class XMLElement extends AbstractElement {

    // 元素名
    private String name = null;
    // 子元素列表
    protected List<AbstractElement> childElements = null;
    // 子属性列表
    protected List<XMLAttribute> attributes = null;

    public XMLElement(String name)
    {
        this.name = name;
    }

    // 增加子元素
    public boolean addElement(AbstractElement xmlElement)
    {
        boolean flag = false;
        if (childElements == null)
        {
            childElements = new ArrayList<AbstractElement>();
        }
        if (xmlElement != null)
        {
            xmlElement.setLevel(this.getLevel() + 1);
            childElements.add(xmlElement);
            flag = true;
        }
        return flag;
    }

    // 根据索引移除子元素
    public AbstractElement removeElement(int index)
    {
        if (childElements == null)
        {
            return null;
        }
        return childElements.remove(index);
    }

    // 根据索引得到子元素
    public AbstractElement getElement(int index)
    {
        if (childElements == null)
        {
            return null;
        }
        return childElements.get(index);
    }

    // 得到本元素元素名
    public String getName()
    {
        return name;
    }

    // 设置元素名
    public boolean setName(String elementName)
    {
        boolean flag = false;
        if (elementName != null)
        {
            this.name = elementName;
            flag = true;
        }
        return flag;
    }

    // 增加属性
    public boolean addAttribute(XMLAttribute attribute)
    {
        boolean flag = true;
        if (attributes == null)
        {
            attributes = new ArrayList<XMLAttribute>();
        }
        if (attribute != null)
        {
            flag = attributes.add(attribute);
        }
        return flag;
    }

    public boolean addAttribute(String name, String value)
    {
        return addAttribute(new XMLAttribute(name, value));
    }

    // 根据属性名移除属性
    public boolean removeAtrribute(String name)
    {
        boolean flag = false;
        if (attributes == null)
        {
            return false;
        }
        if (name != null)
        {
            for (XMLAttribute a : attributes)
            {
                if (a.getAttributeName().equals(name))
                {
                    attributes.remove(a);
                    flag = true;
                    return flag;
                }
            }
        }
        return flag;
    }

    // 得到元素所有内容
    @Override
    public String getAllContent()
    {
        StringBuilder allContent = new StringBuilder();
        // 行首空白
        StringBuilder space = new StringBuilder();
        for (int i = 0; i < getLevel(); i++)
        {
            space.append("    ");
        }
        // 拼接元素名
        allContent.append(space).append("<" + name);
        // 拼接属性
        if (attributes != null && attributes.size() > 0)
        {
            for (XMLAttribute a : attributes)
            {
                allContent.append(" " + a.getAttributeName() + ":" + a.getAttributeContent());
            }
        }
        allContent.append(">
");
        // 拼接元素内容
        if (content != null)
        {
            allContent.append(space).append(content).append("
");
        }
        // 拼接子元素
        if (childElements != null && childElements.size() > 0)
        {
            for (AbstractElement e : childElements)
            {
                allContent.append(e.getAllContent());
            }
        }
        // 拼接元素名后缀
        allContent.append(space).append("</" + name + ">
");
        return allContent.toString();
    }
}

如上，AbstractElement类的所有抛异常的方法，这里都重写了。

3、然后就是我们的注释元素类了，如下：

package composite.qsk;

public class AnnotationElement extends AbstractElement{

    public AnnotationElement(String content) {
        super.content = content;
    }

    @Override
    public String getAllContent()
    {
        StringBuilder allContent = new StringBuilder();
        //行首空白
        StringBuilder space = new StringBuilder();
        for(int i = 0;i<getLevel();i++) {
            space.append("    "); 
        }
        //拼接元素名
        allContent.append(space).append("<!--");
        //拼接元素内容
        if(content != null) {
            allContent.append(content);
        }
        //拼接元素名后缀
        allContent.append("-->
");
        return allContent.toString();
    }
}

这个类很简单。只是做了简单的拼接。

4、此外，还有一个简单的属性类，代表元素的属性，如下：

package composite.qsk;

public class XMLAttribute {

    private String attributeName = null;

    private String attributeContent = null;

    public String getAttributeName()
    {
        return attributeName;
    }

    public void setAttributeName(String attributeName)
    {
        this.attributeName = attributeName;
    }

    public String getAttributeContent()
    {
        return attributeContent;
    }

    public void setAttributeContent(String attributeContent)
    {
        this.attributeContent = attributeContent;
    }

    public XMLAttribute(String attributeName, String attributeContent)
    {
        super();
        this.attributeName = attributeName;
        this.attributeContent = attributeContent;
    }

}

5、完成构建文件的功能需要一个总的类负责，也负责组装xml声明，如下：

package composite.qsk;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class XMLParser {

    // 文件名
    private String fileName = "";
    // 文件
    private File xmlFile = null;
    // XML声明
    private String xmlDeclaration = "<?xml version="1.0" encoding="UTF-8">";
    // 根元素
    private AbstractElement root = null;
    // 所有内容
    private String allContent;

    public XMLParser(String fileName)
    {
        if (fileName.endsWith(".xml"))
        {
            this.fileName = fileName;
        }
        else
        {
            this.fileName = fileName + ".xml";
        }
        xmlFile = new File(fileName);
    }

    public XMLParser()
    {
        this("newXmlFile.xml");
    }

    // 拼接所有内容
    public String getAllContent()
    {
        return allContent = xmlDeclaration + "
" + root.getAllContent();
    }

    public String getXmlDeclaration()
    {
        return xmlDeclaration;
    }

    public void setXmlDeclaration(String xmlDeclaration)
    {
        this.xmlDeclaration = xmlDeclaration;
    }

    public AbstractElement getRoot()
    {
        return root;
    }

    public void setRoot(AbstractElement root)
    {

        if (root != null && root instanceof XMLElement)
        {
            this.root = root;
        }
        else
        {
            throw new UnsupportedOperationException("对象不支持此功能");
        }
    }

    public String getFileName()
    {
        return fileName;
    }

    public void setFileName(String fileName)
    {
        this.fileName = fileName;
    }

    // 输出文件
    public void createFile() throws IOException
    {
        BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(xmlFile)));
        bos.write(getAllContent());
        if (bos != null)
            bos.close();
    }

}

6、下面是简单的测试了：

package composite.qsk;

import java.io.IOException;

public class Test {

    public static void main(String[] args)
    {
        XMLParser xml = new XMLParser("myFile");
        // 根
        AbstractElement root = new XMLElement("qsk");
        // 设置根
        xml.setRoot(root);
        // 各个元素
        AbstractElement e1 = new XMLElement("e1");
        AbstractElement e2 = new XMLElement("e2");
        AbstractElement e3 = new XMLElement("e3");
        AbstractElement e4 = new XMLElement("e4");
        AbstractElement e5 = new XMLElement("e5");
        AbstractElement e6 = new XMLElement("e6");
        AbstractElement e7 = new AnnotationElement("这是一个注释");
        AbstractElement e8 = new AnnotationElement("这是一个注释");
        // 组合各个元素
        root.addElement(e8);
        root.addElement(e1);
        root.addElement(e2);
        e2.addElement(e7);
        e1.addElement(e3);
        e2.addElement(e4);
        e3.addElement(e5);
        e4.addElement(e6);
        // 设置内容
        e5.setContent("e5的内容啊");
        e2.setContent("bbbbbbbb");
        e6.setContent("e6的内容啊");
        // 设置属性
        root.addAttribute(new XMLAttribute("root的属性名", "root的属性值"));
        e1.addAttribute("e1的属性名", "e1的属性值");
        // 打印
        System.out.println(xml.getAllContent());
        // 输出xml文件
        try
        {
            xml.createFile();
        } catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

7、结果如下：

<?xml version="1.0" encoding="UTF-8">
<qsk root的属性名:root的属性值>
    <!--这是一个注释-->
    <e1 e1的属性名:e1的属性值>
        <e3>
            <e5>
            e5的内容啊
            </e5>
        </e3>
    </e1>
    <e2>
    bbbbbbbb
        <!--这是一个注释-->
        <e4>
            <e6>
            e6的内容啊
            </e6>
        </e4>
    </e2>
</qsk>

除了如上控制台的输出外，我们在工程目录也可以看到一个qsk.xml的文件。里面的内容与上相同。

在这个示例中，我们可以看到，通过一个root元素来得到其全部内容是通过方法getAllContent（）的递归，这是一种变形的递归。

三、安全性和透明性

在上面的例子中，我们很明显可以发现，在抽象类中将子类所有可能的方法列出是一件很繁琐的事，看起来也不够优雅。不过这样带来的好处是用户根本不用区分使用的AbstractElement到底是元素还是注释。直接使用就可以了。这就叫做为了透明性而牺牲了安全性，使用注释调用不属于注释的方法，就会报异常。

同样的，我们可以将抽象类完全的抽象，只放子类共有的方法，这样会带来的好处是不会出上述的异常，变的安全，不过子类不再透明。使用时，需要区分到底是哪个类型。各种操作也不再方便。

如下所示：

1、将抽象类AbstractElement的所有报异常的方法都删去：

package composite.qsk;

import java.util.List;

public abstract class AbstractElement {

    // 内容(包含在"<X>"和"</X>"之间的部分，没有用“<”和“>”括起来)
    protected String content = null;

    // 元素层，根层数为0，其子元素层数为1，依次
    private int level = 0;

    // 抽象方法、得到本元素所有内容（类似“<a c=d>efgh </a>”）
    public abstract String getAllContent();

    public List<XMLElement> getChildElements()
    {
        throw new UnsupportedOperationException("对象不支持此功能");
    }

    public int getLevel()
    {
        return level;
    }

    public void setLevel(int level)
    {
        this.level = level;
    }

    // 设置本元素内容
    public boolean setContent(String content)
    {
        boolean flag = false;
        if (content != null)
        {
            this.content = content;
            flag = true;
        }
        return flag;
    }

    // 得到本元素的内容
    public String getContent()
    {
        return content;
    }

}

除此之外，只有测试类需要改动，这里就不再演示了。结果没有区别。