Android调用WebService系列之对象构建传递

上一篇我们讲了如何封装Android调用WebService的能力，把上一章的类加入我们便有了与WebService通讯的能力。往往我们会遇到WebService调用是通过对象来进行实际交互调用的。于是便有了这一章构建对象传递。

首先我们了解一下。

Ksoap2这个开源包里面提供了一个接口

/* Copyright (c) 2003,2004, Stefan Haustein, Oberhausen, Rhld., Germany
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The  above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE. 
 *
 * Contributor(s): John D. Beatty, F. Hunter, Renaud Tognelli
 *
 * */

package org.ksoap2.serialization;

import java.util.Hashtable;

/**
 * Provides get and set methods for properties. Can be used to replace
 * reflection (to some extend) for "serialization-aware" classes. Currently used
 * in kSOAP and the RMS based kobjects object repository
 */

public interface KvmSerializable {

    /**
     * Returns the property at a specified index (for serialization)
     * 
     * @param index
     *            the specified index
     * @return the serialized property
     */
    Object getProperty(int index);

    /** 
     * @return the number of serializable properties 
     */
    int getPropertyCount();

    /**
     * Sets the property with the given index to the given value.
     * 
     * @param index
     *            the index to be set
     * @param value
     *            the value of the property
     */
    void setProperty(int index, Object value);

    /**
     * Fills the given property info record.
     * 
     * @param index
     *            the index to be queried
     * @param properties
     *            information about the (de)serializer.  Not frequently used.
     * @param info
     *            The return parameter, to be filled with information about the
     *            property with the given index.
     */
    void getPropertyInfo(int index, Hashtable properties, PropertyInfo info);

}

 接口的有这么一句话in kSOAP and the RMS based kobjects object repository，大致意思应该就是基于对象存储的时候可以用到他。（当然借助翻译工具翻译的，有什么理解上错误的请联系我）

那么意味着我们只需要把要传递的对象实现这个接口就可以实现对象传输了！

于是乎就有很多网文实现教你如何去实现了！我示例一下！

public Test implements KvmSerializable
{
    public String test1;
    public String test2;
    
    //Returns the property at a specified index (for serialization)
    //通过索引返回特定属性（翻译：返回属性在指定的索引(序列化)）
    @Override
    public Object getProperty(int index) {
       //根据接口注释最直接的会如下操作
       switch(index){
       ...（return test1 之类）
       }
    
    }
    //return the number of serializable properties 
    //返回属性的个数（翻译：返回的数量可序列化的属性）
    @Override
    public int getPropertyCount() {
        // TODO Auto-generated method stub
        //返回固定数量
        return 2;
    }
    //Sets the property with the given index to the given value.
    //根据index给PropertyInfo赋值参数 （翻译：属性与给定的索引设置为给定值。）
    @Override
    public void getPropertyInfo(int index, Hashtable arg1, PropertyInfo a) {
        
        //根据接口注释最直接的会如下操作
        swtich(index){
        ...  （设置a的属性值）
        }
    }
    // Fills the given property info record.
    //给相应索引的属性赋值（翻译：填充给定属性信息记录。）
    @Override
    public void setProperty(int index, Object arg1) {
        switch(index){
        ...(test1 = arg1之类)
        }
    }
}

这样是没有错误的，但是在我们有很多不同的类需要传递的时候呢？这个类属性上百个的时候呢？

那我们岂不是一直需要做重复操作。那么我们何不写一个通用的转换类！

于是在不考虑更复杂，以及特定的一些数据类型的时候我们有了下面这个类：

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Vector;

import org.ksoap2.serialization.KvmSerializable;
import org.ksoap2.serialization.PropertyInfo;
import org.ksoap2.serialization.SoapObject;
/**
 * 对象传输基础类
 * @author 刘亚林
 * @e-mail 461973266@qq.com
 * 
 */
