Android-项目中的XML协议封装

Android-项目中的协议封装
我们为什么要进行协议封装？
以往的处理方式：我们是利用XmlSerializer一点点编写协议并且序列化代码
但是存在问题（假设我们有100个请求需要处理）：
1、需要将协议中的请求分配给不同的组员进行处理，也就是大部分组员需要学习协议。
2、学习情况检验，是不是所有的组员都已经很好的理解了协议（开协议研讨会）。
3、进入协议开发阶段，类似的代码需要出现100次，由于不同人员处理，过程中很容易出现错误且抽取工作不统一。
4、开发过程中协议修改了，这就需要所有的组员停下手中工作，更改各自编写的请求代码

所以由于上面出现的棘手的问题，我们需要自己去封装一个协议提供给别人使用，当然这个协议给别人使用起来非常的简单。
下面就开始封装一个message的xml协议吧。

一 协议的大致内容
一共有四层，需要由内到外封装，这也是封装的原则

<?xml version='1.0' encoding='utf-8'?>
<message version="1.0" > 
    <header> 
        <id>
            123456 
        </id> 
        <source>
            chengzhi 
        </source> 
    </header> 
</message>

二 封装的思想
1.由里到外一层一层封装

2.节点对象化：将每个节点都封装成一个java类

3.节点序列化：
序列化原则：
自己管自己序列化范围：
只有请求的节点涉及序列化
序列化顺序：Leaf、Header、Message 由里到外
Message节点提供请求入口
Message节点提供对外的xml文件数据提供方法

4.请求抽象(接口)化：
所有请求必须实现该接口或继承该抽象类，同时实现定义的方法
因为可能会有很多的请求，抽象出一个通用的接口可以增强程序的健壮性

5.协议通用化：
新协议制定和已有协议
协议格式：xml、json
协议压缩：wbxml、二进制流

三 封装Leaf节点对象
Leaf又叫做叶子节点，就是每一个标签[含有内容]对应的对象

/** * @author chengzhi * 简单的叶子界面 * 要处理节点包含的内容和序列化节点 */
public class Leaf {

    /** * 叶子节点的名称 */
    private String TagName;
    /** * 叶子节点的值 */
    private String TagValue;
    /** * 初始化标签的名称 * @param p_TagName 传入的标签的名称 * */
    public Leaf(String p_TagName)
    {
        super();
        this.TagName = p_TagName;

    }

    /** * 初始化标签的名称和值 * @param p_TagName 标签的名称 * @param p_TagValue 标签的值 */
    public Leaf(String p_TagName, String p_TagValue)
    {
        super();
        this.TagName = p_TagName;
        this.TagValue = p_TagValue;
    }

    public String getTagValue()
    {
        return TagValue;
    }

    public void setTagValue(String mTagValue)
    {
        this.TagValue = mTagValue;
    }


    /** * 序列化叶子节点 * @param p_XmlSerializer 序列化器 */
    public void serializerLeaf(XmlSerializer p_XmlSerializer)
    {
        try
        {
            //开始节点
            p_XmlSerializer.startTag(null, TagName);
            if (null == TagValue)
            {
                TagValue = "";
            }
            //设置节点的值
            p_XmlSerializer.text(TagValue);
            //结束节点
            p_XmlSerializer.endTag(null, TagName);
        } catch (Exception e)
        {
            e.printStackTrace();
        } 
    } 

}

四 封装header节点对象

/** * @author chengzhi * 发送的协议的Header节点 */
public class Header {
    /** * 代理的ID */
    private Leaf agenterid = new Leaf("id", ConstantValues.ID);

    /** * 信息的来源 */
    private Leaf source = new Leaf("source", ConstantValues.SOURCE);

    /** * 序列化xml的header * * @param p_XmlSerializer * 传入的序列化器 * @param p_Body * 传入的body明文 */
    public void serializerHeader(XmlSerializer p_XmlSerializer, String p_Body)
    { 
         //这里写上序列化header的代码
    }

    public Leaf getTransactiontype()
    {
        return transactiontype;
    }

}

五 封装message节点对象

/** * 协议的封装 * * @author chengzhi * */
public class Message {
    /** * 协议的头信息 */
    private Header mHeader = new Header();


    public Header getHeader()
    {
        return mHeader;
    }



    /** * 序列化协议 * * @param p_XmlSerializer * 序列化器 */
    public void serializerMessage(XmlSerializer p_XmlSerializer)
    {
         //序列化message
    }


    /** * 序列化xml文件 * @return */
    public String getXml(Element p_Element)
    { 
        //对外提供获取xml协议的方法和请求的入口p_Element
    }  
}

六 请求的抽象(接口)化
上面使用的入口p_Element是一个接口对象
需要传入自己的实现类

public interface Element { 
    /** * 序列化自己 * @param p_XmlSerializer 序列化器 */
    public void serializerElement(XmlSerializer p_XmlSerializer);
}

实现类：

public class CurrentIssueElement implements Element {

    @Override
    public void serializerElement(XmlSerializer p_XmlSerializer)
    { 
        //实现自己的序列化方式
    }  
}

七 测试协议
使用AndroidTestCase工程

public class XmlTest extends AndroidTestCase {
    public void testGetXml()
    {
        Message m = new Message();
        //请求接口的实现类
        CurrentIssueElement e = new CurrentIssueElement();
        e.getLotteryid().setTagValue("111");
        //传入实现类
        String xml = m.getXml(e);
        System.out.println(xml);

    } 
}

上面就是封装协议的基本步骤，只要按照步骤来就可以了，一定要注意协议的封装原则和四化，只有正确的思想才能很快的写出代码，方便调试，希望可以在工作中帮助大家。