public abstract BaseKvmSerializable implements KvmSerializable
{
    /**
    ** 将首字母大写
    **/
    public static String fristUpperCase(String str) {
	return String.valueOf(str.charAt(0)).toUpperCase().concat(str.substring(1));
    }
    //Returns the property at a specified index (for serialization)
    //通过索引返回特定属性（翻译：返回属性在指定的索引(序列化)）
    @Override
    public Object getProperty(int index) {
        //既然是要返回特定索引的属性值，那么我们何不直接通过反射取对应属性返回
       Field[] fs = this.getClass().getDeclaredFields();
       Field f = fs[index];
       String name = f.getName();
       name = fristUpperCase(name); 
       String getMethodName = "get";
	if (f.getType() == boolean.class || f.getType() == Boolean.class) {
	    getMethodName = "is";
	}
	getMethodName += name;
	Method getMethod;
	Object val = null;
	try {
		getMethod = this.getClass().getMethod(getMethodName);
		getMethod.setAccessible(true);
		val = getMethod.invoke(this);
	} catch (NoSuchMethodException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IllegalAccessException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IllegalArgumentException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (InvocationTargetException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	return val;
   
    }
    //return the number of serializable properties 
    //返回属性的个数（翻译：返回的数量可序列化的属性）
    @Override
    public int getPropertyCount() {
        // TODO Auto-generated method stub
        //返回固定数量
        return this.getClass().getDeclaredFields().length;
    }
    //Sets the property with the given index to the given value.
    //根据index给PropertyInfo赋值参数 （翻译：属性与给定的索引设置为给定值。）
    @Override
    public void getPropertyInfo(int index, Hashtable arg1, PropertyInfo a) {
        
        Field[] fs = this.getClass().getDeclaredFields();
	Field f = fs[index];
	String name = f.getName();
	//主要是设置type和name其他的需要可以继续添加
	a.type = getTypeByClass(f.getType());
	a.name = name;
    }
    // Fills the given property info record.
    //给相应索引的属性赋值（翻译：填充给定属性信息记录。）
    @Override
    public void setProperty(int index, Object arg1) {
        Field[] fs = this.getClass().getDeclaredFields();
	Field f = fs[index];
	String name = f.getName();
	name = fristUpperCase(name);
	String setMethodName = "set" + name;
	Method m;
	try {
	    m = this.getClass().getDeclaredMethod(setMethodName, f.getType());
	    m.setAccessible(true);	
	    m.invoke(this, arg1); 
	} catch (NoSuchMethodException e) {
	    // TODO Auto-generated catch block
	    e.printStackTrace();
	} catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
	    e.printStackTrace();
	} catch (IllegalArgumentException e) {
	    // TODO Auto-generated catch block
	    e.printStackTrace();
	} catch (InvocationTargetException e) {
	    // TODO Auto-generated catch block
	    e.printStackTrace();
	}  
    }
    /**
    **  根据类别获得 PropertyInfo 特定类别 
    **  实际上除了统一类别这个没什么太多用为了心里好过而加
    **  你看下面对于这些类别的的定义就知道了
    **	public static final Class OBJECT_CLASS = new Object().getClass();
    **  public static final Class STRING_CLASS = "".getClass();
    **	public static final Class INTEGER_CLASS = new Integer(0).getClass();
    **	public static final Class LONG_CLASS = new Long(0).getClass();
    **	public static final Class BOOLEAN_CLASS = new Boolean(true).getClass();
    **	public static final Class VECTOR_CLASS = new java.util.Vector().getClass();
    **/
    public Class getTypeByClass(Class cls) {
	if (cls.isAssignableFrom(Boolean.class)
			|| cls.isAssignableFrom(boolean.class)) {
		return PropertyInfo.BOOLEAN_CLASS;
	} else if (cls.isAssignableFrom(String.class)) {
		return PropertyInfo.STRING_CLASS;
	} else if (cls.isAssignableFrom(Integer.class)
			|| cls.isAssignableFrom(int.class)
			|| cls.isAssignableFrom(byte.class)
			|| cls.isAssignableFrom(Byte.class)) {
		return PropertyInfo.INTEGER_CLASS;
	} else if (cls.isAssignableFrom(Vector.class)) {
		return PropertyInfo.VECTOR_CLASS;
	} else if (cls.isAssignableFrom(Long.class)
			|| cls.isAssignableFrom(long.class)) {
		return PropertyInfo.LONG_CLASS;
	} else {	
		return PropertyInfo.OBJECT_CLASS;
		}
	}
}

当然这个类已经基本可以满足大多数不复杂类的调用了。

不过一些嵌套复杂的类型的类仍然可能报序列化的错误，在这里我们将暂时不再深入研究。

有兴趣的可以继续了解一下:

他为什么会报序列化错误？

再writeElement的时候

private void writeElement(XmlSerializer writer, Object element, PropertyInfo type, Object marshal)
			throws IOException
	{
		if (marshal != null)
			((Marshal) marshal).writeInstance(writer, element);
		else if (element instanceof SoapObject)
			writeObjectBody(writer, (SoapObject) element);
		else if (element instanceof KvmSerializable)
			writeObjectBody(writer, (KvmSerializable) element);
		else if (element instanceof Vector)
			writeVectorBody(writer, (Vector) element, type.elementType);
		else
			throw new RuntimeException("Cannot serialize: " + element);
	}

很显然当他没有Marshal 又不是SoapObject KvmSerializable Vector中的一种类型的时候他就无法序列化了！自然就报错了！那么根据这个我们是不是抓住了点什么？

SoapSerializationEnvelope中有一个这样的addMapping方法Marshal

//他的说明是

//Defines a direct mapping from a namespace and name to a java class (and vice versa)

有兴趣可以研究一下。

好了！基础的对象构建传递就将到这里了！

既然有序列化，那么如何对Ksoap2接收到的服务端数据进行解析呢？敬请期待

下一篇《Android调用WebService系列之KSoap2对象解析》